From 6f9d7e687cc776cfa65d705a0b87bd403836935e Mon Sep 17 00:00:00 2001 From: Stewart Mackenzie Date: Fri, 16 Nov 2018 00:12:53 +0800 Subject: [PATCH] * Add nix support using stack2nix * Document how to reproduce * gitignore the generated artefact closes #5 --- .gitignore | 1 + README.md | 11 + default.nix | 39940 ++++++++++++++++++++++++++++++++++++++++++++++++++ 3 files changed, 39952 insertions(+) create mode 100644 default.nix diff --git a/.gitignore b/.gitignore index 1de91f7..f560a42 100644 --- a/.gitignore +++ b/.gitignore @@ -2,3 +2,4 @@ .ghci .stack-work/ backerei.cabal +result diff --git a/README.md b/README.md index 4c994b5..1f181bf 100644 --- a/README.md +++ b/README.md @@ -91,6 +91,17 @@ and cross-check against a payout database generated locally. make build ``` +#### Building for Nix + +```bash +$ nix-shell -p stack2nix +$ stack2nix --revision 5b266bcd84d570de8ab06cb79b2457c0992080d4 https://github.com/cryptiumlabs/backerei.git > default.nix +$ nix-build -A backerei +``` +* Change the above revision number to whatever is the latest `backerei` release. +* You'll also need to manually remove some faulty generated code by `stack2nix`. +- For example; `stack2nix` might generate `{inherit (pkgs) util;};` on line 27042. Remove the `inherit (pkgs) util;` so just the `{};` remains. + #### Testing ```bash diff --git a/default.nix b/default.nix new file mode 100644 index 0000000..76b628d --- /dev/null +++ b/default.nix @@ -0,0 +1,39940 @@ +# Generated using stack2nix 0.2.1. + +{ pkgs ? (import {}) +, compiler ? pkgs.haskell.packages.ghc843 +}: + +with pkgs.haskell.lib; + +let + stackPackages = { pkgs, stdenv, callPackage }: + self: { + array = null; + base = null; + bin-package-db = null; + binary = null; + bytestring = null; + containers = null; + deepseq = null; + directory = null; + filepath = null; + ghc-boot = null; + ghc-boot-th = null; + ghc-prim = null; + ghci = null; + hpc = null; + integer-gmp = null; + pretty = null; + process = null; + rts = null; + template-haskell = null; + terminfo = null; + time = null; + transformers = null; + unix = null; + "ALUT" = callPackage + ({ mkDerivation, base, freealut, OpenAL, StateVar, stdenv + , transformers + }: + mkDerivation { + pname = "ALUT"; + version = "2.4.0.2"; + sha256 = "b8364da380f5f1d85d13e427851a153be2809e1838d16393e37566f34b384b87"; + isLibrary = true; + isExecutable = true; + libraryHaskellDepends = [ base OpenAL StateVar transformers ]; + librarySystemDepends = [ freealut ]; + doHaddock = false; + doCheck = false; + homepage = "https://github.com/haskell-openal/ALUT"; + description = "A binding for the OpenAL Utility Toolkit"; + license = stdenv.lib.licenses.bsd3; + }) {inherit (pkgs) freealut;}; + "ANum" = callPackage + ({ mkDerivation, base, stdenv }: + mkDerivation { + pname = "ANum"; + version = "0.2.0.2"; + sha256 = "f6ae0d1b663100a2aa3dfdab12f4af0851408659eb5c2f78b8b443b0d29dbb1a"; + libraryHaskellDepends = [ base ]; + doHaddock = false; + doCheck = false; + homepage = "https://github.com/DanBurton/ANum#readme"; + description = "Num instance for Applicatives provided via the ANum newtype"; + license = stdenv.lib.licenses.bsd3; + }) {}; + "Agda" = callPackage + ({ mkDerivation, alex, array, async, base, binary, blaze-html + , boxes, bytestring, Cabal, containers, cpphs, data-hash, deepseq + , directory, EdisonCore, edit-distance, emacs, equivalence + , filepath, geniplate-mirror, gitrev, happy, hashable, hashtables + , haskeline, ieee754, mtl, murmur-hash, pretty, process, regex-tdfa + , stdenv, stm, strict, template-haskell, text, time, transformers + , unordered-containers, uri-encode, zlib + }: + mkDerivation { + pname = "Agda"; + version = "2.5.4"; + sha256 = "b40971e3312461771e36a11aaf4002424178301cf315b21a679f527b79c09e09"; + isLibrary = true; + isExecutable = true; + enableSeparateDataOutput = true; + setupHaskellDepends = [ base Cabal filepath process ]; + libraryHaskellDepends = [ + array async base binary blaze-html boxes bytestring containers + data-hash deepseq directory EdisonCore edit-distance equivalence + filepath geniplate-mirror gitrev hashable hashtables haskeline + ieee754 mtl murmur-hash pretty process regex-tdfa stm strict + template-haskell text time transformers unordered-containers + uri-encode zlib + ]; + libraryToolDepends = [ alex cpphs happy ]; + executableHaskellDepends = [ base directory filepath process ]; + executableToolDepends = [ emacs ]; + doHaddock = false; + doCheck = false; + postInstall = '' + files=("$data/share/ghc-"*"/"*"-ghc-"*"/Agda-"*"/lib/prim/Agda/"{Primitive.agda,Builtin"/"*.agda}) + for f in "''${files[@]}" ; do + $out/bin/agda $f + done + for f in "''${files[@]}" ; do + $out/bin/agda -c --no-main $f + done + $out/bin/agda-mode compile + ''; + homepage = "http://wiki.portal.chalmers.se/agda/"; + description = "A dependently typed functional programming language and proof assistant"; + license = "unknown"; + }) {}; + "Allure" = callPackage + ({ mkDerivation, async, base, containers, enummapset, filepath + , LambdaHack, optparse-applicative, random, stdenv + , template-haskell, text, transformers, zlib + }: + mkDerivation { + pname = "Allure"; + version = "0.8.3.0"; + sha256 = "6b83013281da6ccc5f0bf4c483a53acdbff7679c7234a1dfa57261c45a8cf8fb"; + isLibrary = false; + isExecutable = true; + enableSeparateDataOutput = true; + executableHaskellDepends = [ + async base containers enummapset filepath LambdaHack + optparse-applicative random template-haskell text transformers zlib + ]; + doHaddock = false; + doCheck = false; + homepage = "http://allureofthestars.com"; + description = "Near-future Sci-Fi roguelike and tactical squad game"; + license = "unknown"; + }) {}; + "BiobaseNewick" = callPackage + ({ mkDerivation, aeson, attoparsec, base, binary, cereal + , cereal-text, cmdargs, containers, fgl, ForestStructures + , QuickCheck, stdenv, text, text-binary, vector + }: + mkDerivation { + pname = "BiobaseNewick"; + version = "0.0.0.2"; + sha256 = "6432f684a75fd8a2cea59a5359a59f48020ead19119efaed7018ecae726d13bd"; + isLibrary = true; + isExecutable = true; + libraryHaskellDepends = [ + aeson attoparsec base binary cereal cereal-text containers fgl + ForestStructures QuickCheck text text-binary vector + ]; + executableHaskellDepends = [ + base cmdargs ForestStructures text vector + ]; + doHaddock = false; + doCheck = false; + homepage = "https://github.com/choener/BiobaseNewick"; + description = "Newick file format parser"; + license = stdenv.lib.licenses.bsd3; + }) {}; + "Boolean" = callPackage + ({ mkDerivation, base, stdenv }: + mkDerivation { + pname = "Boolean"; + version = "0.2.4"; + sha256 = "67216013b02b8ac5b534a1ef25f409f930eea1a85eae801933a01ad43145eef8"; + libraryHaskellDepends = [ base ]; + doHaddock = false; + doCheck = false; + description = "Generalized booleans and numbers"; + license = stdenv.lib.licenses.bsd3; + }) {}; + "BoundedChan" = callPackage + ({ mkDerivation, array, base, stdenv }: + mkDerivation { + pname = "BoundedChan"; + version = "1.0.3.0"; + sha256 = "531ceaed7f62844c2a63a7cbfdcab332ea5eaa218e9922ca3305580438adc46d"; + libraryHaskellDepends = [ array base ]; + doHaddock = false; + doCheck = false; + description = "Implementation of bounded channels"; + license = stdenv.lib.licenses.bsd3; + }) {}; + "Cabal" = callPackage + ({ mkDerivation, array, base, binary, bytestring, containers + , deepseq, directory, filepath, mtl, parsec, pretty, process + , stdenv, text, time, transformers, unix + }: + mkDerivation { + pname = "Cabal"; + version = "2.2.0.1"; + sha256 = "02b5301304df73cea3c7d544b5026b228141dc3ac1d5b08c9a206f99aa330a7b"; + setupHaskellDepends = [ mtl parsec ]; + libraryHaskellDepends = [ + array base binary bytestring containers deepseq directory filepath + mtl parsec pretty process text time transformers unix + ]; + doHaddock = false; + doCheck = false; + homepage = "http://www.haskell.org/cabal/"; + description = "A framework for packaging Haskell software"; + license = stdenv.lib.licenses.bsd3; + }) {}; + "ChannelT" = callPackage + ({ mkDerivation, base, free, mmorph, mtl, stdenv, transformers-base + }: + mkDerivation { + pname = "ChannelT"; + version = "0.0.0.7"; + sha256 = "3e215d425e3cfccf2e4d84b1402fb39a2081cb33b6556059db616e722a7c77a0"; + libraryHaskellDepends = [ base free mmorph mtl transformers-base ]; + doHaddock = false; + doCheck = false; + homepage = "https://github.com/pthariensflame/ChannelT"; + description = "Generalized stream processors"; + license = stdenv.lib.licenses.bsd3; + }) {}; + "ChasingBottoms" = callPackage + ({ mkDerivation, base, containers, mtl, QuickCheck, random, stdenv + , syb + }: + mkDerivation { + pname = "ChasingBottoms"; + version = "1.3.1.4"; + sha256 = "639867018f33a645305ff60f1bf9ecca2efea4ac630d8c8f9fd72d064db79e19"; + libraryHaskellDepends = [ + base containers mtl QuickCheck random syb + ]; + doHaddock = false; + doCheck = false; + description = "For testing partial and infinite values"; + license = stdenv.lib.licenses.mit; + }) {}; + "Clipboard" = callPackage + ({ mkDerivation, base, directory, stdenv, unix, utf8-string, X11 }: + mkDerivation { + pname = "Clipboard"; + version = "2.3.2.0"; + sha256 = "3f82c8183a599025c5199ba50d0661512683e9cf29e6054858f1abe2ab8b25b7"; + libraryHaskellDepends = [ base directory unix utf8-string X11 ]; + doHaddock = false; + doCheck = false; + homepage = "http://haskell.org/haskellwiki/Clipboard"; + description = "System clipboard interface"; + license = stdenv.lib.licenses.bsd3; + }) {}; + "ClustalParser" = callPackage + ({ mkDerivation, base, cmdargs, either-unwrap, parsec, stdenv, text + , vector + }: + mkDerivation { + pname = "ClustalParser"; + version = "1.2.3"; + sha256 = "fed67bdcb9d89d871b02f556e5a294d0ea6fd05576f92621a8797abff4325a72"; + isLibrary = true; + isExecutable = true; + libraryHaskellDepends = [ base parsec text vector ]; + executableHaskellDepends = [ base cmdargs either-unwrap ]; + doHaddock = false; + doCheck = false; + description = "Libary for parsing Clustal tools output"; + license = stdenv.lib.licenses.gpl3; + }) {}; + "DAV" = callPackage + ({ mkDerivation, base, bytestring, case-insensitive, containers + , data-default, exceptions, haskeline, http-client, http-client-tls + , http-types, lens, mtl, network, network-uri, optparse-applicative + , stdenv, transformers, transformers-base, transformers-compat + , utf8-string, xml-conduit, xml-hamlet + }: + mkDerivation { + pname = "DAV"; + version = "1.3.2"; + sha256 = "613314357579b29e1d3fa8451b51e8b9a1307a2b33b65a3f2b2ef2bece025169"; + isLibrary = true; + isExecutable = true; + libraryHaskellDepends = [ + base bytestring case-insensitive containers data-default exceptions + http-client http-client-tls http-types lens mtl transformers + transformers-base transformers-compat utf8-string xml-conduit + xml-hamlet + ]; + executableHaskellDepends = [ + base bytestring case-insensitive containers data-default exceptions + haskeline http-client http-client-tls http-types lens mtl network + network-uri optparse-applicative transformers transformers-base + transformers-compat utf8-string xml-conduit xml-hamlet + ]; + doHaddock = false; + doCheck = false; + homepage = "http://floss.scru.org/hDAV"; + description = "RFC 4918 WebDAV support"; + license = stdenv.lib.licenses.gpl3; + }) {}; + "DRBG" = callPackage + ({ mkDerivation, base, bytestring, cereal, cipher-aes128 + , crypto-api, cryptohash-cryptoapi, entropy, mtl, parallel + , prettyclass, stdenv, tagged + }: + mkDerivation { + pname = "DRBG"; + version = "0.5.5"; + sha256 = "21df3202486cc83c7cc3f867cb139eac9a3f69bd91b5f6b016ae026e03c33bfd"; + enableSeparateDataOutput = true; + libraryHaskellDepends = [ + base bytestring cereal cipher-aes128 crypto-api + cryptohash-cryptoapi entropy mtl parallel prettyclass tagged + ]; + doHaddock = false; + doCheck = false; + description = "Deterministic random bit generator (aka RNG, PRNG) based HMACs, Hashes, and Ciphers"; + license = stdenv.lib.licenses.bsd3; + }) {}; + "Decimal" = callPackage + ({ mkDerivation, base, deepseq, stdenv }: + mkDerivation { + pname = "Decimal"; + version = "0.5.1"; + sha256 = "575ca5c65a8ea5a5bf2cd7b794a0d16622082cb501bf4b0327c5895c0b80f34c"; + libraryHaskellDepends = [ base deepseq ]; + doHaddock = false; + doCheck = false; + homepage = "https://github.com/PaulJohnson/Haskell-Decimal"; + description = "Decimal numbers with variable precision"; + license = stdenv.lib.licenses.bsd3; + }) {}; + "Diff" = callPackage + ({ mkDerivation, array, base, pretty, stdenv }: + mkDerivation { + pname = "Diff"; + version = "0.3.4"; + sha256 = "77b7daec5a79ade779706748f11b4d9b8f805e57a68e7406c3b5a1dee16e0c2f"; + libraryHaskellDepends = [ array base pretty ]; + doHaddock = false; + doCheck = false; + description = "O(ND) diff algorithm in haskell"; + license = stdenv.lib.licenses.bsd3; + }) {}; + "Earley" = callPackage + ({ mkDerivation, base, ListLike, stdenv }: + mkDerivation { + pname = "Earley"; + version = "0.12.1.0"; + sha256 = "731493be9cb960c3159458dc24b1a217d6f26e1f46a840bef880accd04d5bd1d"; + isLibrary = true; + isExecutable = true; + libraryHaskellDepends = [ base ListLike ]; + doHaddock = false; + doCheck = false; + description = "Parsing all context-free grammars using Earley's algorithm"; + license = stdenv.lib.licenses.bsd3; + }) {}; + "Ebnf2ps" = callPackage + ({ mkDerivation, array, base, containers, directory, happy + , old-time, stdenv, unix + }: + mkDerivation { + pname = "Ebnf2ps"; + version = "1.0.15"; + sha256 = "0ecce7d721d6c8993fa6ba6cfb16f1101d85e00bbaf0b6941d36a00badea2b4b"; + isLibrary = false; + isExecutable = true; + executableHaskellDepends = [ + array base containers directory old-time unix + ]; + executableToolDepends = [ happy ]; + doHaddock = false; + doCheck = false; + homepage = "https://github.com/FranklinChen/Ebnf2ps"; + description = "Peter's Syntax Diagram Drawing Tool"; + license = stdenv.lib.licenses.bsd3; + }) {}; + "EdisonAPI" = callPackage + ({ mkDerivation, base, mtl, stdenv }: + mkDerivation { + pname = "EdisonAPI"; + version = "1.3.1"; + sha256 = "95a3b8d01599520a50456219b5a2e9f7832bcddaaeb8e94ce777bd87a4a6b56e"; + libraryHaskellDepends = [ base mtl ]; + doHaddock = false; + doCheck = false; + homepage = "http://rwd.rdockins.name/edison/home/"; + description = "A library of efficient, purely-functional data structures (API)"; + license = stdenv.lib.licenses.mit; + }) {}; + "EdisonCore" = callPackage + ({ mkDerivation, array, base, containers, EdisonAPI, mtl + , QuickCheck, stdenv + }: + mkDerivation { + pname = "EdisonCore"; + version = "1.3.2.1"; + sha256 = "73c6014d07107a9ed21df76a59f70c9d68d64ac84cced35f7b628f1d792cf239"; + libraryHaskellDepends = [ + array base containers EdisonAPI mtl QuickCheck + ]; + doHaddock = false; + doCheck = false; + homepage = "http://rwd.rdockins.name/edison/home/"; + description = "A library of efficient, purely-functional data structures (Core Implementations)"; + license = stdenv.lib.licenses.mit; + }) {}; + "FenwickTree" = callPackage + ({ mkDerivation, base, QuickCheck, stdenv, template-haskell }: + mkDerivation { + pname = "FenwickTree"; + version = "0.1.2.1"; + sha256 = "9c172d62b24365e663a0355e8eaa34362a1a769c18a64391939a9b50e384f03c"; + enableSeparateDataOutput = true; + libraryHaskellDepends = [ base QuickCheck template-haskell ]; + doHaddock = false; + doCheck = false; + homepage = "https://github.com/mgajda/FenwickTree"; + description = "Data structure for fast query and update of cumulative sums"; + license = stdenv.lib.licenses.bsd3; + }) {}; + "Fin" = callPackage + ({ mkDerivation, base, natural-induction, peano, stdenv }: + mkDerivation { + pname = "Fin"; + version = "0.2.3.0"; + sha256 = "2fd02d1fc6426fb9b50db291d56b19dfc6da85cd3777f0aa64514c15a2b95ab2"; + libraryHaskellDepends = [ base natural-induction peano ]; + doHaddock = false; + doCheck = false; + description = "Finite totally-ordered sets"; + license = stdenv.lib.licenses.bsd3; + }) {}; + "FindBin" = callPackage + ({ mkDerivation, base, directory, filepath, stdenv }: + mkDerivation { + pname = "FindBin"; + version = "0.0.5"; + sha256 = "279c7967e0803ca3b9a0a1956ce7ba9b9a2294eb9f971bea8a557b5f80ddfda4"; + libraryHaskellDepends = [ base directory filepath ]; + doHaddock = false; + doCheck = false; + homepage = "https://github.com/audreyt/findbin"; + description = "Locate directory of original program"; + license = stdenv.lib.licenses.bsd3; + }) {}; + "FontyFruity" = callPackage + ({ mkDerivation, base, binary, bytestring, containers, deepseq + , directory, filepath, stdenv, text, vector, xml + }: + mkDerivation { + pname = "FontyFruity"; + version = "0.5.3.3"; + sha256 = "b0d06e7c5eb1aa7ffd11a85598df05d034bab3a83130fdf37121f89136e0025c"; + libraryHaskellDepends = [ + base binary bytestring containers deepseq directory filepath text + vector xml + ]; + doHaddock = false; + doCheck = false; + description = "A true type file format loader"; + license = stdenv.lib.licenses.bsd3; + }) {}; + "ForestStructures" = callPackage + ({ mkDerivation, base, containers, fgl, QuickCheck, stdenv + , unordered-containers, vector, vector-th-unbox + }: + mkDerivation { + pname = "ForestStructures"; + version = "0.0.0.2"; + sha256 = "fe74067fee601844de5c839a115f2bd75d4a1be9f0ee8ec42c0150bcf886693f"; + libraryHaskellDepends = [ + base containers fgl QuickCheck unordered-containers vector + vector-th-unbox + ]; + doHaddock = false; + doCheck = false; + homepage = "https://github.com/choener/ForestStructures"; + description = "Tree- and forest structures"; + license = stdenv.lib.licenses.bsd3; + }) {}; + "GLFW-b" = callPackage + ({ mkDerivation, base, bindings-GLFW, deepseq, stdenv }: + mkDerivation { + pname = "GLFW-b"; + version = "3.2.1.0"; + sha256 = "31c022e0ad63f259ff9fa582a235924786e929a95b52efae10a3d29fef7cb6a6"; + libraryHaskellDepends = [ base bindings-GLFW deepseq ]; + doHaddock = false; + doCheck = false; + description = "Bindings to GLFW OpenGL library"; + license = stdenv.lib.licenses.bsd3; + }) {}; + "GLURaw" = callPackage + ({ mkDerivation, base, libGL, libGLU, OpenGLRaw, stdenv + , transformers + }: + mkDerivation { + pname = "GLURaw"; + version = "2.0.0.4"; + sha256 = "b863fd5cb26b1a37afb66ef8a81c0335bc073d33b0a67ec5190dfc62cb885dc4"; + libraryHaskellDepends = [ base OpenGLRaw transformers ]; + librarySystemDepends = [ libGL libGLU ]; + doHaddock = false; + doCheck = false; + homepage = "http://www.haskell.org/haskellwiki/Opengl"; + description = "A raw binding for the OpenGL graphics system"; + license = stdenv.lib.licenses.bsd3; + }) {inherit (pkgs) libGL; inherit (pkgs) libGLU;}; + "GLUT" = callPackage + ({ mkDerivation, array, base, containers, OpenGL, StateVar, stdenv + , transformers + }: + mkDerivation { + pname = "GLUT"; + version = "2.7.0.13"; + sha256 = "3d217c0ee5e040992ebc278f5e20911460202a6e13767c8a0ddb01ef4adabac8"; + isLibrary = true; + isExecutable = true; + libraryHaskellDepends = [ + array base containers OpenGL StateVar transformers + ]; + doHaddock = false; + doCheck = false; + homepage = "http://www.haskell.org/haskellwiki/Opengl"; + description = "A binding for the OpenGL Utility Toolkit"; + license = stdenv.lib.licenses.bsd3; + }) {}; + "GenericPretty" = callPackage + ({ mkDerivation, base, ghc-prim, pretty, stdenv }: + mkDerivation { + pname = "GenericPretty"; + version = "1.2.2"; + sha256 = "eeea7ae7081f866de6a83ab8c4c335806b8cbb679d85e416e6224384ffcdae3c"; + libraryHaskellDepends = [ base ghc-prim pretty ]; + doHaddock = false; + doCheck = false; + homepage = "https://github.com/RazvanRanca/GenericPretty"; + description = "A generic, derivable, haskell pretty printer"; + license = stdenv.lib.licenses.bsd3; + }) {}; + "Glob" = callPackage + ({ mkDerivation, base, containers, directory, dlist, filepath + , stdenv, transformers, transformers-compat + }: + mkDerivation { + pname = "Glob"; + version = "0.9.2"; + sha256 = "8fc7134e9a930dd53fd168f200bde8ca07905365788f70adc6a1a4c413667ce5"; + libraryHaskellDepends = [ + base containers directory dlist filepath transformers + transformers-compat + ]; + doHaddock = false; + doCheck = false; + homepage = "http://iki.fi/matti.niemenmaa/glob/"; + description = "Globbing library"; + license = stdenv.lib.licenses.bsd3; + }) {}; + "HCodecs" = callPackage + ({ mkDerivation, array, base, bytestring, QuickCheck, random + , semigroups, stdenv + }: + mkDerivation { + pname = "HCodecs"; + version = "0.5.1"; + sha256 = "a724616b79ac12c2d661dc3f54cfa0e7d530d1ba3eafa1e6c3e7116e035a3143"; + libraryHaskellDepends = [ + array base bytestring QuickCheck random semigroups + ]; + doHaddock = false; + doCheck = false; + homepage = "http://www-db.informatik.uni-tuebingen.de/team/giorgidze"; + description = "A library to read, write and manipulate MIDI, WAVE, and SoundFont2 files"; + license = stdenv.lib.licenses.bsd3; + }) {}; + "HDBC" = callPackage + ({ mkDerivation, base, bytestring, containers, convertible, mtl + , old-time, stdenv, text, time, utf8-string + }: + mkDerivation { + pname = "HDBC"; + version = "2.4.0.2"; + sha256 = "670757fd674b6caf2f456034bdcb54812af2cdf2a32465d7f4b7f0baa377db5a"; + isLibrary = true; + isExecutable = true; + libraryHaskellDepends = [ + base bytestring containers convertible mtl old-time text time + utf8-string + ]; + doHaddock = false; + doCheck = false; + homepage = "https://github.com/hdbc/hdbc"; + description = "Haskell Database Connectivity"; + license = stdenv.lib.licenses.bsd3; + }) {}; + "HDBC-mysql" = callPackage + ({ mkDerivation, base, bytestring, Cabal, HDBC, mysqlclient + , openssl, stdenv, time, utf8-string, zlib + }: + mkDerivation { + pname = "HDBC-mysql"; + version = "0.7.1.0"; + sha256 = "81c985d4a243c965930fb412b3175ca799ba66985f8b6844014fd600df1da7cf"; + setupHaskellDepends = [ base Cabal ]; + libraryHaskellDepends = [ base bytestring HDBC time utf8-string ]; + librarySystemDepends = [ mysqlclient openssl zlib ]; + doHaddock = false; + doCheck = false; + homepage = "http://github.com/ryantm/hdbc-mysql"; + description = "MySQL driver for HDBC"; + license = "LGPL"; + }) {inherit (pkgs) mysqlclient; inherit (pkgs) openssl; +inherit (pkgs) zlib;}; + "HDBC-session" = callPackage + ({ mkDerivation, base, HDBC, stdenv }: + mkDerivation { + pname = "HDBC-session"; + version = "0.1.2.0"; + sha256 = "aa057f18bbc9d2f9876152246682f546c9cf140192515c7c23b5be2fccc296e3"; + libraryHaskellDepends = [ base HDBC ]; + doHaddock = false; + doCheck = false; + homepage = "http://khibino.github.io/haskell-relational-record/"; + description = "Bracketed connection for HDBC"; + license = stdenv.lib.licenses.bsd3; + }) {}; + "HPDF" = callPackage + ({ mkDerivation, array, base, base64-bytestring, binary, bytestring + , containers, errors, mtl, random, stdenv, vector, zlib + }: + mkDerivation { + pname = "HPDF"; + version = "1.4.10"; + sha256 = "de2bfddd93eeef2129a2378e8dce486d086bec3c48ee2a1bf1a5fb01581607d4"; + libraryHaskellDepends = [ + array base base64-bytestring binary bytestring containers errors + mtl random vector zlib + ]; + doHaddock = false; + doCheck = false; + homepage = "http://www.alpheccar.org"; + description = "Generation of PDF documents"; + license = stdenv.lib.licenses.bsd3; + }) {}; + "HSet" = callPackage + ({ mkDerivation, base, containers, hashable, hashtables, stdenv }: + mkDerivation { + pname = "HSet"; + version = "0.0.1"; + sha256 = "eba93be5a76581585ae33af6babe9c2718fae307d41989cd36a605d9b0e8d16a"; + libraryHaskellDepends = [ base containers hashable hashtables ]; + doHaddock = false; + doCheck = false; + description = "Faux heterogeneous sets"; + license = stdenv.lib.licenses.bsd3; + }) {}; + "HSlippyMap" = callPackage + ({ mkDerivation, base, stdenv }: + mkDerivation { + pname = "HSlippyMap"; + version = "3.0.1"; + sha256 = "27eb37f3b1e70780173e732a949776fc0b0ecc5b1ba515c2e239d6545a2beb0d"; + libraryHaskellDepends = [ base ]; + doHaddock = false; + doCheck = false; + homepage = "https://github.com/apeyroux/HSlippyMap"; + description = "OpenStreetMap Slippy Map"; + license = stdenv.lib.licenses.bsd3; + }) {}; + "HStringTemplate" = callPackage + ({ mkDerivation, array, base, blaze-builder, bytestring, containers + , deepseq, directory, filepath, mtl, old-locale, parsec, pretty + , semigroups, stdenv, syb, template-haskell, text, time, void + }: + mkDerivation { + pname = "HStringTemplate"; + version = "0.8.7"; + sha256 = "4f4ea4aa2e45e7c45821b87b0105c201fbadebc2f2d00c211e728403a0af6b0e"; + libraryHaskellDepends = [ + array base blaze-builder bytestring containers deepseq directory + filepath mtl old-locale parsec pretty semigroups syb + template-haskell text time void + ]; + doHaddock = false; + doCheck = false; + description = "StringTemplate implementation in Haskell"; + license = stdenv.lib.licenses.bsd3; + }) {}; + "HSvm" = callPackage + ({ mkDerivation, base, containers, stdenv }: + mkDerivation { + pname = "HSvm"; + version = "0.1.0.3.22"; + sha256 = "8dac8a583c762675f2d64138303618f017d6be95d59e60774ea7cbfc040dab04"; + libraryHaskellDepends = [ base containers ]; + doHaddock = false; + doCheck = false; + description = "Haskell Bindings for libsvm"; + license = stdenv.lib.licenses.bsd3; + }) {}; + "HTF" = callPackage + ({ mkDerivation, aeson, array, base, base64-bytestring, bytestring + , containers, cpphs, Diff, directory, haskell-src, HUnit + , lifted-base, monad-control, mtl, old-time, pretty, process + , QuickCheck, random, regex-compat, stdenv, text, time, unix + , vector, xmlgen + }: + mkDerivation { + pname = "HTF"; + version = "0.13.2.4"; + sha256 = "36c5cafd35683c37379a93098dea61e6194aa1b9cfd0cdad4e0f1643f4cf2bf6"; + isLibrary = true; + isExecutable = true; + libraryHaskellDepends = [ + aeson array base base64-bytestring bytestring containers cpphs Diff + directory haskell-src HUnit lifted-base monad-control mtl old-time + pretty process QuickCheck random regex-compat text time unix vector + xmlgen + ]; + executableHaskellDepends = [ + array base cpphs directory HUnit mtl old-time random text + ]; + doHaddock = false; + doCheck = false; + homepage = "https://github.com/skogsbaer/HTF/"; + description = "The Haskell Test Framework"; + license = stdenv.lib.licenses.lgpl21; + }) {}; + "HTTP" = callPackage + ({ mkDerivation, array, base, bytestring, mtl, network, network-uri + , parsec, stdenv, time + }: + mkDerivation { + pname = "HTTP"; + version = "4000.3.12"; + sha256 = "a3ff6a9c93771079121083f1691188fe45f84380118e0f76bc4578153c361990"; + revision = "2"; + editedCabalFile = "1gw6xzp1n4gsqwnbfr29ds8v4wpk78b2bha8i108dqav97viwm8c"; + libraryHaskellDepends = [ + array base bytestring mtl network network-uri parsec time + ]; + doHaddock = false; + doCheck = false; + homepage = "https://github.com/haskell/HTTP"; + description = "A library for client-side HTTP"; + license = stdenv.lib.licenses.bsd3; + }) {}; + "HUnit" = callPackage + ({ mkDerivation, base, call-stack, deepseq, stdenv }: + mkDerivation { + pname = "HUnit"; + version = "1.6.0.0"; + sha256 = "7448e6b966e98e84b7627deba23f71b508e9a61e7bc571d74304a25d30e6d0de"; + libraryHaskellDepends = [ base call-stack deepseq ]; + doHaddock = false; + doCheck = false; + homepage = "https://github.com/hspec/HUnit#readme"; + description = "A unit testing framework for Haskell"; + license = stdenv.lib.licenses.bsd3; + }) {}; + "HUnit-approx" = callPackage + ({ mkDerivation, base, call-stack, HUnit, stdenv }: + mkDerivation { + pname = "HUnit-approx"; + version = "1.1.1.1"; + sha256 = "4a4327d328bb8b944c73ec211dd29e953e477f99fd3f9e28fe5200f02fa62baf"; + libraryHaskellDepends = [ base call-stack HUnit ]; + doHaddock = false; + doCheck = false; + homepage = "https://github.com/goldfirere/HUnit-approx"; + description = "Approximate equality for floating point numbers with HUnit"; + license = stdenv.lib.licenses.bsd3; + }) {}; + "HaTeX" = callPackage + ({ mkDerivation, base, bytestring, containers, hashable, matrix + , parsec, QuickCheck, stdenv, text, transformers, wl-pprint-extras + }: + mkDerivation { + pname = "HaTeX"; + version = "3.19.0.0"; + sha256 = "1fd977a582f44a62dafe32ad72acde8c0c01b0ae0ce5f7d6bbc4d91b68e24749"; + libraryHaskellDepends = [ + base bytestring containers hashable matrix parsec QuickCheck text + transformers wl-pprint-extras + ]; + doHaddock = false; + doCheck = false; + homepage = "https://github.com/Daniel-Diaz/HaTeX/blob/master/README.md"; + description = "The Haskell LaTeX library"; + license = stdenv.lib.licenses.bsd3; + }) {}; + "HandsomeSoup" = callPackage + ({ mkDerivation, base, containers, HTTP, hxt, hxt-http, mtl + , network, network-uri, parsec, stdenv, transformers + }: + mkDerivation { + pname = "HandsomeSoup"; + version = "0.4.2"; + sha256 = "0ae2dad3fbde1efee9e45b84b2aeb5b526cc7b3ea2cbc5715494f7bde3ceeefb"; + isLibrary = true; + isExecutable = true; + enableSeparateDataOutput = true; + libraryHaskellDepends = [ + base containers HTTP hxt hxt-http mtl network network-uri parsec + transformers + ]; + doHaddock = false; + doCheck = false; + homepage = "https://github.com/egonSchiele/HandsomeSoup"; + description = "Work with HTML more easily in HXT"; + license = stdenv.lib.licenses.bsd3; + }) {}; + "HaskellNet" = callPackage + ({ mkDerivation, array, base, base64-string, bytestring, cryptohash + , mime-mail, mtl, network, old-time, pretty, stdenv, text + }: + mkDerivation { + pname = "HaskellNet"; + version = "0.5.1"; + sha256 = "3245d31ad76f9f9013a2f6e2285d73ed37376eeb073c100b9a6d19e87f0ca838"; + libraryHaskellDepends = [ + array base base64-string bytestring cryptohash mime-mail mtl + network old-time pretty text + ]; + doHaddock = false; + doCheck = false; + homepage = "https://github.com/jtdaugherty/HaskellNet"; + description = "Client support for POP3, SMTP, and IMAP"; + license = stdenv.lib.licenses.bsd3; + }) {}; + "HaskellNet-SSL" = callPackage + ({ mkDerivation, base, bytestring, connection, data-default + , HaskellNet, network, stdenv, tls + }: + mkDerivation { + pname = "HaskellNet-SSL"; + version = "0.3.4.0"; + sha256 = "83ae92547fd5d52b5b74402101ec254423abeac0c0725e14a112d6ffc843040f"; + enableSeparateDataOutput = true; + libraryHaskellDepends = [ + base bytestring connection data-default HaskellNet network tls + ]; + doHaddock = false; + doCheck = false; + homepage = "https://github.com/dpwright/HaskellNet-SSL"; + description = "Helpers to connect to SSL/TLS mail servers with HaskellNet"; + license = stdenv.lib.licenses.bsd3; + }) {}; + "Hoed" = callPackage + ({ mkDerivation, array, base, bytestring, cereal, cereal-text + , cereal-vector, clock, containers, deepseq, directory, hashable + , libgraph, open-browser, primitive, process, QuickCheck + , regex-tdfa, regex-tdfa-text, semigroups, stdenv, strict + , template-haskell, terminal-size, text, transformers, uniplate + , unordered-containers, vector, vector-th-unbox + }: + mkDerivation { + pname = "Hoed"; + version = "0.5.1"; + sha256 = "a8f6dc9717e15642f00cd84a8d1030ac6a7c7870f7015e380bd728a843c3f4e7"; + libraryHaskellDepends = [ + array base bytestring cereal cereal-text cereal-vector clock + containers deepseq directory hashable libgraph open-browser + primitive process QuickCheck regex-tdfa regex-tdfa-text semigroups + strict template-haskell terminal-size text transformers uniplate + unordered-containers vector vector-th-unbox + ]; + doHaddock = false; + doCheck = false; + homepage = "https://github.com/MaartenFaddegon/Hoed"; + description = "Lightweight algorithmic debugging"; + license = stdenv.lib.licenses.bsd3; + }) {}; + "HsOpenSSL" = callPackage + ({ mkDerivation, base, bytestring, Cabal, network, openssl, stdenv + , time + }: + mkDerivation { + pname = "HsOpenSSL"; + version = "0.11.4.14"; + sha256 = "443d0271b24dbc6cb1736994f6e8c290ce502909738f4e03879b27d30bb47489"; + setupHaskellDepends = [ base Cabal ]; + libraryHaskellDepends = [ base bytestring network time ]; + librarySystemDepends = [ openssl ]; + doHaddock = false; + doCheck = false; + homepage = "https://github.com/vshabanov/HsOpenSSL"; + description = "Partial OpenSSL binding for Haskell"; + license = stdenv.lib.licenses.publicDomain; + }) {inherit (pkgs) openssl;}; + "HsOpenSSL-x509-system" = callPackage + ({ mkDerivation, base, bytestring, HsOpenSSL, stdenv, unix }: + mkDerivation { + pname = "HsOpenSSL-x509-system"; + version = "0.1.0.3"; + sha256 = "5bdcb7ae2faba07a374109fea0a1431ae09d080f8574e60ab7a351b46f931f92"; + libraryHaskellDepends = [ base bytestring HsOpenSSL unix ]; + doHaddock = false; + doCheck = false; + homepage = "https://github.com/redneb/HsOpenSSL-x509-system"; + description = "Use the system's native CA certificate store with HsOpenSSL"; + license = stdenv.lib.licenses.bsd3; + }) {}; + "IPv6Addr" = callPackage + ({ mkDerivation, aeson, attoparsec, base, iproute, network + , network-info, random, stdenv, text + }: + mkDerivation { + pname = "IPv6Addr"; + version = "1.1.0"; + sha256 = "494c10e6bacf79b35a0601b056bb89b82902c10ca3b9b3de41d8971ddf64ed38"; + libraryHaskellDepends = [ + aeson attoparsec base iproute network network-info random text + ]; + doHaddock = false; + doCheck = false; + homepage = "https://github.com/MichelBoucey/IPv6Addr"; + description = "Library to deal with IPv6 address text representations"; + license = stdenv.lib.licenses.bsd3; + }) {}; + "Imlib" = callPackage + ({ mkDerivation, array, base, imlib2, stdenv, X11 }: + mkDerivation { + pname = "Imlib"; + version = "0.1.2"; + sha256 = "3ed318a7777a3b0752327b7b128edb3a1d562202b480a6d6b793b79ed90ebd1c"; + libraryHaskellDepends = [ array base X11 ]; + librarySystemDepends = [ imlib2 ]; + doHaddock = false; + doCheck = false; + license = stdenv.lib.licenses.bsd3; + }) {inherit (pkgs) imlib2;}; + "IntervalMap" = callPackage + ({ mkDerivation, base, containers, deepseq, stdenv }: + mkDerivation { + pname = "IntervalMap"; + version = "0.6.0.0"; + sha256 = "8f7d0d81c23a2d2dc7e7333b82824070a53144d40e08741456c8afe078b2111a"; + libraryHaskellDepends = [ base containers deepseq ]; + doHaddock = false; + doCheck = false; + homepage = "http://www.chr-breitkopf.de/comp/IntervalMap"; + description = "Containers for intervals, with efficient search"; + license = stdenv.lib.licenses.bsd3; + }) {}; + "JuicyPixels" = callPackage + ({ mkDerivation, base, binary, bytestring, containers, deepseq, mtl + , primitive, stdenv, transformers, vector, zlib + }: + mkDerivation { + pname = "JuicyPixels"; + version = "3.2.9.5"; + sha256 = "849c6cf4a613f906f7e553a1baefe9c0dc61c13b41a5f5b9605cf80e328cc355"; + libraryHaskellDepends = [ + base binary bytestring containers deepseq mtl primitive + transformers vector zlib + ]; + doHaddock = false; + doCheck = false; + homepage = "https://github.com/Twinside/Juicy.Pixels"; + description = "Picture loading/serialization (in png, jpeg, bitmap, gif, tga, tiff and radiance)"; + license = stdenv.lib.licenses.bsd3; + }) {}; + "JuicyPixels-blp" = callPackage + ({ mkDerivation, attoparsec, base, binary, bytestring, directory + , filepath, hashable, JuicyPixels, optparse-simple, stdenv + , text-show, unordered-containers, vector + }: + mkDerivation { + pname = "JuicyPixels-blp"; + version = "0.1.0.1"; + sha256 = "2c8e0773e41fb841e90a36fb8c839670d2afebc6b89271f782fc5df250cbcc99"; + isLibrary = true; + isExecutable = true; + libraryHaskellDepends = [ + attoparsec base binary bytestring hashable JuicyPixels text-show + vector + ]; + executableHaskellDepends = [ + base bytestring directory filepath JuicyPixels optparse-simple + text-show unordered-containers + ]; + doHaddock = false; + doCheck = false; + homepage = "http://github.com/NCrashed/JuicyPixels-blp#readme"; + description = "BLP format decoder/encoder over JuicyPixels library"; + license = stdenv.lib.licenses.bsd3; + }) {}; + "JuicyPixels-extra" = callPackage + ({ mkDerivation, base, JuicyPixels, stdenv }: + mkDerivation { + pname = "JuicyPixels-extra"; + version = "0.3.0"; + sha256 = "c5a03a9747bcd984924d6f7c9b4771188e297df82160e7d667ea8f4f671b0e22"; + revision = "3"; + editedCabalFile = "1xr4vjhzjw3ynibb6693dhcz2jbvbx4yg2bir8w2s98n37gwsxd7"; + enableSeparateDataOutput = true; + libraryHaskellDepends = [ base JuicyPixels ]; + doHaddock = false; + doCheck = false; + homepage = "https://github.com/mrkkrp/JuicyPixels-extra"; + description = "Efficiently scale, crop, flip images with JuicyPixels"; + license = stdenv.lib.licenses.bsd3; + }) {}; + "JuicyPixels-scale-dct" = callPackage + ({ mkDerivation, base, base-compat, carray, fft, JuicyPixels + , stdenv + }: + mkDerivation { + pname = "JuicyPixels-scale-dct"; + version = "0.1.2"; + sha256 = "f7381b88446224897e6677692bbdc39cb5b755216212f0ad8050046865cd3013"; + revision = "2"; + editedCabalFile = "0pp67ygrd3m6q8ry5229m1b2rhy401gb74368h09bqc6wa3g7ygv"; + libraryHaskellDepends = [ + base base-compat carray fft JuicyPixels + ]; + doHaddock = false; + doCheck = false; + homepage = "https://github.com/phadej/JuicyPixels-scale-dct#readme"; + description = "Scale JuicyPixels images with DCT"; + license = stdenv.lib.licenses.bsd3; + }) {}; + "LambdaHack" = callPackage + ({ mkDerivation, assert-failure, async, base, base-compat, binary + , bytestring, containers, deepseq, directory, enummapset, filepath + , ghc-prim, hashable, hsini, keys, miniutter, optparse-applicative + , pretty-show, random, sdl2, sdl2-ttf, stdenv, stm + , template-haskell, text, time, transformers, unordered-containers + , vector, vector-binary-instances, zlib + }: + mkDerivation { + pname = "LambdaHack"; + version = "0.8.3.0"; + sha256 = "5a9b23a893ba809d8f7ff1ef810d4d542fcd7419876aef4208cf237a3662076c"; + isLibrary = true; + isExecutable = true; + enableSeparateDataOutput = true; + libraryHaskellDepends = [ + assert-failure async base base-compat binary bytestring containers + deepseq directory enummapset filepath ghc-prim hashable hsini keys + miniutter optparse-applicative pretty-show random sdl2 sdl2-ttf stm + text time transformers unordered-containers vector + vector-binary-instances zlib + ]; + executableHaskellDepends = [ + assert-failure async base base-compat binary bytestring containers + deepseq directory enummapset filepath ghc-prim hashable hsini keys + miniutter optparse-applicative pretty-show random stm + template-haskell text time transformers unordered-containers vector + vector-binary-instances zlib + ]; + doHaddock = false; + doCheck = false; + homepage = "https://lambdahack.github.io"; + description = "A game engine library for tactical squad ASCII roguelike dungeon crawlers"; + license = stdenv.lib.licenses.bsd3; + }) {}; + "LibZip" = callPackage + ({ mkDerivation, base, bindings-libzip, bytestring, filepath, mtl + , stdenv, time, utf8-string + }: + mkDerivation { + pname = "LibZip"; + version = "1.0.1"; + sha256 = "a636e0202d2a3f60d894a814bd9834cf8c62313b67ccc48c295f02a4bebe425f"; + libraryHaskellDepends = [ + base bindings-libzip bytestring filepath mtl time utf8-string + ]; + doHaddock = false; + doCheck = false; + homepage = "http://bitbucket.org/astanin/hs-libzip/"; + description = "Bindings to libzip, a library for manipulating zip archives"; + license = stdenv.lib.licenses.bsd3; + }) {}; + "List" = callPackage + ({ mkDerivation, base, stdenv, transformers }: + mkDerivation { + pname = "List"; + version = "0.6.2"; + sha256 = "c4b92be1202fc59112018f76d5b17cd3a659ebc36384a46e000ab2fbaf99b878"; + revision = "1"; + editedCabalFile = "11ws93cdzz7k4nvcld2d74155mdgcvyi6f6an7gpf9z4k523c11n"; + libraryHaskellDepends = [ base transformers ]; + doHaddock = false; + doCheck = false; + homepage = "http://github.com/yairchu/generator"; + description = "List monad transformer and class"; + license = stdenv.lib.licenses.bsd3; + }) {}; + "ListLike" = callPackage + ({ mkDerivation, array, base, bytestring, containers, deepseq + , dlist, fmlist, stdenv, text, utf8-string, vector + }: + mkDerivation { + pname = "ListLike"; + version = "4.6"; + sha256 = "c1cdec79a5f585a5839eea26a2afe6a37aab5ed2f402a16e7d59fe9a4e925a9a"; + revision = "2"; + editedCabalFile = "1mca2r4gjznqdh4kck5cjkn53isgkhvkf3ri09qsn7nsssvgki0g"; + libraryHaskellDepends = [ + array base bytestring containers deepseq dlist fmlist text + utf8-string vector + ]; + doHaddock = false; + doCheck = false; + homepage = "http://github.com/JohnLato/listlike"; + description = "Generic support for list-like structures"; + license = stdenv.lib.licenses.bsd3; + }) {}; + "MemoTrie" = callPackage + ({ mkDerivation, base, newtype-generics, stdenv }: + mkDerivation { + pname = "MemoTrie"; + version = "0.6.9"; + sha256 = "1d6045b8fdf7b89ed6b495e535613f5091cdfc9cdfe05a862207e76ce205f794"; + isLibrary = true; + isExecutable = true; + libraryHaskellDepends = [ base newtype-generics ]; + doHaddock = false; + doCheck = false; + homepage = "https://github.com/conal/MemoTrie"; + description = "Trie-based memo functions"; + license = stdenv.lib.licenses.bsd3; + }) {}; + "MissingH" = callPackage + ({ mkDerivation, array, base, containers, directory, filepath + , hslogger, HUnit, mtl, network, old-locale, old-time, parsec + , process, random, regex-compat, stdenv, time, unix + }: + mkDerivation { + pname = "MissingH"; + version = "1.4.0.1"; + sha256 = "283f2afd46625d98b4e29f77edadfa5e6009a227812ee2ece10091ad6a7e9b71"; + revision = "1"; + editedCabalFile = "04syc14nz11fay6fm6nlixyflrfhpg4jiyxx6mnxrl6asd3cl989"; + libraryHaskellDepends = [ + array base containers directory filepath hslogger HUnit mtl network + old-locale old-time parsec process random regex-compat time unix + ]; + doHaddock = false; + doCheck = false; + homepage = "http://software.complete.org/missingh"; + description = "Large utility library"; + license = stdenv.lib.licenses.bsd3; + }) {}; + "MonadPrompt" = callPackage + ({ mkDerivation, base, mtl, stdenv }: + mkDerivation { + pname = "MonadPrompt"; + version = "1.0.0.5"; + sha256 = "b012cbbe83650f741c7b7f6eafcc89dec299b0ac74a758b6f3a8cdfc5d3bbeda"; + libraryHaskellDepends = [ base mtl ]; + doHaddock = false; + doCheck = false; + description = "MonadPrompt, implementation & examples"; + license = stdenv.lib.licenses.bsd3; + }) {}; + "MonadRandom" = callPackage + ({ mkDerivation, base, mtl, primitive, random, stdenv, transformers + , transformers-compat + }: + mkDerivation { + pname = "MonadRandom"; + version = "0.5.1.1"; + sha256 = "abda4a297acf197e664695b839b4fb70f53e240f5420489dc21bcf6103958470"; + libraryHaskellDepends = [ + base mtl primitive random transformers transformers-compat + ]; + doHaddock = false; + doCheck = false; + description = "Random-number generation monad"; + license = stdenv.lib.licenses.bsd3; + }) {}; + "MusicBrainz" = callPackage + ({ mkDerivation, aeson, base, bytestring, conduit, conduit-extra + , HTTP, http-conduit, http-types, monad-control, resourcet, stdenv + , text, time, time-locale-compat, transformers, unliftio-core + , vector, xml-conduit, xml-types + }: + mkDerivation { + pname = "MusicBrainz"; + version = "0.4"; + sha256 = "b9cbd130921da38a693abe3f3dd5e58c883b382d0b70c112e625b64158605629"; + libraryHaskellDepends = [ + aeson base bytestring conduit conduit-extra HTTP http-conduit + http-types monad-control resourcet text time time-locale-compat + transformers unliftio-core vector xml-conduit xml-types + ]; + doHaddock = false; + doCheck = false; + homepage = "http://floss.scru.org/hMusicBrainz"; + description = "interface to MusicBrainz XML2 and JSON web services"; + license = stdenv.lib.licenses.gpl3; + }) {}; + "Network-NineP" = callPackage + ({ mkDerivation, base, binary, bytestring, containers, convertible + , exceptions, hslogger, monad-loops, monad-peel, mstate, mtl + , network, NineP, regex-posix, stateref, stdenv, transformers + }: + mkDerivation { + pname = "Network-NineP"; + version = "0.4.3"; + sha256 = "8169e46ddfd690b96f25bc9a577568a363a270c2bddbb9fb3e1e7f1959644ec3"; + isLibrary = true; + isExecutable = true; + libraryHaskellDepends = [ + base binary bytestring containers convertible exceptions hslogger + monad-loops monad-peel mstate mtl network NineP regex-posix + stateref transformers + ]; + doHaddock = false; + doCheck = false; + description = "High-level abstraction over 9P protocol"; + license = "unknown"; + }) {}; + "NineP" = callPackage + ({ mkDerivation, base, binary, stdenv }: + mkDerivation { + pname = "NineP"; + version = "0.0.2.1"; + sha256 = "4bb1516b9fb340118960043e0c72aa62316be8ff3f78cc8c1354e2fac96dd8cc"; + libraryHaskellDepends = [ base binary ]; + doHaddock = false; + doCheck = false; + homepage = "http://9ph.googlecode.com"; + description = "9P2000 in pure Haskell"; + license = stdenv.lib.licenses.bsd3; + }) {}; + "NoHoed" = callPackage + ({ mkDerivation, base, stdenv, template-haskell }: + mkDerivation { + pname = "NoHoed"; + version = "0.1.1"; + sha256 = "9b663a234c034e0049126ae7f06d1756dc496012177bf18548c6d8caeec43b3d"; + libraryHaskellDepends = [ base template-haskell ]; + doHaddock = false; + doCheck = false; + homepage = "https://github.com/pepeiborra/NoHoed"; + description = "Placeholder package to preserve debug ability via conditional builds"; + license = stdenv.lib.licenses.bsd3; + }) {}; + "NumInstances" = callPackage + ({ mkDerivation, base, stdenv }: + mkDerivation { + pname = "NumInstances"; + version = "1.4"; + sha256 = "cbdb2a49346f59ceb5ab38592d7bc52e5205580d431d0ac6d852fd9880e59679"; + libraryHaskellDepends = [ base ]; + doHaddock = false; + doCheck = false; + homepage = "https://github.com/conal/NumInstances"; + description = "Instances of numeric classes for functions and tuples"; + license = stdenv.lib.licenses.bsd3; + }) {}; + "ObjectName" = callPackage + ({ mkDerivation, base, stdenv, transformers }: + mkDerivation { + pname = "ObjectName"; + version = "1.1.0.1"; + sha256 = "72dbef237580fd4e8567de2de752835bbadd3629f486d1586486d49a49aad210"; + libraryHaskellDepends = [ base transformers ]; + doHaddock = false; + doCheck = false; + homepage = "https://github.com/svenpanne/ObjectName"; + description = "Explicitly handled object names"; + license = stdenv.lib.licenses.bsd3; + }) {}; + "OneTuple" = callPackage + ({ mkDerivation, base, stdenv }: + mkDerivation { + pname = "OneTuple"; + version = "0.2.2"; + sha256 = "d82e702485bcbdefbda0d12b6a250d318a269572ee58d63b60eee531e56624dc"; + revision = "1"; + editedCabalFile = "07jd23glblzmnlw7sn565sk9gm7vj9h459j46bkbcrrxnp0n0myq"; + libraryHaskellDepends = [ base ]; + doHaddock = false; + doCheck = false; + description = "Singleton Tuple"; + license = stdenv.lib.licenses.bsd3; + }) {}; + "Only" = callPackage + ({ mkDerivation, base, deepseq, stdenv }: + mkDerivation { + pname = "Only"; + version = "0.1"; + sha256 = "ab7aa193e8c257d3bda6b0b3c1cbcf74cdaa85ab08cb20c2dd62ba248c1ab265"; + revision = "1"; + editedCabalFile = "1ahk7p34kmh041mz7lyc10nhcxgv2i4z8nvzxvqm2x34gslmsbzr"; + libraryHaskellDepends = [ base deepseq ]; + doHaddock = false; + doCheck = false; + description = "The 1-tuple type or single-value \"collection\""; + license = stdenv.lib.licenses.bsd3; + }) {}; + "OpenAL" = callPackage + ({ mkDerivation, base, ObjectName, openal, OpenGL, StateVar, stdenv + , transformers + }: + mkDerivation { + pname = "OpenAL"; + version = "1.7.0.4"; + sha256 = "3989f6c4fe437843551004dd011c4308bf63d787ae4fbb8ce71d44b1b0b1f118"; + isLibrary = true; + isExecutable = true; + libraryHaskellDepends = [ + base ObjectName OpenGL StateVar transformers + ]; + librarySystemDepends = [ openal ]; + doHaddock = false; + doCheck = false; + homepage = "https://github.com/haskell-openal/ALUT"; + description = "A binding to the OpenAL cross-platform 3D audio API"; + license = stdenv.lib.licenses.bsd3; + }) {inherit (pkgs) openal;}; + "OpenGL" = callPackage + ({ mkDerivation, base, bytestring, containers, GLURaw, ObjectName + , OpenGLRaw, StateVar, stdenv, text, transformers + }: + mkDerivation { + pname = "OpenGL"; + version = "3.0.2.1"; + sha256 = "7acb891b911de8bb6933afeaa7f8c5291cc986da5557c922c0fc1717c5a559bf"; + libraryHaskellDepends = [ + base bytestring containers GLURaw ObjectName OpenGLRaw StateVar + text transformers + ]; + doHaddock = false; + doCheck = false; + homepage = "http://www.haskell.org/haskellwiki/Opengl"; + description = "A binding for the OpenGL graphics system"; + license = stdenv.lib.licenses.bsd3; + }) {}; + "OpenGLRaw" = callPackage + ({ mkDerivation, base, bytestring, containers, fixed, half, libGL + , stdenv, text, transformers + }: + mkDerivation { + pname = "OpenGLRaw"; + version = "3.3.0.1"; + sha256 = "d889e4040791957157f001d0236c148f531a45007a2215b7e03adbad90baf14b"; + libraryHaskellDepends = [ + base bytestring containers fixed half text transformers + ]; + librarySystemDepends = [ libGL ]; + doHaddock = false; + doCheck = false; + homepage = "http://www.haskell.org/haskellwiki/Opengl"; + description = "A raw binding for the OpenGL graphics system"; + license = stdenv.lib.licenses.bsd3; + }) {inherit (pkgs) libGL;}; + "ParsecTools" = callPackage + ({ mkDerivation, base, parsec, stdenv }: + mkDerivation { + pname = "ParsecTools"; + version = "0.0.2.0"; + sha256 = "ef4843353127aa3e6f6ab0aece9f4245225d375802921e151a1751d797857a87"; + libraryHaskellDepends = [ base parsec ]; + doHaddock = false; + doCheck = false; + description = "Parsec combinators for more complex objects"; + license = stdenv.lib.licenses.gpl3; + }) {}; + "QuasiText" = callPackage + ({ mkDerivation, attoparsec, base, haskell-src-meta, stdenv + , template-haskell, text, th-lift-instances + }: + mkDerivation { + pname = "QuasiText"; + version = "0.1.2.6"; + sha256 = "e801d269e25263645ee66fc090040fe9b9c8a8e5bf10485801dd7a5a30e0f119"; + libraryHaskellDepends = [ + attoparsec base haskell-src-meta template-haskell text + th-lift-instances + ]; + doHaddock = false; + doCheck = false; + homepage = "https://github.com/mikeplus64/QuasiText"; + description = "A QuasiQuoter for Text"; + license = stdenv.lib.licenses.bsd3; + }) {}; + "QuickCheck" = callPackage + ({ mkDerivation, base, containers, deepseq, random, stdenv + , template-haskell, tf-random, transformers + }: + mkDerivation { + pname = "QuickCheck"; + version = "2.11.3"; + sha256 = "488c5652139da0bac8b3e7d76f11320ded298549e62db530938bfee9ca981876"; + libraryHaskellDepends = [ + base containers deepseq random template-haskell tf-random + transformers + ]; + doHaddock = false; + doCheck = false; + homepage = "https://github.com/nick8325/quickcheck"; + description = "Automatic testing of Haskell programs"; + license = stdenv.lib.licenses.bsd3; + }) {}; + "RSA" = callPackage + ({ mkDerivation, base, binary, bytestring, crypto-api + , crypto-pubkey-types, SHA, stdenv + }: + mkDerivation { + pname = "RSA"; + version = "2.3.0"; + sha256 = "eee76dc7f9dd2d2cdeb014af728ff56f2f5d2908212bd3bb8c5e89f5c6485333"; + libraryHaskellDepends = [ + base binary bytestring crypto-api crypto-pubkey-types SHA + ]; + doHaddock = false; + doCheck = false; + description = "Implementation of RSA, using the padding schemes of PKCS#1 v2.1."; + license = stdenv.lib.licenses.bsd3; + }) {}; + "Rasterific" = callPackage + ({ mkDerivation, base, bytestring, containers, dlist, FontyFruity + , free, JuicyPixels, mtl, primitive, stdenv, transformers, vector + , vector-algorithms + }: + mkDerivation { + pname = "Rasterific"; + version = "0.7.3"; + sha256 = "fd0a8770acaf2c594b64aafd15e8288ec5af370d901ac03a933b642deb802279"; + libraryHaskellDepends = [ + base bytestring containers dlist FontyFruity free JuicyPixels mtl + primitive transformers vector vector-algorithms + ]; + doHaddock = false; + doCheck = false; + description = "A pure haskell drawing engine"; + license = stdenv.lib.licenses.bsd3; + }) {}; + "RefSerialize" = callPackage + ({ mkDerivation, base, binary, bytestring, containers, hashtables + , stdenv, stringsearch + }: + mkDerivation { + pname = "RefSerialize"; + version = "0.4.0"; + sha256 = "05b25eb1ab943d96119aa2acca678fc8f194c3411af521e3835f4de5c752bbb2"; + libraryHaskellDepends = [ + base binary bytestring containers hashtables stringsearch + ]; + doHaddock = false; + doCheck = false; + description = "Write to and read from ByteStrings maintaining internal memory references"; + license = stdenv.lib.licenses.bsd3; + }) {}; + "SCalendar" = callPackage + ({ mkDerivation, base, containers, stdenv, text, time }: + mkDerivation { + pname = "SCalendar"; + version = "1.1.0"; + sha256 = "4971bf6df45953434088ba50d0e17dcc49a0e4c2dd37ad06385c1f87d87b348d"; + libraryHaskellDepends = [ base containers text time ]; + doHaddock = false; + doCheck = false; + homepage = "https://www.researchgate.net/publication/311582722_Method_of_Managing_Resources_in_a_Telecommunication_Network_or_a_Computing_System"; + description = "This is a library for handling calendars and resource availability based on the \"top-nodes algorithm\" and set operations"; + license = stdenv.lib.licenses.mit; + }) {}; + "SHA" = callPackage + ({ mkDerivation, array, base, binary, bytestring, stdenv }: + mkDerivation { + pname = "SHA"; + version = "1.6.4.4"; + sha256 = "6bd950df6b11a3998bb1452d875d2da043ee43385459afc5f16d471d25178b44"; + isLibrary = true; + isExecutable = true; + libraryHaskellDepends = [ array base binary bytestring ]; + doHaddock = false; + doCheck = false; + description = "Implementations of the SHA suite of message digest functions"; + license = stdenv.lib.licenses.bsd3; + }) {}; + "STMonadTrans" = callPackage + ({ mkDerivation, array, base, mtl, stdenv }: + mkDerivation { + pname = "STMonadTrans"; + version = "0.4.3"; + sha256 = "574fd56cf74036c20d00a09d815659dbbb0ae51c8103d00c93cd9558ad3322db"; + revision = "1"; + editedCabalFile = "09kqrv9a4yhsdpix49h9qjw0j2fhxrgkjnfrnyxg1nspmqrvl50m"; + libraryHaskellDepends = [ array base mtl ]; + doHaddock = false; + doCheck = false; + description = "A monad transformer version of the ST monad"; + license = stdenv.lib.licenses.bsd3; + }) {}; + "SVGFonts" = callPackage + ({ mkDerivation, attoparsec, base, blaze-markup, blaze-svg + , bytestring, cereal, cereal-vector, containers, data-default-class + , diagrams-core, diagrams-lib, directory, parsec, split, stdenv + , text, vector, xml + }: + mkDerivation { + pname = "SVGFonts"; + version = "1.7"; + sha256 = "da3ccd65e0963473df035f4543b56dfc84b45edca540990050e5de444fa431cd"; + enableSeparateDataOutput = true; + libraryHaskellDepends = [ + attoparsec base blaze-markup blaze-svg bytestring cereal + cereal-vector containers data-default-class diagrams-core + diagrams-lib directory parsec split text vector xml + ]; + doHaddock = false; + doCheck = false; + description = "Fonts from the SVG-Font format"; + license = stdenv.lib.licenses.bsd3; + }) {}; + "SafeSemaphore" = callPackage + ({ mkDerivation, base, containers, stdenv, stm }: + mkDerivation { + pname = "SafeSemaphore"; + version = "0.10.1"; + sha256 = "21e5b737a378cae9e1faf85cab015316d4c84d4b37e6d9d202111cef8c4cef66"; + revision = "1"; + editedCabalFile = "1k61gqgfh6n3sj8ni8sfvpcm39nqc2msjfxk2pgmhfabvv48w5hv"; + libraryHaskellDepends = [ base containers stm ]; + doHaddock = false; + doCheck = false; + homepage = "https://github.com/ChrisKuklewicz/SafeSemaphore"; + description = "Much safer replacement for QSemN, QSem, and SampleVar"; + license = stdenv.lib.licenses.bsd3; + }) {}; + "SegmentTree" = callPackage + ({ mkDerivation, base, stdenv }: + mkDerivation { + pname = "SegmentTree"; + version = "0.3"; + sha256 = "6188c1b1276d7fa0391098a563df73dd522d20b57dc5321fe3418a9e3ca84fc1"; + isLibrary = true; + isExecutable = true; + libraryHaskellDepends = [ base ]; + doHaddock = false; + doCheck = false; + description = "Data structure for querying the set (or count) of intervals covering given point"; + license = stdenv.lib.licenses.bsd3; + }) {}; + "ShellCheck" = callPackage + ({ mkDerivation, aeson, base, bytestring, Cabal, containers + , directory, mtl, parsec, process, QuickCheck, regex-tdfa, stdenv + }: + mkDerivation { + pname = "ShellCheck"; + version = "0.5.0"; + sha256 = "2b9430736f48de17a60c035546a6a969c14392521bec30119e1c869017d3307c"; + isLibrary = true; + isExecutable = true; + setupHaskellDepends = [ base Cabal process ]; + libraryHaskellDepends = [ + aeson base bytestring containers directory mtl parsec process + QuickCheck regex-tdfa + ]; + executableHaskellDepends = [ + aeson base bytestring containers directory mtl parsec QuickCheck + regex-tdfa + ]; + doHaddock = false; + doCheck = false; + homepage = "https://www.shellcheck.net/"; + description = "Shell script analysis tool"; + license = stdenv.lib.licenses.gpl3; + }) {}; + "Spintax" = callPackage + ({ mkDerivation, attoparsec, base, extra, mtl, mwc-random, stdenv + , text + }: + mkDerivation { + pname = "Spintax"; + version = "0.3.3"; + sha256 = "21df2193bf1216d55a0d43691182125993eeadc6f097eaf5eb995c23f2016b13"; + libraryHaskellDepends = [ + attoparsec base extra mtl mwc-random text + ]; + doHaddock = false; + doCheck = false; + homepage = "https://github.com/MichelBoucey/spintax"; + description = "Random text generation based on spintax"; + license = stdenv.lib.licenses.bsd3; + }) {}; + "StateVar" = callPackage + ({ mkDerivation, base, stdenv, stm, transformers }: + mkDerivation { + pname = "StateVar"; + version = "1.1.1.0"; + sha256 = "1a89cd2632c2fc384b4c71fdc12894cc1c3902badbf4771497437e4044274e80"; + libraryHaskellDepends = [ base stm transformers ]; + doHaddock = false; + doCheck = false; + homepage = "https://github.com/haskell-opengl/StateVar"; + description = "State variables"; + license = stdenv.lib.licenses.bsd3; + }) {}; + "Strafunski-StrategyLib" = callPackage + ({ mkDerivation, base, directory, mtl, stdenv, syb, transformers }: + mkDerivation { + pname = "Strafunski-StrategyLib"; + version = "5.0.1.0"; + sha256 = "a018c7420289a381d2b491a753f685b9d691be07cea99855cc5c8e05d5a9a295"; + revision = "1"; + editedCabalFile = "1hngxq1f7fybg6ixkdhmvgsw608mhnxkwbw04ql5zspcfl78v6l2"; + libraryHaskellDepends = [ base directory mtl syb transformers ]; + doHaddock = false; + doCheck = false; + description = "Library for strategic programming"; + license = stdenv.lib.licenses.bsd3; + }) {}; + "TCache" = callPackage + ({ mkDerivation, base, bytestring, containers, directory + , hashtables, mtl, old-time, RefSerialize, stdenv, stm, text + }: + mkDerivation { + pname = "TCache"; + version = "0.12.1"; + sha256 = "f134b45fcdd127fa1a4214f01d44dc34e994fed137cec63f4c4ea632363ab7bd"; + libraryHaskellDepends = [ + base bytestring containers directory hashtables mtl old-time + RefSerialize stm text + ]; + doHaddock = false; + doCheck = false; + description = "A Transactional cache with user-defined persistence"; + license = stdenv.lib.licenses.bsd3; + }) {}; + "ViennaRNAParser" = callPackage + ({ mkDerivation, base, parsec, ParsecTools, process, stdenv + , transformers + }: + mkDerivation { + pname = "ViennaRNAParser"; + version = "1.3.3"; + sha256 = "7ee941d106b8b0c57e1ca5104d19b94215721e4a7b8aeb53fa353d246efbaefe"; + libraryHaskellDepends = [ + base parsec ParsecTools process transformers + ]; + doHaddock = false; + doCheck = false; + description = "Libary for parsing ViennaRNA package output"; + license = stdenv.lib.licenses.gpl3; + }) {}; + "Win32-notify" = callPackage + ({ mkDerivation, base, containers, directory, stdenv, Win32 }: + mkDerivation { + pname = "Win32-notify"; + version = "0.3.0.3"; + sha256 = "0c21dbe06cb1ce3b3e5f1aace0b7ee359b36e7cb057f8fe2c28c943150044116"; + isLibrary = true; + isExecutable = true; + libraryHaskellDepends = [ base containers directory Win32 ]; + doHaddock = false; + doCheck = false; + description = "A binding to part of the Win32 library for file notification"; + license = stdenv.lib.licenses.bsd3; + }) {}; + "X11" = callPackage + ({ mkDerivation, base, data-default, libX11, libXext, libXinerama + , libXrandr, libXrender, libXScrnSaver, stdenv + }: + mkDerivation { + pname = "X11"; + version = "1.9"; + sha256 = "10138e863d8c6f860aad1755a6f1a36949cc02d83e5afacf6677fb3999f10db9"; + libraryHaskellDepends = [ base data-default ]; + librarySystemDepends = [ + libX11 libXext libXinerama libXrandr libXrender libXScrnSaver + ]; + doHaddock = false; + doCheck = false; + homepage = "https://github.com/xmonad/X11"; + description = "A binding to the X11 graphics library"; + license = stdenv.lib.licenses.bsd3; + }) {inherit (pkgs.xorg) libXScrnSaver; inherit (pkgs.xorg) libXext; +inherit (pkgs.xorg) libXinerama; inherit (pkgs.xorg) libXrender;}; + "X11-xft" = callPackage + ({ mkDerivation, base, libXft, stdenv, utf8-string, X11 }: + mkDerivation { + pname = "X11-xft"; + version = "0.3.1"; + sha256 = "4eba3fee62570e06447654030a62fb55f19587884bc2cef77a9c3b2c3458f8d1"; + libraryHaskellDepends = [ base utf8-string X11 ]; + libraryPkgconfigDepends = [ libXft ]; + doHaddock = false; + doCheck = false; + description = "Bindings to the Xft, X Free Type interface library, and some Xrender parts"; + license = "LGPL"; + }) {}; + "Xauth" = callPackage + ({ mkDerivation, base, libXau, stdenv }: + mkDerivation { + pname = "Xauth"; + version = "0.1"; + sha256 = "ba332dea9ec152b3f676d22461eee81a657e16987c3dfb8249e9dbe0cda56ed7"; + libraryHaskellDepends = [ base ]; + libraryPkgconfigDepends = [ libXau ]; + doHaddock = false; + doCheck = false; + description = "A binding to the X11 authentication library"; + license = stdenv.lib.licenses.bsd3; + }) {}; + "abstract-deque" = callPackage + ({ mkDerivation, array, base, containers, random, stdenv, time }: + mkDerivation { + pname = "abstract-deque"; + version = "0.3"; + sha256 = "09aa10f38193a8275a7791b92a4f3a7192a304874637e2a35c897dde25d75ca2"; + libraryHaskellDepends = [ array base containers random time ]; + doHaddock = false; + doCheck = false; + homepage = "https://github.com/rrnewton/haskell-lockfree/wiki"; + description = "Abstract, parameterized interface to mutable Deques"; + license = stdenv.lib.licenses.bsd3; + }) {}; + "abstract-deque-tests" = callPackage + ({ mkDerivation, abstract-deque, array, base, containers, HUnit + , random, stdenv, test-framework, test-framework-hunit, time + }: + mkDerivation { + pname = "abstract-deque-tests"; + version = "0.3"; + sha256 = "5f17fb4cc26559f81c777f494622907e8927181175eaa172fb6adbf14b2feba5"; + libraryHaskellDepends = [ + abstract-deque array base containers HUnit random test-framework + test-framework-hunit time + ]; + doHaddock = false; + doCheck = false; + homepage = "https://github.com/rrnewton/haskell-lockfree/wiki"; + description = "A test-suite for any queue or double-ended queue satisfying an interface"; + license = stdenv.lib.licenses.bsd3; + }) {}; + "abstract-par" = callPackage + ({ mkDerivation, base, deepseq, stdenv }: + mkDerivation { + pname = "abstract-par"; + version = "0.3.3"; + sha256 = "248a8739bd902462cb16755b690b55660e196e58cc7e6ef8157a72c2a3d5d860"; + libraryHaskellDepends = [ base deepseq ]; + doHaddock = false; + doCheck = false; + homepage = "https://github.com/simonmar/monad-par"; + description = "Type classes generalizing the functionality of the 'monad-par' library"; + license = stdenv.lib.licenses.bsd3; + }) {}; + "accuerr" = callPackage + ({ mkDerivation, base, bifunctors, lens, semigroups, stdenv }: + mkDerivation { + pname = "accuerr"; + version = "0.2.0.2"; + sha256 = "4f6a8230d2ad3bc274dea234208ce4f5282e2d9413a5da1f5505fc55a2fa9a36"; + libraryHaskellDepends = [ base bifunctors lens semigroups ]; + doHaddock = false; + doCheck = false; + homepage = "http://www.github.com/massysett/accuerr"; + description = "Data type like Either but with accumulating error type"; + license = stdenv.lib.licenses.bsd3; + }) {}; + "ace" = callPackage + ({ mkDerivation, attoparsec, base, blaze-html, blaze-markup + , data-default, parsec, stdenv, text + }: + mkDerivation { + pname = "ace"; + version = "0.6"; + sha256 = "d3472b659d26cf7ea9afa207ec24ac0314598de997722e636e9bfa24b3900738"; + libraryHaskellDepends = [ + attoparsec base blaze-html blaze-markup data-default parsec text + ]; + doHaddock = false; + doCheck = false; + description = "Attempto Controlled English parser and printer"; + license = stdenv.lib.licenses.bsd3; + }) {}; + "action-permutations" = callPackage + ({ mkDerivation, base, stdenv }: + mkDerivation { + pname = "action-permutations"; + version = "0.0.0.1"; + sha256 = "a419ee59f996e5305afd96336a561a9fcf26844362eaa32ab6b747a8f9fd1466"; + libraryHaskellDepends = [ base ]; + doHaddock = false; + doCheck = false; + description = "Execute a set of actions (e.g. parsers) in each possible order"; + license = stdenv.lib.licenses.bsd3; + }) {}; + "active" = callPackage + ({ mkDerivation, base, lens, linear, semigroupoids, semigroups + , stdenv, vector + }: + mkDerivation { + pname = "active"; + version = "0.2.0.13"; + sha256 = "5d9a141d58bcefbf699ed233a22309ded671c25ed64bcee11a663d00731280fb"; + revision = "7"; + editedCabalFile = "0z4l6j1q3y5zq4941bsb6ypkhfg3pyvb5gcmasymh2nj9g952xkd"; + libraryHaskellDepends = [ + base lens linear semigroupoids semigroups vector + ]; + doHaddock = false; + doCheck = false; + description = "Abstractions for animation"; + license = stdenv.lib.licenses.bsd3; + }) {}; + "ad" = callPackage + ({ mkDerivation, array, base, Cabal, cabal-doctest, comonad + , containers, data-reify, erf, free, nats, reflection, semigroups + , stdenv, transformers + }: + mkDerivation { + pname = "ad"; + version = "4.3.5"; + sha256 = "9c5e754b1f0ff83490bcc30f5dfa8504de5a34ab8f7be03ac232882940dc8d60"; + revision = "5"; + editedCabalFile = "0yzyfqhsafzaqzj8wmjrj5ghm6jwbxya3wxc9sjl59j9q20jc4nq"; + setupHaskellDepends = [ base Cabal cabal-doctest ]; + libraryHaskellDepends = [ + array base comonad containers data-reify erf free nats reflection + semigroups transformers + ]; + doHaddock = false; + doCheck = false; + homepage = "http://github.com/ekmett/ad"; + description = "Automatic Differentiation"; + license = stdenv.lib.licenses.bsd3; + }) {}; + "adjunctions" = callPackage + ({ mkDerivation, array, base, comonad, containers, contravariant + , distributive, free, mtl, profunctors, semigroupoids, semigroups + , stdenv, tagged, transformers, transformers-compat, void + }: + mkDerivation { + pname = "adjunctions"; + version = "4.4"; + sha256 = "507c2ef55337ae61c805f8cbc1213dfd7d2b85187342675d662254b8d8a16ae9"; + revision = "1"; + editedCabalFile = "0582nnn3fab63nd7ng8smk2c8j7pciiyzfj1na34wqid2hs675as"; + libraryHaskellDepends = [ + array base comonad containers contravariant distributive free mtl + profunctors semigroupoids semigroups tagged transformers + transformers-compat void + ]; + doHaddock = false; + doCheck = false; + homepage = "http://github.com/ekmett/adjunctions/"; + description = "Adjunctions and representable functors"; + license = stdenv.lib.licenses.bsd3; + }) {}; + "adler32" = callPackage + ({ mkDerivation, base, bytestring, stdenv, zlib }: + mkDerivation { + pname = "adler32"; + version = "0.1.2.0"; + sha256 = "26b43c9f389f45ed792698ea4880d24ba56ab61c6f7cae51e582a05e0b5866a4"; + libraryHaskellDepends = [ base bytestring ]; + librarySystemDepends = [ zlib ]; + doHaddock = false; + doCheck = false; + homepage = "https://github.com/redneb/hs-adler32"; + description = "An implementation of Adler-32, supporting rolling checksum operation"; + license = stdenv.lib.licenses.bsd3; + }) {inherit (pkgs) zlib;}; + "aern2-mp" = callPackage + ({ mkDerivation, base, convertible, hmpfr, hspec, integer-gmp + , integer-logarithms, lens, mixed-types-num, QuickCheck, regex-tdfa + , stdenv, template-haskell + }: + mkDerivation { + pname = "aern2-mp"; + version = "0.1.2.0"; + sha256 = "9de6632ad943c044115e713f6c87078f33c37c6bde36ff472a5142a96cf53c8c"; + revision = "1"; + editedCabalFile = "09b92kf60m4v0xn2nm9h8wkg8wr7dc1na5c9mg2lk3kplf60sfvk"; + libraryHaskellDepends = [ + base convertible hmpfr hspec integer-gmp integer-logarithms lens + mixed-types-num QuickCheck regex-tdfa template-haskell + ]; + doHaddock = false; + doCheck = false; + homepage = "https://github.com/michalkonecny/aern2"; + description = "Multi-precision floats via MPFR"; + license = stdenv.lib.licenses.bsd3; + }) {}; + "aern2-real" = callPackage + ({ mkDerivation, aern2-mp, aeson, base, bytestring, containers + , convertible, hspec, lens, mixed-types-num, QuickCheck, random + , stdenv, stm, transformers + }: + mkDerivation { + pname = "aern2-real"; + version = "0.1.1.0"; + sha256 = "25e0428536b401d5a06fd3b169025747663359595b3cfcdb56a042be81d002eb"; + isLibrary = true; + isExecutable = true; + libraryHaskellDepends = [ + aern2-mp aeson base bytestring containers convertible hspec lens + mixed-types-num QuickCheck stm transformers + ]; + executableHaskellDepends = [ + aern2-mp base mixed-types-num QuickCheck random + ]; + doHaddock = false; + doCheck = false; + homepage = "https://github.com/michalkonecny/aern2"; + description = "Exact real numbers via Cauchy sequences and MPFR"; + license = stdenv.lib.licenses.bsd3; + }) {}; + "aeson" = callPackage + ({ mkDerivation, attoparsec, base, base-compat, bytestring + , containers, deepseq, dlist, ghc-prim, hashable, scientific + , stdenv, tagged, template-haskell, text, th-abstraction, time + , time-locale-compat, unordered-containers, uuid-types, vector + }: + mkDerivation { + pname = "aeson"; + version = "1.3.1.1"; + sha256 = "843f302f8186c1ee6e0d9c0630588e4c7fc0f41763333a2d0d4b6f07087a31c4"; + libraryHaskellDepends = [ + attoparsec base base-compat bytestring containers deepseq dlist + ghc-prim hashable scientific tagged template-haskell text + th-abstraction time time-locale-compat unordered-containers + uuid-types vector + ]; + doHaddock = false; + doCheck = false; + homepage = "https://github.com/bos/aeson"; + description = "Fast JSON parsing and encoding"; + license = stdenv.lib.licenses.bsd3; + }) {}; + "aeson-attoparsec" = callPackage + ({ mkDerivation, aeson, attoparsec, base, stdenv }: + mkDerivation { + pname = "aeson-attoparsec"; + version = "0.0.0"; + sha256 = "a5868390477938b3086e820f4a432f9d6a3972454f561fc386520634eec72104"; + libraryHaskellDepends = [ aeson attoparsec base ]; + doHaddock = false; + doCheck = false; + homepage = "https://github.com/athanclark/aeson-attoparsec#readme"; + description = "Embed an Attoparsec text parser into an Aeson parser"; + license = stdenv.lib.licenses.bsd3; + }) {}; + "aeson-better-errors" = callPackage + ({ mkDerivation, aeson, base, bytestring, dlist, mtl, scientific + , stdenv, text, transformers, transformers-compat + , unordered-containers, vector, void + }: + mkDerivation { + pname = "aeson-better-errors"; + version = "0.9.1.0"; + sha256 = "68f001bf055ec7b755d91019f2a0ef136307d157a231acddad6b4cc561f67327"; + libraryHaskellDepends = [ + aeson base bytestring dlist mtl scientific text transformers + transformers-compat unordered-containers vector void + ]; + doHaddock = false; + doCheck = false; + homepage = "https://github.com/hdgarrood/aeson-better-errors"; + description = "Better error messages when decoding JSON values"; + license = stdenv.lib.licenses.mit; + }) {}; + "aeson-casing" = callPackage + ({ mkDerivation, aeson, base, stdenv }: + mkDerivation { + pname = "aeson-casing"; + version = "0.1.0.5"; + sha256 = "cfec563dc6822f035858a7190153d8818c200be565806b43b70f198bf5410577"; + libraryHaskellDepends = [ aeson base ]; + doHaddock = false; + doCheck = false; + description = "Tools to change the formatting of field names in Aeson instances"; + license = stdenv.lib.licenses.mit; + }) {}; + "aeson-compat" = callPackage + ({ mkDerivation, aeson, attoparsec, attoparsec-iso8601, base + , base-compat, bytestring, containers, exceptions, hashable + , scientific, stdenv, tagged, text, time, time-locale-compat + , unordered-containers, vector + }: + mkDerivation { + pname = "aeson-compat"; + version = "0.3.8"; + sha256 = "71e4434abe630c48644ebfc38b4fa04d16600187a8af8921f23f88f9ee089b48"; + revision = "1"; + editedCabalFile = "0ayf5hkhl63lmlxpl7w5zvnz0lvpxb2rwmf0wbslff0y2s449mbf"; + libraryHaskellDepends = [ + aeson attoparsec attoparsec-iso8601 base base-compat bytestring + containers exceptions hashable scientific tagged text time + time-locale-compat unordered-containers vector + ]; + doHaddock = false; + doCheck = false; + homepage = "https://github.com/phadej/aeson-compat#readme"; + description = "Compatibility layer for aeson"; + license = stdenv.lib.licenses.bsd3; + }) {}; + "aeson-diff" = callPackage + ({ mkDerivation, aeson, base, bytestring, edit-distance-vector + , hashable, mtl, optparse-applicative, scientific, stdenv, text + , unordered-containers, vector + }: + mkDerivation { + pname = "aeson-diff"; + version = "1.1.0.5"; + sha256 = "61d9dd60b6c19dd5aa350b85083ebed3eab8d8611893db1279e55e43d7c7fbcf"; + isLibrary = true; + isExecutable = true; + libraryHaskellDepends = [ + aeson base bytestring edit-distance-vector hashable mtl scientific + text unordered-containers vector + ]; + executableHaskellDepends = [ + aeson base bytestring optparse-applicative text + ]; + doHaddock = false; + doCheck = false; + homepage = "https://github.com/thsutton/aeson-diff"; + description = "Extract and apply patches to JSON documents"; + license = stdenv.lib.licenses.bsd3; + }) {}; + "aeson-extra" = callPackage + ({ mkDerivation, aeson, aeson-compat, attoparsec + , attoparsec-iso8601, base, base-compat-batteries, bytestring + , containers, deepseq, exceptions, hashable, parsec + , recursion-schemes, scientific, stdenv, template-haskell, text + , these, time, unordered-containers, vector + }: + mkDerivation { + pname = "aeson-extra"; + version = "0.4.1.1"; + sha256 = "d48a65d976cbf496c8e5e9c927118ffcc878d6a83adf2fc9cebd418186d6fdf8"; + revision = "2"; + editedCabalFile = "1iiibpr8pcdr0bjp0rhf1sxvs0kv66jm01nwlhj4243864qx476r"; + libraryHaskellDepends = [ + aeson aeson-compat attoparsec attoparsec-iso8601 base + base-compat-batteries bytestring containers deepseq exceptions + hashable parsec recursion-schemes scientific template-haskell text + these time unordered-containers vector + ]; + doHaddock = false; + doCheck = false; + homepage = "https://github.com/phadej/aeson-extra#readme"; + description = "Extra goodies for aeson"; + license = stdenv.lib.licenses.bsd3; + }) {}; + "aeson-generic-compat" = callPackage + ({ mkDerivation, aeson, base, stdenv }: + mkDerivation { + pname = "aeson-generic-compat"; + version = "0.0.1.2"; + sha256 = "6308ce74043a47289ee183918a362508677e9dd93fbed2b1033dc5132dca0422"; + libraryHaskellDepends = [ aeson base ]; + doHaddock = false; + doCheck = false; + description = "Compatible generic class names of Aeson"; + license = stdenv.lib.licenses.bsd3; + }) {}; + "aeson-iproute" = callPackage + ({ mkDerivation, aeson, base, iproute, stdenv, text + , unordered-containers + }: + mkDerivation { + pname = "aeson-iproute"; + version = "0.2"; + sha256 = "ee4d53338bfdc4a6ce0039dea24e797a0ff1e22c312b31be2e73ddc0bddf268f"; + libraryHaskellDepends = [ + aeson base iproute text unordered-containers + ]; + doHaddock = false; + doCheck = false; + homepage = "https://github.com/greydot/aeson-iproute"; + description = "Aeson instances for iproute types"; + license = stdenv.lib.licenses.bsd3; + }) {}; + "aeson-picker" = callPackage + ({ mkDerivation, aeson, base, lens, lens-aeson, stdenv, text }: + mkDerivation { + pname = "aeson-picker"; + version = "0.1.0.4"; + sha256 = "b20e23905c395d7b61fce6c5f6343758e3753a2dbee61800d3e15e753ac7c452"; + libraryHaskellDepends = [ aeson base lens lens-aeson text ]; + doHaddock = false; + doCheck = false; + homepage = "https://github.com/ozzzzz/aeson-picker#readme"; + description = "Tiny library to get fields from JSON format"; + license = stdenv.lib.licenses.bsd3; + }) {}; + "aeson-pretty" = callPackage + ({ mkDerivation, aeson, attoparsec, base, base-compat, bytestring + , cmdargs, scientific, stdenv, text, unordered-containers, vector + }: + mkDerivation { + pname = "aeson-pretty"; + version = "0.8.7"; + sha256 = "c1c1ecc5e3abd004a6c4c256ee6f61da2a43d7f1452ffa391dee250df43b27d5"; + isLibrary = true; + isExecutable = true; + libraryHaskellDepends = [ + aeson base base-compat bytestring scientific text + unordered-containers vector + ]; + executableHaskellDepends = [ + aeson attoparsec base bytestring cmdargs + ]; + doHaddock = false; + doCheck = false; + homepage = "http://github.com/informatikr/aeson-pretty"; + description = "JSON pretty-printing library and command-line tool"; + license = stdenv.lib.licenses.bsd3; + }) {}; + "aeson-qq" = callPackage + ({ mkDerivation, aeson, attoparsec, base, base-compat + , haskell-src-meta, parsec, scientific, stdenv, template-haskell + , text, vector + }: + mkDerivation { + pname = "aeson-qq"; + version = "0.8.2"; + sha256 = "6db252c94601efcb1ce395de0084ccf931a3525339ccdca011a740e7b11cc152"; + libraryHaskellDepends = [ + aeson attoparsec base base-compat haskell-src-meta parsec + scientific template-haskell text vector + ]; + doHaddock = false; + doCheck = false; + homepage = "https://github.com/sol/aeson-qq#readme"; + description = "JSON quasiquoter for Haskell"; + license = stdenv.lib.licenses.mit; + }) {}; + "aeson-typescript" = callPackage + ({ mkDerivation, aeson, base, containers, interpolate, mtl, stdenv + , template-haskell, text, th-abstraction, unordered-containers + }: + mkDerivation { + pname = "aeson-typescript"; + version = "0.1.0.6"; + sha256 = "2d9aa1534d2cc86a7f95a5876d7ff28006c34dbead6fb7a03aa86d6f5e310187"; + libraryHaskellDepends = [ + aeson base containers interpolate mtl template-haskell text + th-abstraction unordered-containers + ]; + doHaddock = false; + doCheck = false; + homepage = "https://github.com/codedownio/aeson-typescript#readme"; + description = "Generate TypeScript definition files from your ADTs"; + license = stdenv.lib.licenses.bsd3; + }) {}; + "aeson-utils" = callPackage + ({ mkDerivation, aeson, attoparsec, base, bytestring, scientific + , stdenv, text + }: + mkDerivation { + pname = "aeson-utils"; + version = "0.3.0.2"; + sha256 = "71814b1be8849f945395eb81217a2ad464f2943134c50c09afd8a3126add4b1f"; + revision = "7"; + editedCabalFile = "0lnlmsn5imbapdhbza1175wm04ynn1w75llkhlk1akpanx1dnd15"; + libraryHaskellDepends = [ + aeson attoparsec base bytestring scientific text + ]; + doHaddock = false; + doCheck = false; + description = "Utilities for working with Aeson"; + license = stdenv.lib.licenses.bsd3; + }) {}; + "aeson-yak" = callPackage + ({ mkDerivation, aeson, base, stdenv }: + mkDerivation { + pname = "aeson-yak"; + version = "0.1.1.3"; + sha256 = "af4355bc315a152592e9c06f5cc41bdb5ce7b236d85fe572a292c6bac02faa74"; + libraryHaskellDepends = [ aeson base ]; + doHaddock = false; + doCheck = false; + homepage = "https://github.com/tejon/aeson-yak"; + description = "Handle JSON that may or may not be a list, or exist"; + license = stdenv.lib.licenses.mit; + }) {}; + "al" = callPackage + ({ mkDerivation, base, c2hs, mtl, openal, stdenv }: + mkDerivation { + pname = "al"; + version = "0.1.4.2"; + sha256 = "8bf0f3b3a05ea7b7b8e43da282e1952e5c532ed23247d3384d394cd5046cecd2"; + libraryHaskellDepends = [ base mtl ]; + libraryPkgconfigDepends = [ openal ]; + libraryToolDepends = [ c2hs ]; + doHaddock = false; + doCheck = false; + homepage = "http://github.com/phaazon/al"; + description = "OpenAL 1.1 raw API."; + license = stdenv.lib.licenses.bsd3; + }) {inherit (pkgs) openal;}; + "alarmclock" = callPackage + ({ mkDerivation, async, base, clock, stdenv, stm, time + , unbounded-delays + }: + mkDerivation { + pname = "alarmclock"; + version = "0.5.0.2"; + sha256 = "2574a30897a9a63f09ba97a51f1aead1baeade3cd8b4b063a74d5bb8fa73d64c"; + libraryHaskellDepends = [ + async base clock stm time unbounded-delays + ]; + doHaddock = false; + doCheck = false; + homepage = "https://bitbucket.org/davecturner/alarmclock"; + description = "Wake up and perform an action at a certain time"; + license = stdenv.lib.licenses.bsd3; + }) {}; + "alerts" = callPackage + ({ mkDerivation, base, blaze-html, stdenv, text }: + mkDerivation { + pname = "alerts"; + version = "0.1.0.0"; + sha256 = "52418ed3abfff15e802506e5fb45f56d38eee020cb01af3f0acfe163c470ca68"; + libraryHaskellDepends = [ base blaze-html text ]; + doHaddock = false; + doCheck = false; + homepage = "https://github.com/alx741/alerts#readme"; + description = "Alert messages for web applications"; + license = stdenv.lib.licenses.bsd3; + }) {}; + "alex" = callPackage + ({ mkDerivation, array, base, containers, directory, happy, stdenv + }: + mkDerivation { + pname = "alex"; + version = "3.2.4"; + sha256 = "d58e4d708b14ff332a8a8edad4fa8989cb6a9f518a7c6834e96281ac5f8ff232"; + isLibrary = false; + isExecutable = true; + enableSeparateDataOutput = true; + executableHaskellDepends = [ array base containers directory ]; + executableToolDepends = [ happy ]; + doHaddock = false; + doCheck = false; + homepage = "http://www.haskell.org/alex/"; + description = "Alex is a tool for generating lexical analysers in Haskell"; + license = stdenv.lib.licenses.bsd3; + }) {}; + "alg" = callPackage + ({ mkDerivation, base, stdenv, util }: + mkDerivation { + pname = "alg"; + version = "0.2.5.0"; + sha256 = "dd9344c61dffff753f22af7bdd71d1cfd33245d6b32d5f2c2898a2e208cc9c04"; + libraryHaskellDepends = [ base util ]; + doHaddock = false; + doCheck = false; + description = "Algebraic structures"; + license = stdenv.lib.licenses.bsd3; + }) {}; + "algebra" = callPackage + ({ mkDerivation, adjunctions, array, base, containers, distributive + , mtl, nats, semigroupoids, semigroups, stdenv, tagged + , transformers, void + }: + mkDerivation { + pname = "algebra"; + version = "4.3.1"; + sha256 = "25982f929b6f9930ad4df7b2c4084da473178a6e1f33ccc556ec96ee6f541224"; + libraryHaskellDepends = [ + adjunctions array base containers distributive mtl nats + semigroupoids semigroups tagged transformers void + ]; + doHaddock = false; + doCheck = false; + homepage = "http://github.com/ekmett/algebra/"; + description = "Constructive abstract algebra"; + license = stdenv.lib.licenses.bsd3; + }) {}; + "almost-fix" = callPackage + ({ mkDerivation, base, stdenv }: + mkDerivation { + pname = "almost-fix"; + version = "0.0.2"; + sha256 = "20597d015fe9b6bb6bfcb0eaee3eb58b28e38a1f4f43049ad0aeebcc6409a70f"; + libraryHaskellDepends = [ base ]; + doHaddock = false; + doCheck = false; + description = "Recurse while a predicate is satisfied"; + license = stdenv.lib.licenses.bsd3; + }) {}; + "alsa-core" = callPackage + ({ mkDerivation, alsaLib, base, extensible-exceptions, stdenv }: + mkDerivation { + pname = "alsa-core"; + version = "0.5.0.1"; + sha256 = "eb50495ef05ecc7c06a0147da7f0d3efde832a44d23caaf5172dc114882270ab"; + libraryHaskellDepends = [ base extensible-exceptions ]; + libraryPkgconfigDepends = [ alsaLib ]; + doHaddock = false; + doCheck = false; + homepage = "http://www.haskell.org/haskellwiki/ALSA"; + description = "Binding to the ALSA Library API (Exceptions)"; + license = stdenv.lib.licenses.bsd3; + platforms = [ "i686-linux" "x86_64-linux" ]; + }) {inherit (pkgs) alsaLib;}; + "alsa-pcm" = callPackage + ({ mkDerivation, alsa-core, alsaLib, array, base + , extensible-exceptions, sample-frame, semigroups, stdenv + , storable-record + }: + mkDerivation { + pname = "alsa-pcm"; + version = "0.6.1"; + sha256 = "453d768f7b90aaa0b5fd5462bcd7f8f40a97aa9d0ca7dfc7e61fe69e74934e5d"; + isLibrary = true; + isExecutable = true; + libraryHaskellDepends = [ + alsa-core array base extensible-exceptions sample-frame semigroups + storable-record + ]; + libraryPkgconfigDepends = [ alsaLib ]; + doHaddock = false; + doCheck = false; + homepage = "http://www.haskell.org/haskellwiki/ALSA"; + description = "Binding to the ALSA Library API (PCM audio)"; + license = stdenv.lib.licenses.bsd3; + }) {inherit (pkgs) alsaLib;}; + "alsa-seq" = callPackage + ({ mkDerivation, alsa-core, alsaLib, array, base, bytestring + , data-accessor, enumset, extensible-exceptions, poll, stdenv + , transformers, utility-ht + }: + mkDerivation { + pname = "alsa-seq"; + version = "0.6.0.7"; + sha256 = "06cda1e24993aaf0c3592b51a613cf1e187eea603dd77ad3a129a8a7b1e0b778"; + isLibrary = true; + isExecutable = true; + libraryHaskellDepends = [ + alsa-core array base bytestring data-accessor enumset + extensible-exceptions poll transformers utility-ht + ]; + libraryPkgconfigDepends = [ alsaLib ]; + doHaddock = false; + doCheck = false; + homepage = "http://www.haskell.org/haskellwiki/ALSA"; + description = "Binding to the ALSA Library API (MIDI sequencer)"; + license = stdenv.lib.licenses.bsd3; + }) {inherit (pkgs) alsaLib;}; + "alternative-vector" = callPackage + ({ mkDerivation, base, stdenv, vector }: + mkDerivation { + pname = "alternative-vector"; + version = "0.0.0"; + sha256 = "42474bc708dbc81e13a7850887cefc2596db47cb07423610094cd994f754c7b1"; + libraryHaskellDepends = [ base vector ]; + doHaddock = false; + doCheck = false; + homepage = "https://github.com/athanclark/alternative-vector#readme"; + description = "Use vectors instead of lists for many and some"; + license = stdenv.lib.licenses.bsd3; + }) {}; + "alternators" = callPackage + ({ mkDerivation, base, lens, mmorph, mtl, newtype-generics, stdenv + , stm, transformers + }: + mkDerivation { + pname = "alternators"; + version = "1.0.0.0"; + sha256 = "44395b8b42193fdd78f94fd9f62560bfa69aef345a0fb2602df0d8d3613fd339"; + libraryHaskellDepends = [ + base lens mmorph mtl newtype-generics stm transformers + ]; + doHaddock = false; + doCheck = false; + homepage = "https://github.com/louispan/alternators#readme"; + description = "Handy functions when using transformers"; + license = stdenv.lib.licenses.bsd3; + }) {}; + "amazonka" = callPackage + ({ mkDerivation, amazonka-core, base, bytestring, conduit + , conduit-extra, directory, exceptions, http-client, http-conduit + , http-types, ini, mmorph, monad-control, mtl, resourcet, retry + , stdenv, text, time, transformers, transformers-base + , transformers-compat, void + }: + mkDerivation { + pname = "amazonka"; + version = "1.6.0"; + sha256 = "3721892c87946c12bbd87ddba38d9e244aa962db190d8897c16a264c4f3fc41c"; + libraryHaskellDepends = [ + amazonka-core base bytestring conduit conduit-extra directory + exceptions http-client http-conduit http-types ini mmorph + monad-control mtl resourcet retry text time transformers + transformers-base transformers-compat void + ]; + doHaddock = false; + doCheck = false; + homepage = "https://github.com/brendanhay/amazonka"; + description = "Comprehensive Amazon Web Services SDK"; + license = stdenv.lib.licenses.mpl20; + }) {}; + "amazonka-apigateway" = callPackage + ({ mkDerivation, amazonka-core, base, stdenv }: + mkDerivation { + pname = "amazonka-apigateway"; + version = "1.6.0"; + sha256 = "56e63ecfbd8358d0d2766e08f8f2b08362bb435c1059a5791964089dbab75ae8"; + libraryHaskellDepends = [ amazonka-core base ]; + doHaddock = false; + doCheck = false; + homepage = "https://github.com/brendanhay/amazonka"; + description = "Amazon API Gateway SDK"; + license = stdenv.lib.licenses.mpl20; + }) {}; + "amazonka-application-autoscaling" = callPackage + ({ mkDerivation, amazonka-core, base, stdenv }: + mkDerivation { + pname = "amazonka-application-autoscaling"; + version = "1.6.0"; + sha256 = "5536a7d1c24cd5907b85bd743df5989d91cb3325602944062c9c640178a61df7"; + libraryHaskellDepends = [ amazonka-core base ]; + doHaddock = false; + doCheck = false; + homepage = "https://github.com/brendanhay/amazonka"; + description = "Amazon Application Auto Scaling SDK"; + license = stdenv.lib.licenses.mpl20; + }) {}; + "amazonka-appstream" = callPackage + ({ mkDerivation, amazonka-core, base, stdenv }: + mkDerivation { + pname = "amazonka-appstream"; + version = "1.6.0"; + sha256 = "eb90692b932d62c4e7006d661b8022c4dd9f7d4dcc07e5499eceae14b33747df"; + libraryHaskellDepends = [ amazonka-core base ]; + doHaddock = false; + doCheck = false; + homepage = "https://github.com/brendanhay/amazonka"; + description = "Amazon AppStream SDK"; + license = stdenv.lib.licenses.mpl20; + }) {}; + "amazonka-autoscaling" = callPackage + ({ mkDerivation, amazonka-core, base, stdenv }: + mkDerivation { + pname = "amazonka-autoscaling"; + version = "1.6.0"; + sha256 = "1b52132b23ef899937d20cef595d9f8757f85861d142616bcb5ee0ba8ed5f8d3"; + libraryHaskellDepends = [ amazonka-core base ]; + doHaddock = false; + doCheck = false; + homepage = "https://github.com/brendanhay/amazonka"; + description = "Amazon Auto Scaling SDK"; + license = stdenv.lib.licenses.mpl20; + }) {}; + "amazonka-budgets" = callPackage + ({ mkDerivation, amazonka-core, base, stdenv }: + mkDerivation { + pname = "amazonka-budgets"; + version = "1.6.0"; + sha256 = "ccc692856a7f7ddfba573cde6506108a30a59f641748ecc787aece894d7ce4b7"; + libraryHaskellDepends = [ amazonka-core base ]; + doHaddock = false; + doCheck = false; + homepage = "https://github.com/brendanhay/amazonka"; + description = "Amazon Budgets SDK"; + license = stdenv.lib.licenses.mpl20; + }) {}; + "amazonka-certificatemanager" = callPackage + ({ mkDerivation, amazonka-core, base, stdenv }: + mkDerivation { + pname = "amazonka-certificatemanager"; + version = "1.6.0"; + sha256 = "1fdf93c685a1b348a851b793b170a0a2282b06dc65a91c016d4756ea5726aa6a"; + libraryHaskellDepends = [ amazonka-core base ]; + doHaddock = false; + doCheck = false; + homepage = "https://github.com/brendanhay/amazonka"; + description = "Amazon Certificate Manager SDK"; + license = stdenv.lib.licenses.mpl20; + }) {}; + "amazonka-cloudformation" = callPackage + ({ mkDerivation, amazonka-core, base, stdenv }: + mkDerivation { + pname = "amazonka-cloudformation"; + version = "1.6.0"; + sha256 = "15e2c82574906a13d390f68f5a57a83f4bbfc37fb9ce590c9f73e00dcafa8335"; + libraryHaskellDepends = [ amazonka-core base ]; + doHaddock = false; + doCheck = false; + homepage = "https://github.com/brendanhay/amazonka"; + description = "Amazon CloudFormation SDK"; + license = stdenv.lib.licenses.mpl20; + }) {}; + "amazonka-cloudfront" = callPackage + ({ mkDerivation, amazonka-core, base, stdenv }: + mkDerivation { + pname = "amazonka-cloudfront"; + version = "1.6.0"; + sha256 = "956a60988ff3b9bef042bf523b63c882cd7b2c386483cc3f1d1d8534aad334a2"; + libraryHaskellDepends = [ amazonka-core base ]; + doHaddock = false; + doCheck = false; + homepage = "https://github.com/brendanhay/amazonka"; + description = "Amazon CloudFront SDK"; + license = stdenv.lib.licenses.mpl20; + }) {}; + "amazonka-cloudhsm" = callPackage + ({ mkDerivation, amazonka-core, base, stdenv }: + mkDerivation { + pname = "amazonka-cloudhsm"; + version = "1.6.0"; + sha256 = "e4227038a39486e8c390198997571ca1b14ebf5e15fec1146169da7378a41b5f"; + libraryHaskellDepends = [ amazonka-core base ]; + doHaddock = false; + doCheck = false; + homepage = "https://github.com/brendanhay/amazonka"; + description = "Amazon CloudHSM SDK"; + license = stdenv.lib.licenses.mpl20; + }) {}; + "amazonka-cloudsearch" = callPackage + ({ mkDerivation, amazonka-core, base, stdenv }: + mkDerivation { + pname = "amazonka-cloudsearch"; + version = "1.6.0"; + sha256 = "dd17345576acd8f44fd3af82f07b00fdce0781abbd51ab2df827fa48528c6394"; + libraryHaskellDepends = [ amazonka-core base ]; + doHaddock = false; + doCheck = false; + homepage = "https://github.com/brendanhay/amazonka"; + description = "Amazon CloudSearch SDK"; + license = stdenv.lib.licenses.mpl20; + }) {}; + "amazonka-cloudsearch-domains" = callPackage + ({ mkDerivation, amazonka-core, base, stdenv }: + mkDerivation { + pname = "amazonka-cloudsearch-domains"; + version = "1.6.0"; + sha256 = "24f0d36f9aeed5041fd893b8a0d60e5df6f31c8a126cead4652115c6b28f7ca7"; + libraryHaskellDepends = [ amazonka-core base ]; + doHaddock = false; + doCheck = false; + homepage = "https://github.com/brendanhay/amazonka"; + description = "Amazon CloudSearch Domain SDK"; + license = stdenv.lib.licenses.mpl20; + }) {}; + "amazonka-cloudtrail" = callPackage + ({ mkDerivation, amazonka-core, base, stdenv }: + mkDerivation { + pname = "amazonka-cloudtrail"; + version = "1.6.0"; + sha256 = "d9d99df96ac2e46321e0da7d1797f12472ee32011f126d2881a2f19aa7491c24"; + libraryHaskellDepends = [ amazonka-core base ]; + doHaddock = false; + doCheck = false; + homepage = "https://github.com/brendanhay/amazonka"; + description = "Amazon CloudTrail SDK"; + license = stdenv.lib.licenses.mpl20; + }) {}; + "amazonka-cloudwatch" = callPackage + ({ mkDerivation, amazonka-core, base, stdenv }: + mkDerivation { + pname = "amazonka-cloudwatch"; + version = "1.6.0"; + sha256 = "25c812b364b22d96d082e3598cd75d988cb8e3decdb8e3291a0deb9714dbee51"; + libraryHaskellDepends = [ amazonka-core base ]; + doHaddock = false; + doCheck = false; + homepage = "https://github.com/brendanhay/amazonka"; + description = "Amazon CloudWatch SDK"; + license = stdenv.lib.licenses.mpl20; + }) {}; + "amazonka-cloudwatch-events" = callPackage + ({ mkDerivation, amazonka-core, base, stdenv }: + mkDerivation { + pname = "amazonka-cloudwatch-events"; + version = "1.6.0"; + sha256 = "13fb5e436fc4c534d6e01c47ef23f589c01042f8a9d7efb622e89bd8f5d2ec4d"; + libraryHaskellDepends = [ amazonka-core base ]; + doHaddock = false; + doCheck = false; + homepage = "https://github.com/brendanhay/amazonka"; + description = "Amazon CloudWatch Events SDK"; + license = stdenv.lib.licenses.mpl20; + }) {}; + "amazonka-cloudwatch-logs" = callPackage + ({ mkDerivation, amazonka-core, base, stdenv }: + mkDerivation { + pname = "amazonka-cloudwatch-logs"; + version = "1.6.0"; + sha256 = "80e4e74af0fb29f5ecc04f4d956ba0e9950f7936c858c1ff84461b62ca87ee7d"; + libraryHaskellDepends = [ amazonka-core base ]; + doHaddock = false; + doCheck = false; + homepage = "https://github.com/brendanhay/amazonka"; + description = "Amazon CloudWatch Logs SDK"; + license = stdenv.lib.licenses.mpl20; + }) {}; + "amazonka-codebuild" = callPackage + ({ mkDerivation, amazonka-core, base, stdenv }: + mkDerivation { + pname = "amazonka-codebuild"; + version = "1.6.0"; + sha256 = "fdbf43578e0aa54c616b2daf8b442b32a8765b62da0c3b7f6b1df95f4e55a0ab"; + libraryHaskellDepends = [ amazonka-core base ]; + doHaddock = false; + doCheck = false; + homepage = "https://github.com/brendanhay/amazonka"; + description = "Amazon CodeBuild SDK"; + license = stdenv.lib.licenses.mpl20; + }) {}; + "amazonka-codecommit" = callPackage + ({ mkDerivation, amazonka-core, base, stdenv }: + mkDerivation { + pname = "amazonka-codecommit"; + version = "1.6.0"; + sha256 = "8a2f2630bfabd3c71fdb811a9bbafefb058ce085ad18c1756a82f59bdd682415"; + libraryHaskellDepends = [ amazonka-core base ]; + doHaddock = false; + doCheck = false; + homepage = "https://github.com/brendanhay/amazonka"; + description = "Amazon CodeCommit SDK"; + license = stdenv.lib.licenses.mpl20; + }) {}; + "amazonka-codedeploy" = callPackage + ({ mkDerivation, amazonka-core, base, stdenv }: + mkDerivation { + pname = "amazonka-codedeploy"; + version = "1.6.0"; + sha256 = "3315b99ab8851acb5ae1251344474e0ec03796e9fd59f1d18278abc7add3c2df"; + libraryHaskellDepends = [ amazonka-core base ]; + doHaddock = false; + doCheck = false; + homepage = "https://github.com/brendanhay/amazonka"; + description = "Amazon CodeDeploy SDK"; + license = stdenv.lib.licenses.mpl20; + }) {}; + "amazonka-codepipeline" = callPackage + ({ mkDerivation, amazonka-core, base, stdenv }: + mkDerivation { + pname = "amazonka-codepipeline"; + version = "1.6.0"; + sha256 = "c46eea221931601ced439454d3a3fe0030acccbb776bf153182010ca8f2ec043"; + libraryHaskellDepends = [ amazonka-core base ]; + doHaddock = false; + doCheck = false; + homepage = "https://github.com/brendanhay/amazonka"; + description = "Amazon CodePipeline SDK"; + license = stdenv.lib.licenses.mpl20; + }) {}; + "amazonka-cognito-identity" = callPackage + ({ mkDerivation, amazonka-core, base, stdenv }: + mkDerivation { + pname = "amazonka-cognito-identity"; + version = "1.6.0"; + sha256 = "3aac30e210d3fc0f45166b6211c4c61eb7cc4480fb550f106cd6206c8dc9b6d5"; + libraryHaskellDepends = [ amazonka-core base ]; + doHaddock = false; + doCheck = false; + homepage = "https://github.com/brendanhay/amazonka"; + description = "Amazon Cognito Identity SDK"; + license = stdenv.lib.licenses.mpl20; + }) {}; + "amazonka-cognito-idp" = callPackage + ({ mkDerivation, amazonka-core, base, stdenv }: + mkDerivation { + pname = "amazonka-cognito-idp"; + version = "1.6.0"; + sha256 = "a98989c8ca10bb938fb4f27803920462fc8f88d7104cebb5106b9e3728e81fff"; + libraryHaskellDepends = [ amazonka-core base ]; + doHaddock = false; + doCheck = false; + homepage = "https://github.com/brendanhay/amazonka"; + description = "Amazon Cognito Identity Provider SDK"; + license = stdenv.lib.licenses.mpl20; + }) {}; + "amazonka-cognito-sync" = callPackage + ({ mkDerivation, amazonka-core, base, stdenv }: + mkDerivation { + pname = "amazonka-cognito-sync"; + version = "1.6.0"; + sha256 = "5fde10d8e1f31e676433dfd32d061739d805a076ee58abd9c05d8faba36cf435"; + libraryHaskellDepends = [ amazonka-core base ]; + doHaddock = false; + doCheck = false; + homepage = "https://github.com/brendanhay/amazonka"; + description = "Amazon Cognito Sync SDK"; + license = stdenv.lib.licenses.mpl20; + }) {}; + "amazonka-config" = callPackage + ({ mkDerivation, amazonka-core, base, stdenv }: + mkDerivation { + pname = "amazonka-config"; + version = "1.6.0"; + sha256 = "5cb03ebc049efbccfb48ab926e08f0e9824880bb349129601f724679fe42c9cd"; + libraryHaskellDepends = [ amazonka-core base ]; + doHaddock = false; + doCheck = false; + homepage = "https://github.com/brendanhay/amazonka"; + description = "Amazon Config SDK"; + license = stdenv.lib.licenses.mpl20; + }) {}; + "amazonka-core" = callPackage + ({ mkDerivation, aeson, attoparsec, base, bifunctors, bytestring + , case-insensitive, conduit, conduit-extra, cryptonite, deepseq + , exceptions, hashable, http-client, http-conduit, http-types, lens + , memory, mtl, resourcet, scientific, semigroups, stdenv, tagged + , text, time, transformers, transformers-compat + , unordered-containers, xml-conduit, xml-types + }: + mkDerivation { + pname = "amazonka-core"; + version = "1.6.0"; + sha256 = "afe1c5b74aadc0222419bd792688fd179e4f5693aeb75b74232f770fff093dc9"; + libraryHaskellDepends = [ + aeson attoparsec base bifunctors bytestring case-insensitive + conduit conduit-extra cryptonite deepseq exceptions hashable + http-client http-conduit http-types lens memory mtl resourcet + scientific semigroups tagged text time transformers + transformers-compat unordered-containers xml-conduit xml-types + ]; + doHaddock = false; + doCheck = false; + homepage = "https://github.com/brendanhay/amazonka"; + description = "Core data types and functionality for Amazonka libraries"; + license = stdenv.lib.licenses.mpl20; + }) {}; + "amazonka-datapipeline" = callPackage + ({ mkDerivation, amazonka-core, base, stdenv }: + mkDerivation { + pname = "amazonka-datapipeline"; + version = "1.6.0"; + sha256 = "1b212dd70864ef1ccc45e3a7deca936e0e1803c97aacefc34fad966fd85f3ae5"; + libraryHaskellDepends = [ amazonka-core base ]; + doHaddock = false; + doCheck = false; + homepage = "https://github.com/brendanhay/amazonka"; + description = "Amazon Data Pipeline SDK"; + license = stdenv.lib.licenses.mpl20; + }) {}; + "amazonka-devicefarm" = callPackage + ({ mkDerivation, amazonka-core, base, stdenv }: + mkDerivation { + pname = "amazonka-devicefarm"; + version = "1.6.0"; + sha256 = "d81b74b8b0c254a487ce464b1d6f0679d774bd42daf32312867e4dd37e35c569"; + libraryHaskellDepends = [ amazonka-core base ]; + doHaddock = false; + doCheck = false; + homepage = "https://github.com/brendanhay/amazonka"; + description = "Amazon Device Farm SDK"; + license = stdenv.lib.licenses.mpl20; + }) {}; + "amazonka-directconnect" = callPackage + ({ mkDerivation, amazonka-core, base, stdenv }: + mkDerivation { + pname = "amazonka-directconnect"; + version = "1.6.0"; + sha256 = "8d85b9ce865eac817610a3a1db2e28100ff0069b85f41c4359a6aa5978533832"; + libraryHaskellDepends = [ amazonka-core base ]; + doHaddock = false; + doCheck = false; + homepage = "https://github.com/brendanhay/amazonka"; + description = "Amazon Direct Connect SDK"; + license = stdenv.lib.licenses.mpl20; + }) {}; + "amazonka-discovery" = callPackage + ({ mkDerivation, amazonka-core, base, stdenv }: + mkDerivation { + pname = "amazonka-discovery"; + version = "1.6.0"; + sha256 = "7bc67ad76b1413c2aebe48324d56b2e6f4279db6e7d4951e93bdaa5329199213"; + libraryHaskellDepends = [ amazonka-core base ]; + doHaddock = false; + doCheck = false; + homepage = "https://github.com/brendanhay/amazonka"; + description = "Amazon Application Discovery Service SDK"; + license = stdenv.lib.licenses.mpl20; + }) {}; + "amazonka-dms" = callPackage + ({ mkDerivation, amazonka-core, base, stdenv }: + mkDerivation { + pname = "amazonka-dms"; + version = "1.6.0"; + sha256 = "a75f19dc2a7642840a97a135f24cd9120d3f5a81ad924aad6a46c514fba180f3"; + libraryHaskellDepends = [ amazonka-core base ]; + doHaddock = false; + doCheck = false; + homepage = "https://github.com/brendanhay/amazonka"; + description = "Amazon Database Migration Service SDK"; + license = stdenv.lib.licenses.mpl20; + }) {}; + "amazonka-ds" = callPackage + ({ mkDerivation, amazonka-core, base, stdenv }: + mkDerivation { + pname = "amazonka-ds"; + version = "1.6.0"; + sha256 = "06fa338938aee62f81f93755cdc7039515dc0c6b32bb7c0bac33d7c92066d389"; + libraryHaskellDepends = [ amazonka-core base ]; + doHaddock = false; + doCheck = false; + homepage = "https://github.com/brendanhay/amazonka"; + description = "Amazon Directory Service SDK"; + license = stdenv.lib.licenses.mpl20; + }) {}; + "amazonka-dynamodb" = callPackage + ({ mkDerivation, amazonka-core, base, stdenv }: + mkDerivation { + pname = "amazonka-dynamodb"; + version = "1.6.0"; + sha256 = "33f54ee4f898972f1539a00e65a851bb940c8d26058d63ddfcd07fbca57f9a3f"; + libraryHaskellDepends = [ amazonka-core base ]; + doHaddock = false; + doCheck = false; + homepage = "https://github.com/brendanhay/amazonka"; + description = "Amazon DynamoDB SDK"; + license = stdenv.lib.licenses.mpl20; + }) {}; + "amazonka-dynamodb-streams" = callPackage + ({ mkDerivation, amazonka-core, base, stdenv }: + mkDerivation { + pname = "amazonka-dynamodb-streams"; + version = "1.6.0"; + sha256 = "b3f832ddf70e95232cb79d71633276aa65c72e51c6c553118b4bc9db3a48e57f"; + libraryHaskellDepends = [ amazonka-core base ]; + doHaddock = false; + doCheck = false; + homepage = "https://github.com/brendanhay/amazonka"; + description = "Amazon DynamoDB Streams SDK"; + license = stdenv.lib.licenses.mpl20; + }) {}; + "amazonka-ec2" = callPackage + ({ mkDerivation, amazonka-core, base, stdenv }: + mkDerivation { + pname = "amazonka-ec2"; + version = "1.6.0"; + sha256 = "2221c2c4e188aac9f0c9e4bb2e0bce65eb21102e6199c3783c20f3797da955cc"; + libraryHaskellDepends = [ amazonka-core base ]; + doHaddock = false; + doCheck = false; + homepage = "https://github.com/brendanhay/amazonka"; + description = "Amazon Elastic Compute Cloud SDK"; + license = stdenv.lib.licenses.mpl20; + }) {}; + "amazonka-ecr" = callPackage + ({ mkDerivation, amazonka-core, base, stdenv }: + mkDerivation { + pname = "amazonka-ecr"; + version = "1.6.0"; + sha256 = "42088ad4b4d4c01b87267a372fec706f57db4db19b27c06a3c6826ef62ef8450"; + libraryHaskellDepends = [ amazonka-core base ]; + doHaddock = false; + doCheck = false; + homepage = "https://github.com/brendanhay/amazonka"; + description = "Amazon EC2 Container Registry SDK"; + license = stdenv.lib.licenses.mpl20; + }) {}; + "amazonka-ecs" = callPackage + ({ mkDerivation, amazonka-core, base, stdenv }: + mkDerivation { + pname = "amazonka-ecs"; + version = "1.6.0"; + sha256 = "309535abe8359475b3430488c84c398ed8d25a05321101c725e4a04d5f4cde3f"; + libraryHaskellDepends = [ amazonka-core base ]; + doHaddock = false; + doCheck = false; + homepage = "https://github.com/brendanhay/amazonka"; + description = "Amazon EC2 Container Service SDK"; + license = stdenv.lib.licenses.mpl20; + }) {}; + "amazonka-efs" = callPackage + ({ mkDerivation, amazonka-core, base, stdenv }: + mkDerivation { + pname = "amazonka-efs"; + version = "1.6.0"; + sha256 = "268456294406d63eb49422027226af8ef15ce08dc2095be9a6657bf9bf41afbb"; + libraryHaskellDepends = [ amazonka-core base ]; + doHaddock = false; + doCheck = false; + homepage = "https://github.com/brendanhay/amazonka"; + description = "Amazon Elastic File System SDK"; + license = stdenv.lib.licenses.mpl20; + }) {}; + "amazonka-elasticache" = callPackage + ({ mkDerivation, amazonka-core, base, stdenv }: + mkDerivation { + pname = "amazonka-elasticache"; + version = "1.6.0"; + sha256 = "e4a74a2ce2d89534fd738c429dc9a0ee7564ee3539bd93488eba211176763969"; + libraryHaskellDepends = [ amazonka-core base ]; + doHaddock = false; + doCheck = false; + homepage = "https://github.com/brendanhay/amazonka"; + description = "Amazon ElastiCache SDK"; + license = stdenv.lib.licenses.mpl20; + }) {}; + "amazonka-elasticbeanstalk" = callPackage + ({ mkDerivation, amazonka-core, base, stdenv }: + mkDerivation { + pname = "amazonka-elasticbeanstalk"; + version = "1.6.0"; + sha256 = "c1dc065763475b705aabf61086546bcd312e6802dbb328775b9777e682b2386a"; + libraryHaskellDepends = [ amazonka-core base ]; + doHaddock = false; + doCheck = false; + homepage = "https://github.com/brendanhay/amazonka"; + description = "Amazon Elastic Beanstalk SDK"; + license = stdenv.lib.licenses.mpl20; + }) {}; + "amazonka-elasticsearch" = callPackage + ({ mkDerivation, amazonka-core, base, stdenv }: + mkDerivation { + pname = "amazonka-elasticsearch"; + version = "1.6.0"; + sha256 = "3429fcae1c6fec5ebbc8acf1597532615b39def394d2296d641614c0225f3083"; + libraryHaskellDepends = [ amazonka-core base ]; + doHaddock = false; + doCheck = false; + homepage = "https://github.com/brendanhay/amazonka"; + description = "Amazon Elasticsearch Service SDK"; + license = stdenv.lib.licenses.mpl20; + }) {}; + "amazonka-elastictranscoder" = callPackage + ({ mkDerivation, amazonka-core, base, stdenv }: + mkDerivation { + pname = "amazonka-elastictranscoder"; + version = "1.6.0"; + sha256 = "ab12a7c97e09cd1a60e81525e793f5f7b84799f8f9968a2b62bae8b9c9f3c10a"; + libraryHaskellDepends = [ amazonka-core base ]; + doHaddock = false; + doCheck = false; + homepage = "https://github.com/brendanhay/amazonka"; + description = "Amazon Elastic Transcoder SDK"; + license = stdenv.lib.licenses.mpl20; + }) {}; + "amazonka-elb" = callPackage + ({ mkDerivation, amazonka-core, base, stdenv }: + mkDerivation { + pname = "amazonka-elb"; + version = "1.6.0"; + sha256 = "59c974009a2c26f7d267ae9736c71893a82ae69c19f344b87b4e3afd19f97e4d"; + libraryHaskellDepends = [ amazonka-core base ]; + doHaddock = false; + doCheck = false; + homepage = "https://github.com/brendanhay/amazonka"; + description = "Amazon Elastic Load Balancing SDK"; + license = stdenv.lib.licenses.mpl20; + }) {}; + "amazonka-elbv2" = callPackage + ({ mkDerivation, amazonka-core, base, stdenv }: + mkDerivation { + pname = "amazonka-elbv2"; + version = "1.6.0"; + sha256 = "2a53d35e29b613ac7261a3202023cb8221607fd8df5f034c572d6aa751c622c9"; + libraryHaskellDepends = [ amazonka-core base ]; + doHaddock = false; + doCheck = false; + homepage = "https://github.com/brendanhay/amazonka"; + description = "Amazon Elastic Load Balancing SDK"; + license = stdenv.lib.licenses.mpl20; + }) {}; + "amazonka-emr" = callPackage + ({ mkDerivation, amazonka-core, base, stdenv }: + mkDerivation { + pname = "amazonka-emr"; + version = "1.6.0"; + sha256 = "e9a07458ee61feadeff2e98fc83c1542320d5b97744225304dc1cc568ad9774f"; + libraryHaskellDepends = [ amazonka-core base ]; + doHaddock = false; + doCheck = false; + homepage = "https://github.com/brendanhay/amazonka"; + description = "Amazon Elastic MapReduce SDK"; + license = stdenv.lib.licenses.mpl20; + }) {}; + "amazonka-gamelift" = callPackage + ({ mkDerivation, amazonka-core, base, stdenv }: + mkDerivation { + pname = "amazonka-gamelift"; + version = "1.6.0"; + sha256 = "ebcdbd4a43c8d02dc0a0d7302f4b27c8e106a783e910c5cdaa68a7a7ee775ffc"; + libraryHaskellDepends = [ amazonka-core base ]; + doHaddock = false; + doCheck = false; + homepage = "https://github.com/brendanhay/amazonka"; + description = "Amazon GameLift SDK"; + license = stdenv.lib.licenses.mpl20; + }) {}; + "amazonka-glacier" = callPackage + ({ mkDerivation, amazonka-core, base, stdenv }: + mkDerivation { + pname = "amazonka-glacier"; + version = "1.6.0"; + sha256 = "5307434d1fbddfba54b56ceb5eea2e5dfa3ece05b9353e61a998788af3e0f913"; + libraryHaskellDepends = [ amazonka-core base ]; + doHaddock = false; + doCheck = false; + homepage = "https://github.com/brendanhay/amazonka"; + description = "Amazon Glacier SDK"; + license = stdenv.lib.licenses.mpl20; + }) {}; + "amazonka-health" = callPackage + ({ mkDerivation, amazonka-core, base, stdenv }: + mkDerivation { + pname = "amazonka-health"; + version = "1.6.0"; + sha256 = "c216b18e93e998ff04b00a5fc3ab6df8d36ef95d4b9988587eceb837615ba67b"; + libraryHaskellDepends = [ amazonka-core base ]; + doHaddock = false; + doCheck = false; + homepage = "https://github.com/brendanhay/amazonka"; + description = "Amazon Health APIs and Notifications SDK"; + license = stdenv.lib.licenses.mpl20; + }) {}; + "amazonka-iam" = callPackage + ({ mkDerivation, amazonka-core, base, stdenv }: + mkDerivation { + pname = "amazonka-iam"; + version = "1.6.0"; + sha256 = "a335813a795c3d28400b95b94f1b14ada3e621e83d07cb9fd9c7e7edb285905d"; + libraryHaskellDepends = [ amazonka-core base ]; + doHaddock = false; + doCheck = false; + homepage = "https://github.com/brendanhay/amazonka"; + description = "Amazon Identity and Access Management SDK"; + license = stdenv.lib.licenses.mpl20; + }) {}; + "amazonka-importexport" = callPackage + ({ mkDerivation, amazonka-core, base, stdenv }: + mkDerivation { + pname = "amazonka-importexport"; + version = "1.6.0"; + sha256 = "0951f2bcd74e24c687ab39a044cfc9334b68fdb3c885d54693c918a1c97dcd04"; + libraryHaskellDepends = [ amazonka-core base ]; + doHaddock = false; + doCheck = false; + homepage = "https://github.com/brendanhay/amazonka"; + description = "Amazon Import/Export SDK"; + license = stdenv.lib.licenses.mpl20; + }) {}; + "amazonka-inspector" = callPackage + ({ mkDerivation, amazonka-core, base, stdenv }: + mkDerivation { + pname = "amazonka-inspector"; + version = "1.6.0"; + sha256 = "bcef005e38e63b742c1d7c63de84f582a447042a19ea611b1b617751f3cce13e"; + libraryHaskellDepends = [ amazonka-core base ]; + doHaddock = false; + doCheck = false; + homepage = "https://github.com/brendanhay/amazonka"; + description = "Amazon Inspector SDK"; + license = stdenv.lib.licenses.mpl20; + }) {}; + "amazonka-iot" = callPackage + ({ mkDerivation, amazonka-core, base, stdenv }: + mkDerivation { + pname = "amazonka-iot"; + version = "1.6.0"; + sha256 = "180b2169c97bd021e5f013cc72b64fe701270a7a5000950e20fa6373d38a26d0"; + libraryHaskellDepends = [ amazonka-core base ]; + doHaddock = false; + doCheck = false; + homepage = "https://github.com/brendanhay/amazonka"; + description = "Amazon IoT SDK"; + license = stdenv.lib.licenses.mpl20; + }) {}; + "amazonka-iot-dataplane" = callPackage + ({ mkDerivation, amazonka-core, base, stdenv }: + mkDerivation { + pname = "amazonka-iot-dataplane"; + version = "1.6.0"; + sha256 = "aee63bc0e6eca4cc4f76f7c8aa5e20f97e3f98268160006099014c66f4a88742"; + libraryHaskellDepends = [ amazonka-core base ]; + doHaddock = false; + doCheck = false; + homepage = "https://github.com/brendanhay/amazonka"; + description = "Amazon IoT Data Plane SDK"; + license = stdenv.lib.licenses.mpl20; + }) {}; + "amazonka-kinesis" = callPackage + ({ mkDerivation, amazonka-core, base, stdenv }: + mkDerivation { + pname = "amazonka-kinesis"; + version = "1.6.0"; + sha256 = "549e41d29e46ff6aa485676436cb7cf15d2d37c2d0c62e6358b9b12b92e22f38"; + libraryHaskellDepends = [ amazonka-core base ]; + doHaddock = false; + doCheck = false; + homepage = "https://github.com/brendanhay/amazonka"; + description = "Amazon Kinesis SDK"; + license = stdenv.lib.licenses.mpl20; + }) {}; + "amazonka-kinesis-analytics" = callPackage + ({ mkDerivation, amazonka-core, base, stdenv }: + mkDerivation { + pname = "amazonka-kinesis-analytics"; + version = "1.6.0"; + sha256 = "7efb5438596ef4541ebca35e4b87adf3c989bf88032be2d2e617bb14a7f685ee"; + libraryHaskellDepends = [ amazonka-core base ]; + doHaddock = false; + doCheck = false; + homepage = "https://github.com/brendanhay/amazonka"; + description = "Amazon Kinesis Analytics SDK"; + license = stdenv.lib.licenses.mpl20; + }) {}; + "amazonka-kinesis-firehose" = callPackage + ({ mkDerivation, amazonka-core, base, stdenv }: + mkDerivation { + pname = "amazonka-kinesis-firehose"; + version = "1.6.0"; + sha256 = "120545cdc888c031290b2f8a6745b911ebc6e2e5c077005067683118d197549c"; + libraryHaskellDepends = [ amazonka-core base ]; + doHaddock = false; + doCheck = false; + homepage = "https://github.com/brendanhay/amazonka"; + description = "Amazon Kinesis Firehose SDK"; + license = stdenv.lib.licenses.mpl20; + }) {}; + "amazonka-kms" = callPackage + ({ mkDerivation, amazonka-core, base, stdenv }: + mkDerivation { + pname = "amazonka-kms"; + version = "1.6.0"; + sha256 = "7aa5333583b494d0a5585f78ead67833a7e72942b264673ee8b91d7be89e8e99"; + libraryHaskellDepends = [ amazonka-core base ]; + doHaddock = false; + doCheck = false; + homepage = "https://github.com/brendanhay/amazonka"; + description = "Amazon Key Management Service SDK"; + license = stdenv.lib.licenses.mpl20; + }) {}; + "amazonka-lambda" = callPackage + ({ mkDerivation, amazonka-core, base, stdenv }: + mkDerivation { + pname = "amazonka-lambda"; + version = "1.6.0"; + sha256 = "649626896a7572979c5628e9406eb9be090106b7468473455e77aa59cec99b06"; + libraryHaskellDepends = [ amazonka-core base ]; + doHaddock = false; + doCheck = false; + homepage = "https://github.com/brendanhay/amazonka"; + description = "Amazon Lambda SDK"; + license = stdenv.lib.licenses.mpl20; + }) {}; + "amazonka-lightsail" = callPackage + ({ mkDerivation, amazonka-core, base, stdenv }: + mkDerivation { + pname = "amazonka-lightsail"; + version = "1.6.0"; + sha256 = "741b4c6aff2f0e08fe9868aa858708a8ab36f95859bc0a9eecfdd9bd2060aceb"; + libraryHaskellDepends = [ amazonka-core base ]; + doHaddock = false; + doCheck = false; + homepage = "https://github.com/brendanhay/amazonka"; + description = "Amazon Lightsail SDK"; + license = stdenv.lib.licenses.mpl20; + }) {}; + "amazonka-marketplace-analytics" = callPackage + ({ mkDerivation, amazonka-core, base, stdenv }: + mkDerivation { + pname = "amazonka-marketplace-analytics"; + version = "1.6.0"; + sha256 = "4d6c0db0e9c17b5131c6b03cd27bc53fbddb144c3910d46639edfdccbecd5d6a"; + libraryHaskellDepends = [ amazonka-core base ]; + doHaddock = false; + doCheck = false; + homepage = "https://github.com/brendanhay/amazonka"; + description = "Amazon Marketplace Commerce Analytics SDK"; + license = stdenv.lib.licenses.mpl20; + }) {}; + "amazonka-marketplace-metering" = callPackage + ({ mkDerivation, amazonka-core, base, stdenv }: + mkDerivation { + pname = "amazonka-marketplace-metering"; + version = "1.6.0"; + sha256 = "672de14acac579673c8c3cf032c3806554355cc84ae1b61882a589af2afb5f77"; + libraryHaskellDepends = [ amazonka-core base ]; + doHaddock = false; + doCheck = false; + homepage = "https://github.com/brendanhay/amazonka"; + description = "Amazon Marketplace Metering SDK"; + license = stdenv.lib.licenses.mpl20; + }) {}; + "amazonka-ml" = callPackage + ({ mkDerivation, amazonka-core, base, stdenv }: + mkDerivation { + pname = "amazonka-ml"; + version = "1.6.0"; + sha256 = "9dc12d7b71a72ea720efe9de60668ab904adddfdfbe9c422f5ebda940a556dfe"; + libraryHaskellDepends = [ amazonka-core base ]; + doHaddock = false; + doCheck = false; + homepage = "https://github.com/brendanhay/amazonka"; + description = "Amazon Machine Learning SDK"; + license = stdenv.lib.licenses.mpl20; + }) {}; + "amazonka-opsworks" = callPackage + ({ mkDerivation, amazonka-core, base, stdenv }: + mkDerivation { + pname = "amazonka-opsworks"; + version = "1.6.0"; + sha256 = "9a4372339b8ec556331b0198b5faf74bd8116f0816176aa8626d31f3b372d918"; + libraryHaskellDepends = [ amazonka-core base ]; + doHaddock = false; + doCheck = false; + homepage = "https://github.com/brendanhay/amazonka"; + description = "Amazon OpsWorks SDK"; + license = stdenv.lib.licenses.mpl20; + }) {}; + "amazonka-opsworks-cm" = callPackage + ({ mkDerivation, amazonka-core, base, stdenv }: + mkDerivation { + pname = "amazonka-opsworks-cm"; + version = "1.6.0"; + sha256 = "4f9e9b755f70fffd15cea08d0dfef5dc23ee4f822471f8e89f4d9b2f77a748f4"; + libraryHaskellDepends = [ amazonka-core base ]; + doHaddock = false; + doCheck = false; + homepage = "https://github.com/brendanhay/amazonka"; + description = "Amazon OpsWorks for Chef Automate SDK"; + license = stdenv.lib.licenses.mpl20; + }) {}; + "amazonka-pinpoint" = callPackage + ({ mkDerivation, amazonka-core, base, stdenv }: + mkDerivation { + pname = "amazonka-pinpoint"; + version = "1.6.0"; + sha256 = "b0f8cdaabd9f357d5a687999ce83c7670f43023507ab9b25e94bc717f916b005"; + libraryHaskellDepends = [ amazonka-core base ]; + doHaddock = false; + doCheck = false; + homepage = "https://github.com/brendanhay/amazonka"; + description = "Amazon Pinpoint SDK"; + license = stdenv.lib.licenses.mpl20; + }) {}; + "amazonka-polly" = callPackage + ({ mkDerivation, amazonka-core, base, stdenv }: + mkDerivation { + pname = "amazonka-polly"; + version = "1.6.0"; + sha256 = "773edcfa2628cb9e616b9f1f5fab461cd6f0e5822dafa43fef4403c54e958ad0"; + libraryHaskellDepends = [ amazonka-core base ]; + doHaddock = false; + doCheck = false; + homepage = "https://github.com/brendanhay/amazonka"; + description = "Amazon Polly SDK"; + license = stdenv.lib.licenses.mpl20; + }) {}; + "amazonka-rds" = callPackage + ({ mkDerivation, amazonka-core, base, stdenv }: + mkDerivation { + pname = "amazonka-rds"; + version = "1.6.0"; + sha256 = "c793613c53773b3ba8c5db1fa342e68c25fcada39f8557c6ed39feb05f1bc24d"; + libraryHaskellDepends = [ amazonka-core base ]; + doHaddock = false; + doCheck = false; + homepage = "https://github.com/brendanhay/amazonka"; + description = "Amazon Relational Database Service SDK"; + license = stdenv.lib.licenses.mpl20; + }) {}; + "amazonka-redshift" = callPackage + ({ mkDerivation, amazonka-core, base, stdenv }: + mkDerivation { + pname = "amazonka-redshift"; + version = "1.6.0"; + sha256 = "426ab96936e8d42ed85b31f076d99304148a6eb0896edbe90c6b1e570a90b329"; + libraryHaskellDepends = [ amazonka-core base ]; + doHaddock = false; + doCheck = false; + homepage = "https://github.com/brendanhay/amazonka"; + description = "Amazon Redshift SDK"; + license = stdenv.lib.licenses.mpl20; + }) {}; + "amazonka-rekognition" = callPackage + ({ mkDerivation, amazonka-core, base, stdenv }: + mkDerivation { + pname = "amazonka-rekognition"; + version = "1.6.0"; + sha256 = "462e427021e5362747b155ba4f77e4c1d99d794087dca273697fae93aff532a8"; + libraryHaskellDepends = [ amazonka-core base ]; + doHaddock = false; + doCheck = false; + homepage = "https://github.com/brendanhay/amazonka"; + description = "Amazon Rekognition SDK"; + license = stdenv.lib.licenses.mpl20; + }) {}; + "amazonka-route53" = callPackage + ({ mkDerivation, amazonka-core, base, stdenv, text }: + mkDerivation { + pname = "amazonka-route53"; + version = "1.6.0"; + sha256 = "68ef773bd9c44b28cb6166d86e3e499d9d32581915548ba08670f5cb1caa6317"; + libraryHaskellDepends = [ amazonka-core base text ]; + doHaddock = false; + doCheck = false; + homepage = "https://github.com/brendanhay/amazonka"; + description = "Amazon Route 53 SDK"; + license = stdenv.lib.licenses.mpl20; + }) {}; + "amazonka-route53-domains" = callPackage + ({ mkDerivation, amazonka-core, base, stdenv }: + mkDerivation { + pname = "amazonka-route53-domains"; + version = "1.6.0"; + sha256 = "f75bfe2f5f57c7367412479f3406cabcafa11a1436dd19f9a00ead6932e1a5ea"; + libraryHaskellDepends = [ amazonka-core base ]; + doHaddock = false; + doCheck = false; + homepage = "https://github.com/brendanhay/amazonka"; + description = "Amazon Route 53 Domains SDK"; + license = stdenv.lib.licenses.mpl20; + }) {}; + "amazonka-s3" = callPackage + ({ mkDerivation, amazonka-core, base, lens, stdenv, text }: + mkDerivation { + pname = "amazonka-s3"; + version = "1.6.0"; + sha256 = "eca18ebbd0df13a78768d9665827c7624282f76d512b3cf8f0f22a3afd463f47"; + libraryHaskellDepends = [ amazonka-core base lens text ]; + doHaddock = false; + doCheck = false; + homepage = "https://github.com/brendanhay/amazonka"; + description = "Amazon Simple Storage Service SDK"; + license = stdenv.lib.licenses.mpl20; + }) {}; + "amazonka-sdb" = callPackage + ({ mkDerivation, amazonka-core, base, stdenv }: + mkDerivation { + pname = "amazonka-sdb"; + version = "1.6.0"; + sha256 = "b9c28b21326fdb78a0acee0968188ffb6fb156c7fe0faf688a2ec83d3f5fbdfd"; + libraryHaskellDepends = [ amazonka-core base ]; + doHaddock = false; + doCheck = false; + homepage = "https://github.com/brendanhay/amazonka"; + description = "Amazon SimpleDB SDK"; + license = stdenv.lib.licenses.mpl20; + }) {}; + "amazonka-servicecatalog" = callPackage + ({ mkDerivation, amazonka-core, base, stdenv }: + mkDerivation { + pname = "amazonka-servicecatalog"; + version = "1.6.0"; + sha256 = "11f8df3b1b2b43ec636eb5a428c43c8534eae9d9554071298688005bcb46f264"; + libraryHaskellDepends = [ amazonka-core base ]; + doHaddock = false; + doCheck = false; + homepage = "https://github.com/brendanhay/amazonka"; + description = "Amazon Service Catalog SDK"; + license = stdenv.lib.licenses.mpl20; + }) {}; + "amazonka-ses" = callPackage + ({ mkDerivation, amazonka-core, base, stdenv }: + mkDerivation { + pname = "amazonka-ses"; + version = "1.6.0"; + sha256 = "778d32e738faae3fd1a7e12a67dddce063c0480740b95e1a58b5c23dc052bd02"; + libraryHaskellDepends = [ amazonka-core base ]; + doHaddock = false; + doCheck = false; + homepage = "https://github.com/brendanhay/amazonka"; + description = "Amazon Simple Email Service SDK"; + license = stdenv.lib.licenses.mpl20; + }) {}; + "amazonka-shield" = callPackage + ({ mkDerivation, amazonka-core, base, stdenv }: + mkDerivation { + pname = "amazonka-shield"; + version = "1.6.0"; + sha256 = "b983a85b2b5a617bc3cbc911bc8d00a3fbf199ddd5dee67bdb3882b23747ebf4"; + libraryHaskellDepends = [ amazonka-core base ]; + doHaddock = false; + doCheck = false; + homepage = "https://github.com/brendanhay/amazonka"; + description = "Amazon Shield SDK"; + license = stdenv.lib.licenses.mpl20; + }) {}; + "amazonka-sms" = callPackage + ({ mkDerivation, amazonka-core, base, stdenv }: + mkDerivation { + pname = "amazonka-sms"; + version = "1.6.0"; + sha256 = "fc4d359d2988d7604780a5eca5b3371d3d3034180e96d2cbc6148559f0cda47f"; + libraryHaskellDepends = [ amazonka-core base ]; + doHaddock = false; + doCheck = false; + homepage = "https://github.com/brendanhay/amazonka"; + description = "Amazon Server Migration Service SDK"; + license = stdenv.lib.licenses.mpl20; + }) {}; + "amazonka-snowball" = callPackage + ({ mkDerivation, amazonka-core, base, stdenv }: + mkDerivation { + pname = "amazonka-snowball"; + version = "1.6.0"; + sha256 = "534b30fe9205ba1edf8b1c5c4f4f91dccbe124f95a599f5efdf0cc4cd502ee25"; + libraryHaskellDepends = [ amazonka-core base ]; + doHaddock = false; + doCheck = false; + homepage = "https://github.com/brendanhay/amazonka"; + description = "Amazon Import/Export Snowball SDK"; + license = stdenv.lib.licenses.mpl20; + }) {}; + "amazonka-sns" = callPackage + ({ mkDerivation, amazonka-core, base, stdenv }: + mkDerivation { + pname = "amazonka-sns"; + version = "1.6.0"; + sha256 = "1d16b548031359ed593b14d172e7880847934e76bbedf535d014674414e37573"; + libraryHaskellDepends = [ amazonka-core base ]; + doHaddock = false; + doCheck = false; + homepage = "https://github.com/brendanhay/amazonka"; + description = "Amazon Simple Notification Service SDK"; + license = stdenv.lib.licenses.mpl20; + }) {}; + "amazonka-sqs" = callPackage + ({ mkDerivation, amazonka-core, base, stdenv }: + mkDerivation { + pname = "amazonka-sqs"; + version = "1.6.0"; + sha256 = "743838707d28707095700afdf2d875ff34c5fe1d90b214f5a7e48be04c900433"; + libraryHaskellDepends = [ amazonka-core base ]; + doHaddock = false; + doCheck = false; + homepage = "https://github.com/brendanhay/amazonka"; + description = "Amazon Simple Queue Service SDK"; + license = stdenv.lib.licenses.mpl20; + }) {}; + "amazonka-ssm" = callPackage + ({ mkDerivation, amazonka-core, base, stdenv }: + mkDerivation { + pname = "amazonka-ssm"; + version = "1.6.0"; + sha256 = "11218249760a2d06cfd5ad2b41bf67233b6178f86e2ab979c199088a5a1c701a"; + libraryHaskellDepends = [ amazonka-core base ]; + doHaddock = false; + doCheck = false; + homepage = "https://github.com/brendanhay/amazonka"; + description = "Amazon Simple Systems Manager (SSM) SDK"; + license = stdenv.lib.licenses.mpl20; + }) {}; + "amazonka-stepfunctions" = callPackage + ({ mkDerivation, amazonka-core, base, stdenv }: + mkDerivation { + pname = "amazonka-stepfunctions"; + version = "1.6.0"; + sha256 = "99ac8e545d28d7d765e180a26572d216f88d1e6ab9a2cd0f0a874992fa89acbf"; + libraryHaskellDepends = [ amazonka-core base ]; + doHaddock = false; + doCheck = false; + homepage = "https://github.com/brendanhay/amazonka"; + description = "Amazon Step Functions SDK"; + license = stdenv.lib.licenses.mpl20; + }) {}; + "amazonka-storagegateway" = callPackage + ({ mkDerivation, amazonka-core, base, stdenv }: + mkDerivation { + pname = "amazonka-storagegateway"; + version = "1.6.0"; + sha256 = "6f06376650f03107ebd13a622b77b1983da91c6030927e2d10afb4040b48b43d"; + libraryHaskellDepends = [ amazonka-core base ]; + doHaddock = false; + doCheck = false; + homepage = "https://github.com/brendanhay/amazonka"; + description = "Amazon Storage Gateway SDK"; + license = stdenv.lib.licenses.mpl20; + }) {}; + "amazonka-sts" = callPackage + ({ mkDerivation, amazonka-core, base, stdenv }: + mkDerivation { + pname = "amazonka-sts"; + version = "1.6.0"; + sha256 = "36056b67d6f97a5b137f7ae35f39fb5417c61991333347129ed3e77f79a99a12"; + libraryHaskellDepends = [ amazonka-core base ]; + doHaddock = false; + doCheck = false; + homepage = "https://github.com/brendanhay/amazonka"; + description = "Amazon Security Token Service SDK"; + license = stdenv.lib.licenses.mpl20; + }) {}; + "amazonka-support" = callPackage + ({ mkDerivation, amazonka-core, base, stdenv }: + mkDerivation { + pname = "amazonka-support"; + version = "1.6.0"; + sha256 = "7f434aef975f2817d4b9d7aa1c6055d788988e817fdb5c8fae20a787f26853e9"; + libraryHaskellDepends = [ amazonka-core base ]; + doHaddock = false; + doCheck = false; + homepage = "https://github.com/brendanhay/amazonka"; + description = "Amazon Support SDK"; + license = stdenv.lib.licenses.mpl20; + }) {}; + "amazonka-swf" = callPackage + ({ mkDerivation, amazonka-core, base, stdenv }: + mkDerivation { + pname = "amazonka-swf"; + version = "1.6.0"; + sha256 = "1f0e437ba9c1511f46c64df16ae4551667fee39ade3c32f251f9e34b2255aa90"; + libraryHaskellDepends = [ amazonka-core base ]; + doHaddock = false; + doCheck = false; + homepage = "https://github.com/brendanhay/amazonka"; + description = "Amazon Simple Workflow Service SDK"; + license = stdenv.lib.licenses.mpl20; + }) {}; + "amazonka-test" = callPackage + ({ mkDerivation, aeson, amazonka-core, base, bifunctors, bytestring + , case-insensitive, conduit, conduit-extra, groom, http-client + , http-types, process, resourcet, stdenv, tasty, tasty-hunit + , template-haskell, temporary, text, time, unordered-containers + , yaml + }: + mkDerivation { + pname = "amazonka-test"; + version = "1.6.0"; + sha256 = "46a8b77900370524a487f2ca0490473e23d0155664db2461c5504678d275dd28"; + libraryHaskellDepends = [ + aeson amazonka-core base bifunctors bytestring case-insensitive + conduit conduit-extra groom http-client http-types process + resourcet tasty tasty-hunit template-haskell temporary text time + unordered-containers yaml + ]; + doHaddock = false; + doCheck = false; + homepage = "https://github.com/brendanhay/amazonka"; + description = "Common functionality for Amazonka library test-suites"; + license = stdenv.lib.licenses.mpl20; + }) {}; + "amazonka-waf" = callPackage + ({ mkDerivation, amazonka-core, base, stdenv }: + mkDerivation { + pname = "amazonka-waf"; + version = "1.6.0"; + sha256 = "880b9ec52be2d8fb0f5711d1e5357b0ce566e98b775e3bb7921e8f4295bbb980"; + libraryHaskellDepends = [ amazonka-core base ]; + doHaddock = false; + doCheck = false; + homepage = "https://github.com/brendanhay/amazonka"; + description = "Amazon WAF SDK"; + license = stdenv.lib.licenses.mpl20; + }) {}; + "amazonka-workspaces" = callPackage + ({ mkDerivation, amazonka-core, base, stdenv }: + mkDerivation { + pname = "amazonka-workspaces"; + version = "1.6.0"; + sha256 = "56cf348d8c519a4db23693e81cccf822975ec5b37e74dda54f9f020415c91c84"; + libraryHaskellDepends = [ amazonka-core base ]; + doHaddock = false; + doCheck = false; + homepage = "https://github.com/brendanhay/amazonka"; + description = "Amazon WorkSpaces SDK"; + license = stdenv.lib.licenses.mpl20; + }) {}; + "amazonka-xray" = callPackage + ({ mkDerivation, amazonka-core, base, stdenv }: + mkDerivation { + pname = "amazonka-xray"; + version = "1.6.0"; + sha256 = "8f510075361aa600cd7759763f4de55aed07b8a7cce65eb445dfcf9f475590f0"; + libraryHaskellDepends = [ amazonka-core base ]; + doHaddock = false; + doCheck = false; + homepage = "https://github.com/brendanhay/amazonka"; + description = "Amazon X-Ray SDK"; + license = stdenv.lib.licenses.mpl20; + }) {}; + "amqp" = callPackage + ({ mkDerivation, base, binary, bytestring, clock, connection + , containers, data-binary-ieee754, monad-control, network + , network-uri, split, stdenv, stm, text, vector, xml + }: + mkDerivation { + pname = "amqp"; + version = "0.18.1"; + sha256 = "4678e2eb976df97e27cacbc4b1feafeb5a1800a9779b0a36666f04804f43e248"; + isLibrary = true; + isExecutable = true; + libraryHaskellDepends = [ + base binary bytestring clock connection containers + data-binary-ieee754 monad-control network network-uri split stm + text vector + ]; + executableHaskellDepends = [ base containers xml ]; + doHaddock = false; + doCheck = false; + homepage = "https://github.com/hreinhardt/amqp"; + description = "Client library for AMQP servers (currently only RabbitMQ)"; + license = stdenv.lib.licenses.bsd3; + }) {}; + "annotated-wl-pprint" = callPackage + ({ mkDerivation, base, stdenv }: + mkDerivation { + pname = "annotated-wl-pprint"; + version = "0.7.0"; + sha256 = "0c262d7fe13a9a50216438ec882c13e25f31236b886a5692e3c35b85cd773d18"; + revision = "1"; + editedCabalFile = "138k24qxvl90l7dwdw1b3w36mpw93n0xi0nljblqg88pxg7jcvjx"; + libraryHaskellDepends = [ base ]; + doHaddock = false; + doCheck = false; + homepage = "https://github.com/david-christiansen/annotated-wl-pprint"; + description = "The Wadler/Leijen Pretty Printer, with annotation support"; + license = stdenv.lib.licenses.bsd3; + }) {}; + "ansi-terminal" = callPackage + ({ mkDerivation, base, colour, stdenv }: + mkDerivation { + pname = "ansi-terminal"; + version = "0.8.0.4"; + sha256 = "eb3cb8b0d0ce1c67ae3146c0b73a83e640c6f049d36bd6e859b6b951117e4810"; + isLibrary = true; + isExecutable = true; + libraryHaskellDepends = [ base colour ]; + doHaddock = false; + doCheck = false; + homepage = "https://github.com/feuerbach/ansi-terminal"; + description = "Simple ANSI terminal support, with Windows compatibility"; + license = stdenv.lib.licenses.bsd3; + }) {}; + "ansi-wl-pprint" = callPackage + ({ mkDerivation, ansi-terminal, base, stdenv }: + mkDerivation { + pname = "ansi-wl-pprint"; + version = "0.6.8.2"; + sha256 = "a630721bd57678c3bfeb6c703f8249e434cbf85f40daceec4660fb8c6725cb3e"; + isLibrary = true; + isExecutable = true; + libraryHaskellDepends = [ ansi-terminal base ]; + doHaddock = false; + doCheck = false; + homepage = "http://github.com/ekmett/ansi-wl-pprint"; + description = "The Wadler/Leijen Pretty Printer for colored ANSI terminal output"; + license = stdenv.lib.licenses.bsd3; + }) {}; + "api-field-json-th" = callPackage + ({ mkDerivation, aeson, base, lens, split, stdenv, template-haskell + , text + }: + mkDerivation { + pname = "api-field-json-th"; + version = "0.1.0.2"; + sha256 = "b8d49c3869bc8104539c43d5544ed2271d1e68a963440d781ee71d2252b0f724"; + libraryHaskellDepends = [ + aeson base lens split template-haskell text + ]; + doHaddock = false; + doCheck = false; + homepage = "https://github.com/nakaji-dayo/api-field-json-th"; + description = "option of aeson's deriveJSON"; + license = stdenv.lib.licenses.bsd3; + }) {}; + "app-settings" = callPackage + ({ mkDerivation, base, containers, directory, mtl, parsec, stdenv + , text + }: + mkDerivation { + pname = "app-settings"; + version = "0.2.0.11"; + sha256 = "6a14c69aca4e55cf27933475f5ae0ffead3a83f69f4233896eb13c41dccd50b1"; + libraryHaskellDepends = [ + base containers directory mtl parsec text + ]; + doHaddock = false; + doCheck = false; + homepage = "https://github.com/emmanueltouzery/app-settings"; + description = "A library to manage application settings (INI file-like)"; + license = stdenv.lib.licenses.bsd3; + }) {}; + "appar" = callPackage + ({ mkDerivation, base, bytestring, stdenv }: + mkDerivation { + pname = "appar"; + version = "0.1.4"; + sha256 = "58ea66abe4dd502d2fc01eecdb0828d5e214704a3c1b33b1f8b33974644c4b26"; + libraryHaskellDepends = [ base bytestring ]; + doHaddock = false; + doCheck = false; + description = "A simple applicative parser"; + license = stdenv.lib.licenses.bsd3; + }) {}; + "apply-refact" = callPackage + ({ mkDerivation, base, containers, directory, filemanip, filepath + , ghc, ghc-exactprint, mtl, optparse-applicative, process, refact + , stdenv, syb, temporary, transformers, unix-compat + }: + mkDerivation { + pname = "apply-refact"; + version = "0.5.0.0"; + sha256 = "1f5fb9b53f5750c5c73e36f93a708189e15f7300cd2fb95da77ba87a215b74af"; + isLibrary = true; + isExecutable = true; + libraryHaskellDepends = [ + base containers directory filemanip ghc ghc-exactprint mtl process + refact syb temporary transformers unix-compat + ]; + executableHaskellDepends = [ + base containers directory filemanip filepath ghc ghc-exactprint mtl + optparse-applicative process refact syb temporary transformers + unix-compat + ]; + doHaddock = false; + doCheck = false; + description = "Perform refactorings specified by the refact library"; + license = stdenv.lib.licenses.bsd3; + }) {}; + "apportionment" = callPackage + ({ mkDerivation, base, containers, stdenv, utility-ht }: + mkDerivation { + pname = "apportionment"; + version = "0.0.0.2"; + sha256 = "352d9564ffdb01d3312a1087f8badc544b3478185cbc27d4ca29fc1f18c9f82b"; + libraryHaskellDepends = [ base containers utility-ht ]; + doHaddock = false; + doCheck = false; + homepage = "http://hub.darcs.net/thielema/apportionment"; + description = "Round a set of numbers while maintaining its sum"; + license = stdenv.lib.licenses.bsd3; + }) {}; + "approximate" = callPackage + ({ mkDerivation, base, binary, bytes, Cabal, cabal-doctest, cereal + , comonad, deepseq, ghc-prim, hashable, lens, log-domain, pointed + , safecopy, semigroupoids, semigroups, stdenv, vector + }: + mkDerivation { + pname = "approximate"; + version = "0.3.1"; + sha256 = "d837f716d9e73d68a53a17321f0433dd9ffe71df24d550aed6a34ec1c2ad2ea2"; + setupHaskellDepends = [ base Cabal cabal-doctest ]; + libraryHaskellDepends = [ + base binary bytes cereal comonad deepseq ghc-prim hashable lens + log-domain pointed safecopy semigroupoids semigroups vector + ]; + doHaddock = false; + doCheck = false; + homepage = "http://github.com/analytics/approximate/"; + description = "Approximate discrete values and numbers"; + license = stdenv.lib.licenses.bsd3; + }) {}; + "arithmoi" = callPackage + ({ mkDerivation, array, base, containers, exact-pi, ghc-prim + , integer-gmp, integer-logarithms, mtl, random, stdenv, vector + }: + mkDerivation { + pname = "arithmoi"; + version = "0.7.0.0"; + sha256 = "8b33049122c6194d61467b3685294c2c0029a3e877f481598f4b21b7285e030c"; + revision = "3"; + editedCabalFile = "1s0jm2y0jhfrj7af80csckiizkfq5h0v4zb92mkwh1pkfi763fha"; + configureFlags = [ "-f-llvm" ]; + libraryHaskellDepends = [ + array base containers exact-pi ghc-prim integer-gmp + integer-logarithms mtl random vector + ]; + doHaddock = false; + doCheck = false; + homepage = "https://github.com/cartazio/arithmoi"; + description = "Efficient basic number-theoretic functions"; + license = stdenv.lib.licenses.mit; + }) {}; + "array-memoize" = callPackage + ({ mkDerivation, array, base, stdenv }: + mkDerivation { + pname = "array-memoize"; + version = "0.6.0"; + sha256 = "76c88cb3ed04875821a5601f6a1c40f4e15ef8cb36e8a3d4004df956d1db05dc"; + libraryHaskellDepends = [ array base ]; + doHaddock = false; + doCheck = false; + description = "Memoization combinators using arrays for finite sub-domains of functions"; + license = stdenv.lib.licenses.bsd3; + }) {}; + "arrow-extras" = callPackage + ({ mkDerivation, base, stdenv }: + mkDerivation { + pname = "arrow-extras"; + version = "0.1.0.1"; + sha256 = "c13c3aba839d1ec78a49991fa4038a68c5eb9ef6da61eceb6e68bc3ce0586a6c"; + libraryHaskellDepends = [ base ]; + doHaddock = false; + doCheck = false; + homepage = "https://github.com/louispan/arrow-extras#readme"; + description = "Extra functions for Control.Arrow"; + license = stdenv.lib.licenses.bsd3; + }) {}; + "arrow-list" = callPackage + ({ mkDerivation, base, containers, mtl, stdenv }: + mkDerivation { + pname = "arrow-list"; + version = "0.7"; + sha256 = "33f836f23648aa2cea11533f7a9941127c397eecdca105b2084dded9e039d5d8"; + libraryHaskellDepends = [ base containers mtl ]; + doHaddock = false; + doCheck = false; + homepage = "https://github.com/silkapp/arrow-list"; + description = "List arrows for Haskell"; + license = stdenv.lib.licenses.bsd3; + }) {}; + "ascii-progress" = callPackage + ({ mkDerivation, async, base, concurrent-output, data-default + , stdenv, time + }: + mkDerivation { + pname = "ascii-progress"; + version = "0.3.3.0"; + sha256 = "7e3fa6b80c09a83c9ba8a0644ef304ca92d65b76383b8dd023ff9f89ebec913e"; + isLibrary = true; + isExecutable = true; + libraryHaskellDepends = [ + async base concurrent-output data-default time + ]; + doHaddock = false; + doCheck = false; + homepage = "https://github.com/yamadapc/haskell-ascii-progress"; + description = "A simple progress bar for the console"; + license = stdenv.lib.licenses.mit; + }) {}; + "asn1-encoding" = callPackage + ({ mkDerivation, asn1-types, base, bytestring, hourglass, stdenv }: + mkDerivation { + pname = "asn1-encoding"; + version = "0.9.5"; + sha256 = "1e863bfd363f6c3760cc80f2c0d422e17845a9f79fe006030db202ecab5aaf29"; + libraryHaskellDepends = [ asn1-types base bytestring hourglass ]; + doHaddock = false; + doCheck = false; + homepage = "http://github.com/vincenthz/hs-asn1"; + description = "ASN1 data reader and writer in RAW, BER and DER forms"; + license = stdenv.lib.licenses.bsd3; + }) {}; + "asn1-parse" = callPackage + ({ mkDerivation, asn1-encoding, asn1-types, base, bytestring + , stdenv + }: + mkDerivation { + pname = "asn1-parse"; + version = "0.9.4"; + sha256 = "c6a328f570c69db73f8d2416f9251e8a03753f90d5d19e76cbe69509a3ceb708"; + libraryHaskellDepends = [ + asn1-encoding asn1-types base bytestring + ]; + doHaddock = false; + doCheck = false; + homepage = "https://github.com/vincenthz/hs-asn1"; + description = "Simple monadic parser for ASN1 stream types"; + license = stdenv.lib.licenses.bsd3; + }) {}; + "asn1-types" = callPackage + ({ mkDerivation, base, bytestring, hourglass, memory, stdenv }: + mkDerivation { + pname = "asn1-types"; + version = "0.3.2"; + sha256 = "0c571fff4a10559c6a630d4851ba3cdf1d558185ce3dcfca1136f9883d647217"; + libraryHaskellDepends = [ base bytestring hourglass memory ]; + doHaddock = false; + doCheck = false; + homepage = "http://github.com/vincenthz/hs-asn1-types"; + description = "ASN.1 types"; + license = stdenv.lib.licenses.bsd3; + }) {}; + "assert-failure" = callPackage + ({ mkDerivation, base, pretty-show, stdenv, text }: + mkDerivation { + pname = "assert-failure"; + version = "0.1.2.2"; + sha256 = "f69416fd527b4f6933586edfc9ee741a2163c3741471e9b8e46a244495bd4a9d"; + enableSeparateDataOutput = true; + libraryHaskellDepends = [ base pretty-show text ]; + doHaddock = false; + doCheck = false; + homepage = "https://github.com/Mikolaj/assert-failure"; + description = "Syntactic sugar improving 'assert' and 'error'"; + license = stdenv.lib.licenses.bsd3; + }) {}; + "astro" = callPackage + ({ mkDerivation, base, matrix, stdenv, time }: + mkDerivation { + pname = "astro"; + version = "0.4.2.1"; + sha256 = "da5dde1bcf42e4f48f5f23dbf3a890a2904ecaf86df3d75e365e071b924afe29"; + libraryHaskellDepends = [ base matrix time ]; + doHaddock = false; + doCheck = false; + homepage = "https://github.com/aligusnet/astro"; + description = "Amateur astronomical computations"; + license = stdenv.lib.licenses.bsd3; + }) {}; + "async" = callPackage + ({ mkDerivation, base, hashable, stdenv, stm }: + mkDerivation { + pname = "async"; + version = "2.2.1"; + sha256 = "8f0b86022a1319d3c1c68655790da4b7f98017982e27ec3f3dbfe01029d39027"; + revision = "1"; + editedCabalFile = "0lg8c3iixm7vjjq2nydkqswj78i4iyx2k83hgs12z829yj196y31"; + isLibrary = true; + isExecutable = true; + libraryHaskellDepends = [ base hashable stm ]; + doHaddock = false; + doCheck = false; + homepage = "https://github.com/simonmar/async"; + description = "Run IO operations asynchronously and wait for their results"; + license = stdenv.lib.licenses.bsd3; + }) {}; + "async-extra" = callPackage + ({ mkDerivation, async, base, deepseq, split, stdenv }: + mkDerivation { + pname = "async-extra"; + version = "0.2.0.0"; + sha256 = "0d06d5a5cb835597ff1668ae58a1f0d048830164876838533dec4a78eb11cc43"; + libraryHaskellDepends = [ async base deepseq split ]; + doHaddock = false; + doCheck = false; + homepage = "https://github.com/agrafix/async-extra#readme"; + description = "Useful concurrent combinators"; + license = stdenv.lib.licenses.mit; + }) {}; + "async-refresh" = callPackage + ({ mkDerivation, base, formatting, lifted-async, microlens + , microlens-th, monad-logger, safe-exceptions, stdenv, stm, text + , unliftio, unliftio-core + }: + mkDerivation { + pname = "async-refresh"; + version = "0.3.0.0"; + sha256 = "da68061b2548a9b5b3e6f4af60120554ebfae9638dfa0b10cf7a244710a334c9"; + libraryHaskellDepends = [ + base formatting lifted-async microlens microlens-th monad-logger + safe-exceptions stm text unliftio unliftio-core + ]; + doHaddock = false; + doCheck = false; + homepage = "https://github.com/mtesseract/async-refresh"; + description = "Package implementing core logic for refreshing of expiring data"; + license = stdenv.lib.licenses.bsd3; + }) {}; + "async-refresh-tokens" = callPackage + ({ mkDerivation, async-refresh, base, bytestring, formatting + , microlens, microlens-th, monad-logger, safe-exceptions, stdenv + , text, unliftio, unliftio-core + }: + mkDerivation { + pname = "async-refresh-tokens"; + version = "0.4.0.0"; + sha256 = "67a7419449428fc5f80e9cfc392df115f03721811d6cd73a6c7cbd83f48dc7df"; + libraryHaskellDepends = [ + async-refresh base bytestring formatting microlens microlens-th + monad-logger safe-exceptions text unliftio unliftio-core + ]; + doHaddock = false; + doCheck = false; + homepage = "https://github.com/mtesseract/async-refresh-tokens#readme"; + description = "Package implementing core logic for refreshing of expiring access tokens"; + license = stdenv.lib.licenses.bsd3; + }) {}; + "async-timer" = callPackage + ({ mkDerivation, async, base, safe-exceptions, stdenv, unliftio + , unliftio-core + }: + mkDerivation { + pname = "async-timer"; + version = "0.2.0.0"; + sha256 = "0632bfc4c141aa47c461747b3edb59f76ef5523a66ac03be0f32868a5e04cee0"; + libraryHaskellDepends = [ + async base safe-exceptions unliftio unliftio-core + ]; + doHaddock = false; + doCheck = false; + homepage = "https://github.com/mtesseract/async-timer#readme"; + description = "Provides API for timer based execution of IO actions"; + license = stdenv.lib.licenses.bsd3; + }) {}; + "atom-basic" = callPackage + ({ mkDerivation, base, base64-bytestring, bytestring, network + , network-uri, stdenv, text, time + }: + mkDerivation { + pname = "atom-basic"; + version = "0.2.5"; + sha256 = "24be9667b8bad3ad63b2e9b42fdea5aa0fd96f7e90f52fb1203adfa71d2f75ee"; + libraryHaskellDepends = [ + base base64-bytestring bytestring network network-uri text time + ]; + doHaddock = false; + doCheck = false; + description = "Basic Atom feed construction"; + license = stdenv.lib.licenses.bsd3; + }) {}; + "atom-conduit" = callPackage + ({ mkDerivation, base, blaze-builder, conduit, conduit-combinators + , lens-simple, mono-traversable, parsers, safe-exceptions, stdenv + , text, time, timerep, uri-bytestring, xml-conduit, xml-types + }: + mkDerivation { + pname = "atom-conduit"; + version = "0.5.0.1"; + sha256 = "8c88c5c77567753b56163bfa596f50a9cfdde28796e66bb194ca6d9057e831cd"; + libraryHaskellDepends = [ + base blaze-builder conduit conduit-combinators lens-simple + mono-traversable parsers safe-exceptions text time timerep + uri-bytestring xml-conduit xml-types + ]; + doHaddock = false; + doCheck = false; + description = "Streaming parser/renderer for the Atom 1.0 standard (RFC 4287)."; + license = stdenv.lib.licenses.publicDomain; + }) {}; + "atomic-primops" = callPackage + ({ mkDerivation, base, ghc-prim, primitive, stdenv }: + mkDerivation { + pname = "atomic-primops"; + version = "0.8.2"; + sha256 = "67f8872e0c1e634d819a967365eb4ad514e9b2cde967fbc710da7cdc4d17d933"; + revision = "1"; + editedCabalFile = "0gdcd84x2s4jiry0was74rzv9l53an1q6ad8jiaj37fr4fim0wcc"; + libraryHaskellDepends = [ base ghc-prim primitive ]; + doHaddock = false; + doCheck = false; + homepage = "https://github.com/rrnewton/haskell-lockfree/wiki"; + description = "A safe approach to CAS and other atomic ops in Haskell"; + license = stdenv.lib.licenses.bsd3; + }) {}; + "atomic-write" = callPackage + ({ mkDerivation, base, bytestring, directory, filepath, stdenv + , temporary, text, unix-compat + }: + mkDerivation { + pname = "atomic-write"; + version = "0.2.0.5"; + sha256 = "dbc7b4c31c734ad12d8f6c05b5d1384ee57f50ad8ff1a703d560b39e2f0458c5"; + libraryHaskellDepends = [ + base bytestring directory filepath temporary text unix-compat + ]; + doHaddock = false; + doCheck = false; + homepage = "https://github.com/stackbuilders/atomic-write"; + description = "Atomically write to a file"; + license = stdenv.lib.licenses.mit; + }) {}; + "attoparsec" = callPackage + ({ mkDerivation, array, base, bytestring, containers, deepseq + , scientific, stdenv, text, transformers + }: + mkDerivation { + pname = "attoparsec"; + version = "0.13.2.2"; + sha256 = "dd93471eb969172cc4408222a3842d867adda3dd7fb39ad8a4df1b121a67d848"; + revision = "2"; + editedCabalFile = "1j06na26rsahrbkzrs71nl7ym8fk390pnvh577wlxs4ik6hsn2va"; + libraryHaskellDepends = [ + array base bytestring containers deepseq scientific text + transformers + ]; + doHaddock = false; + doCheck = false; + homepage = "https://github.com/bos/attoparsec"; + description = "Fast combinator parsing for bytestrings and text"; + license = stdenv.lib.licenses.bsd3; + }) {}; + "attoparsec-base64" = callPackage + ({ mkDerivation, attoparsec, base, bytestring, stdenv, text, word8 + }: + mkDerivation { + pname = "attoparsec-base64"; + version = "0.0.0"; + sha256 = "0833530c8b4a46217272d14638f91325e156b22046fa291b528228afe66173e7"; + libraryHaskellDepends = [ attoparsec base bytestring text word8 ]; + doHaddock = false; + doCheck = false; + homepage = "https://github.com/athanclark/attoparsec-base64#readme"; + description = "Fetch only base64 characters, erroring in the attoparsec monad on failure"; + license = stdenv.lib.licenses.bsd3; + }) {}; + "attoparsec-binary" = callPackage + ({ mkDerivation, attoparsec, base, bytestring, stdenv }: + mkDerivation { + pname = "attoparsec-binary"; + version = "0.2"; + sha256 = "05e6445b20b396c99275de3e37bf8bb18559a5666ad5136907857bf574e77a0b"; + libraryHaskellDepends = [ attoparsec base bytestring ]; + doHaddock = false; + doCheck = false; + description = "Binary processing extensions to Attoparsec"; + license = stdenv.lib.licenses.bsd3; + }) {}; + "attoparsec-expr" = callPackage + ({ mkDerivation, attoparsec, base, stdenv }: + mkDerivation { + pname = "attoparsec-expr"; + version = "0.1.1.2"; + sha256 = "8d4cd436112ce9007d2831776d4c5102a5322c48993229d2d41e259c07bb457c"; + libraryHaskellDepends = [ attoparsec base ]; + doHaddock = false; + doCheck = false; + description = "Port of parsec's expression parser to attoparsec"; + license = stdenv.lib.licenses.bsd3; + }) {}; + "attoparsec-ip" = callPackage + ({ mkDerivation, attoparsec, base, ip, stdenv }: + mkDerivation { + pname = "attoparsec-ip"; + version = "0.0.1"; + sha256 = "8da5ca8ae483bbb8dacfae3a888fa9438f55f84f8605e7c769091ee5b6555629"; + libraryHaskellDepends = [ attoparsec base ip ]; + doHaddock = false; + doCheck = false; + homepage = "https://github.com/athanclark/attoparsec-ip#readme"; + description = "Parse IP data types with attoparsec"; + license = stdenv.lib.licenses.bsd3; + }) {}; + "attoparsec-iso8601" = callPackage + ({ mkDerivation, attoparsec, base, base-compat, stdenv, text, time + }: + mkDerivation { + pname = "attoparsec-iso8601"; + version = "1.0.0.0"; + sha256 = "aa6c6d87587383e386cb85e7ffcc4a6317aa8dafb8ba9a104ecac365ce2a858a"; + revision = "1"; + editedCabalFile = "06f7pgmmc8456p3hc1y23kz1y127gfczy7s00wz1rls9g2sm2vi4"; + libraryHaskellDepends = [ attoparsec base base-compat text time ]; + doHaddock = false; + doCheck = false; + homepage = "https://github.com/bos/aeson"; + description = "Parsing of ISO 8601 dates, originally from aeson"; + license = stdenv.lib.licenses.bsd3; + }) {}; + "attoparsec-path" = callPackage + ({ mkDerivation, attoparsec, base, path, stdenv, text }: + mkDerivation { + pname = "attoparsec-path"; + version = "0.0.0.1"; + sha256 = "d07126622210fdb18722f585c61bda0a17389aecc83e786f9f6e621ec120b60c"; + libraryHaskellDepends = [ attoparsec base path text ]; + doHaddock = false; + doCheck = false; + homepage = "https://github.com/athanclark/attoparsec-path#readme"; + description = "Convenience bindings between path and attoparsec"; + license = stdenv.lib.licenses.bsd3; + }) {}; + "attoparsec-uri" = callPackage + ({ mkDerivation, attoparsec, attoparsec-ip, base, bytedump, ip + , stdenv, strict, text, vector + }: + mkDerivation { + pname = "attoparsec-uri"; + version = "0.0.4"; + sha256 = "4e032ccaa65f96edac79556431ade75ad400371d0a5c19aeed6a7adbd3d2f1f3"; + libraryHaskellDepends = [ + attoparsec attoparsec-ip base bytedump ip strict text vector + ]; + doHaddock = false; + doCheck = false; + homepage = "https://github.com/athanclark/attoparsec-uri#readme"; + description = "URI parser / printer using attoparsec"; + license = stdenv.lib.licenses.bsd3; + }) {}; + "audacity" = callPackage + ({ mkDerivation, base, bytestring, deepseq, directory + , explicit-exception, filepath, non-empty, semigroups, stdenv + , storable-record, storablevector, tagchup, transformers + , utility-ht, xml-basic + }: + mkDerivation { + pname = "audacity"; + version = "0.0.2"; + sha256 = "d9d2dfb1c4e6ad39b535561feb720a7889dc1151ad6625fd5522d4212dbc26a4"; + isLibrary = true; + isExecutable = true; + libraryHaskellDepends = [ + base bytestring deepseq directory explicit-exception filepath + non-empty semigroups storable-record storablevector tagchup + transformers utility-ht xml-basic + ]; + doHaddock = false; + doCheck = false; + homepage = "http://hub.darcs.net/thielema/audacity"; + description = "Interchange with the Audacity sound signal editor"; + license = stdenv.lib.licenses.bsd3; + }) {}; + "authenticate" = callPackage + ({ mkDerivation, aeson, attoparsec, base, blaze-builder, bytestring + , case-insensitive, conduit, containers, http-conduit, http-types + , network-uri, resourcet, stdenv, tagstream-conduit, text + , transformers, unordered-containers, xml-conduit + }: + mkDerivation { + pname = "authenticate"; + version = "1.3.4"; + sha256 = "3fd566dbfdf75d81ad1bebd19facb9f01509ead6e27d9aed802404ecde932fb8"; + libraryHaskellDepends = [ + aeson attoparsec base blaze-builder bytestring case-insensitive + conduit containers http-conduit http-types network-uri resourcet + tagstream-conduit text transformers unordered-containers + xml-conduit + ]; + doHaddock = false; + doCheck = false; + homepage = "http://github.com/yesodweb/authenticate"; + description = "Authentication methods for Haskell web applications"; + license = stdenv.lib.licenses.mit; + }) {}; + "authenticate-oauth" = callPackage + ({ mkDerivation, base, base64-bytestring, blaze-builder, bytestring + , crypto-pubkey-types, data-default, http-client, http-types + , random, RSA, SHA, stdenv, time, transformers, transformers-compat + }: + mkDerivation { + pname = "authenticate-oauth"; + version = "1.6"; + sha256 = "d26d9f10fd57e06fa2af066df65e578ff3ec7541efc3e6648b29a743b13f8375"; + revision = "1"; + editedCabalFile = "1fxwn8bn6qs8dhxq0q04psq7zp1qvw1b6g3vmsclgyj9p7kr77ms"; + libraryHaskellDepends = [ + base base64-bytestring blaze-builder bytestring crypto-pubkey-types + data-default http-client http-types random RSA SHA time + transformers transformers-compat + ]; + doHaddock = false; + doCheck = false; + homepage = "http://github.com/yesodweb/authenticate"; + description = "Library to authenticate with OAuth for Haskell web applications"; + license = stdenv.lib.licenses.bsd3; + }) {}; + "auto" = callPackage + ({ mkDerivation, base, base-orphans, bytestring, cereal, containers + , deepseq, MonadRandom, profunctors, random, semigroups, stdenv + , transformers + }: + mkDerivation { + pname = "auto"; + version = "0.4.3.1"; + sha256 = "c6e26d1cbb17e3645e55bc8e9432b124520fbcba5ff32445acd4260c25cd3b41"; + libraryHaskellDepends = [ + base base-orphans bytestring cereal containers deepseq MonadRandom + profunctors random semigroups transformers + ]; + doHaddock = false; + doCheck = false; + homepage = "https://github.com/mstksg/auto"; + description = "Denotative, locally stateful programming DSL & platform"; + license = stdenv.lib.licenses.mit; + }) {}; + "auto-update" = callPackage + ({ mkDerivation, base, stdenv }: + mkDerivation { + pname = "auto-update"; + version = "0.1.4"; + sha256 = "5e96c151024e8bcaf4eaa932e16995872b2017f46124b967e155744d9580b425"; + libraryHaskellDepends = [ base ]; + doHaddock = false; + doCheck = false; + homepage = "https://github.com/yesodweb/wai"; + description = "Efficiently run periodic, on-demand actions"; + license = stdenv.lib.licenses.mit; + }) {}; + "autoexporter" = callPackage + ({ mkDerivation, base, Cabal, directory, filepath, stdenv }: + mkDerivation { + pname = "autoexporter"; + version = "1.1.10"; + sha256 = "1938c27312af0adef6e2fc60a2870fd92dfe366800a420337bb6d46f0f44c265"; + isLibrary = true; + isExecutable = true; + libraryHaskellDepends = [ base Cabal directory filepath ]; + executableHaskellDepends = [ base Cabal directory filepath ]; + doHaddock = false; + doCheck = false; + homepage = "https://github.com/tfausak/autoexporter#readme"; + description = "Automatically re-export modules"; + license = stdenv.lib.licenses.mit; + }) {}; + "avro" = callPackage + ({ mkDerivation, aeson, array, base, base16-bytestring, binary + , bytestring, containers, data-binary-ieee754, entropy, fail + , hashable, mtl, pure-zlib, scientific, semigroups, stdenv, tagged + , template-haskell, text, unordered-containers, vector + }: + mkDerivation { + pname = "avro"; + version = "0.3.2.0"; + sha256 = "40053917302ac3c3af9f077756dd8e1b0765a9d99f344baa2bcf8a5b0ea6d610"; + revision = "1"; + editedCabalFile = "08pi93ia3pqndr3429c4mm338kg4bj6byjyzd9vhkss4lc3i13n0"; + libraryHaskellDepends = [ + aeson array base base16-bytestring binary bytestring containers + data-binary-ieee754 entropy fail hashable mtl pure-zlib scientific + semigroups tagged template-haskell text unordered-containers vector + ]; + doHaddock = false; + doCheck = false; + homepage = "https://github.com/GaloisInc/avro.git#readme"; + description = "Avro serialization support for Haskell"; + license = stdenv.lib.licenses.bsd3; + }) {}; + "avwx" = callPackage + ({ mkDerivation, attoparsec, base, HTTP, lens, optparse-applicative + , parsers, pretty-show, stdenv, text + }: + mkDerivation { + pname = "avwx"; + version = "0.3.0.2"; + sha256 = "b4299cc4e05a4c94f53d06f05b30baac1e15c59663b59afd1dd32417a280fb0a"; + isLibrary = true; + isExecutable = true; + libraryHaskellDepends = [ attoparsec base HTTP lens parsers text ]; + executableHaskellDepends = [ + base optparse-applicative pretty-show text + ]; + doHaddock = false; + doCheck = false; + homepage = "https://www.hcesperer.org/posts/2016-09-20-avwx.html"; + description = "Parse aviation weather reports"; + license = stdenv.lib.licenses.mit; + }) {}; + "backerei" = callPackage + ({ mkDerivation, aeson, aeson-pretty, ansi-wl-pprint, atomic-write + , base, base16-bytestring, base58string, bytestring, containers + , data-default-class, directory, fetchgit, foundation, gitrev + , hpack, optparse-applicative, posix-pty, process, req + , servant-client, stdenv, telegram-bot-simple, text, time, vector + , yaml + }: + mkDerivation { + pname = "backerei"; + version = "0.1.0.0"; + src = fetchgit { + url = "https://github.com/cryptiumlabs/backerei.git"; + sha256 = "0ggrz21pkqp9rgkbx5q0jan1lpryg33c2m5rc2z6401v79wcsyzr"; + rev = "5b266bcd84d570de8ab06cb79b2457c0992080d4"; + fetchSubmodules = true; + }; + isLibrary = true; + isExecutable = true; + libraryHaskellDepends = [ + aeson base base16-bytestring base58string bytestring containers + data-default-class foundation req text time vector + ]; + libraryToolDepends = [ hpack ]; + executableHaskellDepends = [ + aeson aeson-pretty ansi-wl-pprint atomic-write base bytestring + containers directory foundation gitrev optparse-applicative + posix-pty process servant-client telegram-bot-simple text yaml + ]; + doHaddock = false; + doCheck = false; + preConfigure = "hpack"; + homepage = "https://github.com/cryptiumlabs/backerei#readme"; + license = stdenv.lib.licenses.mit; + }) {}; + "backprop" = callPackage + ({ mkDerivation, base, containers, deepseq, microlens, primitive + , reflection, simple-reflect, stdenv, transformers, vector, vinyl + }: + mkDerivation { + pname = "backprop"; + version = "0.2.5.0"; + sha256 = "aa2dbe41de6aa015cd3c0d9edb21ab24254d19b9205fbc440fc2a6cbccae6bf5"; + libraryHaskellDepends = [ + base containers deepseq microlens primitive reflection + simple-reflect transformers vector vinyl + ]; + doHaddock = false; + doCheck = false; + homepage = "https://backprop.jle.im"; + description = "Heterogeneous automatic differentation"; + license = stdenv.lib.licenses.bsd3; + }) {}; + "bank-holidays-england" = callPackage + ({ mkDerivation, base, containers, stdenv, time }: + mkDerivation { + pname = "bank-holidays-england"; + version = "0.1.0.7"; + sha256 = "7a4af621db84fba450edcab43d275b5c3f5f8bf3ed5b5211d75e5275986ad4a4"; + libraryHaskellDepends = [ base containers time ]; + doHaddock = false; + doCheck = false; + homepage = "https://bitbucket.org/davecturner/bank-holidays-england"; + description = "Calculation of bank holidays in England and Wales"; + license = stdenv.lib.licenses.bsd3; + }) {}; + "barrier" = callPackage + ({ mkDerivation, base, blaze-svg, bytestring, stdenv + , template-haskell, text, unordered-containers + }: + mkDerivation { + pname = "barrier"; + version = "0.1.1"; + sha256 = "6395da01eea1984c7bcc85c624b1b5dfbe0b6b764adeed7b04c9fa4d8de91ed9"; + revision = "1"; + editedCabalFile = "167akvi72l47gcqbq5609m24469pq0xmv0kjbmivnrxs796gh890"; + isLibrary = true; + isExecutable = true; + enableSeparateDataOutput = true; + libraryHaskellDepends = [ + base blaze-svg bytestring template-haskell text + unordered-containers + ]; + doHaddock = false; + doCheck = false; + homepage = "https://github.com/philopon/barrier"; + description = "Shields.io style badge generator"; + license = stdenv.lib.licenses.mit; + }) {}; + "base-compat" = callPackage + ({ mkDerivation, base, stdenv, unix }: + mkDerivation { + pname = "base-compat"; + version = "0.10.4"; + sha256 = "0d693707a70bcb553acd133129a9fbca0ea257eeebe714700de3e8fe404a574f"; + libraryHaskellDepends = [ base unix ]; + doHaddock = false; + doCheck = false; + description = "A compatibility layer for base"; + license = stdenv.lib.licenses.mit; + }) {}; + "base-compat-batteries" = callPackage + ({ mkDerivation, base, base-compat, stdenv }: + mkDerivation { + pname = "base-compat-batteries"; + version = "0.10.1"; + sha256 = "15578bafe45db81f7c7ad33253b2b047dab9b6df4ca7ca57f541d64084f113c9"; + libraryHaskellDepends = [ base base-compat ]; + doHaddock = false; + doCheck = false; + description = "base-compat with extra batteries"; + license = stdenv.lib.licenses.mit; + }) {}; + "base-orphans" = callPackage + ({ mkDerivation, base, ghc-prim, stdenv }: + mkDerivation { + pname = "base-orphans"; + version = "0.7"; + sha256 = "0aaddc39e3d0bba13acfcf0009ef57bf91d2ee74b295041d63e14c6caf4dee14"; + libraryHaskellDepends = [ base ghc-prim ]; + doHaddock = false; + doCheck = false; + homepage = "https://github.com/haskell-compat/base-orphans#readme"; + description = "Backwards-compatible orphan instances for base"; + license = stdenv.lib.licenses.mit; + }) {}; + "base-prelude" = callPackage + ({ mkDerivation, base, stdenv }: + mkDerivation { + pname = "base-prelude"; + version = "1.3"; + sha256 = "e3cc66e99d6c83aac548c4d8e6a166e5bd9cf557947cde49161026d0341267fe"; + libraryHaskellDepends = [ base ]; + doHaddock = false; + doCheck = false; + homepage = "https://github.com/nikita-volkov/base-prelude"; + description = "The most complete prelude formed solely from the \"base\" package"; + license = stdenv.lib.licenses.mit; + }) {}; + "base-unicode-symbols" = callPackage + ({ mkDerivation, base, stdenv }: + mkDerivation { + pname = "base-unicode-symbols"; + version = "0.2.2.4"; + sha256 = "a2f841430fec32edba778b74bde83bf0170ada7c5e2e59d7187c8f06d92dcca9"; + libraryHaskellDepends = [ base ]; + doHaddock = false; + doCheck = false; + homepage = "http://haskell.org/haskellwiki/Unicode-symbols"; + description = "Unicode alternatives for common functions and operators"; + license = stdenv.lib.licenses.bsd3; + }) {}; + "base16-bytestring" = callPackage + ({ mkDerivation, base, bytestring, ghc-prim, stdenv }: + mkDerivation { + pname = "base16-bytestring"; + version = "0.1.1.6"; + sha256 = "5afe65a152c5418f5f4e3579a5e0d5ca19c279dc9bf31c1a371ccbe84705c449"; + libraryHaskellDepends = [ base bytestring ghc-prim ]; + doHaddock = false; + doCheck = false; + homepage = "http://github.com/bos/base16-bytestring"; + description = "Fast base16 (hex) encoding and decoding for ByteStrings"; + license = stdenv.lib.licenses.bsd3; + }) {}; + "base32string" = callPackage + ({ mkDerivation, aeson, base, binary, bytestring, stdenv, text }: + mkDerivation { + pname = "base32string"; + version = "0.9.1"; + sha256 = "9e931613aeba5f630f9292fc99131388f406e4b34d8f050515ed93aaf632ea32"; + enableSeparateDataOutput = true; + libraryHaskellDepends = [ aeson base binary bytestring text ]; + doHaddock = false; + doCheck = false; + homepage = "http://www.leonmergen.com/opensource.html"; + description = "Fast and safe representation of a Base-32 string"; + license = stdenv.lib.licenses.mit; + }) {}; + "base58string" = callPackage + ({ mkDerivation, aeson, base, binary, bytestring, stdenv, text }: + mkDerivation { + pname = "base58string"; + version = "0.10.0"; + sha256 = "3b72607dd76e30a5054acea656c3805f7191e27d67884a7db5fbc73c17e9c088"; + enableSeparateDataOutput = true; + libraryHaskellDepends = [ aeson base binary bytestring text ]; + doHaddock = false; + doCheck = false; + homepage = "http://www.leonmergen.com/opensource.html"; + description = "Fast and safe representation of a Base-58 string"; + license = stdenv.lib.licenses.mit; + }) {}; + "base64-bytestring" = callPackage + ({ mkDerivation, base, bytestring, stdenv }: + mkDerivation { + pname = "base64-bytestring"; + version = "1.0.0.1"; + sha256 = "ab25abf4b00a2f52b270bc3ed43f1d59f16c8eec9d7dffb14df1e9265b233b50"; + libraryHaskellDepends = [ base bytestring ]; + doHaddock = false; + doCheck = false; + homepage = "https://github.com/bos/base64-bytestring"; + description = "Fast base64 encoding and decoding for ByteStrings"; + license = stdenv.lib.licenses.bsd3; + }) {}; + "base64-bytestring-type" = callPackage + ({ mkDerivation, aeson, base, base-compat, base64-bytestring + , binary, bytestring, cereal, deepseq, hashable, QuickCheck, stdenv + , text + }: + mkDerivation { + pname = "base64-bytestring-type"; + version = "1"; + sha256 = "74019bd11f8012ae5ccc88c206bc5a8024f7605130099aabbac012073160e440"; + revision = "4"; + editedCabalFile = "0yfhy4a9n67l9w3amqrzzy79q47yyj6qbv5i5lqym5z7ygwmlzn6"; + libraryHaskellDepends = [ + aeson base base-compat base64-bytestring binary bytestring cereal + deepseq hashable QuickCheck text + ]; + doHaddock = false; + doCheck = false; + homepage = "https://github.com/futurice/haskell-base64-bytestring-type#readme"; + description = "A newtype around ByteString, for base64 encoding"; + license = stdenv.lib.licenses.bsd3; + }) {}; + "base64-string" = callPackage + ({ mkDerivation, base, stdenv }: + mkDerivation { + pname = "base64-string"; + version = "0.2"; + sha256 = "3ec896ca7261ad4ddeffbaa3bdf4d5cb61775250c303fca9929aa9a56acc705e"; + libraryHaskellDepends = [ base ]; + doHaddock = false; + doCheck = false; + homepage = "http://urchin.earth.li/~ian/cabal/base64-string/"; + description = "Base64 implementation for String's"; + license = "unknown"; + }) {}; + "basement" = callPackage + ({ mkDerivation, base, ghc-prim, stdenv }: + mkDerivation { + pname = "basement"; + version = "0.0.8"; + sha256 = "c7f41b97f2b0a71804c3c7d760047dc9adc9734e789084ca1198c4764ce192a4"; + revision = "1"; + editedCabalFile = "005w4d6bkx6xq1whgwna4rqmxc36vgjbvb8q35sh1z2s76l89ajy"; + libraryHaskellDepends = [ base ghc-prim ]; + doHaddock = false; + doCheck = false; + homepage = "https://github.com/haskell-foundation/foundation#readme"; + description = "Foundation scrap box of array & string"; + license = stdenv.lib.licenses.bsd3; + }) {}; + "basic-prelude" = callPackage + ({ mkDerivation, base, bytestring, containers, filepath, hashable + , stdenv, text, transformers, unordered-containers, vector + }: + mkDerivation { + pname = "basic-prelude"; + version = "0.7.0"; + sha256 = "10755f892548faa956b81b40d1d03ec6e94609fd8ec8e92be09b4453b7ad9379"; + libraryHaskellDepends = [ + base bytestring containers filepath hashable text transformers + unordered-containers vector + ]; + doHaddock = false; + doCheck = false; + homepage = "https://github.com/snoyberg/basic-prelude#readme"; + description = "An enhanced core prelude; a common foundation for alternate preludes"; + license = stdenv.lib.licenses.mit; + }) {}; + "bbdb" = callPackage + ({ mkDerivation, base, parsec, stdenv }: + mkDerivation { + pname = "bbdb"; + version = "0.8"; + sha256 = "dce7798cb8e46e1c0f7048579496cabeebddaba9b6233820fd0496723fbc2a5c"; + libraryHaskellDepends = [ base parsec ]; + doHaddock = false; + doCheck = false; + homepage = "https://github.com/henrylaxen/bbdb"; + description = "Ability to read, write, and modify BBDB files"; + license = stdenv.lib.licenses.gpl3; + }) {}; + "bcrypt" = callPackage + ({ mkDerivation, base, bytestring, data-default, entropy, memory + , stdenv + }: + mkDerivation { + pname = "bcrypt"; + version = "0.0.11"; + sha256 = "e4331788eda7b65064d88930b4b7a50f5011bdec0ad46059d8c4ee6a5e72fcef"; + libraryHaskellDepends = [ + base bytestring data-default entropy memory + ]; + doHaddock = false; + doCheck = false; + description = "Haskell bindings to the bcrypt password hash"; + license = stdenv.lib.licenses.bsd3; + }) {}; + "beam-core" = callPackage + ({ mkDerivation, aeson, base, bytestring, containers, dlist, free + , ghc-prim, hashable, microlens, mtl, network-uri, stdenv, tagged + , text, time, vector-sized + }: + mkDerivation { + pname = "beam-core"; + version = "0.7.2.2"; + sha256 = "1231aedb995f40758924ad39d3476a51b3a186e5e849f3d4b284860838500f98"; + revision = "1"; + editedCabalFile = "1fvds5arsm0h81fw4rf5fsg5sa9jfqn350amhhc247f0hhjy3csf"; + libraryHaskellDepends = [ + aeson base bytestring containers dlist free ghc-prim hashable + microlens mtl network-uri tagged text time vector-sized + ]; + doHaddock = false; + doCheck = false; + homepage = "http://travis.athougies.net/projects/beam.html"; + description = "Type-safe, feature-complete SQL query and manipulation interface for Haskell"; + license = stdenv.lib.licenses.mit; + }) {}; + "beam-migrate" = callPackage + ({ mkDerivation, aeson, base, beam-core, bytestring, containers + , deepseq, dependent-map, dependent-sum, free, ghc-prim, hashable + , haskell-src-exts, mtl, parallel, pqueue, pretty, scientific + , stdenv, text, time, unordered-containers, uuid-types, vector + }: + mkDerivation { + pname = "beam-migrate"; + version = "0.3.2.1"; + sha256 = "2d195926ead3ed550e5efddd32f87f4cc93a5bad6ac8c2906478387ed0f39373"; + revision = "1"; + editedCabalFile = "1ghg6n0dj63i0am7wh0cg95hwyf29gnkm0llrw3wb5pj8f7937gv"; + libraryHaskellDepends = [ + aeson base beam-core bytestring containers deepseq dependent-map + dependent-sum free ghc-prim hashable haskell-src-exts mtl parallel + pqueue pretty scientific text time unordered-containers uuid-types + vector + ]; + doHaddock = false; + doCheck = false; + homepage = "https://travis.athougies.net/projects/beam.html"; + description = "SQL DDL support and migrations support library for Beam"; + license = stdenv.lib.licenses.mit; + }) {}; + "bench" = callPackage + ({ mkDerivation, base, criterion, optparse-applicative, process + , silently, stdenv, text, turtle + }: + mkDerivation { + pname = "bench"; + version = "1.0.11"; + sha256 = "a84e6faa55e62b7cb9f7d28a1d1828298f1c37b24c2a16da86954a35534a3b97"; + isLibrary = false; + isExecutable = true; + executableHaskellDepends = [ + base criterion optparse-applicative process silently text turtle + ]; + doHaddock = false; + doCheck = false; + homepage = "https://github.com/Gabriel439/bench"; + description = "Command-line benchmark tool"; + license = stdenv.lib.licenses.bsd3; + }) {}; + "bencode" = callPackage + ({ mkDerivation, base, binary, bytestring, containers, parsec + , stdenv + }: + mkDerivation { + pname = "bencode"; + version = "0.6.0.0"; + sha256 = "3b8efdfecee9bc486d9bcdbb633b7128ca235360f102478a7e0f8c895281f68a"; + libraryHaskellDepends = [ + base binary bytestring containers parsec + ]; + doHaddock = false; + doCheck = false; + description = "Parser and printer for bencoded data"; + license = stdenv.lib.licenses.bsd3; + }) {}; + "between" = callPackage + ({ mkDerivation, base, stdenv }: + mkDerivation { + pname = "between"; + version = "0.11.0.0"; + sha256 = "8337351326c5a613d9b7520b6a8203234c04454e23550a81739beaa6f671465d"; + libraryHaskellDepends = [ base ]; + doHaddock = false; + doCheck = false; + homepage = "https://github.com/trskop/between"; + description = "Function combinator \"between\" and derived combinators"; + license = stdenv.lib.licenses.bsd3; + }) {}; + "bibtex" = callPackage + ({ mkDerivation, base, latex, parsec, stdenv, utility-ht }: + mkDerivation { + pname = "bibtex"; + version = "0.1.0.6"; + sha256 = "090a3b9589388bdf9d2bf60d8d1898aa0313a2874b551ba86cbbd049f3ee5f04"; + isLibrary = true; + isExecutable = true; + libraryHaskellDepends = [ base latex parsec utility-ht ]; + doHaddock = false; + doCheck = false; + homepage = "http://www.haskell.org/haskellwiki/BibTeX"; + description = "Parse, format and processing BibTeX files"; + license = stdenv.lib.licenses.bsd3; + }) {}; + "bifunctors" = callPackage + ({ mkDerivation, base, base-orphans, comonad, containers + , semigroups, stdenv, tagged, template-haskell, th-abstraction + , transformers + }: + mkDerivation { + pname = "bifunctors"; + version = "5.5.3"; + sha256 = "d434528fd2ea765bace57c4ade0bc9fa32ba2c425f563b33a4b60f625ecfc9ca"; + libraryHaskellDepends = [ + base base-orphans comonad containers semigroups tagged + template-haskell th-abstraction transformers + ]; + doHaddock = false; + doCheck = false; + homepage = "http://github.com/ekmett/bifunctors/"; + description = "Bifunctors"; + license = stdenv.lib.licenses.bsd3; + }) {}; + "bimap" = callPackage + ({ mkDerivation, base, containers, exceptions, stdenv }: + mkDerivation { + pname = "bimap"; + version = "0.3.3"; + sha256 = "73829355c7bcbd3eedba22a382a04a3ab641702b00828790ec082ec2db3a8ad1"; + libraryHaskellDepends = [ base containers exceptions ]; + doHaddock = false; + doCheck = false; + homepage = "https://github.com/joelwilliamson/bimap"; + description = "Bidirectional mapping between two key types"; + license = stdenv.lib.licenses.bsd3; + }) {}; + "bimap-server" = callPackage + ({ mkDerivation, aeson, base, bimap, binary, directory, http-types + , stdenv, unix, wai, warp + }: + mkDerivation { + pname = "bimap-server"; + version = "0.1.0.1"; + sha256 = "09dfd1865812f40e317b610cbe05cc65ba6ea7215428748e1038ff7fc38ef535"; + libraryHaskellDepends = [ + aeson base bimap binary directory http-types unix wai warp + ]; + doHaddock = false; + doCheck = false; + description = "Two-column database server"; + license = stdenv.lib.licenses.bsd3; + }) {}; + "binary-bits" = callPackage + ({ mkDerivation, base, binary, bytestring, stdenv }: + mkDerivation { + pname = "binary-bits"; + version = "0.5"; + sha256 = "16534a018a4754d8d1eab051711c23fb741f41a0d141b289001c52824b5be794"; + libraryHaskellDepends = [ base binary bytestring ]; + doHaddock = false; + doCheck = false; + description = "Bit parsing/writing on top of binary"; + license = stdenv.lib.licenses.bsd3; + }) {}; + "binary-conduit" = callPackage + ({ mkDerivation, base, binary, bytestring, conduit, exceptions + , stdenv, vector + }: + mkDerivation { + pname = "binary-conduit"; + version = "1.3"; + sha256 = "43f9bd47b679b552b295132680a8cd0ade6489fc33d5d98aed1f5c948320cccd"; + revision = "1"; + editedCabalFile = "0y08nw3y5jgrw5waa25b75iwsibnd1m9rbpqrvz5j4xq6baqw6kx"; + libraryHaskellDepends = [ + base binary bytestring conduit exceptions vector + ]; + doHaddock = false; + doCheck = false; + homepage = "http://github.com/qnikst/binary-conduit/"; + description = "data serialization/deserialization conduit library"; + license = stdenv.lib.licenses.mit; + }) {}; + "binary-ext" = callPackage + ({ mkDerivation, attoparsec, base, binary, bytestring, conduit + , conduit-combinators, data-binary-ieee754, errors, exceptions + , monad-control, monad-loops, mono-traversable, mtl, scientific + , stdenv, text, transformers, transformers-base + }: + mkDerivation { + pname = "binary-ext"; + version = "2.0.4"; + sha256 = "6e58e19bde26d6f271916ceb43a28903136e28cf7868d86f65e68a60152ade08"; + libraryHaskellDepends = [ + attoparsec base binary bytestring conduit conduit-combinators + data-binary-ieee754 errors exceptions monad-control monad-loops + mono-traversable mtl scientific text transformers transformers-base + ]; + doHaddock = false; + doCheck = false; + homepage = "https://github.com/A1-Triard/binary-ext#readme"; + description = "An alternate with strong-typed errors for `Data.Binary.Get` monad from `binary` package."; + license = stdenv.lib.licenses.asl20; + }) {}; + "binary-ieee754" = callPackage + ({ mkDerivation, array, base, binary, stdenv }: + mkDerivation { + pname = "binary-ieee754"; + version = "0.1.0.0"; + sha256 = "15c489898bcd346b4067a27579cb5fc62e2fafecbec81ea0446165a24aee4d54"; + libraryHaskellDepends = [ array base binary ]; + doHaddock = false; + doCheck = false; + homepage = "https://github.com/winterland1989/binary-ieee754"; + description = "Backport ieee754 float double combinators to older binary"; + license = stdenv.lib.licenses.bsd3; + }) {}; + "binary-list" = callPackage + ({ mkDerivation, base, binary, bytestring, deepseq, phantom-state + , stdenv, transformers + }: + mkDerivation { + pname = "binary-list"; + version = "1.1.1.2"; + sha256 = "6b21e58ea4091b9572cb24a92dfb1ddc14fcea82d2272d30a83eb1b430dd1878"; + libraryHaskellDepends = [ + base binary bytestring deepseq phantom-state transformers + ]; + doHaddock = false; + doCheck = false; + description = "Lists of length a power of two"; + license = stdenv.lib.licenses.bsd3; + }) {}; + "binary-orphans" = callPackage + ({ mkDerivation, aeson, base, binary, case-insensitive, hashable + , scientific, stdenv, tagged, text, text-binary, time + , unordered-containers, vector, vector-binary-instances + }: + mkDerivation { + pname = "binary-orphans"; + version = "0.1.8.0"; + sha256 = "f17557ccd98931df2bea038f25e7f835f38019ea7d53bd763f71fe64f931c0cc"; + revision = "5"; + editedCabalFile = "1dny1jvwwcyrbzhqvymmn6n7ib48bpy0nasbrcrdrpzjypkmg500"; + libraryHaskellDepends = [ + aeson base binary case-insensitive hashable scientific tagged text + text-binary time unordered-containers vector + vector-binary-instances + ]; + doHaddock = false; + doCheck = false; + homepage = "https://github.com/phadej/binary-orphans#readme"; + description = "Orphan instances for binary"; + license = stdenv.lib.licenses.bsd3; + }) {}; + "binary-parser" = callPackage + ({ mkDerivation, base, base-prelude, bytestring, mtl, stdenv, text + , transformers + }: + mkDerivation { + pname = "binary-parser"; + version = "0.5.5"; + sha256 = "1dab718e06a978118cd28d2412bceaa0b6ec8d67785bdb0982e259fb60fe43b3"; + revision = "3"; + editedCabalFile = "14n41yazmks2qw0v4krxcqw3ac0wdy2z53d0qz0rdjcd94fpghjf"; + libraryHaskellDepends = [ + base base-prelude bytestring mtl text transformers + ]; + doHaddock = false; + doCheck = false; + homepage = "https://github.com/nikita-volkov/binary-parser"; + description = "A highly-efficient but limited parser API specialised for bytestrings"; + license = stdenv.lib.licenses.mit; + }) {}; + "binary-parsers" = callPackage + ({ mkDerivation, base, binary, bytestring, bytestring-lexing + , scientific, stdenv + }: + mkDerivation { + pname = "binary-parsers"; + version = "0.2.3.0"; + sha256 = "bc6195493b950efcbeb9ef54dfe47a6badf894dff934cf02a4b170331c1b217a"; + revision = "1"; + editedCabalFile = "09ag18yr1m26fl3w7ab1d5q5j201ygbw7qsbsy41bwd6iq87rq15"; + libraryHaskellDepends = [ + base binary bytestring bytestring-lexing scientific + ]; + doHaddock = false; + doCheck = false; + homepage = "https://github.com/winterland1989/binary-parsers"; + description = "Extends binary with parsec/attoparsec style parsing combinators"; + license = stdenv.lib.licenses.bsd3; + }) {}; + "binary-search" = callPackage + ({ mkDerivation, base, containers, stdenv, transformers }: + mkDerivation { + pname = "binary-search"; + version = "1.0.0.3"; + sha256 = "b0e32df46aeddceac57bd6afa940f84f275f82fb251479e10fadd7c14414f6fa"; + libraryHaskellDepends = [ base containers transformers ]; + doHaddock = false; + doCheck = false; + description = "Binary and exponential searches"; + license = stdenv.lib.licenses.bsd3; + }) {}; + "binary-shared" = callPackage + ({ mkDerivation, base, binary, bytestring, containers, mtl, stdenv + }: + mkDerivation { + pname = "binary-shared"; + version = "0.8.3"; + sha256 = "830116505018fc43de09867bea9039b0bfa29e77564efa8c3f3b708933c098b2"; + libraryHaskellDepends = [ base binary bytestring containers mtl ]; + doHaddock = false; + doCheck = false; + homepage = "http://www.leksah.org"; + description = "Sharing for the binary package"; + license = "GPL"; + }) {}; + "binary-tagged" = callPackage + ({ mkDerivation, aeson, array, base, base16-bytestring, binary + , bytestring, containers, generics-sop, hashable, scientific, SHA + , stdenv, tagged, text, time, unordered-containers, vector + }: + mkDerivation { + pname = "binary-tagged"; + version = "0.1.5"; + sha256 = "d4b733a9013069f19249acad76e7f73fb41303c44dcbd2229de8d534558605e8"; + revision = "1"; + editedCabalFile = "0vddb305g3455f0rh0xs6c9i2vllnf83y0pbp53wjwb3l575bqyp"; + libraryHaskellDepends = [ + aeson array base base16-bytestring binary bytestring containers + generics-sop hashable scientific SHA tagged text time + unordered-containers vector + ]; + doHaddock = false; + doCheck = false; + homepage = "https://github.com/phadej/binary-tagged#readme"; + description = "Tagged binary serialisation"; + license = stdenv.lib.licenses.bsd3; + }) {}; + "bindings-DSL" = callPackage + ({ mkDerivation, base, stdenv }: + mkDerivation { + pname = "bindings-DSL"; + version = "1.0.25"; + sha256 = "63de32380c68d1cc5e9c7b3622d67832c786da21163ba0c8a4835e6dd169194f"; + libraryHaskellDepends = [ base ]; + doHaddock = false; + doCheck = false; + homepage = "https://github.com/jwiegley/bindings-dsl/wiki"; + description = "FFI domain specific language, on top of hsc2hs"; + license = stdenv.lib.licenses.bsd3; + }) {}; + "bindings-GLFW" = callPackage + ({ mkDerivation, base, bindings-DSL, libGL, libX11, libXcursor + , libXext, libXfixes, libXi, libXinerama, libXrandr, libXxf86vm + , stdenv + }: + mkDerivation { + pname = "bindings-GLFW"; + version = "3.2.1.1"; + sha256 = "6b24c66b20ebfd8ff2e4ac32e3b435889bba0a32477598ba69fc7adc9608160e"; + libraryHaskellDepends = [ base bindings-DSL ]; + librarySystemDepends = [ + libGL libX11 libXcursor libXext libXfixes libXi libXinerama + libXrandr libXxf86vm + ]; + doHaddock = false; + doCheck = false; + description = "Low-level bindings to GLFW OpenGL library"; + license = stdenv.lib.licenses.bsd3; + }) {inherit (pkgs) libGL; inherit (pkgs.xorg) libXext; +inherit (pkgs.xorg) libXfixes;}; + "bindings-libzip" = callPackage + ({ mkDerivation, base, bindings-DSL, libzip, stdenv }: + mkDerivation { + pname = "bindings-libzip"; + version = "1.0.1"; + sha256 = "908d060360d66974b1d9400dea28a1dce35a88baf5d73a6e3c12be8e74cda2ec"; + libraryHaskellDepends = [ base bindings-DSL ]; + libraryPkgconfigDepends = [ libzip ]; + doHaddock = false; + doCheck = false; + homepage = "http://bitbucket.org/astanin/hs-libzip/"; + description = "Low level bindings to libzip"; + license = stdenv.lib.licenses.bsd3; + }) {inherit (pkgs) libzip;}; + "bindings-uname" = callPackage + ({ mkDerivation, base, stdenv }: + mkDerivation { + pname = "bindings-uname"; + version = "0.1"; + sha256 = "130e75c3fd95e232452c7d903efbfab2d2ff6c9d455b617adeaebe5d60235cd3"; + libraryHaskellDepends = [ base ]; + doHaddock = false; + doCheck = false; + description = "Low-level binding to POSIX uname(3)"; + license = stdenv.lib.licenses.publicDomain; + }) {}; + "bit-stream" = callPackage + ({ mkDerivation, base, ghc-prim, stdenv, vector }: + mkDerivation { + pname = "bit-stream"; + version = "0.1.0.2"; + sha256 = "811f2e7d4a827440bc21557e48c5310fe91e1b17f337ec35208546e1c5639bf4"; + isLibrary = true; + isExecutable = true; + libraryHaskellDepends = [ base ghc-prim vector ]; + doHaddock = false; + doCheck = false; + homepage = "https://github.com/Bodigrim/bit-stream#readme"; + description = "Lazy, infinite, compact stream of Bool with O(1) indexing"; + license = stdenv.lib.licenses.bsd3; + }) {}; + "bitarray" = callPackage + ({ mkDerivation, array, base, stdenv }: + mkDerivation { + pname = "bitarray"; + version = "0.0.1.1"; + sha256 = "b27f6f1065053a0e8e24fbf9382b7060af9962d8d150b631c682c0c58469d802"; + revision = "1"; + editedCabalFile = "10fk92v9afjqk43zi621jxl0n8kci0xjj32lz3vqa9xbh67zjz45"; + libraryHaskellDepends = [ array base ]; + doHaddock = false; + doCheck = false; + homepage = "http://code.haskell.org/~bkomuves/"; + description = "Mutable and immutable bit arrays"; + license = stdenv.lib.licenses.bsd3; + }) {}; + "bitcoin-api" = callPackage + ({ mkDerivation, aeson, base, base58string, binary, bitcoin-block + , bitcoin-script, bitcoin-tx, bitcoin-types, bytestring, hexstring + , lens, lens-aeson, stdenv, text, unordered-containers, wreq + }: + mkDerivation { + pname = "bitcoin-api"; + version = "0.12.1"; + sha256 = "c978de1519b24c5c04ff518ad1209f74f91df31d65e23592dc639219df6b3e30"; + enableSeparateDataOutput = true; + libraryHaskellDepends = [ + aeson base base58string binary bitcoin-block bitcoin-script + bitcoin-tx bitcoin-types bytestring hexstring lens lens-aeson text + unordered-containers wreq + ]; + doHaddock = false; + doCheck = false; + homepage = "http://www.leonmergen.com/opensource.html"; + description = "Provides access to the RPC API of Bitcoin Core"; + license = stdenv.lib.licenses.mit; + }) {}; + "bitcoin-api-extra" = callPackage + ({ mkDerivation, base, binary, bitcoin-api, bitcoin-block + , bitcoin-tx, bytestring, conduit, lens, stdenv, stm, stm-chans + , stm-conduit, text, transformers + }: + mkDerivation { + pname = "bitcoin-api-extra"; + version = "0.9.1"; + sha256 = "c423c6007d0f830dd2bbc0e1bc9219980e6fb2bde684890e265e1bfce4bdd7fc"; + enableSeparateDataOutput = true; + libraryHaskellDepends = [ + base binary bitcoin-api bitcoin-block bitcoin-tx bytestring conduit + lens stm stm-chans stm-conduit text transformers + ]; + doHaddock = false; + doCheck = false; + homepage = "http://www.leonmergen.com/opensource.html"; + description = "Higher level constructs on top of the bitcoin-api package"; + license = stdenv.lib.licenses.mit; + }) {}; + "bitcoin-block" = callPackage + ({ mkDerivation, base, binary, bitcoin-tx, bitcoin-types + , bytestring, cryptohash, hexstring, largeword, lens, stdenv + }: + mkDerivation { + pname = "bitcoin-block"; + version = "0.13.1"; + sha256 = "d7f57c0fe71045dab85d223dc15d64db3a15cc7fd8446bfe4ebd98cd9d417d5a"; + enableSeparateDataOutput = true; + libraryHaskellDepends = [ + base binary bitcoin-tx bitcoin-types bytestring cryptohash + hexstring largeword lens + ]; + doHaddock = false; + doCheck = false; + homepage = "http://www.leonmergen.com/opensource.html"; + description = "Utility functions for manipulating bitcoin blocks"; + license = stdenv.lib.licenses.mit; + }) {}; + "bitcoin-script" = callPackage + ({ mkDerivation, base, base16-bytestring, binary, bytestring + , stdenv, text + }: + mkDerivation { + pname = "bitcoin-script"; + version = "0.11.1"; + sha256 = "398c1d86e918731b5b2026351bb3b0b90b20606517e7c21e42f05d6c6e197b4c"; + enableSeparateDataOutput = true; + libraryHaskellDepends = [ + base base16-bytestring binary bytestring text + ]; + doHaddock = false; + doCheck = false; + homepage = "http://www.leonmergen.com/opensource.html"; + description = "Compilation, manipulation and decompilation of Bitcoin scripts"; + license = stdenv.lib.licenses.mit; + }) {}; + "bitcoin-tx" = callPackage + ({ mkDerivation, base, binary, bitcoin-script, bitcoin-types + , bytestring, cryptohash, hexstring, lens, stdenv + }: + mkDerivation { + pname = "bitcoin-tx"; + version = "0.13.1"; + sha256 = "3bb88265353066c394e96a56b2dc555fa13d37ca7f820978b793196c6829cc00"; + enableSeparateDataOutput = true; + libraryHaskellDepends = [ + base binary bitcoin-script bitcoin-types bytestring cryptohash + hexstring lens + ]; + doHaddock = false; + doCheck = false; + homepage = "http://www.leonmergen.com/opensource.html"; + description = "Utility functions for manipulating bitcoin transactions"; + license = stdenv.lib.licenses.mit; + }) {}; + "bitcoin-types" = callPackage + ({ mkDerivation, base, base58string, binary, bytestring, hexstring + , stdenv, text + }: + mkDerivation { + pname = "bitcoin-types"; + version = "0.9.2"; + sha256 = "b72f9448508b64706d5f443748dc9b8abde8e749959187ce3d8356cde0d6c40b"; + enableSeparateDataOutput = true; + libraryHaskellDepends = [ + base base58string binary bytestring hexstring text + ]; + doHaddock = false; + doCheck = false; + homepage = "http://www.leonmergen.com/opensource.html"; + description = "Provides consistent low-level types used commonly among Bitcoin implementations"; + license = stdenv.lib.licenses.mit; + }) {}; + "bits" = callPackage + ({ mkDerivation, base, bytes, Cabal, cabal-doctest, mtl, stdenv + , transformers + }: + mkDerivation { + pname = "bits"; + version = "0.5.1"; + sha256 = "657e557bb913b53fb3b3fc7eda820cf3c85a5b89692d242275d3e8e8d9479c93"; + revision = "5"; + editedCabalFile = "012qycmsfz5l6y82d3zgjmp1k3pgvhlpjdk6rwlpc1wlfbpdqiaw"; + setupHaskellDepends = [ base Cabal cabal-doctest ]; + libraryHaskellDepends = [ base bytes mtl transformers ]; + doHaddock = false; + doCheck = false; + homepage = "http://github.com/ekmett/bits"; + description = "Various bit twiddling and bitwise serialization primitives"; + license = stdenv.lib.licenses.bsd3; + }) {}; + "bits-extra" = callPackage + ({ mkDerivation, base, ghc-prim, stdenv, vector }: + mkDerivation { + pname = "bits-extra"; + version = "0.0.1.3"; + sha256 = "692b08b3e9a490f5b2776b8f20277320fad247d9c4ea158225fee0f27f91afed"; + libraryHaskellDepends = [ base ghc-prim vector ]; + doHaddock = false; + doCheck = false; + homepage = "https://github.com/haskell-works/bits-extra#readme"; + description = "Useful bitwise operations"; + license = stdenv.lib.licenses.bsd3; + }) {}; + "bitset-word8" = callPackage + ({ mkDerivation, base, containers, stdenv, template-haskell + , th-lift-instances + }: + mkDerivation { + pname = "bitset-word8"; + version = "0.1.1.0"; + sha256 = "14e9eded3d5f535dbb1ce6debe4edd2d227765af31cc58e072b78824cd9f9b06"; + libraryHaskellDepends = [ + base containers template-haskell th-lift-instances + ]; + doHaddock = false; + doCheck = false; + homepage = "https://github.com/nshimaza/bitset-word8#readme"; + description = "Space efficient set of Word8 and some pre-canned sets useful for parsing HTTP"; + license = stdenv.lib.licenses.mit; + }) {}; + "bitx-bitcoin" = callPackage + ({ mkDerivation, aeson, base, bytestring, deepseq, exceptions + , http-client, http-client-tls, http-types, microlens, microlens-th + , network, QuickCheck, scientific, split, stdenv, text, time + }: + mkDerivation { + pname = "bitx-bitcoin"; + version = "0.12.0.0"; + sha256 = "31f2398bbb0deff80361fdabb108c1552ae097b15a44c6ca6674977ae735c871"; + libraryHaskellDepends = [ + aeson base bytestring deepseq exceptions http-client + http-client-tls http-types microlens microlens-th network + QuickCheck scientific split text time + ]; + doHaddock = false; + doCheck = false; + homepage = "https://github.com/tebello-thejane/bitx.hs"; + description = "A Haskell library for working with the BitX bitcoin exchange"; + license = stdenv.lib.licenses.bsd3; + }) {}; + "blake2" = callPackage + ({ mkDerivation, base, bytestring, stdenv }: + mkDerivation { + pname = "blake2"; + version = "0.2.0"; + sha256 = "07d910e3f5c6e98f5a6b9d53dbe5f52506c3859b513bc7493b52552a28382cfc"; + libraryHaskellDepends = [ base bytestring ]; + doHaddock = false; + doCheck = false; + homepage = "https://github.com/centromere/blake2"; + description = "A library providing BLAKE2"; + license = stdenv.lib.licenses.publicDomain; + }) {}; + "blank-canvas" = callPackage + ({ mkDerivation, aeson, base, base-compat-batteries + , base64-bytestring, bytestring, colour, containers + , data-default-class, http-types, kansas-comet, mime-types, scotty + , semigroups, stdenv, stm, text, text-show, transformers, vector + , wai, wai-extra, warp + }: + mkDerivation { + pname = "blank-canvas"; + version = "0.6.3"; + sha256 = "739d24ff7035fd675e95c2d33bd9d3cb7d1ef0cca94c16bbf950c4a7f7b320b4"; + revision = "2"; + editedCabalFile = "0sybv2swx9gwpkjh704xfmilm9jhdb66jqc296agpzp85s2s75zz"; + enableSeparateDataOutput = true; + libraryHaskellDepends = [ + aeson base base-compat-batteries base64-bytestring bytestring + colour containers data-default-class http-types kansas-comet + mime-types scotty semigroups stm text text-show transformers vector + wai wai-extra warp + ]; + doHaddock = false; + doCheck = false; + homepage = "https://github.com/ku-fpg/blank-canvas/wiki"; + description = "HTML5 Canvas Graphics Library"; + license = stdenv.lib.licenses.bsd3; + }) {}; + "blas-carray" = callPackage + ({ mkDerivation, base, blas-ffi, carray, netlib-carray, netlib-ffi + , stdenv, storable-complex, transformers + }: + mkDerivation { + pname = "blas-carray"; + version = "0.0.1.1"; + sha256 = "bdad1b777d36e46a63bec022190bd009d2782018d7a447f41e3c2db772635f46"; + libraryHaskellDepends = [ + base blas-ffi carray netlib-carray netlib-ffi storable-complex + transformers + ]; + doHaddock = false; + doCheck = false; + homepage = "http://hub.darcs.net/thielema/blas-carray/"; + description = "Auto-generated interface to Fortran BLAS via CArrays"; + license = stdenv.lib.licenses.bsd3; + }) {}; + "blas-ffi" = callPackage + ({ mkDerivation, base, blas, netlib-ffi, stdenv }: + mkDerivation { + pname = "blas-ffi"; + version = "0.0.1.1"; + sha256 = "ee0d88ad15d127e08dd273264befe2259bb64646156adb9e830aa8692dc3f036"; + libraryHaskellDepends = [ base netlib-ffi ]; + libraryPkgconfigDepends = [ blas ]; + doHaddock = false; + doCheck = false; + homepage = "http://hub.darcs.net/thielema/blas-ffi/"; + description = "Auto-generated interface to Fortran BLAS"; + license = stdenv.lib.licenses.bsd3; + }) {inherit (pkgs) blas;}; + "blas-hs" = callPackage + ({ mkDerivation, base, blas, stdenv, storable-complex }: + mkDerivation { + pname = "blas-hs"; + version = "0.1.1.0"; + sha256 = "80e06b0927982b391d239f8656ed437cd29665969d1a078ea4e42a2bf196b086"; + libraryHaskellDepends = [ base storable-complex ]; + librarySystemDepends = [ blas ]; + doHaddock = false; + doCheck = false; + homepage = "https://github.com/Rufflewind/blas-hs"; + description = "Low-level Haskell bindings to Blas"; + license = stdenv.lib.licenses.mit; + }) {inherit (pkgs) blas;}; + "blaze-bootstrap" = callPackage + ({ mkDerivation, base, blaze-html, stdenv, text }: + mkDerivation { + pname = "blaze-bootstrap"; + version = "0.1.0.1"; + sha256 = "53b54c0b55ae7a436ec7e5d4e29d50fceb1ccd459ef715236358a3c661d05163"; + libraryHaskellDepends = [ base blaze-html text ]; + doHaddock = false; + doCheck = false; + homepage = "http://github.com/agrafix/blaze-bootstrap"; + description = "Blaze helper functions for bootstrap pages"; + license = stdenv.lib.licenses.mit; + }) {}; + "blaze-builder" = callPackage + ({ mkDerivation, base, bytestring, deepseq, stdenv, text }: + mkDerivation { + pname = "blaze-builder"; + version = "0.4.1.0"; + sha256 = "91fc8b966f3e9dc9461e1675c7566b881740f99abc906495491a3501630bc814"; + libraryHaskellDepends = [ base bytestring deepseq text ]; + doHaddock = false; + doCheck = false; + homepage = "http://github.com/lpsmith/blaze-builder"; + description = "Efficient buffered output"; + license = stdenv.lib.licenses.bsd3; + }) {}; + "blaze-colonnade" = callPackage + ({ mkDerivation, base, blaze-html, blaze-markup, colonnade, stdenv + , text + }: + mkDerivation { + pname = "blaze-colonnade"; + version = "1.2.2"; + sha256 = "1f2f7116ffea5ad2a04337b9bdc1277de0b12a71fb4b830b216c37911d8ea14c"; + libraryHaskellDepends = [ + base blaze-html blaze-markup colonnade text + ]; + doHaddock = false; + doCheck = false; + homepage = "https://github.com/andrewthad/colonnade#readme"; + description = "Helper functions for using blaze-html with colonnade"; + license = stdenv.lib.licenses.bsd3; + }) {}; + "blaze-html" = callPackage + ({ mkDerivation, base, blaze-builder, blaze-markup, bytestring + , stdenv, text + }: + mkDerivation { + pname = "blaze-html"; + version = "0.9.1.1"; + sha256 = "ea0e944298dbbd692b41af4f15dbd1a1574aec7b8f91f38391d25106b143bb1b"; + libraryHaskellDepends = [ + base blaze-builder blaze-markup bytestring text + ]; + doHaddock = false; + doCheck = false; + homepage = "http://jaspervdj.be/blaze"; + description = "A blazingly fast HTML combinator library for Haskell"; + license = stdenv.lib.licenses.bsd3; + }) {}; + "blaze-markup" = callPackage + ({ mkDerivation, base, blaze-builder, bytestring, stdenv, text }: + mkDerivation { + pname = "blaze-markup"; + version = "0.8.2.1"; + sha256 = "90ab7cbc29df9fbe24e208ade58ca9828e3074f1163618f1faaf4da8f0600146"; + libraryHaskellDepends = [ base blaze-builder bytestring text ]; + doHaddock = false; + doCheck = false; + homepage = "http://jaspervdj.be/blaze"; + description = "A blazingly fast markup combinator library for Haskell"; + license = stdenv.lib.licenses.bsd3; + }) {}; + "blaze-svg" = callPackage + ({ mkDerivation, base, blaze-markup, mtl, stdenv }: + mkDerivation { + pname = "blaze-svg"; + version = "0.3.6.1"; + sha256 = "f6a4f1bba1e973b336e94de73369f4562778fde43b6ac7c0b32d6a501527aa60"; + libraryHaskellDepends = [ base blaze-markup mtl ]; + doHaddock = false; + doCheck = false; + homepage = "https://github.com/deepakjois/blaze-svg"; + description = "SVG combinator library"; + license = stdenv.lib.licenses.bsd3; + }) {}; + "blaze-textual" = callPackage + ({ mkDerivation, base, blaze-builder, bytestring, ghc-prim + , integer-gmp, old-locale, stdenv, text, time, vector + }: + mkDerivation { + pname = "blaze-textual"; + version = "0.2.1.0"; + sha256 = "1042795ab0bab891c034c24a51bafecbb89870ccd28af39534ab3d9ae7f46c2d"; + libraryHaskellDepends = [ + base blaze-builder bytestring ghc-prim integer-gmp old-locale text + time vector + ]; + doHaddock = false; + doCheck = false; + homepage = "http://github.com/bos/blaze-textual"; + description = "Fast rendering of common datatypes"; + license = stdenv.lib.licenses.bsd3; + }) {}; + "bmp" = callPackage + ({ mkDerivation, base, binary, bytestring, stdenv }: + mkDerivation { + pname = "bmp"; + version = "1.2.6.3"; + sha256 = "3cc63de40fe088ce4d1c869180fd2309bcec35a940c9e3d1904d3520ca2fdacc"; + libraryHaskellDepends = [ base binary bytestring ]; + doHaddock = false; + doCheck = false; + homepage = "https://github.com/benl23x5/bmp"; + description = "Read and write uncompressed BMP image files"; + license = stdenv.lib.licenses.mit; + }) {}; + "bno055-haskell" = callPackage + ({ mkDerivation, base, bytestring, cereal, h2c, mtl, resourcet + , stdenv + }: + mkDerivation { + pname = "bno055-haskell"; + version = "0.1.0"; + sha256 = "7adc29f94755047b4214115c23b63041e9d3970d2648f53dcd38b84725059ad8"; + libraryHaskellDepends = [ + base bytestring cereal h2c mtl resourcet + ]; + doHaddock = false; + doCheck = false; + homepage = "https://bitbucket.org/fmapE/bno055-haskell"; + description = "Library for communication with the Bosch BNO055 orientation sensor"; + license = stdenv.lib.licenses.mit; + }) {}; + "boltzmann-samplers" = callPackage + ({ mkDerivation, ad, base, containers, hashable, hmatrix, ieee754 + , MonadRandom, mtl, QuickCheck, stdenv, transformers + , unordered-containers, vector + }: + mkDerivation { + pname = "boltzmann-samplers"; + version = "0.1.1.0"; + sha256 = "de7c3e1f77b0ae27c78cb53e539dbaa8dc2f6e3f3605c25f1611545806ad878e"; + libraryHaskellDepends = [ + ad base containers hashable hmatrix ieee754 MonadRandom mtl + QuickCheck transformers unordered-containers vector + ]; + doHaddock = false; + doCheck = false; + homepage = "https://github.com/Lysxia/boltzmann-samplers#readme"; + description = "Uniform random generators"; + license = stdenv.lib.licenses.mit; + }) {}; + "boolean-like" = callPackage + ({ mkDerivation, attoparsec, base, bytestring, containers + , semigroups, stdenv, text, vector + }: + mkDerivation { + pname = "boolean-like"; + version = "0.1.1.0"; + sha256 = "6ca47b21a6d98161edfd94f4d5a19daacc13d229b87a0c107e868ff0259658b8"; + libraryHaskellDepends = [ + attoparsec base bytestring containers semigroups text vector + ]; + doHaddock = false; + doCheck = false; + homepage = "http://github.com/Shou/boolean-like"; + description = "Logical combinatory operations dealing with datatypes representing booleans by their constructors"; + license = stdenv.lib.licenses.bsd3; + }) {}; + "boolsimplifier" = callPackage + ({ mkDerivation, base, containers, stdenv }: + mkDerivation { + pname = "boolsimplifier"; + version = "0.1.8"; + sha256 = "096fa9377241520ee114403fd53b51a7369187fb4dca65f19f85a727d689828f"; + revision = "1"; + editedCabalFile = "0xqm0vn9i49b75fnvnvcnr9m4zwvhqynrkcjdxghrsxayg420lnh"; + libraryHaskellDepends = [ base containers ]; + doHaddock = false; + doCheck = false; + description = "Simplification tools for simple propositional formulas"; + license = stdenv.lib.licenses.bsd3; + }) {}; + "bordacount" = callPackage + ({ mkDerivation, base, containers, stdenv }: + mkDerivation { + pname = "bordacount"; + version = "0.1.0.0"; + sha256 = "cb691095f688dc2c1726750d5e5d267d3f49466377869a574d6416090a46fdce"; + libraryHaskellDepends = [ base containers ]; + doHaddock = false; + doCheck = false; + homepage = "https://github.com/hverr/bordacount#readme"; + description = "Implementation of the Borda count election method"; + license = stdenv.lib.licenses.bsd3; + }) {}; + "boring" = callPackage + ({ mkDerivation, adjunctions, base, base-compat, constraints, fin + , generics-sop, stdenv, streams, tagged, transformers + , transformers-compat, vec + }: + mkDerivation { + pname = "boring"; + version = "0.1"; + sha256 = "73d60829c3a789f3d377d56ce7844aaaea6b517bcea43e06579ab785181b4664"; + revision = "2"; + editedCabalFile = "1jxaby4cagbhii194x9x0j75ms1v5bm14sx7d19zz3844mh9qyci"; + libraryHaskellDepends = [ + adjunctions base base-compat constraints fin generics-sop streams + tagged transformers transformers-compat vec + ]; + doHaddock = false; + doCheck = false; + homepage = "https://github.com/phadej/boring"; + description = "Boring and Absurd types"; + license = stdenv.lib.licenses.bsd3; + }) {}; + "both" = callPackage + ({ mkDerivation, base, semigroups, stdenv, zero }: + mkDerivation { + pname = "both"; + version = "0.1.1.0"; + sha256 = "6f4ee8b7745fb3054282240fe941dd74cf2481f1a07b170d211c2b8791340e8e"; + libraryHaskellDepends = [ base semigroups zero ]; + doHaddock = false; + doCheck = false; + homepage = "https://github.com/barrucadu/both"; + description = "Like Maybe, but with a different Monoid instance"; + license = stdenv.lib.licenses.mit; + }) {}; + "bound" = callPackage + ({ mkDerivation, base, bifunctors, binary, bytes, Cabal + , cabal-doctest, cereal, comonad, deepseq, hashable, mmorph + , profunctors, stdenv, template-haskell, transformers + , transformers-compat + }: + mkDerivation { + pname = "bound"; + version = "2.0.1"; + sha256 = "294a206f33b6583e56bd3aad620e4a7bd0a22b4bf4c6fe5988b2fe55159fbb76"; + revision = "6"; + editedCabalFile = "18fqzxy3f8r09jwcsfzjlrpvnlz711jq5gcjp4dal1pvsbbw6i09"; + setupHaskellDepends = [ base Cabal cabal-doctest ]; + libraryHaskellDepends = [ + base bifunctors binary bytes cereal comonad deepseq hashable mmorph + profunctors template-haskell transformers transformers-compat + ]; + doHaddock = false; + doCheck = false; + homepage = "http://github.com/ekmett/bound/"; + description = "Making de Bruijn Succ Less"; + license = stdenv.lib.licenses.bsd3; + }) {}; + "boundingboxes" = callPackage + ({ mkDerivation, base, lens, stdenv }: + mkDerivation { + pname = "boundingboxes"; + version = "0.2.3"; + sha256 = "e80947aa2c2c7f11e7eb2eb088a463d1cd1cdf03790e4c2746b629dcb1737564"; + libraryHaskellDepends = [ base lens ]; + doHaddock = false; + doCheck = false; + homepage = "https://github.com/fumieval/boundingboxes"; + description = "A generic boundingbox for an arbitrary vector"; + license = stdenv.lib.licenses.bsd3; + }) {}; + "bower-json" = callPackage + ({ mkDerivation, aeson, aeson-better-errors, base, bytestring + , deepseq, ghc-prim, mtl, scientific, stdenv, text, transformers + , unordered-containers, vector + }: + mkDerivation { + pname = "bower-json"; + version = "1.0.0.1"; + sha256 = "7aa954e2b1bf79307db710c158108bd9ddb45b333ca96072cdbfaf96c77b7e73"; + libraryHaskellDepends = [ + aeson aeson-better-errors base bytestring deepseq ghc-prim mtl + scientific text transformers unordered-containers vector + ]; + doHaddock = false; + doCheck = false; + homepage = "https://github.com/hdgarrood/bower-json"; + description = "Read bower.json from Haskell"; + license = stdenv.lib.licenses.mit; + }) {}; + "boxes" = callPackage + ({ mkDerivation, base, split, stdenv }: + mkDerivation { + pname = "boxes"; + version = "0.1.5"; + sha256 = "38e1782e8a458f342a0acbb74af8f55cb120756bc3af7ee7220d955812af56c3"; + libraryHaskellDepends = [ base split ]; + doHaddock = false; + doCheck = false; + description = "2D text pretty-printing library"; + license = stdenv.lib.licenses.bsd3; + }) {}; + "brick" = callPackage + ({ mkDerivation, base, config-ini, containers, contravariant + , data-clist, deepseq, dlist, microlens, microlens-mtl + , microlens-th, stdenv, stm, template-haskell, text, text-zipper + , transformers, vector, vty, word-wrap + }: + mkDerivation { + pname = "brick"; + version = "0.37.2"; + sha256 = "7cb86cd88d344d4a8b997677f805e3a3adaecf37d65478e06081737efbc1d99c"; + revision = "1"; + editedCabalFile = "0cj98cjlr400yf47lg50syj5zpvh6q9mm1hp4blns6ndz2xys5rz"; + isLibrary = true; + isExecutable = true; + libraryHaskellDepends = [ + base config-ini containers contravariant data-clist deepseq dlist + microlens microlens-mtl microlens-th stm template-haskell text + text-zipper transformers vector vty word-wrap + ]; + doHaddock = false; + doCheck = false; + homepage = "https://github.com/jtdaugherty/brick/"; + description = "A declarative terminal user interface library"; + license = stdenv.lib.licenses.bsd3; + }) {}; + "brittany" = callPackage + ({ mkDerivation, aeson, base, butcher, bytestring, cmdargs + , containers, czipwith, data-tree-print, deepseq, directory, extra + , filepath, ghc, ghc-boot-th, ghc-exactprint, ghc-paths, monad-memo + , mtl, multistate, neat-interpolation, pretty, random, safe + , semigroups, stdenv, strict, syb, text, transformers, uniplate + , unsafe, yaml + }: + mkDerivation { + pname = "brittany"; + version = "0.11.0.0"; + sha256 = "46a80e13ff5543913d6f019a58ad7f0b2dc34faa190dc0d0d4ecf882498decb9"; + revision = "2"; + editedCabalFile = "1f20w6zzbygnpa7f6xbaqxx34l62r53ikywg2snn0zkfizf3lcgx"; + isLibrary = true; + isExecutable = true; + libraryHaskellDepends = [ + aeson base butcher bytestring cmdargs containers czipwith + data-tree-print deepseq directory extra filepath ghc ghc-boot-th + ghc-exactprint ghc-paths monad-memo mtl multistate + neat-interpolation pretty random safe semigroups strict syb text + transformers uniplate unsafe yaml + ]; + executableHaskellDepends = [ + aeson base butcher bytestring cmdargs containers czipwith + data-tree-print deepseq directory extra filepath ghc ghc-boot-th + ghc-exactprint ghc-paths monad-memo mtl multistate + neat-interpolation pretty safe semigroups strict syb text + transformers uniplate unsafe yaml + ]; + doHaddock = false; + doCheck = false; + homepage = "https://github.com/lspitzner/brittany/"; + description = "Haskell source code formatter"; + license = stdenv.lib.licenses.agpl3; + }) {}; + "broadcast-chan" = callPackage + ({ mkDerivation, base, stdenv }: + mkDerivation { + pname = "broadcast-chan"; + version = "0.1.1"; + sha256 = "ad5bd65a301aff6df38c4111f02e73cce3bcfed7bfae6c66c2e70310f1e985f2"; + revision = "1"; + editedCabalFile = "03bmddz9bryh3viskh2nldj4hbzl5b9xkkx2pml73vq9bn2aq5s4"; + libraryHaskellDepends = [ base ]; + doHaddock = false; + doCheck = false; + homepage = "https://github.com/merijn/broadcast-chan"; + description = "Broadcast channel type that avoids 0 reader space leaks"; + license = stdenv.lib.licenses.bsd3; + }) {}; + "bsb-http-chunked" = callPackage + ({ mkDerivation, base, bytestring, bytestring-builder, stdenv }: + mkDerivation { + pname = "bsb-http-chunked"; + version = "0.0.0.2"; + sha256 = "28cb750979763c815fbf69a6dc510f837b7ccbe262adf0a28ad270966737d5f4"; + libraryHaskellDepends = [ base bytestring bytestring-builder ]; + doHaddock = false; + doCheck = false; + homepage = "http://github.com/sjakobi/bsb-http-chunked"; + description = "Chunked HTTP transfer encoding for bytestring builders"; + license = stdenv.lib.licenses.bsd3; + }) {}; + "bson" = callPackage + ({ mkDerivation, base, binary, bytestring, cryptohash + , data-binary-ieee754, mtl, network, stdenv, text, time + }: + mkDerivation { + pname = "bson"; + version = "0.3.2.6"; + sha256 = "738dc3615aafa1dd553f51a67373af2f27db90e75266ed6cdee5cecb7f6fce80"; + libraryHaskellDepends = [ + base binary bytestring cryptohash data-binary-ieee754 mtl network + text time + ]; + doHaddock = false; + doCheck = false; + homepage = "http://github.com/mongodb-haskell/bson"; + description = "BSON documents are JSON-like objects with a standard binary encoding"; + license = stdenv.lib.licenses.asl20; + }) {}; + "bson-lens" = callPackage + ({ mkDerivation, base, bson, lens, stdenv, text }: + mkDerivation { + pname = "bson-lens"; + version = "0.1.1"; + sha256 = "d73bb417def2d8cb1efebfc22482a859e119bcc4005dd10106c82dff5ceeb160"; + libraryHaskellDepends = [ base bson lens text ]; + doHaddock = false; + doCheck = false; + homepage = "https://github.com/jb55/bson-lens"; + description = "BSON lenses"; + license = stdenv.lib.licenses.mit; + }) {}; + "btrfs" = callPackage + ({ mkDerivation, base, bytestring, stdenv, time, unix }: + mkDerivation { + pname = "btrfs"; + version = "0.1.2.3"; + sha256 = "7efc0b5c65623dcf60910baf896aec7da7ac2df4231f03a3072c78fb5b2fb88d"; + revision = "1"; + editedCabalFile = "1py88k9sjmx9x41l0wmp19a52ng9fdf66rmd0n9404gxxbqd5jxv"; + isLibrary = true; + isExecutable = true; + libraryHaskellDepends = [ base bytestring time unix ]; + doHaddock = false; + doCheck = false; + homepage = "https://github.com/redneb/hs-btrfs"; + description = "Bindings to the btrfs API"; + license = stdenv.lib.licenses.bsd3; + }) {}; + "buffer-builder" = callPackage + ({ mkDerivation, base, bytestring, mtl, stdenv, text + , unordered-containers, vector + }: + mkDerivation { + pname = "buffer-builder"; + version = "0.2.4.6"; + sha256 = "54383e4d9a412eeefd06ec6b92db065347536b0917f5d2d94fe9cdc472b15d64"; + libraryHaskellDepends = [ + base bytestring mtl text unordered-containers vector + ]; + doHaddock = false; + doCheck = false; + homepage = "https://github.com/chadaustin/buffer-builder"; + description = "Library for efficiently building up buffers, one piece at a time"; + license = stdenv.lib.licenses.bsd3; + }) {}; + "buffer-pipe" = callPackage + ({ mkDerivation, base, stdenv }: + mkDerivation { + pname = "buffer-pipe"; + version = "0.0"; + sha256 = "0875b6e41988f70e20d2e9d1a092ae03d545954732f93d65a3481b5c4b52dccf"; + isLibrary = false; + isExecutable = true; + executableHaskellDepends = [ base ]; + doHaddock = false; + doCheck = false; + description = "Read from stdin and write to stdout in large blocks"; + license = stdenv.lib.licenses.bsd3; + }) {}; + "butcher" = callPackage + ({ mkDerivation, base, bifunctors, containers, deque, extra, free + , microlens, microlens-th, mtl, multistate, pretty, stdenv + , transformers, unsafe, void + }: + mkDerivation { + pname = "butcher"; + version = "1.3.1.1"; + sha256 = "1f1ca26d2f0657f1762a60d623e065132d57aabe84ef494255c7918a1ed690d2"; + revision = "4"; + editedCabalFile = "1barqg8sn15c3npb551pl7kgbr9iqlf2bf4y86lcaa1cwkr4swym"; + libraryHaskellDepends = [ + base bifunctors containers deque extra free microlens microlens-th + mtl multistate pretty transformers unsafe void + ]; + doHaddock = false; + doCheck = false; + homepage = "https://github.com/lspitzner/butcher/"; + description = "Chops a command or program invocation into digestable pieces"; + license = stdenv.lib.licenses.bsd3; + }) {}; + "butter" = callPackage + ({ mkDerivation, aeson, base, bytestring, containers + , forkable-monad, free, HUnit, network-simple, stdenv, stm + , template-haskell, text, transformers + }: + mkDerivation { + pname = "butter"; + version = "0.1.0.6"; + sha256 = "8640b2681a57c0bc545684c821e80a97d57fe14bc6036e9030dc4cc63c2e4164"; + libraryHaskellDepends = [ + aeson base bytestring containers forkable-monad free HUnit + network-simple stm template-haskell text transformers + ]; + doHaddock = false; + doCheck = false; + homepage = "https://github.com/System-Indystress/Butter#readme"; + description = "Monad Transformer for Asyncronous Message Passing"; + license = stdenv.lib.licenses.bsd3; + }) {}; + "bv" = callPackage + ({ mkDerivation, base, ghc-prim, integer-gmp, stdenv }: + mkDerivation { + pname = "bv"; + version = "0.5"; + sha256 = "04a189ab1758f6adc51ffff0a10705d8c8b54959946a90a3b9a750c930c77bda"; + isLibrary = true; + isExecutable = true; + libraryHaskellDepends = [ base ghc-prim integer-gmp ]; + doHaddock = false; + doCheck = false; + homepage = "https://github.com/iagoabal/haskell-bv"; + description = "Bit-vector arithmetic library"; + license = stdenv.lib.licenses.bsd3; + }) {}; + "bv-little" = callPackage + ({ mkDerivation, base, deepseq, hashable, integer-gmp + , mono-traversable, primitive, QuickCheck, stdenv + }: + mkDerivation { + pname = "bv-little"; + version = "0.1.1"; + sha256 = "68e6d6d1ed6922e92e471e93ecb5c643f28f2e9c761f9c1a3697e9527c696b94"; + libraryHaskellDepends = [ + base deepseq hashable integer-gmp mono-traversable primitive + QuickCheck + ]; + doHaddock = false; + doCheck = false; + homepage = "https://github.com/recursion-ninja/bv-little"; + description = "Efficient little-endian bit vector library"; + license = stdenv.lib.licenses.bsd3; + }) {}; + "byteable" = callPackage + ({ mkDerivation, base, bytestring, stdenv }: + mkDerivation { + pname = "byteable"; + version = "0.1.1"; + sha256 = "243b34a1b5b64b39e39fe58f75c18f6cad5b668b10cabcd86816cbde27783fe2"; + enableSeparateDataOutput = true; + libraryHaskellDepends = [ base bytestring ]; + doHaddock = false; + doCheck = false; + homepage = "http://github.com/vincenthz/hs-byteable"; + description = "Type class for sequence of bytes"; + license = stdenv.lib.licenses.bsd3; + }) {}; + "bytedump" = callPackage + ({ mkDerivation, base, bytestring, stdenv }: + mkDerivation { + pname = "bytedump"; + version = "1.0"; + sha256 = "ae17b5040f0423eec792505f14d1d3e53f5ff81ddf83524f1c5dc7a16c0dc0dd"; + isLibrary = true; + isExecutable = true; + enableSeparateDataOutput = true; + libraryHaskellDepends = [ base bytestring ]; + doHaddock = false; + doCheck = false; + homepage = "http://github.com/vincenthz/hs-bytedump"; + description = "Flexible byte dump helpers for human readers"; + license = stdenv.lib.licenses.bsd3; + }) {}; + "byteorder" = callPackage + ({ mkDerivation, base, stdenv }: + mkDerivation { + pname = "byteorder"; + version = "1.0.4"; + sha256 = "bd20bbb586947f99c38a4c93d9d0266f49f6fc581767b51ba568f6d5d52d2919"; + libraryHaskellDepends = [ base ]; + doHaddock = false; + doCheck = false; + homepage = "http://community.haskell.org/~aslatter/code/byteorder"; + description = "Exposes the native endianness or byte ordering of the system"; + license = stdenv.lib.licenses.bsd3; + }) {}; + "bytes" = callPackage + ({ mkDerivation, base, binary, bytestring, Cabal, cabal-doctest + , cereal, containers, hashable, mtl, scientific, stdenv, text, time + , transformers, transformers-compat, unordered-containers, void + }: + mkDerivation { + pname = "bytes"; + version = "0.15.5"; + sha256 = "039935e6b367eb8657aa3eb109e719b257a06524b0d9ff5246e8029bb7a07118"; + setupHaskellDepends = [ base Cabal cabal-doctest ]; + libraryHaskellDepends = [ + base binary bytestring cereal containers hashable mtl scientific + text time transformers transformers-compat unordered-containers + void + ]; + doHaddock = false; + doCheck = false; + homepage = "https://github.com/ekmett/bytes"; + description = "Sharing code for serialization between binary and cereal"; + license = stdenv.lib.licenses.bsd3; + }) {}; + "byteset" = callPackage + ({ mkDerivation, base, binary, stdenv }: + mkDerivation { + pname = "byteset"; + version = "0.1.1.0"; + sha256 = "13499c5b279f022097e9ae1d0aeef3fcea12b7f18f50157d4950aec58741afa1"; + libraryHaskellDepends = [ base binary ]; + doHaddock = false; + doCheck = false; + description = "Set of bytes"; + license = stdenv.lib.licenses.bsd3; + }) {}; + "bytestring-builder" = callPackage + ({ mkDerivation, base, bytestring, deepseq, stdenv }: + mkDerivation { + pname = "bytestring-builder"; + version = "0.10.8.1.0"; + sha256 = "6d7404773621efb88b256ff88912a7dbcebc7fb86d27868ef58478249892dbc2"; + libraryHaskellDepends = [ base bytestring deepseq ]; + doHaddock = false; + doCheck = false; + description = "The new bytestring builder, packaged outside of GHC"; + license = stdenv.lib.licenses.bsd3; + }) {}; + "bytestring-conversion" = callPackage + ({ mkDerivation, attoparsec, base, bytestring, case-insensitive + , double-conversion, stdenv, text + }: + mkDerivation { + pname = "bytestring-conversion"; + version = "0.3.1"; + sha256 = "13b7ea48737dc7a7fd4c894ff1fb9344cf8d9ef8f4201e813d578b613e874ef8"; + revision = "2"; + editedCabalFile = "1x8c42cfzb6fdvgkxxdxcpdf16csimlzsgahb1axnplmr6b3ba63"; + libraryHaskellDepends = [ + attoparsec base bytestring case-insensitive double-conversion text + ]; + doHaddock = false; + doCheck = false; + homepage = "https://github.com/twittner/bytestring-conversion/"; + description = "Type-classes to convert values to and from ByteString"; + license = stdenv.lib.licenses.mpl20; + }) {}; + "bytestring-lexing" = callPackage + ({ mkDerivation, base, bytestring, stdenv }: + mkDerivation { + pname = "bytestring-lexing"; + version = "0.5.0.2"; + sha256 = "01f9add3f25067a89c5ae9ab1f2fd8ab75ec9f386987ee0d83f73ec855b43f73"; + libraryHaskellDepends = [ base bytestring ]; + doHaddock = false; + doCheck = false; + homepage = "http://code.haskell.org/~wren/"; + description = "Parse and produce literals efficiently from strict or lazy bytestrings"; + license = stdenv.lib.licenses.bsd2; + }) {}; + "bytestring-strict-builder" = callPackage + ({ mkDerivation, base, base-prelude, bytestring, semigroups, stdenv + }: + mkDerivation { + pname = "bytestring-strict-builder"; + version = "0.4.5.1"; + sha256 = "1879edb56e530169f5c4a738fff46ac56faeb30f9ac3d59f1361183111a5c69e"; + revision = "1"; + editedCabalFile = "1snn8qb17maa76zji75i4yfz9x8ci16xp6zwg6kgwb33lf06imnd"; + libraryHaskellDepends = [ + base base-prelude bytestring semigroups + ]; + doHaddock = false; + doCheck = false; + homepage = "https://github.com/nikita-volkov/bytestring-strict-builder"; + description = "An efficient strict bytestring builder"; + license = stdenv.lib.licenses.mit; + }) {}; + "bytestring-tree-builder" = callPackage + ({ mkDerivation, base, base-prelude, bytestring, semigroups, stdenv + , text + }: + mkDerivation { + pname = "bytestring-tree-builder"; + version = "0.2.7.2"; + sha256 = "a12df2ef970eab34c7bb968ba1a157fb01e478cd9abada097fc3e4ec61b5020e"; + libraryHaskellDepends = [ + base base-prelude bytestring semigroups text + ]; + doHaddock = false; + doCheck = false; + homepage = "https://github.com/nikita-volkov/bytestring-tree-builder"; + description = "A very efficient ByteString builder implementation based on the binary tree"; + license = stdenv.lib.licenses.mit; + }) {}; + "bzlib" = callPackage + ({ mkDerivation, base, bytestring, bzip2, stdenv }: + mkDerivation { + pname = "bzlib"; + version = "0.5.0.5"; + sha256 = "9ee7d0ac7461b330820af928c13c6668bf4fe3601f171c42432a85c33718017e"; + libraryHaskellDepends = [ base bytestring ]; + librarySystemDepends = [ bzip2 ]; + doHaddock = false; + doCheck = false; + description = "Compression and decompression in the bzip2 format"; + license = stdenv.lib.licenses.bsd3; + }) {inherit (pkgs) bzip2;}; + "bzlib-conduit" = callPackage + ({ mkDerivation, base, bindings-DSL, bytestring, bzip2, conduit + , data-default-class, mtl, resourcet, stdenv + }: + mkDerivation { + pname = "bzlib-conduit"; + version = "0.3.0.1"; + sha256 = "43d811549f7fb0710e4895ad54f78418271579f7e27d75e3c3470b74b285a239"; + enableSeparateDataOutput = true; + libraryHaskellDepends = [ + base bindings-DSL bytestring conduit data-default-class mtl + resourcet + ]; + librarySystemDepends = [ bzip2 ]; + doHaddock = false; + doCheck = false; + homepage = "https://github.com/snoyberg/bzlib-conduit#readme"; + description = "Streaming compression/decompression via conduits"; + license = stdenv.lib.licenses.bsd3; + }) {inherit (pkgs) bzip2;}; + "c2hs" = callPackage + ({ mkDerivation, array, base, bytestring, containers, directory + , dlist, filepath, language-c, pretty, process, stdenv + }: + mkDerivation { + pname = "c2hs"; + version = "0.28.5"; + sha256 = "bd10ab1260f5c838bbe239170d11d44ca2d7caef683f0d4df5190dc64e4a2df6"; + revision = "1"; + editedCabalFile = "1d6i1wr1kbn61yi7nk1scjfm2800vm2ynnx7555fjkdx4d8va711"; + isLibrary = false; + isExecutable = true; + enableSeparateDataOutput = true; + executableHaskellDepends = [ + array base bytestring containers directory dlist filepath + language-c pretty process + ]; + doHaddock = false; + doCheck = false; + homepage = "https://github.com/haskell/c2hs"; + description = "C->Haskell FFI tool that gives some cross-language type safety"; + license = stdenv.lib.licenses.gpl2; + }) {}; + "cabal-doctest" = callPackage + ({ mkDerivation, base, Cabal, directory, filepath, stdenv }: + mkDerivation { + pname = "cabal-doctest"; + version = "1.0.6"; + sha256 = "decaaa5a73eaabaf3c4f8c644bd7f6e3f428b6244e935c0cf105f75f9b24ed2d"; + revision = "2"; + editedCabalFile = "1kbiwqm4fxrsdpcqijdq98h8wzmxydcvxd03f1z8dliqzyqsbd60"; + libraryHaskellDepends = [ base Cabal directory filepath ]; + doHaddock = false; + doCheck = false; + homepage = "https://github.com/phadej/cabal-doctest"; + description = "A Setup.hs helper for doctests running"; + license = stdenv.lib.licenses.bsd3; + }) {}; + "cabal-install" = callPackage + ({ mkDerivation, array, async, base, base16-bytestring, binary + , bytestring, Cabal, containers, cryptohash-sha256, deepseq + , directory, echo, edit-distance, filepath, hackage-security + , hashable, HTTP, mtl, network, network-uri, pretty, process + , random, resolv, stdenv, stm, tar, time, unix, zlib + }: + mkDerivation { + pname = "cabal-install"; + version = "2.2.0.0"; + sha256 = "c856a2dd93c5a7b909597c066b9f9ca27fbda1a502b3f96077b7918c0f64a3d9"; + revision = "1"; + editedCabalFile = "0f1svlhh4cpj3p5fs9bcjpv15qp291lnvlaxxcw7aib8a1gn3wim"; + isLibrary = true; + isExecutable = true; + setupHaskellDepends = [ base Cabal filepath process ]; + executableHaskellDepends = [ + array async base base16-bytestring binary bytestring Cabal + containers cryptohash-sha256 deepseq directory echo edit-distance + filepath hackage-security hashable HTTP mtl network network-uri + pretty process random resolv stm tar time unix zlib + ]; + doHaddock = false; + doCheck = false; + postInstall = '' + mkdir $out/etc + mv bash-completion $out/etc/bash_completion.d + ''; + homepage = "http://www.haskell.org/cabal/"; + description = "The command-line interface for Cabal and Hackage"; + license = stdenv.lib.licenses.bsd3; + }) {}; + "cabal-rpm" = callPackage + ({ mkDerivation, base, bytestring, Cabal, directory, filepath + , http-client, http-client-tls, http-conduit, process, stdenv, time + , unix + }: + mkDerivation { + pname = "cabal-rpm"; + version = "0.12.4"; + sha256 = "62a466f0805c2ca2fca3d8241571a90a766c31bacd2188ef4583f153aa5dfaf3"; + isLibrary = false; + isExecutable = true; + executableHaskellDepends = [ + base bytestring Cabal directory filepath http-client + http-client-tls http-conduit process time unix + ]; + doHaddock = false; + doCheck = false; + homepage = "https://github.com/juhp/cabal-rpm"; + description = "RPM packaging tool for Haskell Cabal-based packages"; + license = stdenv.lib.licenses.gpl3; + }) {}; + "cabal2nix" = callPackage + ({ mkDerivation, aeson, ansi-wl-pprint, base, bytestring, Cabal + , containers, deepseq, directory, distribution-nixpkgs, filepath + , hackage-db, hopenssl, hpack, language-nix, lens, monad-par + , monad-par-extras, mtl, optparse-applicative, pretty, process + , split, stdenv, text, time, transformers, yaml + }: + mkDerivation { + pname = "cabal2nix"; + version = "2.9.3"; + sha256 = "129fcefe74fcb0c15aa4747603116820d751b0ea904376cd1603381a339a8182"; + isLibrary = true; + isExecutable = true; + libraryHaskellDepends = [ + aeson ansi-wl-pprint base bytestring Cabal containers deepseq + directory distribution-nixpkgs filepath hackage-db hopenssl hpack + language-nix lens optparse-applicative pretty process split text + time transformers yaml + ]; + executableHaskellDepends = [ + aeson base bytestring Cabal containers directory + distribution-nixpkgs filepath hopenssl language-nix lens monad-par + monad-par-extras mtl optparse-applicative pretty + ]; + doHaddock = false; + doCheck = false; + preCheck = '' + export PATH="$PWD/dist/build/cabal2nix:$PATH" + export HOME="$TMPDIR/home" + ''; + homepage = "https://github.com/nixos/cabal2nix#readme"; + description = "Convert Cabal files into Nix build instructions"; + license = stdenv.lib.licenses.bsd3; + }) {}; + "cabal2spec" = callPackage + ({ mkDerivation, base, Cabal, filepath, optparse-applicative + , stdenv, time + }: + mkDerivation { + pname = "cabal2spec"; + version = "2.1.1"; + sha256 = "ad063835309823388883324a42d951f15c5da9b4e324bfe3de97751f4fdca9ba"; + isLibrary = true; + isExecutable = true; + libraryHaskellDepends = [ base Cabal filepath time ]; + executableHaskellDepends = [ + base Cabal filepath optparse-applicative + ]; + doHaddock = false; + doCheck = false; + homepage = "https://github.com/peti/cabal2spec"; + description = "Convert Cabal files into rpm spec files"; + license = stdenv.lib.licenses.gpl3; + }) {}; + "cache" = callPackage + ({ mkDerivation, base, clock, hashable, stdenv, stm, transformers + , unordered-containers + }: + mkDerivation { + pname = "cache"; + version = "0.1.1.0"; + sha256 = "14756f8383e991affe6120d299ba23c4f53753519700f8a771cfcec9782b78ff"; + libraryHaskellDepends = [ + base clock hashable stm transformers unordered-containers + ]; + doHaddock = false; + doCheck = false; + homepage = "https://github.com/hverr/haskell-cache#readme"; + description = "An in-memory key/value store with expiration support"; + license = stdenv.lib.licenses.bsd3; + }) {}; + "cachix" = callPackage + ({ mkDerivation, async, base, base16-bytestring, base64-bytestring + , bifunctors, bytestring, cachix-api, conduit, conduit-combinators + , conduit-extra, cookie, cryptonite, dhall, directory, ed25519 + , fsnotify, here, hspec-discover, http-client, http-client-tls + , http-conduit, http-types, lzma-conduit, megaparsec, memory + , mmorph, optparse-applicative, process, protolude, resourcet + , servant, servant-auth, servant-auth-client, servant-client + , servant-client-core, servant-streaming-client, stdenv, streaming + , text, unix, uri-bytestring, versions + }: + mkDerivation { + pname = "cachix"; + version = "0.1.0.2"; + sha256 = "94f1c5ba33ff9c34d5e06e756ae8aa7c38c9a71e436e539d154f3722e4b06ae4"; + isLibrary = true; + isExecutable = true; + libraryHaskellDepends = [ + async base base16-bytestring base64-bytestring bifunctors + bytestring cachix-api conduit conduit-combinators conduit-extra + cookie cryptonite dhall directory ed25519 fsnotify here http-client + http-client-tls http-conduit http-types lzma-conduit megaparsec + memory mmorph optparse-applicative process protolude resourcet + servant servant-auth servant-auth-client servant-client + servant-client-core servant-streaming-client streaming text unix + uri-bytestring versions + ]; + executableHaskellDepends = [ + async base base16-bytestring base64-bytestring bifunctors + bytestring cachix-api conduit conduit-combinators conduit-extra + cookie cryptonite dhall directory ed25519 fsnotify here http-client + http-client-tls http-conduit http-types lzma-conduit megaparsec + memory mmorph optparse-applicative process protolude resourcet + servant servant-auth servant-auth-client servant-client + servant-client-core servant-streaming-client streaming text unix + uri-bytestring versions + ]; + executableToolDepends = [ hspec-discover ]; + doHaddock = false; + doCheck = false; + homepage = "https://github.com/cachix/cachix#readme"; + description = "Command line client for Nix binary cache hosting https://cachix.org"; + license = stdenv.lib.licenses.asl20; + }) {}; + "cachix-api" = callPackage + ({ mkDerivation, aeson, amazonka, base, base16-bytestring + , bytestring, conduit, conduit-combinators, cookie, cryptonite + , http-api-data, http-media, lens, memory, servant, servant-auth + , servant-auth-server, servant-auth-swagger, servant-streaming + , servant-swagger, servant-swagger-ui-core, stdenv, string-conv + , swagger2, text, transformers + }: + mkDerivation { + pname = "cachix-api"; + version = "0.1.0.1"; + sha256 = "c60feb84da86c12d3dc72095c875b56f7b34c752864eb408c3de6384225b2d7d"; + isLibrary = true; + isExecutable = true; + libraryHaskellDepends = [ + aeson amazonka base base16-bytestring bytestring conduit + conduit-combinators cookie cryptonite http-api-data http-media lens + memory servant servant-auth servant-auth-server + servant-auth-swagger servant-streaming servant-swagger + servant-swagger-ui-core string-conv swagger2 text transformers + ]; + executableHaskellDepends = [ + aeson amazonka base base16-bytestring bytestring conduit + conduit-combinators cookie cryptonite http-api-data http-media lens + memory servant servant-auth servant-auth-server + servant-auth-swagger servant-streaming servant-swagger + servant-swagger-ui-core string-conv swagger2 text transformers + ]; + doHaddock = false; + doCheck = false; + homepage = "https://github.com/cachix/cachix#readme"; + description = "Servant HTTP API specification for https://cachix.org"; + license = stdenv.lib.licenses.asl20; + }) {}; + "cairo" = callPackage + ({ mkDerivation, array, base, bytestring, Cabal, cairo + , gtk2hs-buildtools, mtl, stdenv, text, utf8-string + }: + mkDerivation { + pname = "cairo"; + version = "0.13.5.0"; + sha256 = "420acd81e0b5578ad188bcdd38463135293c233221abb741cc4004d4c8a6bef3"; + enableSeparateDataOutput = true; + setupHaskellDepends = [ base Cabal gtk2hs-buildtools ]; + libraryHaskellDepends = [ + array base bytestring mtl text utf8-string + ]; + libraryPkgconfigDepends = [ cairo ]; + doHaddock = false; + doCheck = false; + homepage = "http://projects.haskell.org/gtk2hs/"; + description = "Binding to the Cairo library"; + license = stdenv.lib.licenses.bsd3; + }) {inherit (pkgs) cairo;}; + "calendar-recycling" = callPackage + ({ mkDerivation, base, containers, html, old-time, stdenv + , utility-ht + }: + mkDerivation { + pname = "calendar-recycling"; + version = "0.0"; + sha256 = "a33e62c5bdbbece82491b6b795510496467df9993c715c819a7aad7707ee7963"; + isLibrary = false; + isExecutable = true; + executableHaskellDepends = [ + base containers html old-time utility-ht + ]; + doHaddock = false; + doCheck = false; + homepage = "http://hub.darcs.net/thielema/calendar-recycling"; + description = "List years with the same calendars"; + license = stdenv.lib.licenses.bsd3; + }) {}; + "call-stack" = callPackage + ({ mkDerivation, base, stdenv }: + mkDerivation { + pname = "call-stack"; + version = "0.1.0"; + sha256 = "f25f5e0992a39371079cc25c2a14b5abb872fa7d868a32753aac3a258b83b1e2"; + libraryHaskellDepends = [ base ]; + doHaddock = false; + doCheck = false; + homepage = "https://github.com/sol/call-stack#readme"; + description = "Use GHC call-stacks in a backward compatible way"; + license = stdenv.lib.licenses.mit; + }) {}; + "capataz" = callPackage + ({ mkDerivation, async, base, bytestring, pretty-show + , prettyprinter, rio, stdenv, teardown, time, uuid + }: + mkDerivation { + pname = "capataz"; + version = "0.2.0.0"; + sha256 = "a4dfc60ccd24bb3102127cb0226f23abfc12b7263fe45e74747cf674d736022c"; + libraryHaskellDepends = [ + async base bytestring pretty-show prettyprinter rio teardown time + uuid + ]; + doHaddock = false; + doCheck = false; + homepage = "https://github.com/roman/Haskell-capataz#readme"; + description = "OTP-like supervision trees in Haskell"; + license = stdenv.lib.licenses.mit; + }) {}; + "carray" = callPackage + ({ mkDerivation, array, base, binary, bytestring, ix-shapable + , QuickCheck, stdenv, syb + }: + mkDerivation { + pname = "carray"; + version = "0.1.6.8"; + sha256 = "8f1967d54c7cf9680481c6f630eafa66f6d916b93c98f3b3c47449f682f11613"; + libraryHaskellDepends = [ + array base binary bytestring ix-shapable QuickCheck syb + ]; + doHaddock = false; + doCheck = false; + description = "A C-compatible array library"; + license = stdenv.lib.licenses.bsd3; + }) {}; + "case-insensitive" = callPackage + ({ mkDerivation, base, bytestring, deepseq, hashable, stdenv, text + }: + mkDerivation { + pname = "case-insensitive"; + version = "1.2.0.11"; + sha256 = "a7ce6d17e50caaa0f19ad8e67361499022860554c521b1e57993759da3eb37e3"; + libraryHaskellDepends = [ base bytestring deepseq hashable text ]; + doHaddock = false; + doCheck = false; + homepage = "https://github.com/basvandijk/case-insensitive"; + description = "Case insensitive string comparison"; + license = stdenv.lib.licenses.bsd3; + }) {}; + "cased" = callPackage + ({ mkDerivation, base, stdenv, text }: + mkDerivation { + pname = "cased"; + version = "0.1.0.0"; + sha256 = "8394e6705ed83152875e1de1c51c54c26b04a2359919d8958d66997b2b60ad23"; + libraryHaskellDepends = [ base text ]; + doHaddock = false; + doCheck = false; + homepage = "https://github.com/jb55/cased"; + description = "Track string casing in its type"; + license = stdenv.lib.licenses.mit; + }) {}; + "cases" = callPackage + ({ mkDerivation, attoparsec, base-prelude, loch-th, stdenv, text }: + mkDerivation { + pname = "cases"; + version = "0.1.3.2"; + sha256 = "9ecf632f7751aac2ed7ec93407f9499237316f2eb50f331bb4969abf3359a8a9"; + libraryHaskellDepends = [ attoparsec base-prelude loch-th text ]; + doHaddock = false; + doCheck = false; + homepage = "https://github.com/nikita-volkov/cases"; + description = "A converter for spinal, snake and camel cases"; + license = stdenv.lib.licenses.mit; + }) {}; + "casing" = callPackage + ({ mkDerivation, base, split, stdenv }: + mkDerivation { + pname = "casing"; + version = "0.1.4.0"; + sha256 = "8e8a3631ef5823ae53dfeb7497ad4856c6758e3e380ff164f6a261f41685f6d7"; + libraryHaskellDepends = [ base split ]; + doHaddock = false; + doCheck = false; + description = "Convert between various source code casing conventions"; + license = stdenv.lib.licenses.mit; + }) {}; + "cassava" = callPackage + ({ mkDerivation, array, attoparsec, base, bytestring, containers + , deepseq, hashable, Only, scientific, stdenv, text, text-short + , unordered-containers, vector + }: + mkDerivation { + pname = "cassava"; + version = "0.5.1.0"; + sha256 = "762c8aaea2cdad61f52bad1b9f1f3b32764b4b6da03371aba6e5017f69614277"; + revision = "1"; + editedCabalFile = "1brz20js95synh0yw942ihy4y9y6nk4xnsqcjqi9580y24zcigkl"; + configureFlags = [ "-f-bytestring--lt-0_10_4" ]; + libraryHaskellDepends = [ + array attoparsec base bytestring containers deepseq hashable Only + scientific text text-short unordered-containers vector + ]; + doHaddock = false; + doCheck = false; + homepage = "https://github.com/hvr/cassava"; + description = "A CSV parsing and encoding library"; + license = stdenv.lib.licenses.bsd3; + }) {}; + "cassava-conduit" = callPackage + ({ mkDerivation, array, base, bifunctors, bytestring, cassava + , conduit, containers, mtl, stdenv, text + }: + mkDerivation { + pname = "cassava-conduit"; + version = "0.5.0"; + sha256 = "19460ab99942455cc12fa38b15c07da80df496eb5494675e7e524d197d874876"; + libraryHaskellDepends = [ + array base bifunctors bytestring cassava conduit containers mtl + text + ]; + doHaddock = false; + doCheck = false; + homepage = "https://github.com/domdere/cassava-conduit"; + description = "Conduit interface for cassava package"; + license = stdenv.lib.licenses.bsd3; + }) {}; + "cassava-records" = callPackage + ({ mkDerivation, attoparsec, base, bytestring, cassava, foldl + , stdenv, template-haskell, text, unordered-containers, vector + }: + mkDerivation { + pname = "cassava-records"; + version = "0.1.0.4"; + sha256 = "11f832c11125bd7a73b57941284d9aeb7f1e7572004da7e37311b34d3366af8d"; + libraryHaskellDepends = [ + attoparsec base bytestring cassava foldl template-haskell text + unordered-containers vector + ]; + doHaddock = false; + doCheck = false; + homepage = "https://github.com/gdevanla/cassava-records#readme"; + description = "Auto-generation of records data type"; + license = stdenv.lib.licenses.bsd3; + }) {}; + "cast" = callPackage + ({ mkDerivation, base, stdenv }: + mkDerivation { + pname = "cast"; + version = "0.1.0.2"; + sha256 = "24d545e5974436b6e3ee9dfda7ed68218c9f698103adae676a60860d90d7bc91"; + libraryHaskellDepends = [ base ]; + doHaddock = false; + doCheck = false; + homepage = "https://github.com/haskell-patterns/cast#readme"; + description = "Abstact cast pattern"; + license = stdenv.lib.licenses.bsd3; + }) {}; + "category" = callPackage + ({ mkDerivation, alg, base, stdenv }: + mkDerivation { + pname = "category"; + version = "0.2.0.1"; + sha256 = "07d0b37638ec5c46d96874c9318ca385ea489ae0538c62e9c559b6f56809ab6c"; + libraryHaskellDepends = [ alg base ]; + doHaddock = false; + doCheck = false; + description = "Categorical types and classes"; + license = stdenv.lib.licenses.bsd3; + }) {}; + "cereal" = callPackage + ({ mkDerivation, array, base, bytestring, containers, ghc-prim + , stdenv + }: + mkDerivation { + pname = "cereal"; + version = "0.5.5.0"; + sha256 = "0b97320ffbfa6df2e5679022215dbd0fe6e3b5ae8428c2ff4310d9e1acf16822"; + libraryHaskellDepends = [ + array base bytestring containers ghc-prim + ]; + doHaddock = false; + doCheck = false; + homepage = "https://github.com/GaloisInc/cereal"; + description = "A binary serialization library"; + license = stdenv.lib.licenses.bsd3; + }) {}; + "cereal-conduit" = callPackage + ({ mkDerivation, base, bytestring, cereal, conduit, resourcet + , stdenv, transformers + }: + mkDerivation { + pname = "cereal-conduit"; + version = "0.8.0"; + sha256 = "d95c4518a9984feacfd811c64be993705bff74c1f2daa00b4687bbb79f3a39eb"; + revision = "1"; + editedCabalFile = "1imyl3g2bni8bc6kajr857xh94fscphksj3286pxfpa8yp9vqqpc"; + libraryHaskellDepends = [ + base bytestring cereal conduit resourcet transformers + ]; + doHaddock = false; + doCheck = false; + homepage = "https://github.com/snoyberg/conduit"; + description = "Turn Data.Serialize Gets and Puts into Sources, Sinks, and Conduits"; + license = stdenv.lib.licenses.bsd3; + }) {}; + "cereal-text" = callPackage + ({ mkDerivation, base, cereal, stdenv, text }: + mkDerivation { + pname = "cereal-text"; + version = "0.1.0.2"; + sha256 = "3c7a15f4681fa53b66dcd5165f31f56ff9751a752ac5123ecc5bcf5c3ea0354c"; + libraryHaskellDepends = [ base cereal text ]; + doHaddock = false; + doCheck = false; + homepage = "https://github.com/ulikoehler/cereal-text"; + description = "Data.Text instances for the cereal serialization library"; + license = stdenv.lib.licenses.asl20; + }) {}; + "cereal-time" = callPackage + ({ mkDerivation, base, cereal, stdenv, time }: + mkDerivation { + pname = "cereal-time"; + version = "0.1.0.0"; + sha256 = "bec6d5103ec45bee242825da4cf695f574f101bb1d48778bf7823175dfa43cb2"; + libraryHaskellDepends = [ base cereal time ]; + doHaddock = false; + doCheck = false; + description = "Serialize instances for types from `time` package"; + license = stdenv.lib.licenses.bsd3; + }) {}; + "cereal-vector" = callPackage + ({ mkDerivation, base, bytestring, cereal, stdenv, vector }: + mkDerivation { + pname = "cereal-vector"; + version = "0.2.0.1"; + sha256 = "ff0685a6c39e7aae32f8b4165e2ae06f284c867298ad4f7b776c1c1b2859f933"; + libraryHaskellDepends = [ base bytestring cereal vector ]; + doHaddock = false; + doCheck = false; + homepage = "https://github.com/acfoltzer/cereal-vector"; + description = "Serialize instances for Data.Vector types."; + license = stdenv.lib.licenses.bsd3; + }) {}; + "cfenv" = callPackage + ({ mkDerivation, aeson, base, bytestring, containers, stdenv }: + mkDerivation { + pname = "cfenv"; + version = "0.1.0.0"; + sha256 = "8ce96643559ebe4504c0641f9817d8795b22631f614084af50c88e51277e747e"; + libraryHaskellDepends = [ aeson base bytestring containers ]; + doHaddock = false; + doCheck = false; + homepage = "https://github.com/tomphp/haskell-cfenv#readme"; + description = "A library getting the environment when running on Cloud Foundry"; + license = stdenv.lib.licenses.bsd3; + }) {}; + "chan" = callPackage + ({ mkDerivation, async, base, stdenv, stm }: + mkDerivation { + pname = "chan"; + version = "0.0.3"; + sha256 = "f9e988023fd53fc60b00fbb5546f9e75045ab1dc83e21aa0c56288c681072232"; + libraryHaskellDepends = [ async base stm ]; + doHaddock = false; + doCheck = false; + homepage = "https://github.com/athanclark/chan#readme"; + description = "Some extra kit for Chans"; + license = stdenv.lib.licenses.bsd3; + }) {}; + "charset" = callPackage + ({ mkDerivation, array, base, bytestring, containers, semigroups + , stdenv, unordered-containers + }: + mkDerivation { + pname = "charset"; + version = "0.3.7.1"; + sha256 = "3d415d2883bd7bf0cc9f038e8323f19c71e07dd12a3c712f449ccb8b4daac0be"; + revision = "1"; + editedCabalFile = "1z6nxw2g9vgsjq0g159sk8mwj68lwzxzi5iv5ynha0h85jcqxszy"; + libraryHaskellDepends = [ + array base bytestring containers semigroups unordered-containers + ]; + doHaddock = false; + doCheck = false; + homepage = "http://github.com/ekmett/charset"; + description = "Fast unicode character sets based on complemented PATRICIA tries"; + license = stdenv.lib.licenses.bsd3; + }) {}; + "charsetdetect-ae" = callPackage + ({ mkDerivation, base, bytestring, stdenv }: + mkDerivation { + pname = "charsetdetect-ae"; + version = "1.1.0.4"; + sha256 = "9bbaa48d3026abdd403ed59ee5f41978b2f5be6d0dc545e142c86d5aa790410c"; + libraryHaskellDepends = [ base bytestring ]; + doHaddock = false; + doCheck = false; + homepage = "http://github.com/aelve/charsetdetect-ae"; + description = "Character set detection using Mozilla's Universal Character Set Detector"; + license = "LGPL"; + }) {}; + "chart-unit" = callPackage + ({ mkDerivation, base, colour, data-default, diagrams-lib + , diagrams-svg, foldl, formatting, generic-lens, lens, linear + , numhask, numhask-prelude, numhask-range, palette, protolude + , scientific, stdenv, svg-builder, SVGFonts, text, time + }: + mkDerivation { + pname = "chart-unit"; + version = "0.7.0.0"; + sha256 = "97f893f3a9f28cf93d8ad30991ed6fec04c908e8a5bbc4f8e018f06a00bab20e"; + libraryHaskellDepends = [ + base colour data-default diagrams-lib diagrams-svg foldl formatting + generic-lens lens linear numhask numhask-prelude numhask-range + palette protolude scientific svg-builder SVGFonts text time + ]; + doHaddock = false; + doCheck = false; + homepage = "https://github.com/tonyday567/chart-unit#readme"; + description = "Native haskell charts"; + license = stdenv.lib.licenses.bsd3; + }) {}; + "chaselev-deque" = callPackage + ({ mkDerivation, abstract-deque, array, atomic-primops, base + , ghc-prim, stdenv, transformers, vector + }: + mkDerivation { + pname = "chaselev-deque"; + version = "0.5.0.5"; + sha256 = "4d58f8d56228e9f5bea2a65717dea65106323cb5ead9b5f39f904dac5c0043f4"; + libraryHaskellDepends = [ + abstract-deque array atomic-primops base ghc-prim transformers + vector + ]; + doHaddock = false; + doCheck = false; + homepage = "https://github.com/rrnewton/haskell-lockfree/wiki"; + description = "Chase & Lev work-stealing lock-free double-ended queues (deques)"; + license = stdenv.lib.licenses.bsd3; + }) {}; + "chatwork" = callPackage + ({ mkDerivation, aeson, aeson-casing, base, bytestring, connection + , data-default-class, http-api-data, http-client, http-client-tls + , http-types, req, stdenv, text + }: + mkDerivation { + pname = "chatwork"; + version = "0.1.3.4"; + sha256 = "624f2cc2ea0d1e967170099646c112c35329b947d6354ff6a79fb6c4b15b289b"; + isLibrary = true; + isExecutable = true; + libraryHaskellDepends = [ + aeson aeson-casing base bytestring connection data-default-class + http-api-data http-client http-client-tls http-types req text + ]; + executableHaskellDepends = [ + aeson aeson-casing base bytestring connection data-default-class + http-api-data http-client http-client-tls http-types req text + ]; + doHaddock = false; + doCheck = false; + homepage = "https://github.com/matsubara0507/chatwork#readme"; + description = "The ChatWork API in Haskell"; + license = stdenv.lib.licenses.mit; + }) {}; + "cheapskate" = callPackage + ({ mkDerivation, base, blaze-html, bytestring, containers + , data-default, deepseq, mtl, stdenv, syb, text, uniplate + , xss-sanitize + }: + mkDerivation { + pname = "cheapskate"; + version = "0.1.1"; + sha256 = "621041bf50cb9d94bf6a4eb90a038e0b0a6cb9794802f985fe126a73e08938c2"; + revision = "1"; + editedCabalFile = "1zrbp211ciia8j1br6krbxbqsj69kmx0rgkbvbpxdklmbgpfam3b"; + isLibrary = true; + isExecutable = true; + libraryHaskellDepends = [ + base blaze-html containers data-default deepseq mtl syb text + uniplate xss-sanitize + ]; + executableHaskellDepends = [ base blaze-html bytestring text ]; + doHaddock = false; + doCheck = false; + homepage = "http://github.com/jgm/cheapskate"; + description = "Experimental markdown processor"; + license = stdenv.lib.licenses.bsd3; + }) {}; + "cheapskate-highlight" = callPackage + ({ mkDerivation, base, blaze-html, cheapskate, highlighting-kate + , stdenv, text + }: + mkDerivation { + pname = "cheapskate-highlight"; + version = "0.1.0.0"; + sha256 = "5af7afb26b4ea80952963b44db695cbf18da34d3e8a7d32382a7dbfa4832d370"; + revision = "1"; + editedCabalFile = "1c8kxqdqf0j962xjdrrjfcbjsl0c1kax31rjykymv7w16d6hmlj4"; + libraryHaskellDepends = [ + base blaze-html cheapskate highlighting-kate text + ]; + doHaddock = false; + doCheck = false; + homepage = "http://github.com/aelve/cheapskate-highlight"; + description = "Code highlighting for cheapskate"; + license = stdenv.lib.licenses.bsd3; + }) {}; + "cheapskate-lucid" = callPackage + ({ mkDerivation, base, blaze-html, cheapskate, lucid, stdenv }: + mkDerivation { + pname = "cheapskate-lucid"; + version = "0.1.0.0"; + sha256 = "f582e512befd2707a7056c1d15541967de2e0ce5702bc2197a3fced58a777245"; + revision = "1"; + editedCabalFile = "197nx95xw21i7zyvgzcgnr36ab6vrk17c66iz8ndwz61vp1jf6hc"; + libraryHaskellDepends = [ base blaze-html cheapskate lucid ]; + doHaddock = false; + doCheck = false; + homepage = "http://github.com/aelve/cheapskate-lucid"; + description = "Use cheapskate with Lucid"; + license = stdenv.lib.licenses.bsd3; + }) {}; + "check-email" = callPackage + ({ mkDerivation, base, bytestring, email-validate, resolv, stdenv + }: + mkDerivation { + pname = "check-email"; + version = "1.0.2"; + sha256 = "1c2615fadba09a5d7aa5c68648d12218a595efb759842fb4f524cf380afa9327"; + libraryHaskellDepends = [ base bytestring email-validate ]; + librarySystemDepends = [ resolv ]; + doHaddock = false; + doCheck = false; + homepage = "https://github.com/qoelet/check-email#readme"; + description = "Confirm whether an email is valid and probably existant"; + license = stdenv.lib.licenses.bsd3; + }) {inherit (pkgs) resolv;}; + "checkers" = callPackage + ({ mkDerivation, array, base, QuickCheck, random, semigroupoids + , stdenv + }: + mkDerivation { + pname = "checkers"; + version = "0.4.10"; + sha256 = "89f739106f528998cc83bc25ab1b3e483cd2ffb21ca120fcb8b2e5c43306711e"; + libraryHaskellDepends = [ + array base QuickCheck random semigroupoids + ]; + doHaddock = false; + doCheck = false; + homepage = "https://github.com/conal/checkers"; + description = "Check properties on standard classes and data structures"; + license = stdenv.lib.licenses.bsd3; + }) {}; + "checksum" = callPackage + ({ mkDerivation, base, explicit-exception, stdenv, utility-ht }: + mkDerivation { + pname = "checksum"; + version = "0.0"; + sha256 = "337a0f6fcf7687469ecd410a3ed41c85ab68de08b5da0798d0d0aeb861a4470c"; + libraryHaskellDepends = [ base explicit-exception utility-ht ]; + doHaddock = false; + doCheck = false; + homepage = "http://hub.darcs.net/thielema/checksum"; + description = "Compute and verify checksums of ISBN, IBAN, etc"; + license = stdenv.lib.licenses.bsd3; + }) {}; + "choice" = callPackage + ({ mkDerivation, base, stdenv }: + mkDerivation { + pname = "choice"; + version = "0.2.2"; + sha256 = "d367e4321329df5913216f9746528e4526e14b5ad1f33edc82de8288ad719e61"; + libraryHaskellDepends = [ base ]; + doHaddock = false; + doCheck = false; + homepage = "https://github.com/mboes/choice#readme"; + description = "A solution to boolean blindness"; + license = stdenv.lib.licenses.publicDomain; + }) {}; + "chronologique" = callPackage + ({ mkDerivation, aeson, base, hourglass, stdenv, text, time, vector + }: + mkDerivation { + pname = "chronologique"; + version = "0.3.1.1"; + sha256 = "c538bc2e7b1cb9c1f4ae4177a5545c08d3ff66c29c80ef8faddd92daaa499e16"; + libraryHaskellDepends = [ aeson base hourglass text time vector ]; + doHaddock = false; + doCheck = false; + homepage = "https://github.com/afcowie/chronologique/"; + description = "Time to manipulate time"; + license = stdenv.lib.licenses.bsd3; + }) {}; + "chunked-data" = callPackage + ({ mkDerivation, base, bytestring, containers, semigroups, stdenv + , text, transformers, vector + }: + mkDerivation { + pname = "chunked-data"; + version = "0.3.1"; + sha256 = "f710c581aee1f899e807fc9e6cba721b27d53dc9d56986f1922bc7ccddf1a79a"; + libraryHaskellDepends = [ + base bytestring containers semigroups text transformers vector + ]; + doHaddock = false; + doCheck = false; + homepage = "https://github.com/snoyberg/mono-traversable#readme"; + description = "Typeclasses for dealing with various chunked data representations"; + license = stdenv.lib.licenses.mit; + }) {}; + "cipher-aes" = callPackage + ({ mkDerivation, base, byteable, bytestring, crypto-cipher-types + , securemem, stdenv + }: + mkDerivation { + pname = "cipher-aes"; + version = "0.2.11"; + sha256 = "d3b171895698c73da24d7ce97543f725d26637f038de670c0fd4012ca7f95015"; + libraryHaskellDepends = [ + base byteable bytestring crypto-cipher-types securemem + ]; + doHaddock = false; + doCheck = false; + homepage = "https://github.com/vincenthz/hs-cipher-aes"; + description = "Fast AES cipher implementation with advanced mode of operations"; + license = stdenv.lib.licenses.bsd3; + }) {}; + "cipher-aes128" = callPackage + ({ mkDerivation, base, bytestring, Cabal, cereal, crypto-api + , process, stdenv, tagged + }: + mkDerivation { + pname = "cipher-aes128"; + version = "0.7.0.3"; + sha256 = "6f27bea8bcd1987072fc75b6b423ae9c691574324b6a328ec1e2866f84412e3a"; + revision = "1"; + editedCabalFile = "1c3lr80vcdrajlvks9ny9s8m2n2kc9jw14nh65668dfikp0pqc61"; + isLibrary = true; + isExecutable = true; + setupHaskellDepends = [ base Cabal process ]; + libraryHaskellDepends = [ + base bytestring cereal crypto-api tagged + ]; + doHaddock = false; + doCheck = false; + homepage = "https://github.com/TomMD/cipher-aes128"; + description = "AES and common modes using AES-NI when available"; + license = stdenv.lib.licenses.bsd3; + }) {}; + "cipher-blowfish" = callPackage + ({ mkDerivation, base, byteable, bytestring, crypto-cipher-types + , securemem, stdenv, vector + }: + mkDerivation { + pname = "cipher-blowfish"; + version = "0.0.3"; + sha256 = "8f41170a851dba6d0b6f07298af3213baca09ab2a8aaf2adb733631feb3b6641"; + libraryHaskellDepends = [ + base byteable bytestring crypto-cipher-types securemem vector + ]; + doHaddock = false; + doCheck = false; + homepage = "http://github.com/vincenthz/hs-crypto-cipher"; + description = "Blowfish cipher"; + license = stdenv.lib.licenses.bsd3; + }) {}; + "cipher-camellia" = callPackage + ({ mkDerivation, base, byteable, bytestring, crypto-cipher-types + , securemem, stdenv, vector + }: + mkDerivation { + pname = "cipher-camellia"; + version = "0.0.2"; + sha256 = "8d0cd137cdb890646bb5d3bb52b20fa6d74e1b0c35d7d524d60edd9d43ace2a7"; + libraryHaskellDepends = [ + base byteable bytestring crypto-cipher-types securemem vector + ]; + doHaddock = false; + doCheck = false; + homepage = "http://github.com/vincenthz/hs-crypto-cipher"; + description = "Camellia block cipher primitives"; + license = stdenv.lib.licenses.bsd3; + }) {}; + "cipher-des" = callPackage + ({ mkDerivation, base, byteable, bytestring, crypto-cipher-types + , securemem, stdenv + }: + mkDerivation { + pname = "cipher-des"; + version = "0.0.6"; + sha256 = "85f1bccdec625a120ecf83b861afcb6478f8f899ceaa06fc083e642b54ff4ac7"; + libraryHaskellDepends = [ + base byteable bytestring crypto-cipher-types securemem + ]; + doHaddock = false; + doCheck = false; + homepage = "http://github.com/vincenthz/hs-crypto-cipher"; + description = "DES and 3DES primitives"; + license = stdenv.lib.licenses.bsd3; + }) {}; + "cipher-rc4" = callPackage + ({ mkDerivation, base, byteable, bytestring, crypto-cipher-types + , stdenv + }: + mkDerivation { + pname = "cipher-rc4"; + version = "0.1.4"; + sha256 = "c67e731bc9e7f3882e33609c3d9ec97b4e9bbd2f95cd882926acfb621970384d"; + libraryHaskellDepends = [ + base byteable bytestring crypto-cipher-types + ]; + doHaddock = false; + doCheck = false; + homepage = "http://github.com/vincenthz/hs-cipher-rc4"; + description = "Fast RC4 cipher implementation"; + license = stdenv.lib.licenses.bsd3; + }) {}; + "circle-packing" = callPackage + ({ mkDerivation, base, stdenv }: + mkDerivation { + pname = "circle-packing"; + version = "0.1.0.6"; + sha256 = "64ee44a90da3e5fe20d5b78bfe6eba93102a6b52c65f8a7b99af7799798ee81b"; + revision = "2"; + editedCabalFile = "1ag213lv6yfzxdc4ghbywy165qblnqx5b3j9d23kc6fcyf19nfyk"; + libraryHaskellDepends = [ base ]; + doHaddock = false; + doCheck = false; + description = "Simple heuristic for packing discs of varying radii in a circle"; + license = stdenv.lib.licenses.bsd3; + }) {}; + "cisco-spark-api" = callPackage + ({ mkDerivation, aeson, attoparsec, base, bitset-word8, bytestring + , conduit, data-default, http-conduit, network-uri + , optparse-applicative, stdenv, text, utf8-string + }: + mkDerivation { + pname = "cisco-spark-api"; + version = "0.1.0.3"; + sha256 = "7e962a9f34e5b0c66fe858f4c6a322d22586bc7a8ac602a317697d2d9b6228ba"; + isLibrary = true; + isExecutable = true; + libraryHaskellDepends = [ + aeson attoparsec base bitset-word8 bytestring conduit data-default + http-conduit network-uri text + ]; + executableHaskellDepends = [ + aeson base bytestring conduit data-default http-conduit + optparse-applicative text utf8-string + ]; + doHaddock = false; + doCheck = false; + homepage = "https://github.com/nshimaza/webex-teams-api#readme"; + description = "A Haskell bindings for Webex Teams API"; + license = stdenv.lib.licenses.mit; + }) {}; + "clang-compilation-database" = callPackage + ({ mkDerivation, aeson, base, bytestring, stdenv, text }: + mkDerivation { + pname = "clang-compilation-database"; + version = "0.1.0.1"; + sha256 = "114601a1769471e4fc2e8d100c5546e95fa803b9e56dcd342dab9829d0dc1ca8"; + libraryHaskellDepends = [ aeson base bytestring text ]; + doHaddock = false; + doCheck = false; + homepage = "https://github.com/lambdageek/clang-compilation-database"; + description = "JSON Compilation Database Format encoding and decoding"; + license = stdenv.lib.licenses.mit; + }) {}; + "clash-ghc" = callPackage + ({ mkDerivation, array, base, bifunctors, bytestring, clash-lib + , clash-prelude, concurrent-supply, containers, deepseq, directory + , filepath, ghc, ghc-boot, ghc-prim, ghc-typelits-extra + , ghc-typelits-knownnat, ghc-typelits-natnormalise, ghci, hashable + , haskeline, integer-gmp, lens, mtl, process, reflection, stdenv + , text, time, transformers, unbound-generics, uniplate, unix + , unordered-containers + }: + mkDerivation { + pname = "clash-ghc"; + version = "0.99.2"; + sha256 = "44ec74bca8294f182521dfefaf11aab8f29dd3ff81e4d93b44ec844d78cfa7b8"; + isLibrary = true; + isExecutable = true; + libraryHaskellDepends = [ + array base bifunctors bytestring clash-lib clash-prelude + concurrent-supply containers deepseq directory filepath ghc + ghc-boot ghc-prim ghc-typelits-extra ghc-typelits-knownnat + ghc-typelits-natnormalise ghci hashable haskeline integer-gmp lens + mtl process reflection text time transformers unbound-generics + uniplate unix unordered-containers + ]; + executableHaskellDepends = [ base ]; + doHaddock = false; + doCheck = false; + homepage = "http://www.clash-lang.org/"; + description = "CAES Language for Synchronous Hardware"; + license = stdenv.lib.licenses.bsd2; + }) {}; + "clash-lib" = callPackage + ({ mkDerivation, aeson, ansi-wl-pprint, attoparsec, base + , bytestring, clash-prelude, concurrent-supply, containers + , data-binary-ieee754, deepseq, directory, errors, fgl, filepath + , ghc, hashable, integer-gmp, lens, mtl, parsers, prettyprinter + , process, reducers, stdenv, template-haskell, text, time + , transformers, trifecta, unbound-generics, unordered-containers + }: + mkDerivation { + pname = "clash-lib"; + version = "0.99.2"; + sha256 = "6e5f3df6fa6c266643f337e1b2242e122ab068082549c9cdf60d3703e0ecf36a"; + enableSeparateDataOutput = true; + libraryHaskellDepends = [ + aeson ansi-wl-pprint attoparsec base bytestring clash-prelude + concurrent-supply containers data-binary-ieee754 deepseq directory + errors fgl filepath ghc hashable integer-gmp lens mtl parsers + prettyprinter process reducers template-haskell text time + transformers trifecta unbound-generics unordered-containers + ]; + doHaddock = false; + doCheck = false; + homepage = "http://www.clash-lang.org/"; + description = "CAES Language for Synchronous Hardware - As a Library"; + license = stdenv.lib.licenses.bsd2; + }) {}; + "clash-prelude" = callPackage + ({ mkDerivation, array, base, bifunctors, constraints + , data-binary-ieee754, data-default, deepseq, ghc-prim + , ghc-typelits-extra, ghc-typelits-knownnat + , ghc-typelits-natnormalise, half, integer-gmp, lens, QuickCheck + , reflection, singletons, stdenv, template-haskell, transformers + , vector + }: + mkDerivation { + pname = "clash-prelude"; + version = "0.99.2"; + sha256 = "f1ac0ba1a41c0f5e1249709e9c100a24dc56d124f5fa2e7c52027bf1e67044bf"; + libraryHaskellDepends = [ + array base bifunctors constraints data-binary-ieee754 data-default + deepseq ghc-prim ghc-typelits-extra ghc-typelits-knownnat + ghc-typelits-natnormalise half integer-gmp lens QuickCheck + reflection singletons template-haskell transformers vector + ]; + doHaddock = false; + doCheck = false; + homepage = "http://www.clash-lang.org/"; + description = "CAES Language for Synchronous Hardware - Prelude library"; + license = stdenv.lib.licenses.bsd2; + }) {}; + "classy-prelude" = callPackage + ({ mkDerivation, async, base, basic-prelude, bifunctors, bytestring + , chunked-data, containers, deepseq, dlist, ghc-prim, hashable + , mono-traversable, mono-traversable-instances, mtl + , mutable-containers, primitive, say, semigroups, stdenv, stm + , stm-chans, text, time, transformers, unliftio + , unordered-containers, vector, vector-instances + }: + mkDerivation { + pname = "classy-prelude"; + version = "1.4.0"; + sha256 = "2b3b255676ab0fdeb39aebafa3543535ddd684d00c645b643e50cb9e2d25f9e0"; + revision = "1"; + editedCabalFile = "1gf615lz0bfsn09vrjgj63d8zcpsmz1cgvdv8px3h0b4jrwdij6v"; + libraryHaskellDepends = [ + async base basic-prelude bifunctors bytestring chunked-data + containers deepseq dlist ghc-prim hashable mono-traversable + mono-traversable-instances mtl mutable-containers primitive say + semigroups stm stm-chans text time transformers unliftio + unordered-containers vector vector-instances + ]; + doHaddock = false; + doCheck = false; + homepage = "https://github.com/snoyberg/mono-traversable#readme"; + description = "A typeclass-based Prelude"; + license = stdenv.lib.licenses.mit; + }) {}; + "classy-prelude-conduit" = callPackage + ({ mkDerivation, base, bytestring, classy-prelude, conduit + , monad-control, resourcet, stdenv, transformers, void + }: + mkDerivation { + pname = "classy-prelude-conduit"; + version = "1.4.0"; + sha256 = "39ef2567a3542ebf91f6ebc103cc4afb64c2a4ec051c7ce578b577ef9931c424"; + libraryHaskellDepends = [ + base bytestring classy-prelude conduit monad-control resourcet + transformers void + ]; + doHaddock = false; + doCheck = false; + homepage = "https://github.com/snoyberg/mono-traversable#readme"; + description = "classy-prelude together with conduit functions"; + license = stdenv.lib.licenses.mit; + }) {}; + "classy-prelude-yesod" = callPackage + ({ mkDerivation, aeson, base, classy-prelude + , classy-prelude-conduit, data-default, http-conduit, http-types + , persistent, stdenv, yesod, yesod-newsfeed, yesod-static + }: + mkDerivation { + pname = "classy-prelude-yesod"; + version = "1.4.0"; + sha256 = "0cd2a88f42c3541ba4bce6801c8b8d9c331e1c49a6288bf16f764676a34b9e28"; + libraryHaskellDepends = [ + aeson base classy-prelude classy-prelude-conduit data-default + http-conduit http-types persistent yesod yesod-newsfeed + yesod-static + ]; + doHaddock = false; + doCheck = false; + homepage = "https://github.com/snoyberg/mono-traversable#readme"; + description = "Provide a classy prelude including common Yesod functionality"; + license = stdenv.lib.licenses.mit; + }) {}; + "classyplate" = callPackage + ({ mkDerivation, base, stdenv, template-haskell }: + mkDerivation { + pname = "classyplate"; + version = "0.3.1.0"; + sha256 = "9548f228998d7aa00372385e94d51d2802f1a5400b3b85dcb31fda4d75f7d12b"; + libraryHaskellDepends = [ base template-haskell ]; + doHaddock = false; + doCheck = false; + description = "Fuseable type-class based generics"; + license = stdenv.lib.licenses.bsd3; + }) {}; + "clay" = callPackage + ({ mkDerivation, base, mtl, stdenv, text }: + mkDerivation { + pname = "clay"; + version = "0.13.1"; + sha256 = "844e9101cc1835eb12bac50e289d00f19c24eeee12bcdebae1b633edffa328a3"; + libraryHaskellDepends = [ base mtl text ]; + doHaddock = false; + doCheck = false; + homepage = "http://fvisser.nl/clay"; + description = "CSS preprocessor as embedded Haskell"; + license = stdenv.lib.licenses.bsd3; + }) {}; + "clientsession" = callPackage + ({ mkDerivation, base, base64-bytestring, bytestring, cereal + , cipher-aes, cprng-aes, crypto-api, crypto-random, directory + , entropy, setenv, skein, stdenv, tagged + }: + mkDerivation { + pname = "clientsession"; + version = "0.9.1.2"; + sha256 = "5915adc4de26d2a8b03f1a445bac0b0f5d10a5b0380a4eed71b79a20a727d068"; + isLibrary = true; + isExecutable = true; + libraryHaskellDepends = [ + base base64-bytestring bytestring cereal cipher-aes cprng-aes + crypto-api crypto-random directory entropy setenv skein tagged + ]; + executableHaskellDepends = [ base ]; + doHaddock = false; + doCheck = false; + homepage = "http://github.com/yesodweb/clientsession/tree/master"; + description = "Securely store session data in a client-side cookie"; + license = stdenv.lib.licenses.mit; + }) {}; + "clock" = callPackage + ({ mkDerivation, base, stdenv }: + mkDerivation { + pname = "clock"; + version = "0.7.2"; + sha256 = "886601978898d3a91412fef895e864576a7125d661e1f8abc49a2a08840e691f"; + libraryHaskellDepends = [ base ]; + doHaddock = false; + doCheck = false; + homepage = "https://github.com/corsis/clock"; + description = "High-resolution clock functions: monotonic, realtime, cputime"; + license = stdenv.lib.licenses.bsd3; + }) {}; + "clock-extras" = callPackage + ({ mkDerivation, base, clock, stdenv }: + mkDerivation { + pname = "clock-extras"; + version = "0.1.0.2"; + sha256 = "a9ed097aa9d48b53c6a555bc5f67e347249b08e2252dd4fc998fb4ab42edda59"; + libraryHaskellDepends = [ base clock ]; + doHaddock = false; + doCheck = false; + description = "A couple functions that probably should be in the 'clock' package"; + license = stdenv.lib.licenses.bsd3; + }) {}; + "closed" = callPackage + ({ mkDerivation, aeson, base, cassava, deepseq, hashable + , persistent, QuickCheck, stdenv, text + }: + mkDerivation { + pname = "closed"; + version = "0.2.0"; + sha256 = "7a301c6c543ae60354b737c56c2259dfc9e01ddf9eee452e4469c6262c53c21c"; + libraryHaskellDepends = [ + aeson base cassava deepseq hashable persistent QuickCheck text + ]; + doHaddock = false; + doCheck = false; + homepage = "https://github.com/frontrowed/closed#readme"; + description = "Integers bounded by a closed interval"; + license = stdenv.lib.licenses.mit; + }) {}; + "clr-host" = callPackage + ({ mkDerivation, base, bytestring, Cabal, clr-marshal, directory + , file-embed, filepath, glib, mono, stdenv, text, transformers + }: + mkDerivation { + pname = "clr-host"; + version = "0.2.0.1"; + sha256 = "5306ea1368b922d595159f237877f5b76fb9744e082f8c286c4546dc1a6f0e96"; + setupHaskellDepends = [ + base Cabal directory filepath transformers + ]; + libraryHaskellDepends = [ + base bytestring clr-marshal file-embed text + ]; + librarySystemDepends = [ glib mono ]; + doHaddock = false; + doCheck = false; + homepage = "https://gitlab.com/tim-m89/clr-haskell/tree/master/libs/clr-host"; + description = "Hosting the Common Language Runtime"; + license = stdenv.lib.licenses.bsd3; + }) {inherit (pkgs) glib; inherit (pkgs) mono;}; + "clr-marshal" = callPackage + ({ mkDerivation, base, stdenv, text }: + mkDerivation { + pname = "clr-marshal"; + version = "0.2.0.0"; + sha256 = "4113651f3d10de21813b2a44b78ca19f9ab62b6c6d9df0c25a88940fabebdcd6"; + libraryHaskellDepends = [ base text ]; + doHaddock = false; + doCheck = false; + homepage = "https://gitlab.com/tim-m89/clr-haskell/tree/master/libs/clr-marshal"; + description = "Marshaling for the clr"; + license = stdenv.lib.licenses.bsd3; + }) {}; + "clumpiness" = callPackage + ({ mkDerivation, base, containers, stdenv, tree-fun }: + mkDerivation { + pname = "clumpiness"; + version = "0.17.0.0"; + sha256 = "fd4b303d206eaf242c779bb65c42256e42220c8497a6bcf3bc59589b9396c495"; + libraryHaskellDepends = [ base containers tree-fun ]; + doHaddock = false; + doCheck = false; + description = "Calculate the clumpiness of leaf properties in a tree"; + license = stdenv.lib.licenses.gpl3; + }) {}; + "cmark-gfm" = callPackage + ({ mkDerivation, base, bytestring, stdenv, text }: + mkDerivation { + pname = "cmark-gfm"; + version = "0.1.4"; + sha256 = "15f02f37dd59e8d5cfb1ed7b17d412c6034a0172a192d1f5546832e5eea14c4a"; + libraryHaskellDepends = [ base bytestring text ]; + doHaddock = false; + doCheck = false; + homepage = "https://github.com/kivikakk/cmark-gfm-hs"; + description = "Fast, accurate GitHub Flavored Markdown parser and renderer"; + license = stdenv.lib.licenses.bsd3; + }) {}; + "cmdargs" = callPackage + ({ mkDerivation, base, filepath, process, stdenv, template-haskell + , transformers + }: + mkDerivation { + pname = "cmdargs"; + version = "0.10.20"; + sha256 = "0e269dc48c3d4c0447c96ffd772a6fe69dfa1260c323f4cd7bf171cbf2ab7331"; + isLibrary = true; + isExecutable = true; + libraryHaskellDepends = [ + base filepath process template-haskell transformers + ]; + doHaddock = false; + doCheck = false; + homepage = "https://github.com/ndmitchell/cmdargs#readme"; + description = "Command line argument processing"; + license = stdenv.lib.licenses.bsd3; + }) {}; + "code-builder" = callPackage + ({ mkDerivation, base, containers, stdenv }: + mkDerivation { + pname = "code-builder"; + version = "0.1.3"; + sha256 = "559e47a44cec85a8e95df92e5d2693cacc9761503c30be3b83eaebd95360a4ab"; + libraryHaskellDepends = [ base containers ]; + doHaddock = false; + doCheck = false; + description = "Simple system for generating code"; + license = stdenv.lib.licenses.bsd3; + }) {}; + "code-page" = callPackage + ({ mkDerivation, base, stdenv }: + mkDerivation { + pname = "code-page"; + version = "0.1.3"; + sha256 = "e65c86600e06d85f2e2c2a9df4b3d68e2dbd3adb2df9e922a4cd744966762191"; + libraryHaskellDepends = [ base ]; + doHaddock = false; + doCheck = false; + homepage = "https://github.com/RyanGlScott/code-page"; + description = "Windows code page library for Haskell"; + license = stdenv.lib.licenses.bsd3; + }) {}; + "codec" = callPackage + ({ mkDerivation, aeson, base, binary, binary-bits, bytestring, mtl + , profunctors, stdenv, template-haskell, text, transformers + , unordered-containers, vector + }: + mkDerivation { + pname = "codec"; + version = "0.2.1"; + sha256 = "ffc261b58108c3d90c0b0b68461857d1148208d1a9645916e63241aaa3c25b28"; + libraryHaskellDepends = [ + aeson base binary binary-bits bytestring mtl profunctors + template-haskell text transformers unordered-containers vector + ]; + doHaddock = false; + doCheck = false; + homepage = "https://github.com/chpatrick/codec"; + description = "Simple bidirectional serialization"; + license = stdenv.lib.licenses.bsd3; + }) {}; + "codec-beam" = callPackage + ({ mkDerivation, base, bytestring, containers, stdenv, text, zlib + }: + mkDerivation { + pname = "codec-beam"; + version = "0.2.0"; + sha256 = "61eb624e5f347ec9249f976bc8b62ae597777604d82ab0e62acb9901374ae365"; + libraryHaskellDepends = [ base bytestring containers text zlib ]; + doHaddock = false; + doCheck = false; + homepage = "https://github.com/hkgumbs/codec-beam#readme"; + description = "Erlang VM byte code assembler"; + license = stdenv.lib.licenses.bsd3; + }) {}; + "codec-rpm" = callPackage + ({ mkDerivation, attoparsec, attoparsec-binary, base, bytestring + , conduit, conduit-extra, cpio-conduit, exceptions, lzma-conduit + , mtl, parsec, pretty, resourcet, stdenv, text + }: + mkDerivation { + pname = "codec-rpm"; + version = "0.2.2"; + sha256 = "a34b88378dc79b08b56c39515763b6d940166595c24dc45e61cc8d2bb4ed4b97"; + libraryHaskellDepends = [ + attoparsec attoparsec-binary base bytestring conduit conduit-extra + cpio-conduit exceptions lzma-conduit mtl parsec pretty resourcet + text + ]; + doHaddock = false; + doCheck = false; + homepage = "https://github.com/weldr/codec-rpm"; + description = "A library for manipulating RPM files"; + license = stdenv.lib.licenses.lgpl21; + }) {}; + "codo-notation" = callPackage + ({ mkDerivation, base, comonad, haskell-src-meta, parsec, stdenv + , template-haskell, uniplate + }: + mkDerivation { + pname = "codo-notation"; + version = "0.5.2"; + sha256 = "78eb57004541ed29eb4c54196b91ac2dd1028a3315f51cd4dc00debfc0938eaf"; + libraryHaskellDepends = [ + base comonad haskell-src-meta parsec template-haskell uniplate + ]; + doHaddock = false; + doCheck = false; + description = "A notation for comonads, analogous to the do-notation for monads"; + license = stdenv.lib.licenses.bsd3; + }) {}; + "coercible-utils" = callPackage + ({ mkDerivation, base, stdenv }: + mkDerivation { + pname = "coercible-utils"; + version = "0.0.0"; + sha256 = "2a624986cdc010c7fc3e90f8c94f722995af9fe6e88b9d52a94ebaa319b08c98"; + libraryHaskellDepends = [ base ]; + doHaddock = false; + doCheck = false; + homepage = "https://github.com/sjakobi/coercible-utils"; + description = "Utility functions for Coercible types"; + license = stdenv.lib.licenses.bsd3; + }) {}; + "colonnade" = callPackage + ({ mkDerivation, base, bytestring, contravariant, profunctors + , stdenv, text, vector + }: + mkDerivation { + pname = "colonnade"; + version = "1.2.0.1"; + sha256 = "32ebd86360c9a363d62a2490b7120de5651a6674a79c4f9d85e13d2cc8cb3e8b"; + libraryHaskellDepends = [ + base bytestring contravariant profunctors text vector + ]; + doHaddock = false; + doCheck = false; + homepage = "https://github.com/andrewthad/colonnade#readme"; + description = "Generic types and functions for columnar encoding and decoding"; + license = stdenv.lib.licenses.bsd3; + }) {}; + "colorful-monoids" = callPackage + ({ mkDerivation, base, stdenv }: + mkDerivation { + pname = "colorful-monoids"; + version = "0.2.1.1"; + sha256 = "0bf5f8d9632dec436a6744d584003d09b15169e600e9e5c2636e2c3f4d4f2e58"; + libraryHaskellDepends = [ base ]; + doHaddock = false; + doCheck = false; + homepage = "https://github.com/minad/colorful-monoids#readme"; + description = "Styled console text output using ANSI escape sequences"; + license = stdenv.lib.licenses.mit; + }) {}; + "colorize-haskell" = callPackage + ({ mkDerivation, ansi-terminal, base, haskell-lexer, stdenv }: + mkDerivation { + pname = "colorize-haskell"; + version = "1.0.1"; + sha256 = "03764374bd1aed5c63e20517441ccaae7c95cb2fa9e416da952f26be8dba9aec"; + isLibrary = true; + isExecutable = true; + libraryHaskellDepends = [ ansi-terminal base haskell-lexer ]; + executableHaskellDepends = [ ansi-terminal base haskell-lexer ]; + doHaddock = false; + doCheck = false; + homepage = "http://github.com/yav/colorize-haskell"; + description = "Highligt Haskell source"; + license = stdenv.lib.licenses.bsd3; + }) {}; + "colour" = callPackage + ({ mkDerivation, base, stdenv }: + mkDerivation { + pname = "colour"; + version = "2.3.4"; + sha256 = "0f439f00b322ce3d551f28a4dd1520aa2c91d699de4cdc6d485b9b04be0dc5eb"; + enableSeparateDataOutput = true; + libraryHaskellDepends = [ base ]; + doHaddock = false; + doCheck = false; + homepage = "http://www.haskell.org/haskellwiki/Colour"; + description = "A model for human colour/color perception"; + license = stdenv.lib.licenses.mit; + }) {}; + "combinatorial" = callPackage + ({ mkDerivation, array, base, containers, stdenv, transformers + , utility-ht + }: + mkDerivation { + pname = "combinatorial"; + version = "0.1"; + sha256 = "096e6dacd9f99c7ce63e95b991df33b74645f71f7df2dd90627843d96324b4a8"; + revision = "1"; + editedCabalFile = "1bqcg04w48dqk4n1n36j9ykajrmwqdd4qpcjjjfhzvm83z5ypsh7"; + libraryHaskellDepends = [ + array base containers transformers utility-ht + ]; + doHaddock = false; + doCheck = false; + homepage = "http://hub.darcs.net/thielema/combinatorial/"; + description = "Count, enumerate, rank and unrank combinatorial objects"; + license = stdenv.lib.licenses.bsd3; + }) {}; + "comfort-graph" = callPackage + ({ mkDerivation, base, containers, QuickCheck, semigroups, stdenv + , transformers, utility-ht + }: + mkDerivation { + pname = "comfort-graph"; + version = "0.0.3"; + sha256 = "b9d67c0f19e34c27fe759c149939c37d655a170482760389de07cca9cb534387"; + libraryHaskellDepends = [ + base containers QuickCheck semigroups transformers utility-ht + ]; + doHaddock = false; + doCheck = false; + homepage = "http://hub.darcs.net/thielema/comfort-graph"; + description = "Graph structure with type parameters for nodes and edges"; + license = stdenv.lib.licenses.bsd3; + }) {}; + "commutative" = callPackage + ({ mkDerivation, base, random, semigroups, stdenv }: + mkDerivation { + pname = "commutative"; + version = "0.0.1.4"; + sha256 = "0de746012c73543b5dcf649434046e36d5e158e0967e8e2ae122e85d5457c9cf"; + libraryHaskellDepends = [ base random semigroups ]; + doHaddock = false; + doCheck = false; + description = "Commutative binary operations"; + license = stdenv.lib.licenses.mit; + }) {}; + "comonad" = callPackage + ({ mkDerivation, base, Cabal, cabal-doctest, containers + , contravariant, distributive, semigroups, stdenv, tagged + , transformers, transformers-compat + }: + mkDerivation { + pname = "comonad"; + version = "5.0.4"; + sha256 = "78a89d7f9f0975b40b3294adcb70885649572b687ac5f5dc98e452471838e825"; + setupHaskellDepends = [ base Cabal cabal-doctest ]; + libraryHaskellDepends = [ + base containers contravariant distributive semigroups tagged + transformers transformers-compat + ]; + doHaddock = false; + doCheck = false; + homepage = "http://github.com/ekmett/comonad/"; + description = "Comonads"; + license = stdenv.lib.licenses.bsd3; + }) {}; + "compactmap" = callPackage + ({ mkDerivation, base, stdenv, vector }: + mkDerivation { + pname = "compactmap"; + version = "0.1.4.2.1"; + sha256 = "22166e0a2a78bf2b7cff49448ed9fcb145dece4f034de9afc8ce5b692fd0f774"; + libraryHaskellDepends = [ base vector ]; + doHaddock = false; + doCheck = false; + description = "A read-only memory-efficient key-value store"; + license = stdenv.lib.licenses.bsd3; + }) {}; + "compensated" = callPackage + ({ mkDerivation, base, bifunctors, binary, bytes, Cabal + , cabal-doctest, cereal, comonad, deepseq, distributive, hashable + , lens, log-domain, safecopy, semigroupoids, semigroups, stdenv + , vector + }: + mkDerivation { + pname = "compensated"; + version = "0.7.2"; + sha256 = "c7f9bf47a586720deda33b82ddc633d3507c8bc199eb5555c80931f6c323cae2"; + setupHaskellDepends = [ base Cabal cabal-doctest ]; + libraryHaskellDepends = [ + base bifunctors binary bytes cereal comonad deepseq distributive + hashable lens log-domain safecopy semigroupoids semigroups vector + ]; + doHaddock = false; + doCheck = false; + homepage = "http://github.com/analytics/compensated/"; + description = "Compensated floating-point arithmetic"; + license = stdenv.lib.licenses.bsd3; + }) {}; + "compiler-warnings" = callPackage + ({ mkDerivation, base, binary, parsec, stdenv, text }: + mkDerivation { + pname = "compiler-warnings"; + version = "0.1.0"; + sha256 = "8cf4c57e1b4d61b1163969faa6e9f2cb8f22073fa75bf982d9b8a328225f5ce3"; + libraryHaskellDepends = [ base binary parsec text ]; + doHaddock = false; + doCheck = false; + homepage = "https://github.com/yi-editor/compiler-warnings#readme"; + description = "Parser for common compiler warning formats"; + license = stdenv.lib.licenses.bsd2; + }) {}; + "componentm" = callPackage + ({ mkDerivation, base, containers, deepseq, exceptions, pretty-show + , prettyprinter, rio, stdenv, teardown + }: + mkDerivation { + pname = "componentm"; + version = "0.0.0.2"; + sha256 = "efe23d927d3ad2aee5052ef379f7a472f60e1b0749195e9b46bbf0d8c756b6a7"; + libraryHaskellDepends = [ + base containers deepseq exceptions pretty-show prettyprinter rio + teardown + ]; + doHaddock = false; + doCheck = false; + homepage = "https://github.com/roman/Haskell-componentm#readme"; + description = "Monad for allocation and cleanup of application resources"; + license = stdenv.lib.licenses.mit; + }) {}; + "componentm-devel" = callPackage + ({ mkDerivation, base, componentm, foreign-store, rio, stdenv + , teardown + }: + mkDerivation { + pname = "componentm-devel"; + version = "0.0.0.2"; + sha256 = "2dd7303c9b26d748baf1a0893b19072ef2a2817c8c77639e3c844e559cd85b0a"; + libraryHaskellDepends = [ + base componentm foreign-store rio teardown + ]; + doHaddock = false; + doCheck = false; + homepage = "https://github.com/roman/Haskell-componentm#readme"; + description = "Easy REPL driven development using ComponentM"; + license = stdenv.lib.licenses.mit; + }) {}; + "composable-associations" = callPackage + ({ mkDerivation, base, stdenv }: + mkDerivation { + pname = "composable-associations"; + version = "0.1.0.0"; + sha256 = "9d1a10bc7ee1b514221bd8d0fc71f43f8d2338b1faebe6722f1d4db3bc29800e"; + libraryHaskellDepends = [ base ]; + doHaddock = false; + doCheck = false; + homepage = "https://github.com/SamProtas/composable-associations#readme"; + description = "Types and helpers for composing types into a single larger key-value type"; + license = stdenv.lib.licenses.bsd3; + }) {}; + "composable-associations-aeson" = callPackage + ({ mkDerivation, aeson, base, composable-associations, stdenv, text + , unordered-containers + }: + mkDerivation { + pname = "composable-associations-aeson"; + version = "0.1.0.0"; + sha256 = "dbd754ed6d624469f16c4cd2ad51c441eeb8c62d6af66673f76034c7517c2a4f"; + libraryHaskellDepends = [ + aeson base composable-associations text unordered-containers + ]; + doHaddock = false; + doCheck = false; + homepage = "https://github.com/SamProtas/composable-associations#readme"; + description = "Aeson ToJSON/FromJSON implementation for the types of composable-associations"; + license = stdenv.lib.licenses.bsd3; + }) {}; + "composition" = callPackage + ({ mkDerivation, stdenv }: + mkDerivation { + pname = "composition"; + version = "1.0.2.1"; + sha256 = "7123300f5eca5a7cec4eb731dc0e9c2c44aabe26b37e6579582a7267d9f7ad6a"; + doHaddock = false; + doCheck = false; + description = "Combinators for unorthodox function composition"; + license = stdenv.lib.licenses.bsd3; + }) {}; + "composition-extra" = callPackage + ({ mkDerivation, base, composition, contravariant, stdenv }: + mkDerivation { + pname = "composition-extra"; + version = "2.0.0"; + sha256 = "c998244a8fd160af3dd7ee93c417f665af51a46a04ce6b7d4623f46596ba7129"; + libraryHaskellDepends = [ base composition contravariant ]; + doHaddock = false; + doCheck = false; + description = "Combinators for unorthodox structure composition"; + license = stdenv.lib.licenses.bsd3; + }) {}; + "composition-prelude" = callPackage + ({ mkDerivation, base, stdenv }: + mkDerivation { + pname = "composition-prelude"; + version = "1.5.0.8"; + sha256 = "ec6adf0c05bd7e2c47fdf2a509047c10d9deeb4e39770351a2d1da5b5695f7dd"; + libraryHaskellDepends = [ base ]; + doHaddock = false; + doCheck = false; + description = "Higher-order function combinators"; + license = stdenv.lib.licenses.bsd3; + }) {}; + "compressed" = callPackage + ({ mkDerivation, base, comonad, containers, fingertree, hashable + , keys, pointed, reducers, semigroupoids, semigroups, stdenv + , unordered-containers + }: + mkDerivation { + pname = "compressed"; + version = "3.11"; + sha256 = "d77bbf2f445d32f138dfde9e860e68db5de8ae04c52ffda23941ddf7bdabdd3d"; + libraryHaskellDepends = [ + base comonad containers fingertree hashable keys pointed reducers + semigroupoids semigroups unordered-containers + ]; + doHaddock = false; + doCheck = false; + homepage = "http://github.com/ekmett/compressed/"; + description = "Compressed containers and reducers"; + license = stdenv.lib.licenses.bsd3; + }) {}; + "concise" = callPackage + ({ mkDerivation, base, bytestring, lens, stdenv, text }: + mkDerivation { + pname = "concise"; + version = "0.1.0.1"; + sha256 = "5c27df5a3e1fe820548e90abc4a0e326b6d0fb286218619aa22d3af90c7b9925"; + libraryHaskellDepends = [ base bytestring lens text ]; + doHaddock = false; + doCheck = false; + homepage = "https://github.com/frasertweedale/hs-concise"; + description = "Utilities for Control.Lens.Cons"; + license = stdenv.lib.licenses.bsd3; + }) {}; + "concurrency" = callPackage + ({ mkDerivation, array, atomic-primops, base, exceptions + , monad-control, mtl, stdenv, stm, transformers + }: + mkDerivation { + pname = "concurrency"; + version = "1.6.0.0"; + sha256 = "93f2567005f470689b190f526cc39d625fb402b7396240b61dd7be5aeee2eb93"; + libraryHaskellDepends = [ + array atomic-primops base exceptions monad-control mtl stm + transformers + ]; + doHaddock = false; + doCheck = false; + homepage = "https://github.com/barrucadu/dejafu"; + description = "Typeclasses, functions, and data types for concurrency and STM"; + license = stdenv.lib.licenses.mit; + }) {}; + "concurrent-extra" = callPackage + ({ mkDerivation, base, stdenv, stm, unbounded-delays }: + mkDerivation { + pname = "concurrent-extra"; + version = "0.7.0.12"; + sha256 = "040e6db9e0147de9929661759930f1566a7250add4c7f65b04dc6e070c991df9"; + libraryHaskellDepends = [ base stm unbounded-delays ]; + doHaddock = false; + doCheck = false; + homepage = "https://github.com/basvandijk/concurrent-extra"; + description = "Extra concurrency primitives"; + license = stdenv.lib.licenses.bsd3; + }) {}; + "concurrent-output" = callPackage + ({ mkDerivation, ansi-terminal, async, base, directory, exceptions + , process, stdenv, stm, terminal-size, text, transformers, unix + }: + mkDerivation { + pname = "concurrent-output"; + version = "1.10.6"; + sha256 = "2301a6d8be9b0defd5d3a640a7e1a293bb77016bbd548ff8ccec6122e30e97e2"; + libraryHaskellDepends = [ + ansi-terminal async base directory exceptions process stm + terminal-size text transformers unix + ]; + doHaddock = false; + doCheck = false; + description = "Ungarble output from several threads or commands"; + license = stdenv.lib.licenses.bsd2; + }) {}; + "concurrent-split" = callPackage + ({ mkDerivation, base, stdenv }: + mkDerivation { + pname = "concurrent-split"; + version = "0.0.1"; + sha256 = "60793c8eeff1fa0fe03910951d1925f3c66aec61ead64bf3f98dd6110a05b8e7"; + libraryHaskellDepends = [ base ]; + doHaddock = false; + doCheck = false; + description = "MVars and Channels with distinguished input and output side"; + license = stdenv.lib.licenses.bsd3; + }) {}; + "concurrent-supply" = callPackage + ({ mkDerivation, base, ghc-prim, hashable, stdenv }: + mkDerivation { + pname = "concurrent-supply"; + version = "0.1.8"; + sha256 = "ccf827dcd221298ae93fad6021c63a06707456de0671706b44f1f2fed867f21f"; + libraryHaskellDepends = [ base ghc-prim hashable ]; + doHaddock = false; + doCheck = false; + homepage = "http://github.com/ekmett/concurrent-supply/"; + description = "A fast concurrent unique identifier supply with a pure API"; + license = stdenv.lib.licenses.bsd3; + }) {}; + "cond" = callPackage + ({ mkDerivation, base, stdenv }: + mkDerivation { + pname = "cond"; + version = "0.4.1.1"; + sha256 = "039c76e43b5484bdc78627f50740106ae2844b3c877d92b5228de9106997ac8b"; + libraryHaskellDepends = [ base ]; + doHaddock = false; + doCheck = false; + homepage = "https://github.com/kallisti-dev/cond"; + description = "Basic conditional and boolean operators with monadic variants"; + license = stdenv.lib.licenses.bsd3; + }) {}; + "conduit" = callPackage + ({ mkDerivation, base, bytestring, directory, exceptions, filepath + , mono-traversable, mtl, primitive, resourcet, stdenv, text + , transformers, unix, unliftio-core, vector + }: + mkDerivation { + pname = "conduit"; + version = "1.3.0.3"; + sha256 = "bb741f1650c2c90ef5104489541258689240e750869c9230fd2d458c417d56e9"; + libraryHaskellDepends = [ + base bytestring directory exceptions filepath mono-traversable mtl + primitive resourcet text transformers unix unliftio-core vector + ]; + doHaddock = false; + doCheck = false; + homepage = "http://github.com/snoyberg/conduit"; + description = "Streaming data processing library"; + license = stdenv.lib.licenses.mit; + }) {}; + "conduit-algorithms" = callPackage + ({ mkDerivation, async, base, bytestring, bzlib-conduit, conduit + , conduit-combinators, conduit-extra, containers, deepseq + , exceptions, lzma-conduit, monad-control, mtl, pqueue, resourcet + , stdenv, stm, stm-conduit, streaming-commons, transformers + , unliftio-core, vector + }: + mkDerivation { + pname = "conduit-algorithms"; + version = "0.0.8.1"; + sha256 = "cda5a50fa746c63001e39a8210d945015412c1c335078249e06eadd00616fd1d"; + libraryHaskellDepends = [ + async base bytestring bzlib-conduit conduit conduit-combinators + conduit-extra containers deepseq exceptions lzma-conduit + monad-control mtl pqueue resourcet stm stm-conduit + streaming-commons transformers unliftio-core vector + ]; + doHaddock = false; + doCheck = false; + homepage = "https://github.com/luispedro/conduit-algorithms#readme"; + description = "Conduit-based algorithms"; + license = stdenv.lib.licenses.mit; + }) {}; + "conduit-combinators" = callPackage + ({ mkDerivation, base, stdenv }: + mkDerivation { + pname = "conduit-combinators"; + version = "1.3.0"; + sha256 = "9717d916a0422a7fb7cc262302333269607530d40cd0bea3be947872f906e7d3"; + libraryHaskellDepends = [ base ]; + doHaddock = false; + doCheck = false; + homepage = "https://github.com/snoyberg/mono-traversable#readme"; + description = "DEPRECATED Functionality merged into the conduit package itself"; + license = stdenv.lib.licenses.mit; + }) {}; + "conduit-connection" = callPackage + ({ mkDerivation, base, bytestring, conduit, connection, resourcet + , stdenv, transformers + }: + mkDerivation { + pname = "conduit-connection"; + version = "0.1.0.4"; + sha256 = "5e784117f3698dc653b286fbb53d530068d0cdadbe130ec02abf42e3f2c821fc"; + libraryHaskellDepends = [ + base bytestring conduit connection resourcet transformers + ]; + doHaddock = false; + doCheck = false; + homepage = "https://github.com/sdroege/conduit-connection"; + description = "Conduit source and sink for Network.Connection."; + license = stdenv.lib.licenses.bsd3; + }) {}; + "conduit-extra" = callPackage + ({ mkDerivation, async, attoparsec, base, bytestring, conduit + , directory, filepath, network, primitive, process, resourcet + , stdenv, stm, streaming-commons, text, transformers, typed-process + , unliftio-core + }: + mkDerivation { + pname = "conduit-extra"; + version = "1.3.0"; + sha256 = "2c41c925fc53d9ba2e640c7cdca72c492b28c0d45f1a82e94baef8dfa65922ae"; + libraryHaskellDepends = [ + async attoparsec base bytestring conduit directory filepath network + primitive process resourcet stm streaming-commons text transformers + typed-process unliftio-core + ]; + doHaddock = false; + doCheck = false; + homepage = "http://github.com/snoyberg/conduit"; + description = "Batteries included conduit: adapters for common libraries"; + license = stdenv.lib.licenses.mit; + }) {}; + "conduit-iconv" = callPackage + ({ mkDerivation, base, bytestring, conduit, stdenv }: + mkDerivation { + pname = "conduit-iconv"; + version = "0.1.1.3"; + sha256 = "1c71304782e4599a2987321028b50356c4982b45d9096d954e0b7c0b7ad3acb6"; + libraryHaskellDepends = [ base bytestring conduit ]; + doHaddock = false; + doCheck = false; + homepage = "https://github.com/sdroege/conduit-iconv"; + description = "Conduit for character encoding conversion"; + license = stdenv.lib.licenses.bsd3; + }) {}; + "conduit-parse" = callPackage + ({ mkDerivation, base, conduit, dlist, mtl, parsers, safe + , safe-exceptions, stdenv, text, transformers + }: + mkDerivation { + pname = "conduit-parse"; + version = "0.2.1.0"; + sha256 = "b585dbdc0c1e3a844a9cd97cd1e72d7a73521b66b856001960afe4057130dae1"; + revision = "1"; + editedCabalFile = "1bgxjn9lbx67584xpwl2k9jrwvlgyqf4vkv0s7vs1nnc1h6qk7qw"; + libraryHaskellDepends = [ + base conduit dlist mtl parsers safe safe-exceptions text + transformers + ]; + doHaddock = false; + doCheck = false; + homepage = "https://github.com/k0ral/conduit-parse"; + description = "Parsing framework based on conduit"; + license = stdenv.lib.licenses.publicDomain; + }) {}; + "conduit-throttle" = callPackage + ({ mkDerivation, async, base, conduit, conduit-combinators + , conduit-extra, monad-control, resourcet, stdenv, stm, stm-chans + , throttle-io-stream, unliftio, unliftio-core + }: + mkDerivation { + pname = "conduit-throttle"; + version = "0.3.1.0"; + sha256 = "8dd6d616f5ddce25668bb34069bfdcdfe2a866c8d708b725a9b2e450a95aa329"; + libraryHaskellDepends = [ + async base conduit conduit-combinators conduit-extra monad-control + resourcet stm stm-chans throttle-io-stream unliftio unliftio-core + ]; + doHaddock = false; + doCheck = false; + homepage = "https://github.com/mtesseract/conduit-throttle#readme"; + description = "Throttle Conduit Producers"; + license = stdenv.lib.licenses.bsd3; + }) {}; + "config-ini" = callPackage + ({ mkDerivation, base, containers, megaparsec, stdenv, text + , transformers, unordered-containers + }: + mkDerivation { + pname = "config-ini"; + version = "0.2.2.0"; + sha256 = "364d67b876abf867d97eaacac630e920521ff96478fe9869a41983893ce140a0"; + libraryHaskellDepends = [ + base containers megaparsec text transformers unordered-containers + ]; + doHaddock = false; + doCheck = false; + homepage = "https://github.com/aisamanra/config-ini"; + description = "A library for simple INI-based configuration files"; + license = stdenv.lib.licenses.bsd3; + }) {}; + "configuration-tools" = callPackage + ({ mkDerivation, aeson, ansi-wl-pprint, attoparsec, base + , base-unicode-symbols, base64-bytestring, bytestring, Cabal + , case-insensitive, connection, data-default, deepseq, directory + , dlist, enclosed-exceptions, filepath, http-client + , http-client-tls, http-types, monad-control, mtl, network-uri + , optparse-applicative, process, profunctors, semigroups, stdenv + , text, tls, transformers, unordered-containers, x509, x509-system + , x509-validation, yaml + }: + mkDerivation { + pname = "configuration-tools"; + version = "0.3.1"; + sha256 = "e0df7e71b084c1bd831cd9887584f06e016e359291dc4f71b72d2027f7f86e47"; + libraryHaskellDepends = [ + aeson ansi-wl-pprint attoparsec base base-unicode-symbols + base64-bytestring bytestring Cabal case-insensitive connection + data-default deepseq directory dlist enclosed-exceptions filepath + http-client http-client-tls http-types monad-control mtl + network-uri optparse-applicative process profunctors semigroups + text tls transformers unordered-containers x509 x509-system + x509-validation yaml + ]; + doHaddock = false; + doCheck = false; + homepage = "https://github.com/alephcloud/hs-configuration-tools"; + description = "Tools for specifying and parsing configurations"; + license = stdenv.lib.licenses.mit; + }) {}; + "configurator" = callPackage + ({ mkDerivation, attoparsec, base, bytestring, directory, hashable + , stdenv, text, unix-compat, unordered-containers + }: + mkDerivation { + pname = "configurator"; + version = "0.3.0.0"; + sha256 = "6eb9996b672e9f7112ca23482c42fa533553312c3c13f38a8a06476e67c031b4"; + enableSeparateDataOutput = true; + libraryHaskellDepends = [ + attoparsec base bytestring directory hashable text unix-compat + unordered-containers + ]; + doHaddock = false; + doCheck = false; + homepage = "http://github.com/bos/configurator"; + description = "Configuration management"; + license = stdenv.lib.licenses.bsd3; + }) {}; + "configurator-export" = callPackage + ({ mkDerivation, base, base-compat, configurator, pretty + , semigroups, stdenv, text, unordered-containers + }: + mkDerivation { + pname = "configurator-export"; + version = "0.1.0.1"; + sha256 = "9dbd62ef29c97792ccdfdb1b3b79aedfa527dce49a9ac5054f21b29a7f9b824c"; + libraryHaskellDepends = [ + base base-compat configurator pretty semigroups text + unordered-containers + ]; + doHaddock = false; + doCheck = false; + homepage = "http://github.com/mstksg/configurator-export"; + description = "Pretty printer and exporter for configurations from the \"configurator\" library"; + license = stdenv.lib.licenses.bsd3; + }) {}; + "connection" = callPackage + ({ mkDerivation, base, byteable, bytestring, containers + , data-default-class, network, socks, stdenv, tls, x509, x509-store + , x509-system, x509-validation + }: + mkDerivation { + pname = "connection"; + version = "0.2.8"; + sha256 = "70b1f44e8786320c18b26fc5d4ec115fc8ac016ba1f852fa8137f55d785a93eb"; + libraryHaskellDepends = [ + base byteable bytestring containers data-default-class network + socks tls x509 x509-store x509-system x509-validation + ]; + doHaddock = false; + doCheck = false; + homepage = "http://github.com/vincenthz/hs-connection"; + description = "Simple and easy network connections API"; + license = stdenv.lib.licenses.bsd3; + }) {}; + "connection-pool" = callPackage + ({ mkDerivation, base, between, data-default-class, monad-control + , network, resource-pool, stdenv, streaming-commons, time + , transformers-base + }: + mkDerivation { + pname = "connection-pool"; + version = "0.2.2"; + sha256 = "f2cf43b7698b719b05467b3625884d00c748de2b3eb1229d19490b029a667353"; + libraryHaskellDepends = [ + base between data-default-class monad-control network resource-pool + streaming-commons time transformers-base + ]; + doHaddock = false; + doCheck = false; + homepage = "https://github.com/trskop/connection-pool"; + description = "Connection pool built on top of resource-pool and streaming-commons"; + license = stdenv.lib.licenses.bsd3; + }) {}; + "console-style" = callPackage + ({ mkDerivation, base, mtl, stdenv, transformers }: + mkDerivation { + pname = "console-style"; + version = "0.0.2.1"; + sha256 = "6d818ea841d7acfe6c42cc3fc7751e324656abfd0509ce470bc8bdbf52d1bd7f"; + libraryHaskellDepends = [ base mtl transformers ]; + doHaddock = false; + doCheck = false; + homepage = "https://github.com/minad/console-style#readme"; + description = "Styled console text output using ANSI escape sequences"; + license = stdenv.lib.licenses.mit; + }) {}; + "constraint" = callPackage + ({ mkDerivation, base, category, stdenv }: + mkDerivation { + pname = "constraint"; + version = "0.1.1.1"; + sha256 = "22800d629e3255c7e37d9265ac70b9a4ec4bee2d5f4cc19948e8d28b911ddf47"; + libraryHaskellDepends = [ base category ]; + doHaddock = false; + doCheck = false; + description = "Reified constraints"; + license = stdenv.lib.licenses.bsd3; + }) {}; + "constraints" = callPackage + ({ mkDerivation, base, binary, deepseq, ghc-prim, hashable, mtl + , semigroups, stdenv, transformers, transformers-compat + }: + mkDerivation { + pname = "constraints"; + version = "0.10.1"; + sha256 = "5880ec261e053841b307c7c8c59614f46c2efbd5189f0f2a3c817589cedec3f7"; + libraryHaskellDepends = [ + base binary deepseq ghc-prim hashable mtl semigroups transformers + transformers-compat + ]; + doHaddock = false; + doCheck = false; + homepage = "http://github.com/ekmett/constraints/"; + description = "Constraint manipulation"; + license = stdenv.lib.licenses.bsd2; + }) {}; + "consul-haskell" = callPackage + ({ mkDerivation, aeson, base, base64-bytestring, bytestring + , connection, either, exceptions, http-client, http-client-tls + , http-types, lifted-async, lifted-base, monad-control, network + , retry, stdenv, stm, text, transformers, unordered-containers + , vector + }: + mkDerivation { + pname = "consul-haskell"; + version = "0.4.2"; + sha256 = "b10812b70dfbce7037f9f23eda71fa2fa6fc97ed309bd63c00f226522d30d80a"; + libraryHaskellDepends = [ + aeson base base64-bytestring bytestring connection either + exceptions http-client http-client-tls http-types lifted-async + lifted-base monad-control network retry stm text transformers + unordered-containers vector + ]; + doHaddock = false; + doCheck = false; + homepage = "https://github.com/alphaHeavy/consul-haskell"; + description = "A consul client for Haskell"; + license = stdenv.lib.licenses.bsd3; + }) {}; + "containers-unicode-symbols" = callPackage + ({ mkDerivation, base, base-unicode-symbols, containers, stdenv }: + mkDerivation { + pname = "containers-unicode-symbols"; + version = "0.3.1.1"; + sha256 = "4655f286a2d116cb5f2b89f472df54df739bf904ac8e932b2fd34d3f713e9b31"; + libraryHaskellDepends = [ base base-unicode-symbols containers ]; + doHaddock = false; + doCheck = false; + homepage = "http://haskell.org/haskellwiki/Unicode-symbols"; + description = "Unicode alternatives for common functions and operators"; + license = stdenv.lib.licenses.bsd3; + }) {}; + "contravariant" = callPackage + ({ mkDerivation, base, StateVar, stdenv, transformers + , transformers-compat + }: + mkDerivation { + pname = "contravariant"; + version = "1.4.1"; + sha256 = "c93d3d619fa378f3fdf92c53bb8b04b8f47963b88aba7cfa54b57656189ad0ed"; + revision = "1"; + editedCabalFile = "0qj5nymccrb9p0cd6hffsy90jidjng14g9yv95z8v6h4q84sbzvx"; + libraryHaskellDepends = [ + base StateVar transformers transformers-compat + ]; + doHaddock = false; + doCheck = false; + homepage = "http://github.com/ekmett/contravariant/"; + description = "Contravariant functors"; + license = stdenv.lib.licenses.bsd3; + }) {}; + "contravariant-extras" = callPackage + ({ mkDerivation, base, base-prelude, contravariant, semigroups + , stdenv, template-haskell, tuple-th + }: + mkDerivation { + pname = "contravariant-extras"; + version = "0.3.4"; + sha256 = "36a9239d5a84bc6a418a3aa1a0df145d76ece24d00b76deb817b92441913e63d"; + revision = "1"; + editedCabalFile = "1h2955ahga6i4fn7k8v66l03v77p6fhsac6ck8gpabkc08ij60wp"; + libraryHaskellDepends = [ + base base-prelude contravariant semigroups template-haskell + tuple-th + ]; + doHaddock = false; + doCheck = false; + homepage = "https://github.com/nikita-volkov/contravariant-extras"; + description = "Extras for the \"contravariant\" package"; + license = stdenv.lib.licenses.mit; + }) {}; + "control-bool" = callPackage + ({ mkDerivation, base, stdenv }: + mkDerivation { + pname = "control-bool"; + version = "0.2.1"; + sha256 = "e46a85d2985a65f8d7ecbcdab0cfb12734b4d6e4c558631e6ab01fe742ed5581"; + libraryHaskellDepends = [ base ]; + doHaddock = false; + doCheck = false; + homepage = "https://github.com/fumieval/control-bool"; + description = "Useful combinators for boolean expressions"; + license = stdenv.lib.licenses.bsd3; + }) {}; + "control-monad-free" = callPackage + ({ mkDerivation, base, prelude-extras, stdenv, transformers }: + mkDerivation { + pname = "control-monad-free"; + version = "0.6.1"; + sha256 = "fea9173d3c29729a8e0789d654bf3b16928e0b740465bd8798ac2cfeec492286"; + revision = "2"; + editedCabalFile = "07ygqmvl0k9ap868djgz4nlvgzllaf6qmdd397kf5imbbq849zz1"; + libraryHaskellDepends = [ base prelude-extras transformers ]; + doHaddock = false; + doCheck = false; + homepage = "http://github.com/pepeiborra/control-monad-free"; + description = "Free monads and monad transformers"; + license = stdenv.lib.licenses.publicDomain; + }) {}; + "control-monad-omega" = callPackage + ({ mkDerivation, base, stdenv }: + mkDerivation { + pname = "control-monad-omega"; + version = "0.3.1"; + sha256 = "383b98ecf5db5add42f318672af9eb1c8b9d99ec42d48c240e209a93b5cf1186"; + libraryHaskellDepends = [ base ]; + doHaddock = false; + doCheck = false; + homepage = "http://github.com/luqui/control-monad-omega"; + description = "A breadth-first list monad"; + license = stdenv.lib.licenses.publicDomain; + }) {}; + "convertible" = callPackage + ({ mkDerivation, base, bytestring, containers, mtl, old-locale + , old-time, stdenv, text, time + }: + mkDerivation { + pname = "convertible"; + version = "1.1.1.0"; + sha256 = "e9f9a70904b9995314c2aeb41580d654a2c76293feb955fb6bd63256c355286c"; + isLibrary = true; + isExecutable = true; + libraryHaskellDepends = [ + base bytestring containers mtl old-locale old-time text time + ]; + doHaddock = false; + doCheck = false; + homepage = "http://hackage.haskell.org/package/convertible"; + description = "Typeclasses and instances for converting between types"; + license = stdenv.lib.licenses.bsd3; + }) {}; + "cookie" = callPackage + ({ mkDerivation, base, bytestring, data-default-class, deepseq + , stdenv, text, time + }: + mkDerivation { + pname = "cookie"; + version = "0.4.4"; + sha256 = "3245ed04ae933cf7becede816d1f76043b851472700abf558ae90b28414cc0e3"; + libraryHaskellDepends = [ + base bytestring data-default-class deepseq text time + ]; + doHaddock = false; + doCheck = false; + homepage = "http://github.com/snoyberg/cookie"; + description = "HTTP cookie parsing and rendering"; + license = stdenv.lib.licenses.mit; + }) {}; + "countable" = callPackage + ({ mkDerivation, base, stdenv }: + mkDerivation { + pname = "countable"; + version = "1.0"; + sha256 = "f9a0eb6f697a044bdf72e9c08126d4cb0f2d6de82cce07e55cb87ddbae6a0e6c"; + libraryHaskellDepends = [ base ]; + doHaddock = false; + doCheck = false; + homepage = "https://github.com/AshleyYakeley/countable"; + description = "Countable, Searchable, Finite, Empty classes"; + license = stdenv.lib.licenses.bsd3; + }) {}; + "country" = callPackage + ({ mkDerivation, aeson, attoparsec, base, bytestring, deepseq + , ghc-prim, hashable, primitive, scientific, stdenv, text + , unordered-containers + }: + mkDerivation { + pname = "country"; + version = "0.1.6"; + sha256 = "09b36e30dfb1fa5fa7a2c5c38f316a70e0c740b8a4dd6e340abe9770ad149928"; + revision = "1"; + editedCabalFile = "04a2s0zlm4garihnm3xl9avf88vjnbvpsyb2ckk3z7ydjq0y3938"; + libraryHaskellDepends = [ + aeson attoparsec base bytestring deepseq ghc-prim hashable + primitive scientific text unordered-containers + ]; + doHaddock = false; + doCheck = false; + homepage = "https://github.com/andrewthad/country#readme"; + description = "Country data type and functions"; + license = stdenv.lib.licenses.bsd3; + }) {}; + "courier" = callPackage + ({ mkDerivation, async, base, bytestring, cereal, containers + , hslogger, network, stdenv, stm, text, uuid + }: + mkDerivation { + pname = "courier"; + version = "0.1.1.5"; + sha256 = "ac9e674ff33de347b173da2892859b3807a408b341d10d6101d2a7d07ac334d3"; + isLibrary = true; + isExecutable = true; + libraryHaskellDepends = [ + async base bytestring cereal containers hslogger network stm text + uuid + ]; + executableHaskellDepends = [ base cereal ]; + doHaddock = false; + doCheck = false; + homepage = "http://github.com/hargettp/courier"; + description = "A message-passing library for simplifying network applications"; + license = stdenv.lib.licenses.mit; + }) {}; + "cpio-conduit" = callPackage + ({ mkDerivation, base, base16-bytestring, binary, bytestring + , conduit, conduit-extra, stdenv + }: + mkDerivation { + pname = "cpio-conduit"; + version = "0.7.0"; + sha256 = "8f0be7538b234496ef3b2fb2633336908ae99040ecb6d9832b3dbd1d0750f513"; + libraryHaskellDepends = [ + base base16-bytestring binary bytestring conduit conduit-extra + ]; + doHaddock = false; + doCheck = false; + homepage = "http://github.com/da-x/cpio-conduit"; + description = "Conduit-based CPIO"; + license = stdenv.lib.licenses.asl20; + }) {}; + "cpphs" = callPackage + ({ mkDerivation, base, directory, old-locale, old-time, polyparse + , stdenv + }: + mkDerivation { + pname = "cpphs"; + version = "1.20.8"; + sha256 = "e56d64a7d8058e0fb63f0669397c1c861efb20a0376e0e74d86942ac151105ae"; + isLibrary = true; + isExecutable = true; + libraryHaskellDepends = [ + base directory old-locale old-time polyparse + ]; + executableHaskellDepends = [ + base directory old-locale old-time polyparse + ]; + doHaddock = false; + doCheck = false; + homepage = "http://projects.haskell.org/cpphs/"; + description = "A liberalised re-implementation of cpp, the C pre-processor"; + license = "LGPL"; + }) {}; + "cprng-aes" = callPackage + ({ mkDerivation, base, byteable, bytestring, cipher-aes + , crypto-random, stdenv + }: + mkDerivation { + pname = "cprng-aes"; + version = "0.6.1"; + sha256 = "64592a01de8c6683c5e29f538dceee918887ffe211d87214a2e38559d72c21f3"; + enableSeparateDataOutput = true; + libraryHaskellDepends = [ + base byteable bytestring cipher-aes crypto-random + ]; + doHaddock = false; + doCheck = false; + homepage = "http://github.com/vincenthz/hs-cprng-aes"; + description = "Crypto Pseudo Random Number Generator using AES in counter mode"; + license = stdenv.lib.licenses.bsd3; + }) {}; + "cpu" = callPackage + ({ mkDerivation, base, stdenv }: + mkDerivation { + pname = "cpu"; + version = "0.1.2"; + sha256 = "5627feb4974a3ff8499c42cc958927e88761a2e004c4000d34e9cd6a15ad2974"; + isLibrary = true; + isExecutable = true; + enableSeparateDataOutput = true; + libraryHaskellDepends = [ base ]; + doHaddock = false; + doCheck = false; + homepage = "http://github.com/vincenthz/hs-cpu"; + description = "Cpu information and properties helpers"; + license = stdenv.lib.licenses.bsd3; + }) {}; + "cpuinfo" = callPackage + ({ mkDerivation, attoparsec, base, bytestring, deepseq, stdenv }: + mkDerivation { + pname = "cpuinfo"; + version = "0.1.0.1"; + sha256 = "d1b3e3992cc0c82edfb21f30e1684bb66e6a3cb23a26b777a079702362d05655"; + libraryHaskellDepends = [ attoparsec base bytestring deepseq ]; + doHaddock = false; + doCheck = false; + homepage = "https://github.com/TravisWhitaker/cpuinfo"; + description = "Haskell Library for Checking CPU Information"; + license = stdenv.lib.licenses.mit; + }) {}; + "cql" = callPackage + ({ mkDerivation, base, bytestring, cereal, containers, Decimal + , iproute, network, stdenv, template-haskell, text, time + , transformers, uuid, vector + }: + mkDerivation { + pname = "cql"; + version = "4.0.1"; + sha256 = "89294c6a6ed2c6f8c6037ee2ca4236d3606bf9019a39df9e39b7ad8dcd573808"; + libraryHaskellDepends = [ + base bytestring cereal containers Decimal iproute network + template-haskell text time transformers uuid vector + ]; + doHaddock = false; + doCheck = false; + homepage = "https://gitlab.com/twittner/cql/"; + description = "Cassandra CQL binary protocol"; + license = "unknown"; + }) {}; + "cql-io" = callPackage + ({ mkDerivation, async, auto-update, base, bytestring, containers + , cql, cryptohash, data-default-class, exceptions, hashable + , HsOpenSSL, iproute, lens, monad-control, mtl, mwc-random, network + , retry, semigroups, stdenv, stm, text, time, tinylog, transformers + , transformers-base, unordered-containers, uuid, vector + }: + mkDerivation { + pname = "cql-io"; + version = "1.0.1"; + sha256 = "b874e70d55c144064d8ed2df1e90063071811ec55734a051b6f240279969351a"; + libraryHaskellDepends = [ + async auto-update base bytestring containers cql cryptohash + data-default-class exceptions hashable HsOpenSSL iproute lens + monad-control mtl mwc-random network retry semigroups stm text time + tinylog transformers transformers-base unordered-containers uuid + vector + ]; + doHaddock = false; + doCheck = false; + homepage = "https://gitlab.com/twittner/cql-io/"; + description = "Cassandra CQL client"; + license = stdenv.lib.licenses.mpl20; + }) {}; + "credential-store" = callPackage + ({ mkDerivation, base, bytestring, containers, cryptonite, dbus + , memory, safe-exceptions, stdenv + }: + mkDerivation { + pname = "credential-store"; + version = "0.1.2"; + sha256 = "4dadbc219a7187442258608c1d834f4297652fb605fc6bbbb41d751fef6a9284"; + isLibrary = true; + isExecutable = true; + libraryHaskellDepends = [ + base bytestring containers cryptonite dbus memory safe-exceptions + ]; + executableHaskellDepends = [ base bytestring ]; + doHaddock = false; + doCheck = false; + homepage = "https://github.com/rblaze/credential-store#readme"; + description = "Library to access secure credential storage providers"; + license = stdenv.lib.licenses.asl20; + }) {}; + "criterion" = callPackage + ({ mkDerivation, aeson, ansi-wl-pprint, base, base-compat-batteries + , binary, bytestring, cassava, code-page, containers, deepseq + , directory, exceptions, filepath, Glob, js-flot, js-jquery + , microstache, mtl, mwc-random, optparse-applicative, parsec + , semigroups, statistics, stdenv, text, time, transformers + , transformers-compat, vector, vector-algorithms + }: + mkDerivation { + pname = "criterion"; + version = "1.4.1.0"; + sha256 = "c49306676aa7927c3ca3c1807b081d1e86771eb8da99c8391f9c4dacb24a826c"; + revision = "1"; + editedCabalFile = "0jg7mk9y9br5aqi29vrrrq28mnyknyg96zmr8rrlxw0rf68l892a"; + isLibrary = true; + isExecutable = true; + enableSeparateDataOutput = true; + libraryHaskellDepends = [ + aeson ansi-wl-pprint base base-compat-batteries binary bytestring + cassava code-page containers deepseq directory exceptions filepath + Glob js-flot js-jquery microstache mtl mwc-random + optparse-applicative parsec semigroups statistics text time + transformers transformers-compat vector vector-algorithms + ]; + executableHaskellDepends = [ + base base-compat-batteries optparse-applicative semigroups + ]; + doHaddock = false; + doCheck = false; + homepage = "http://www.serpentine.com/criterion"; + description = "Robust, reliable performance measurement and analysis"; + license = stdenv.lib.licenses.bsd3; + }) {}; + "criterion-measurement" = callPackage + ({ mkDerivation, aeson, base, base-compat, binary, containers + , deepseq, stdenv, vector + }: + mkDerivation { + pname = "criterion-measurement"; + version = "0.1.0.0"; + sha256 = "fe6423d77a5c7f3571bf16abac2b9729a45feaba2d3f293bce6029592debc6ce"; + libraryHaskellDepends = [ + aeson base base-compat binary containers deepseq vector + ]; + doHaddock = false; + doCheck = false; + homepage = "https://github.com/bos/criterion"; + description = "Criterion measurement functionality and associated types"; + license = stdenv.lib.licenses.bsd3; + }) {}; + "cron" = callPackage + ({ mkDerivation, attoparsec, base, data-default-class, mtl + , mtl-compat, old-locale, semigroups, stdenv, text, time + }: + mkDerivation { + pname = "cron"; + version = "0.6.1"; + sha256 = "8c1af53bde729026809b722468f6b36c4f96cb532f26a390f32f1c91fb8b3251"; + libraryHaskellDepends = [ + attoparsec base data-default-class mtl mtl-compat old-locale + semigroups text time + ]; + doHaddock = false; + doCheck = false; + homepage = "http://github.com/michaelxavier/cron"; + description = "Cron datatypes and Attoparsec parser"; + license = stdenv.lib.licenses.mit; + }) {}; + "crypt-sha512" = callPackage + ({ mkDerivation, attoparsec, base, bytestring, cryptohash-sha512 + , stdenv + }: + mkDerivation { + pname = "crypt-sha512"; + version = "0"; + sha256 = "c2be6252bf12f38c74950eb778039426c730e9a7cd7f034a4cc3e6965d5255f3"; + revision = "2"; + editedCabalFile = "071lxiwsf23ga1fkbjd47ykz7f5irhsh7q7zz2qczzjgnvzadadh"; + libraryHaskellDepends = [ + attoparsec base bytestring cryptohash-sha512 + ]; + doHaddock = false; + doCheck = false; + homepage = "https://github.com/phadej/crypt-sha512"; + description = "Pure Haskell implelementation for GNU SHA512 crypt algorithm"; + license = stdenv.lib.licenses.bsd3; + }) {}; + "crypto-api" = callPackage + ({ mkDerivation, base, bytestring, cereal, entropy, stdenv, tagged + , transformers + }: + mkDerivation { + pname = "crypto-api"; + version = "0.13.3"; + sha256 = "298a9ea7ce97c8ccf4bfe46d4864092c3a007a56bede73560070db3bf1ac7aa5"; + revision = "1"; + editedCabalFile = "1z6n1sa5pn3iqvqjrd8hv4bc2pxzsrhm5sh0l8z7g9lbqp6w0wp5"; + libraryHaskellDepends = [ + base bytestring cereal entropy tagged transformers + ]; + doHaddock = false; + doCheck = false; + homepage = "https://github.com/TomMD/crypto-api"; + description = "A generic interface for cryptographic operations"; + license = stdenv.lib.licenses.bsd3; + }) {}; + "crypto-api-tests" = callPackage + ({ mkDerivation, base, bytestring, cereal, crypto-api, directory + , filepath, HUnit, QuickCheck, stdenv, test-framework + , test-framework-hunit, test-framework-quickcheck2 + }: + mkDerivation { + pname = "crypto-api-tests"; + version = "0.3"; + sha256 = "f44aecdd4ceb9da9f38330e84d9c17745a82b0611085ebb34442d2dce4207270"; + enableSeparateDataOutput = true; + libraryHaskellDepends = [ + base bytestring cereal crypto-api directory filepath HUnit + QuickCheck test-framework test-framework-hunit + test-framework-quickcheck2 + ]; + doHaddock = false; + doCheck = false; + homepage = "http://trac.haskell.org/crypto-api/wiki"; + description = "A test framework and KATs for cryptographic operations"; + license = stdenv.lib.licenses.bsd3; + }) {}; + "crypto-cipher-tests" = callPackage + ({ mkDerivation, base, byteable, bytestring, crypto-cipher-types + , HUnit, mtl, QuickCheck, securemem, stdenv, test-framework + , test-framework-hunit, test-framework-quickcheck2 + }: + mkDerivation { + pname = "crypto-cipher-tests"; + version = "0.0.11"; + sha256 = "dfb670b73d4091b8683634d0d4d5a40576d573ad160650d5e518244ced8b98a7"; + libraryHaskellDepends = [ + base byteable bytestring crypto-cipher-types HUnit mtl QuickCheck + securemem test-framework test-framework-hunit + test-framework-quickcheck2 + ]; + doHaddock = false; + doCheck = false; + homepage = "http://github.com/vincenthz/hs-crypto-cipher"; + description = "Generic cryptography cipher tests"; + license = stdenv.lib.licenses.bsd3; + }) {}; + "crypto-cipher-types" = callPackage + ({ mkDerivation, base, byteable, bytestring, securemem, stdenv }: + mkDerivation { + pname = "crypto-cipher-types"; + version = "0.0.9"; + sha256 = "2073f6b70df7916aebe2da49d224497183662d56d19da87b76f70039430c0a0f"; + enableSeparateDataOutput = true; + libraryHaskellDepends = [ base byteable bytestring securemem ]; + doHaddock = false; + doCheck = false; + homepage = "http://github.com/vincenthz/hs-crypto-cipher"; + description = "Generic cryptography cipher types"; + license = stdenv.lib.licenses.bsd3; + }) {}; + "crypto-enigma" = callPackage + ({ mkDerivation, base, containers, MissingH, mtl, split, stdenv }: + mkDerivation { + pname = "crypto-enigma"; + version = "0.0.2.12"; + sha256 = "2bb942397a3ca2a099e8c4b59a3810a0fe3a4d255c077e8e0db8e8764fb6b83c"; + libraryHaskellDepends = [ base containers MissingH mtl split ]; + doHaddock = false; + doCheck = false; + homepage = "https://github.com/orome/crypto-enigma-hs"; + description = "An Enigma machine simulator with display"; + license = stdenv.lib.licenses.bsd3; + }) {}; + "crypto-numbers" = callPackage + ({ mkDerivation, base, bytestring, crypto-random, ghc-prim + , integer-gmp, stdenv, vector + }: + mkDerivation { + pname = "crypto-numbers"; + version = "0.2.7"; + sha256 = "420aeb17e9cdcfdf8c950c6c6f10c54503c5524d36f611aa7238e3fd65f189a6"; + revision = "1"; + editedCabalFile = "1jjkhid8kwrz5894nad537rqxzzyx6b687bmgyk70nv0ny336j9b"; + libraryHaskellDepends = [ + base bytestring crypto-random ghc-prim integer-gmp vector + ]; + doHaddock = false; + doCheck = false; + homepage = "https://github.com/vincenthz/hs-crypto-numbers"; + description = "Cryptographic numbers: functions and algorithms"; + license = stdenv.lib.licenses.bsd3; + }) {}; + "crypto-pubkey" = callPackage + ({ mkDerivation, base, byteable, bytestring, crypto-numbers + , crypto-pubkey-types, crypto-random, cryptohash, stdenv + }: + mkDerivation { + pname = "crypto-pubkey"; + version = "0.2.8"; + sha256 = "c0ccf2f5c38517de1f1626cb0a2542f35aefad8842f8ad5c1fac0b8c9de8b56e"; + libraryHaskellDepends = [ + base byteable bytestring crypto-numbers crypto-pubkey-types + crypto-random cryptohash + ]; + doHaddock = false; + doCheck = false; + homepage = "https://github.com/vincenthz/hs-crypto-pubkey"; + description = "Public Key cryptography"; + license = stdenv.lib.licenses.bsd3; + }) {}; + "crypto-pubkey-types" = callPackage + ({ mkDerivation, asn1-encoding, asn1-types, base, stdenv }: + mkDerivation { + pname = "crypto-pubkey-types"; + version = "0.4.3"; + sha256 = "7ed9f52281ec4e34021a91818fe45288e33d65bff937f60334a3f45be5a71c60"; + libraryHaskellDepends = [ asn1-encoding asn1-types base ]; + doHaddock = false; + doCheck = false; + homepage = "http://github.com/vincenthz/hs-crypto-pubkey-types"; + description = "Generic cryptography Public keys algorithm types"; + license = stdenv.lib.licenses.bsd3; + }) {}; + "crypto-random" = callPackage + ({ mkDerivation, base, bytestring, securemem, stdenv, unix, vector + }: + mkDerivation { + pname = "crypto-random"; + version = "0.0.9"; + sha256 = "170a7a18441379c2d1c19b502ee5919026a19adc6e78641cd4fb40b1d69a6904"; + libraryHaskellDepends = [ base bytestring securemem unix vector ]; + doHaddock = false; + doCheck = false; + homepage = "http://github.com/vincenthz/hs-crypto-random"; + description = "Simple cryptographic random related types"; + license = stdenv.lib.licenses.bsd3; + }) {}; + "crypto-random-api" = callPackage + ({ mkDerivation, base, bytestring, entropy, stdenv }: + mkDerivation { + pname = "crypto-random-api"; + version = "0.2.0"; + sha256 = "56e9777061bd9ce553683d097ba3a11fdc371724060b62ca103f1f291f9f897c"; + libraryHaskellDepends = [ base bytestring entropy ]; + doHaddock = false; + doCheck = false; + homepage = "http://github.com/vincenthz/hs-crypto-random-api"; + description = "Simple random generators API for cryptography related code"; + license = stdenv.lib.licenses.bsd3; + }) {}; + "cryptocipher" = callPackage + ({ mkDerivation, base, cipher-aes, cipher-blowfish, cipher-camellia + , cipher-des, cipher-rc4, crypto-cipher-types, stdenv + }: + mkDerivation { + pname = "cryptocipher"; + version = "0.6.2"; + sha256 = "34b9e62dee36c4019dd0c0e86576295d0bd1bb573eeb24686ec635a09550e346"; + libraryHaskellDepends = [ + base cipher-aes cipher-blowfish cipher-camellia cipher-des + cipher-rc4 crypto-cipher-types + ]; + doHaddock = false; + doCheck = false; + homepage = "http://github.com/vincenthz/hs-crypto-cipher"; + description = "Symmetrical block and stream ciphers"; + license = stdenv.lib.licenses.bsd3; + }) {}; + "cryptocompare" = callPackage + ({ mkDerivation, aeson, base, bytestring, containers, directory + , exceptions, http-conduit, MissingH, stdenv, text, time + , transformers, unordered-containers + }: + mkDerivation { + pname = "cryptocompare"; + version = "0.1.1"; + sha256 = "d12e0f6fd133e538852e5700b0a31d81c6885dc8b1e9e88d1b331dcec38316b3"; + libraryHaskellDepends = [ + aeson base bytestring containers directory exceptions http-conduit + MissingH text time transformers unordered-containers + ]; + doHaddock = false; + doCheck = false; + homepage = "https://github.com/aviaviavi/cryptocompare"; + description = "Haskell wrapper for the cryptocompare API"; + license = stdenv.lib.licenses.mit; + }) {}; + "cryptohash" = callPackage + ({ mkDerivation, base, byteable, bytestring, cryptonite, ghc-prim + , memory, stdenv + }: + mkDerivation { + pname = "cryptohash"; + version = "0.11.9"; + sha256 = "c28f847fc1fcd65b6eea2e74a100300af940919f04bb21d391f6a773968f22fb"; + libraryHaskellDepends = [ + base byteable bytestring cryptonite ghc-prim memory + ]; + doHaddock = false; + doCheck = false; + homepage = "http://github.com/vincenthz/hs-cryptohash"; + description = "collection of crypto hashes, fast, pure and practical"; + license = stdenv.lib.licenses.bsd3; + }) {}; + "cryptohash-cryptoapi" = callPackage + ({ mkDerivation, base, bytestring, cereal, crypto-api, cryptonite + , memory, stdenv, tagged + }: + mkDerivation { + pname = "cryptohash-cryptoapi"; + version = "0.1.4"; + sha256 = "717a8664ebfaa1c31aaec1d78c9b7c776a5adcfdfc50ad88e21a34566f72058e"; + enableSeparateDataOutput = true; + libraryHaskellDepends = [ + base bytestring cereal crypto-api cryptonite memory tagged + ]; + doHaddock = false; + doCheck = false; + homepage = "https://github.com/vincenthz/hs-cryptohash-cryptoapi"; + description = "Crypto-api interfaces for cryptohash"; + license = stdenv.lib.licenses.bsd3; + }) {}; + "cryptohash-md5" = callPackage + ({ mkDerivation, base, bytestring, stdenv }: + mkDerivation { + pname = "cryptohash-md5"; + version = "0.11.100.1"; + sha256 = "710bd48770fa3e9a3b05428c6dc77fb72c91956d334a1eb89ded11bb843e18f9"; + revision = "3"; + editedCabalFile = "0ld224mdmw9mgzcl20q82rqkyl7d5vmi1iknsyymq58gcvcwdi2m"; + libraryHaskellDepends = [ base bytestring ]; + doHaddock = false; + doCheck = false; + homepage = "https://github.com/hvr/cryptohash-md5"; + description = "Fast, pure and practical MD5 implementation"; + license = stdenv.lib.licenses.bsd3; + }) {}; + "cryptohash-sha1" = callPackage + ({ mkDerivation, base, bytestring, stdenv }: + mkDerivation { + pname = "cryptohash-sha1"; + version = "0.11.100.1"; + sha256 = "3c79af33542512442f8f87f6abb1faef7cd43bbfb2859260a33251d861eb0dab"; + revision = "3"; + editedCabalFile = "0i30cc85732v27baibdjy2kjjkdfv335ib5sk5ggwvsysvvvr66l"; + libraryHaskellDepends = [ base bytestring ]; + doHaddock = false; + doCheck = false; + homepage = "https://github.com/hvr/cryptohash-sha1"; + description = "Fast, pure and practical SHA-1 implementation"; + license = stdenv.lib.licenses.bsd3; + }) {}; + "cryptohash-sha256" = callPackage + ({ mkDerivation, base, bytestring, stdenv }: + mkDerivation { + pname = "cryptohash-sha256"; + version = "0.11.101.0"; + sha256 = "52756435dbea248e344fbcbcc5df5307f60dfacf337dfd11ae30f1c7a4da05dd"; + revision = "2"; + editedCabalFile = "0m5h68xm60wrjv88gg6cn1q5qki5674mxl4d6sn3vxpbcj9b5417"; + isLibrary = true; + isExecutable = true; + libraryHaskellDepends = [ base bytestring ]; + doHaddock = false; + doCheck = false; + homepage = "https://github.com/hvr/cryptohash-sha256"; + description = "Fast, pure and practical SHA-256 implementation"; + license = stdenv.lib.licenses.bsd3; + }) {}; + "cryptohash-sha512" = callPackage + ({ mkDerivation, base, bytestring, stdenv }: + mkDerivation { + pname = "cryptohash-sha512"; + version = "0.11.100.1"; + sha256 = "10698bb9575eaa414a65d9644caa9408f9276c63447406e0a4faef91db1071a9"; + revision = "3"; + editedCabalFile = "19m1fp0i7ba84aa72d5wf59c7j0p4yr1bc43in8pspgywhsr3lfl"; + libraryHaskellDepends = [ base bytestring ]; + doHaddock = false; + doCheck = false; + homepage = "https://github.com/hvr/cryptohash-sha512"; + description = "Fast, pure and practical SHA-512 implementation"; + license = stdenv.lib.licenses.bsd3; + }) {}; + "cryptonite" = callPackage + ({ mkDerivation, base, basement, bytestring, deepseq, ghc-prim + , integer-gmp, memory, stdenv + }: + mkDerivation { + pname = "cryptonite"; + version = "0.25"; + sha256 = "89be1a18af8730a7bfe4d718d7d5f6ce858e9df93a411566d15bf992db5a3c8c"; + libraryHaskellDepends = [ + base basement bytestring deepseq ghc-prim integer-gmp memory + ]; + doHaddock = false; + doCheck = false; + homepage = "https://github.com/haskell-crypto/cryptonite"; + description = "Cryptography Primitives sink"; + license = stdenv.lib.licenses.bsd3; + }) {}; + "cryptonite-conduit" = callPackage + ({ mkDerivation, base, bytestring, conduit, conduit-extra + , cryptonite, exceptions, memory, resourcet, stdenv, transformers + }: + mkDerivation { + pname = "cryptonite-conduit"; + version = "0.2.2"; + sha256 = "705d69ab3f79b7b8810c7b9e7da81a1c6686b6a4323b1e78150576a25a658dae"; + revision = "1"; + editedCabalFile = "1hh2nzfz4qpxgivfilgk4ll416lph8b2fdkzpzrmqfjglivydfmz"; + libraryHaskellDepends = [ + base bytestring conduit conduit-extra cryptonite exceptions memory + resourcet transformers + ]; + doHaddock = false; + doCheck = false; + homepage = "https://github.com/haskell-crypto/cryptonite-conduit"; + description = "cryptonite conduit"; + license = stdenv.lib.licenses.bsd3; + }) {}; + "cryptonite-openssl" = callPackage + ({ mkDerivation, base, basement, bytestring, cryptonite, memory + , openssl, stdenv + }: + mkDerivation { + pname = "cryptonite-openssl"; + version = "0.7"; + sha256 = "9e4e1c08264f26e602ef3054f3c827c3c65d153e5b9d68a0cb44f446ca0844f6"; + libraryHaskellDepends = [ + base basement bytestring cryptonite memory + ]; + librarySystemDepends = [ openssl ]; + doHaddock = false; + doCheck = false; + homepage = "https://github.com/haskell-crypto/cryptonite-openssl"; + description = "Crypto stuff using OpenSSL cryptographic library"; + license = stdenv.lib.licenses.bsd3; + }) {inherit (pkgs) openssl;}; + "csg" = callPackage + ({ mkDerivation, attoparsec, base, bytestring, containers, gloss + , gloss-raster, QuickCheck, simple-vec3, stdenv, strict + , system-filepath, transformers, turtle + }: + mkDerivation { + pname = "csg"; + version = "0.1.0.4"; + sha256 = "9d9537fec60bf44b98b87445b99e9f9300e317ca48402b8d26e059ec55a231b7"; + isLibrary = true; + isExecutable = true; + libraryHaskellDepends = [ + attoparsec base bytestring containers QuickCheck simple-vec3 strict + transformers + ]; + executableHaskellDepends = [ + base gloss gloss-raster QuickCheck simple-vec3 strict + system-filepath turtle + ]; + doHaddock = false; + doCheck = false; + homepage = "https://github.com/dzhus/csg#readme"; + description = "Analytical CSG (Constructive Solid Geometry) library"; + license = stdenv.lib.licenses.bsd3; + }) {}; + "csp" = callPackage + ({ mkDerivation, base, containers, mtl, nondeterminism, stdenv }: + mkDerivation { + pname = "csp"; + version = "1.4.0"; + sha256 = "08877f5ff196772675ac55b3c43ab39b527259114da8cfc36122c0cd7ce93496"; + libraryHaskellDepends = [ base containers mtl nondeterminism ]; + doHaddock = false; + doCheck = false; + description = "Discrete constraint satisfaction problem (CSP) solver"; + license = "LGPL"; + }) {}; + "css-syntax" = callPackage + ({ mkDerivation, attoparsec, base, bytestring, scientific, stdenv + , text + }: + mkDerivation { + pname = "css-syntax"; + version = "0.0.7"; + sha256 = "23fc1d47e94620eee586001c56c4e0c1ba17f5dab9c496245c7cff7ab9cd6064"; + libraryHaskellDepends = [ + attoparsec base bytestring scientific text + ]; + doHaddock = false; + doCheck = false; + description = "This package implments a parser for the CSS syntax"; + license = stdenv.lib.licenses.mit; + }) {}; + "css-text" = callPackage + ({ mkDerivation, attoparsec, base, stdenv, text }: + mkDerivation { + pname = "css-text"; + version = "0.1.3.0"; + sha256 = "5ff507bf3863219f41e7f2d215e5511fe15ee13d1e28bd3ee64e0b0b894bcd7a"; + libraryHaskellDepends = [ attoparsec base text ]; + doHaddock = false; + doCheck = false; + homepage = "https://github.com/yesodweb/css-text.git#readme"; + description = "CSS parser and renderer"; + license = stdenv.lib.licenses.mit; + }) {}; + "csv" = callPackage + ({ mkDerivation, base, filepath, parsec, stdenv }: + mkDerivation { + pname = "csv"; + version = "0.1.2"; + sha256 = "8cf43442325faa1368f9b55ad952beccf677d9980cdffa3d70a7f204a23ae600"; + libraryHaskellDepends = [ base filepath parsec ]; + doHaddock = false; + doCheck = false; + description = "CSV loader and dumper"; + license = stdenv.lib.licenses.mit; + }) {}; + "ctrie" = callPackage + ({ mkDerivation, atomic-primops, base, hashable, primitive, stdenv + }: + mkDerivation { + pname = "ctrie"; + version = "0.2"; + sha256 = "20e3a6d39f65ed1663ff5ab2c5431dc12b1c601d2133a74bc7bea1596ad9c814"; + libraryHaskellDepends = [ atomic-primops base hashable primitive ]; + doHaddock = false; + doCheck = false; + homepage = "https://github.com/mcschroeder/ctrie"; + description = "Non-blocking concurrent map"; + license = stdenv.lib.licenses.mit; + }) {}; + "cubicbezier" = callPackage + ({ mkDerivation, base, containers, fast-math, integration, matrices + , microlens, microlens-mtl, microlens-th, mtl, stdenv, vector + , vector-space + }: + mkDerivation { + pname = "cubicbezier"; + version = "0.6.0.5"; + sha256 = "c5c9825782d97c4059b2261dddd6471fdb270ddac0ff97d6d02d4f0d44b62758"; + libraryHaskellDepends = [ + base containers fast-math integration matrices microlens + microlens-mtl microlens-th mtl vector vector-space + ]; + doHaddock = false; + doCheck = false; + description = "Efficient manipulating of 2D cubic bezier curves"; + license = stdenv.lib.licenses.bsd3; + }) {}; + "cubicspline" = callPackage + ({ mkDerivation, base, hmatrix, safe, stdenv }: + mkDerivation { + pname = "cubicspline"; + version = "0.1.2"; + sha256 = "5b6ced9ca65b0d01ddceaf18605c8f915491d8d4a6aaef73475c4e8d4b1a9b79"; + libraryHaskellDepends = [ base hmatrix safe ]; + doHaddock = false; + doCheck = false; + description = "Natural cubic spline interpolation"; + license = stdenv.lib.licenses.bsd3; + }) {}; + "cue-sheet" = callPackage + ({ mkDerivation, base, bytestring, containers, data-default-class + , exceptions, megaparsec, mtl, QuickCheck, stdenv, text + }: + mkDerivation { + pname = "cue-sheet"; + version = "1.0.1"; + sha256 = "214a58e87a849c8311eb652ca215b4f5789d724e7499324544b3a01187577f8f"; + revision = "3"; + editedCabalFile = "14kgk1digf1vbsr7v5jvj8gajkx0rkn3zjl4m8csqhxalkaxa2zl"; + enableSeparateDataOutput = true; + libraryHaskellDepends = [ + base bytestring containers data-default-class exceptions megaparsec + mtl QuickCheck text + ]; + doHaddock = false; + doCheck = false; + homepage = "https://github.com/mrkkrp/cue-sheet"; + description = "Support for construction, rendering, and parsing of CUE sheets"; + license = stdenv.lib.licenses.bsd3; + }) {}; + "curl" = callPackage + ({ mkDerivation, base, bytestring, containers, curl, stdenv }: + mkDerivation { + pname = "curl"; + version = "1.3.8"; + sha256 = "9087c936bfcdb865bad3166baa3f12bf37acf076fa76010e3b5f82a1d485446e"; + revision = "1"; + editedCabalFile = "02sq2bjw5igc2k9f9ssh58k2ivii2xsvk5r00ky3cxh8j61qy86q"; + libraryHaskellDepends = [ base bytestring containers ]; + librarySystemDepends = [ curl ]; + doHaddock = false; + doCheck = false; + description = "Haskell binding to libcurl"; + license = stdenv.lib.licenses.bsd3; + }) {inherit (pkgs) curl;}; + "curl-runnings" = callPackage + ({ mkDerivation, aeson, aeson-pretty, base, bytestring + , case-insensitive, cmdargs, directory, hspec, hspec-expectations + , http-conduit, http-types, megaparsec, stdenv, text + , unordered-containers, vector, yaml + }: + mkDerivation { + pname = "curl-runnings"; + version = "0.6.0"; + sha256 = "44204017b483d96659948011a3abe78f05afa5b63cd561bcaa36ea5f21efac19"; + isLibrary = true; + isExecutable = true; + libraryHaskellDepends = [ + aeson aeson-pretty base bytestring case-insensitive directory hspec + hspec-expectations http-conduit http-types megaparsec text + unordered-containers vector yaml + ]; + executableHaskellDepends = [ base cmdargs text ]; + doHaddock = false; + doCheck = false; + homepage = "https://github.com/aviaviavi/curl-runnings#readme"; + description = "A framework for declaratively writing curl based API tests"; + license = stdenv.lib.licenses.mit; + }) {}; + "currencies" = callPackage + ({ mkDerivation, base, stdenv, text }: + mkDerivation { + pname = "currencies"; + version = "0.2.0.0"; + sha256 = "fb7292d4a5b9c4389690d1386fe24ce6a93eacbcfa952936ca6d4fd3afa98499"; + libraryHaskellDepends = [ base text ]; + doHaddock = false; + doCheck = false; + homepage = "https://github.com/alx741/currencies#readme"; + description = "Currencies representation, pretty printing and conversion"; + license = stdenv.lib.licenses.bsd3; + }) {}; + "currency" = callPackage + ({ mkDerivation, base, containers, hashable, iso3166-country-codes + , stdenv + }: + mkDerivation { + pname = "currency"; + version = "0.2.0.0"; + sha256 = "bcd517f3d9f47f0dd3c4e802143159239e4a90db2fc552be4a99d759ffe9417a"; + libraryHaskellDepends = [ + base containers hashable iso3166-country-codes + ]; + doHaddock = false; + doCheck = false; + homepage = "https://github.com/singpolyma/currency-haskell"; + description = "Types representing standard and non-standard currencies"; + license = "unknown"; + }) {}; + "cutter" = callPackage + ({ mkDerivation, base, bytestring, explicit-exception, spreadsheet + , stdenv, utility-ht + }: + mkDerivation { + pname = "cutter"; + version = "0.0"; + sha256 = "117319c36a20efea6d9edd0a8d902e37ec0386512f2eb8a6e5563411c00c6ac2"; + isLibrary = false; + isExecutable = true; + executableHaskellDepends = [ + base bytestring explicit-exception spreadsheet utility-ht + ]; + doHaddock = false; + doCheck = false; + description = "Cut files according to a position list"; + license = stdenv.lib.licenses.bsd3; + }) {}; + "cyclotomic" = callPackage + ({ mkDerivation, arithmoi, base, containers, stdenv }: + mkDerivation { + pname = "cyclotomic"; + version = "0.5.1"; + sha256 = "f72098bac1ec2fe561a2cc654334d8931b1a9074424be0081157901df56f5ffd"; + libraryHaskellDepends = [ arithmoi base containers ]; + doHaddock = false; + doCheck = false; + description = "A subfield of the complex numbers for exact calculation"; + license = stdenv.lib.licenses.gpl3; + }) {}; + "czipwith" = callPackage + ({ mkDerivation, base, stdenv, template-haskell }: + mkDerivation { + pname = "czipwith"; + version = "1.0.1.0"; + sha256 = "17b89163347298f78b6e9537b38d621286dff39bd105116a7e852774ccf92f68"; + libraryHaskellDepends = [ base template-haskell ]; + doHaddock = false; + doCheck = false; + homepage = "https://github.com/lspitzner/czipwith/"; + description = "CZipWith class and deriving via TH"; + license = stdenv.lib.licenses.bsd3; + }) {}; + "darcs" = callPackage + ({ mkDerivation, array, async, attoparsec, base, base16-bytestring + , binary, bytestring, Cabal, containers, cryptohash, curl + , data-ordlist, directory, fgl, filepath, graphviz, hashable + , haskeline, html, HTTP, mmap, mtl, network, network-uri, old-time + , parsec, process, random, regex-applicative, regex-compat-tdfa + , sandi, stdenv, stm, tar, terminfo, text, time, transformers, unix + , unix-compat, utf8-string, vector, zip-archive, zlib + }: + mkDerivation { + pname = "darcs"; + version = "2.14.1"; + sha256 = "61ddbc99acaf06df3a114437064e9241e0da467c23d1d3fb520a782eee32cd35"; + configureFlags = [ "-fforce-char8-encoding" "-flibrary" ]; + isLibrary = true; + isExecutable = true; + setupHaskellDepends = [ base Cabal directory filepath process ]; + libraryHaskellDepends = [ + array async attoparsec base base16-bytestring binary bytestring + containers cryptohash data-ordlist directory fgl filepath graphviz + hashable haskeline html HTTP mmap mtl network network-uri old-time + parsec process random regex-applicative regex-compat-tdfa sandi stm + tar terminfo text time transformers unix unix-compat utf8-string + vector zip-archive zlib + ]; + librarySystemDepends = [ curl ]; + executableHaskellDepends = [ base ]; + doHaddock = false; + doCheck = false; + postInstall = '' + mkdir -p $out/etc/bash_completion.d + mv contrib/darcs_completion $out/etc/bash_completion.d/darcs + ''; + homepage = "http://darcs.net/"; + description = "a distributed, interactive, smart revision control system"; + license = stdenv.lib.licenses.gpl2; + }) {inherit (pkgs) curl;}; + "data-accessor" = callPackage + ({ mkDerivation, array, base, containers, stdenv, transformers }: + mkDerivation { + pname = "data-accessor"; + version = "0.2.2.7"; + sha256 = "3465227ad5f81059a885d354e2f3c108d550287580e6939e18350fa65e78c2ed"; + libraryHaskellDepends = [ array base containers transformers ]; + doHaddock = false; + doCheck = false; + homepage = "http://www.haskell.org/haskellwiki/Record_access"; + description = "Utilities for accessing and manipulating fields of records"; + license = stdenv.lib.licenses.bsd3; + }) {}; + "data-accessor-mtl" = callPackage + ({ mkDerivation, base, data-accessor, mtl, stdenv }: + mkDerivation { + pname = "data-accessor-mtl"; + version = "0.2.0.4"; + sha256 = "10cf9166e2e046076b7e58987718e57b31408e7cada9f26c8ff111e0379814c5"; + libraryHaskellDepends = [ base data-accessor mtl ]; + doHaddock = false; + doCheck = false; + homepage = "http://www.haskell.org/haskellwiki/Record_access"; + description = "Use Accessor to access state in mtl State monad class"; + license = stdenv.lib.licenses.bsd3; + }) {}; + "data-accessor-template" = callPackage + ({ mkDerivation, base, data-accessor, stdenv, template-haskell + , utility-ht + }: + mkDerivation { + pname = "data-accessor-template"; + version = "0.2.1.15"; + sha256 = "802b7f55ef02773b44d42c19175f52b5ef1b122df0e91ad0ef9a8add4d33ba6f"; + libraryHaskellDepends = [ + base data-accessor template-haskell utility-ht + ]; + doHaddock = false; + doCheck = false; + homepage = "http://www.haskell.org/haskellwiki/Record_access"; + description = "Utilities for accessing and manipulating fields of records"; + license = stdenv.lib.licenses.bsd3; + }) {}; + "data-accessor-transformers" = callPackage + ({ mkDerivation, base, data-accessor, stdenv, transformers }: + mkDerivation { + pname = "data-accessor-transformers"; + version = "0.2.1.7"; + sha256 = "20c8823dc16c7ca6f55c64eb5564c9aae4b5565406987a046ded2ea73618e07a"; + libraryHaskellDepends = [ base data-accessor transformers ]; + doHaddock = false; + doCheck = false; + homepage = "http://www.haskell.org/haskellwiki/Record_access"; + description = "Use Accessor to access state in transformers State monad"; + license = stdenv.lib.licenses.bsd3; + }) {}; + "data-binary-ieee754" = callPackage + ({ mkDerivation, base, binary, stdenv }: + mkDerivation { + pname = "data-binary-ieee754"; + version = "0.4.4"; + sha256 = "59975abed8f4caa602f0780c10a9b2493479e6feb71ad189bb10c3ac5678df0a"; + libraryHaskellDepends = [ base binary ]; + doHaddock = false; + doCheck = false; + homepage = "https://john-millikin.com/software/data-binary-ieee754/"; + description = "Parser/Serialiser for IEEE-754 floating-point values"; + license = stdenv.lib.licenses.mit; + }) {}; + "data-bword" = callPackage + ({ mkDerivation, base, ghc-prim, stdenv }: + mkDerivation { + pname = "data-bword"; + version = "0.1.0.1"; + sha256 = "70f01f857865edcf1d1d20128b0202320b1635cc03b00954b6d1447cd699db7d"; + libraryHaskellDepends = [ base ghc-prim ]; + doHaddock = false; + doCheck = false; + homepage = "https://github.com/mvv/data-bword"; + description = "Extra operations on binary words of fixed length"; + license = stdenv.lib.licenses.bsd3; + }) {}; + "data-checked" = callPackage + ({ mkDerivation, base, deepseq, stdenv }: + mkDerivation { + pname = "data-checked"; + version = "0.3"; + sha256 = "dc87d09c7c8587c9e6e372166e8de3b42c2cd804a493ff100c253e4d713c5676"; + libraryHaskellDepends = [ base deepseq ]; + doHaddock = false; + doCheck = false; + homepage = "https://github.com/mvv/data-checked"; + description = "Type-indexed runtime-checked properties"; + license = stdenv.lib.licenses.bsd3; + }) {}; + "data-clist" = callPackage + ({ mkDerivation, base, deepseq, QuickCheck, stdenv }: + mkDerivation { + pname = "data-clist"; + version = "0.1.2.1"; + sha256 = "9a1882e286e2f5428517375e129dc3c6fb12114f360cd4a767e7a699d67c8416"; + libraryHaskellDepends = [ base deepseq QuickCheck ]; + doHaddock = false; + doCheck = false; + homepage = "https://github.com/sw17ch/data-clist"; + description = "Simple functional ring type"; + license = stdenv.lib.licenses.bsd3; + }) {}; + "data-default" = callPackage + ({ mkDerivation, base, data-default-class + , data-default-instances-containers, data-default-instances-dlist + , data-default-instances-old-locale, stdenv + }: + mkDerivation { + pname = "data-default"; + version = "0.7.1.1"; + sha256 = "b0f95d279cd75cacaa8152a01590dc3460f7134f6840b37052abb3ba3cb2a511"; + libraryHaskellDepends = [ + base data-default-class data-default-instances-containers + data-default-instances-dlist data-default-instances-old-locale + ]; + doHaddock = false; + doCheck = false; + description = "A class for types with a default value"; + license = stdenv.lib.licenses.bsd3; + }) {}; + "data-default-class" = callPackage + ({ mkDerivation, base, stdenv }: + mkDerivation { + pname = "data-default-class"; + version = "0.1.2.0"; + sha256 = "4f01b423f000c3e069aaf52a348564a6536797f31498bb85c3db4bd2d0973e56"; + libraryHaskellDepends = [ base ]; + doHaddock = false; + doCheck = false; + description = "A class for types with a default value"; + license = stdenv.lib.licenses.bsd3; + }) {}; + "data-default-instances-containers" = callPackage + ({ mkDerivation, base, containers, data-default-class, stdenv }: + mkDerivation { + pname = "data-default-instances-containers"; + version = "0.0.1"; + sha256 = "a55e07af005c9815d82f3fc95e125db82994377c9f4a769428878701d4ec081a"; + libraryHaskellDepends = [ base containers data-default-class ]; + doHaddock = false; + doCheck = false; + description = "Default instances for types in containers"; + license = stdenv.lib.licenses.bsd3; + }) {}; + "data-default-instances-dlist" = callPackage + ({ mkDerivation, base, data-default-class, dlist, stdenv }: + mkDerivation { + pname = "data-default-instances-dlist"; + version = "0.0.1"; + sha256 = "7d683711cbf08abd7adcd5ac2be825381308d220397315a5570fe61b719b5959"; + libraryHaskellDepends = [ base data-default-class dlist ]; + doHaddock = false; + doCheck = false; + description = "Default instances for types in dlist"; + license = stdenv.lib.licenses.bsd3; + }) {}; + "data-default-instances-old-locale" = callPackage + ({ mkDerivation, base, data-default-class, old-locale, stdenv }: + mkDerivation { + pname = "data-default-instances-old-locale"; + version = "0.0.1"; + sha256 = "60d3b02922958c4908d7bf2b24ddf61511665745f784227d206745784b0c0802"; + libraryHaskellDepends = [ base data-default-class old-locale ]; + doHaddock = false; + doCheck = false; + description = "Default instances for types in old-locale"; + license = stdenv.lib.licenses.bsd3; + }) {}; + "data-diverse" = callPackage + ({ mkDerivation, base, containers, deepseq, ghc-prim, stdenv + , tagged + }: + mkDerivation { + pname = "data-diverse"; + version = "4.6.0.0"; + sha256 = "094d44446b2429bad5707b4aef0f1f63a9d101739d9a244cb2131f7646eccbd4"; + libraryHaskellDepends = [ + base containers deepseq ghc-prim tagged + ]; + doHaddock = false; + doCheck = false; + homepage = "https://github.com/louispan/data-diverse#readme"; + description = "Extensible records and polymorphic variants"; + license = stdenv.lib.licenses.bsd3; + }) {}; + "data-diverse-lens" = callPackage + ({ mkDerivation, base, data-diverse, data-has, lens, profunctors + , stdenv, tagged + }: + mkDerivation { + pname = "data-diverse-lens"; + version = "4.3.0.0"; + sha256 = "97d049769f0a3693428bac8eb8de73e004f6fc9a1d0e3dc0c567f9d39f8ed986"; + libraryHaskellDepends = [ + base data-diverse data-has lens profunctors tagged + ]; + doHaddock = false; + doCheck = false; + homepage = "https://github.com/louispan/data-diverse-lens#readme"; + description = "Isos & Lens for Data.Diverse.Many and Prisms for Data.Diverse.Which"; + license = stdenv.lib.licenses.bsd3; + }) {}; + "data-dword" = callPackage + ({ mkDerivation, base, data-bword, ghc-prim, hashable, stdenv + , template-haskell + }: + mkDerivation { + pname = "data-dword"; + version = "0.3.1.2"; + sha256 = "6b677600221de86eaee21dd2d4c23c04320370c594a56f7bb3477ef4e4b69120"; + libraryHaskellDepends = [ + base data-bword ghc-prim hashable template-haskell + ]; + doHaddock = false; + doCheck = false; + homepage = "https://github.com/mvv/data-dword"; + description = "Stick two binary words together to get a bigger one"; + license = stdenv.lib.licenses.bsd3; + }) {}; + "data-endian" = callPackage + ({ mkDerivation, base, stdenv }: + mkDerivation { + pname = "data-endian"; + version = "0.1.1"; + sha256 = "8c1d4f30374f8331d31f4d7c6b39284331b6b9436e7b50f86547417bd05f2ac0"; + libraryHaskellDepends = [ base ]; + doHaddock = false; + doCheck = false; + homepage = "https://github.com/mvv/data-endian"; + description = "Endian-sensitive data"; + license = stdenv.lib.licenses.bsd3; + }) {}; + "data-fix" = callPackage + ({ mkDerivation, base, stdenv }: + mkDerivation { + pname = "data-fix"; + version = "0.2.0"; + sha256 = "7e5718055cb27ccac1e0bf25be70ba9bfe2b0d021cfe0a57a163355830341392"; + libraryHaskellDepends = [ base ]; + doHaddock = false; + doCheck = false; + homepage = "https://github.com/anton-k/data-fix"; + description = "Fixpoint data types"; + license = stdenv.lib.licenses.bsd3; + }) {}; + "data-has" = callPackage + ({ mkDerivation, base, stdenv }: + mkDerivation { + pname = "data-has"; + version = "0.3.0.0"; + sha256 = "3c25d403605ecb196df53c8c8fb7829cd7b6a88e0ea04b88038602ba7faa7379"; + libraryHaskellDepends = [ base ]; + doHaddock = false; + doCheck = false; + homepage = "https://github.com/winterland1989/data-has"; + description = "Simple extensible product"; + license = stdenv.lib.licenses.bsd3; + }) {}; + "data-hash" = callPackage + ({ mkDerivation, array, base, containers, stdenv }: + mkDerivation { + pname = "data-hash"; + version = "0.2.0.1"; + sha256 = "9117dd49013ca28ff188fc71c3595ac3af23d56d301c1f39bac93d44d8c60bbe"; + libraryHaskellDepends = [ array base containers ]; + doHaddock = false; + doCheck = false; + description = "Combinators for building fast hashing functions"; + license = stdenv.lib.licenses.bsd3; + }) {}; + "data-inttrie" = callPackage + ({ mkDerivation, base, stdenv }: + mkDerivation { + pname = "data-inttrie"; + version = "0.1.4"; + sha256 = "6b3a7d8d49b0676c09486ac08107b0e5a6dfd66d9627443be440e9fd11e7bd54"; + libraryHaskellDepends = [ base ]; + doHaddock = false; + doCheck = false; + homepage = "https://github.com/luqui/data-inttrie"; + description = "A simple lazy, infinite trie from integers"; + license = stdenv.lib.licenses.bsd3; + }) {}; + "data-lens-light" = callPackage + ({ mkDerivation, base, mtl, stdenv, template-haskell }: + mkDerivation { + pname = "data-lens-light"; + version = "0.1.2.2"; + sha256 = "72d3e6a73bde4a32eccd2024eb58ca96da962d4b659d76baed4ab37f28dcb36e"; + libraryHaskellDepends = [ base mtl template-haskell ]; + doHaddock = false; + doCheck = false; + homepage = "https://github.com/feuerbach/data-lens-light"; + description = "Simple lenses, minimum dependencies"; + license = stdenv.lib.licenses.mit; + }) {}; + "data-memocombinators" = callPackage + ({ mkDerivation, array, base, data-inttrie, stdenv }: + mkDerivation { + pname = "data-memocombinators"; + version = "0.5.1"; + sha256 = "b4341d2024b84a43f92edc39f6d6766bf4f0f00a40fd834b9f6f8e987b606ed7"; + libraryHaskellDepends = [ array base data-inttrie ]; + doHaddock = false; + doCheck = false; + homepage = "http://github.com/luqui/data-memocombinators"; + description = "Combinators for building memo tables"; + license = stdenv.lib.licenses.bsd3; + }) {}; + "data-msgpack" = callPackage + ({ mkDerivation, base, binary, bytestring, data-binary-ieee754 + , data-msgpack-types, groom, stdenv, text + }: + mkDerivation { + pname = "data-msgpack"; + version = "0.0.11"; + sha256 = "2904fc96617dc7885d0ebdac75149ed969f223af8a18628f72927da3832eb885"; + isLibrary = true; + isExecutable = true; + libraryHaskellDepends = [ + base binary bytestring data-binary-ieee754 data-msgpack-types text + ]; + executableHaskellDepends = [ base bytestring groom ]; + doHaddock = false; + doCheck = false; + homepage = "http://msgpack.org/"; + description = "A Haskell implementation of MessagePack"; + license = stdenv.lib.licenses.bsd3; + }) {}; + "data-msgpack-types" = callPackage + ({ mkDerivation, base, bytestring, containers, deepseq, hashable + , QuickCheck, stdenv, text, unordered-containers, vector, void + }: + mkDerivation { + pname = "data-msgpack-types"; + version = "0.0.1"; + sha256 = "529f139f089643a240c6e139b76c4ca1f18bce24dd352615584ebf041e94a898"; + libraryHaskellDepends = [ + base bytestring containers deepseq hashable QuickCheck text + unordered-containers vector void + ]; + doHaddock = false; + doCheck = false; + homepage = "http://msgpack.org/"; + description = "A Haskell implementation of MessagePack"; + license = stdenv.lib.licenses.bsd3; + }) {}; + "data-or" = callPackage + ({ mkDerivation, base, stdenv }: + mkDerivation { + pname = "data-or"; + version = "1.0.0.5"; + sha256 = "9defb64f1c7210460a940beb7f32ba1c79f363fbf3a5bd126feb876930c6e672"; + libraryHaskellDepends = [ base ]; + doHaddock = false; + doCheck = false; + homepage = "http://code.haskell.org/~wren/"; + description = "A data type for non-exclusive disjunction"; + license = stdenv.lib.licenses.bsd3; + }) {}; + "data-ordlist" = callPackage + ({ mkDerivation, base, stdenv }: + mkDerivation { + pname = "data-ordlist"; + version = "0.4.7.0"; + sha256 = "6f6c1e7a9a9155ad78ca78cb9abd6f7e2e1c78b3e549b179dc0874e6428f490d"; + libraryHaskellDepends = [ base ]; + doHaddock = false; + doCheck = false; + description = "Set and bag operations on ordered lists"; + license = stdenv.lib.licenses.bsd3; + }) {}; + "data-ref" = callPackage + ({ mkDerivation, base, stdenv, stm, transformers }: + mkDerivation { + pname = "data-ref"; + version = "0.0.1.1"; + sha256 = "a4dabee83c7419199791d0ebf7870f926b1ca834a361ecfeb3c134f7fa64f268"; + libraryHaskellDepends = [ base stm transformers ]; + doHaddock = false; + doCheck = false; + homepage = "http://wiki.haskell.org/Mutable_variable"; + description = "Unify STRef and IORef in plain Haskell 98"; + license = stdenv.lib.licenses.bsd3; + }) {}; + "data-reify" = callPackage + ({ mkDerivation, base, containers, stdenv }: + mkDerivation { + pname = "data-reify"; + version = "0.6.1"; + sha256 = "61350a1e96cb1276c2b6b8b13fa1bade5d4e63c702509a3f5e90bbc19ad9b202"; + revision = "1"; + editedCabalFile = "0ixlibqrz7fd4bg9vnnd431a9kqvz4ajx8sbgyvpx9l2yjrabwzp"; + isLibrary = true; + isExecutable = true; + libraryHaskellDepends = [ base containers ]; + doHaddock = false; + doCheck = false; + homepage = "http://ku-fpg.github.io/software/data-reify/"; + description = "Reify a recursive data structure into an explicit graph"; + license = stdenv.lib.licenses.bsd3; + }) {}; + "data-serializer" = callPackage + ({ mkDerivation, base, binary, bytestring, cereal, data-endian + , parsers, semigroups, split, stdenv + }: + mkDerivation { + pname = "data-serializer"; + version = "0.3.4"; + sha256 = "e793156aa2262ca294183a9d045f37e6ff2070825b40d2ffe5a8d64e0b455ec6"; + libraryHaskellDepends = [ + base binary bytestring cereal data-endian parsers semigroups split + ]; + doHaddock = false; + doCheck = false; + homepage = "https://github.com/mvv/data-serializer"; + description = "Common API for serialization libraries"; + license = stdenv.lib.licenses.bsd3; + }) {}; + "data-textual" = callPackage + ({ mkDerivation, base, bytestring, parsers, stdenv, text + , text-latin1, text-printer + }: + mkDerivation { + pname = "data-textual"; + version = "0.3.0.2"; + sha256 = "44c530b081a486c50d668004637814223d1f1890716d39f7b692c83644d29830"; + libraryHaskellDepends = [ + base bytestring parsers text text-latin1 text-printer + ]; + doHaddock = false; + doCheck = false; + homepage = "https://github.com/mvv/data-textual"; + description = "Human-friendly textual representations"; + license = stdenv.lib.licenses.bsd3; + }) {}; + "data-tree-print" = callPackage + ({ mkDerivation, base, pretty, stdenv, syb }: + mkDerivation { + pname = "data-tree-print"; + version = "0.1.0.1"; + sha256 = "cec8c278e1033695ce97e2d7bf5db2b1b45a764976e59d06c67a6fe4fc5401fe"; + libraryHaskellDepends = [ base pretty syb ]; + doHaddock = false; + doCheck = false; + homepage = "https://github.com/lspitzner/data-tree-print"; + description = "Print Data instances as a nested tree"; + license = stdenv.lib.licenses.bsd3; + }) {}; + "datadog" = callPackage + ({ mkDerivation, aeson, auto-update, base, buffer-builder + , bytestring, dlist, http-client, http-client-tls, http-types, lens + , lifted-base, monad-control, network, old-locale, stdenv, text + , time, transformers-base, unordered-containers, vector + }: + mkDerivation { + pname = "datadog"; + version = "0.2.2.0"; + sha256 = "450fb6fba21d9739c8269f167ecf084d966e2248084386ab5c04b2748b4b6944"; + libraryHaskellDepends = [ + aeson auto-update base buffer-builder bytestring dlist http-client + http-client-tls http-types lens lifted-base monad-control network + old-locale text time transformers-base unordered-containers vector + ]; + doHaddock = false; + doCheck = false; + homepage = "https://github.com/iand675/datadog"; + description = "Datadog client for Haskell. Supports both the HTTP API and StatsD."; + license = stdenv.lib.licenses.mit; + }) {}; + "datasets" = callPackage + ({ mkDerivation, aeson, attoparsec, base, bytestring, cassava + , directory, file-embed, filepath, hashable, microlens, stdenv + , stringsearch, text, time, vector, wreq + }: + mkDerivation { + pname = "datasets"; + version = "0.2.5"; + sha256 = "9a9139130936102bbfa60324e1ed7f9fd5b9a68db096917f589e8bb07999fdba"; + libraryHaskellDepends = [ + aeson attoparsec base bytestring cassava directory file-embed + filepath hashable microlens stringsearch text time vector wreq + ]; + doHaddock = false; + doCheck = false; + homepage = "https://github.com/diffusionkinetics/open/datasets"; + description = "Classical data sets for statistics and machine learning"; + license = stdenv.lib.licenses.mit; + }) {}; + "dataurl" = callPackage + ({ mkDerivation, attoparsec, base, base64-bytestring, bytestring + , stdenv, text + }: + mkDerivation { + pname = "dataurl"; + version = "0.1.0.0"; + sha256 = "b1e72b48dbe72520f0b43b06ae75cb025e9750213982583f527e16b605660fb2"; + libraryHaskellDepends = [ + attoparsec base base64-bytestring bytestring text + ]; + doHaddock = false; + doCheck = false; + homepage = "http://github.com/agrafix/dataurl#readme"; + description = "Handle data-urls"; + license = stdenv.lib.licenses.mit; + }) {}; + "dawg-ord" = callPackage + ({ mkDerivation, base, containers, mtl, stdenv, transformers + , vector + }: + mkDerivation { + pname = "dawg-ord"; + version = "0.5.1.0"; + sha256 = "d9129acfb71ce41b6994d2c72a040319fc85af408226122d3958d5617e8922e9"; + libraryHaskellDepends = [ + base containers mtl transformers vector + ]; + doHaddock = false; + doCheck = false; + homepage = "https://github.com/kawu/dawg-ord"; + description = "Directed acyclic word graphs"; + license = stdenv.lib.licenses.bsd3; + }) {}; + "dbcleaner" = callPackage + ({ mkDerivation, base, postgresql-simple, stdenv, text }: + mkDerivation { + pname = "dbcleaner"; + version = "0.1.3"; + sha256 = "0817b0e1698d8d48ac58d631f51dc6e34663f4e97af7bac3fd03e31349830f35"; + libraryHaskellDepends = [ base postgresql-simple text ]; + doHaddock = false; + doCheck = false; + description = "Clean database tables automatically around hspec tests"; + license = stdenv.lib.licenses.mit; + }) {}; + "dbus" = callPackage + ({ mkDerivation, base, bytestring, cereal, containers, deepseq + , filepath, lens, libxml-sax, network, parsec, random, split + , stdenv, template-haskell, text, th-lift, transformers, unix + , vector, xml-types + }: + mkDerivation { + pname = "dbus"; + version = "1.0.1"; + sha256 = "a325b5c6958a343b30fd378d54ac01f9db889a4d7cadb14b2103da7ef4e7e8f5"; + libraryHaskellDepends = [ + base bytestring cereal containers deepseq filepath lens libxml-sax + network parsec random split template-haskell text th-lift + transformers unix vector xml-types + ]; + doHaddock = false; + doCheck = false; + homepage = "https://github.com/rblaze/haskell-dbus#readme"; + description = "A client library for the D-Bus IPC system"; + license = stdenv.lib.licenses.asl20; + }) {}; + "debian-build" = callPackage + ({ mkDerivation, base, directory, filepath, process, split, stdenv + , transformers + }: + mkDerivation { + pname = "debian-build"; + version = "0.10.1.1"; + sha256 = "d3e6a924367ddd7087f00ac448afb3f12cb5a70392194f1bcd15a33b81766537"; + isLibrary = true; + isExecutable = true; + libraryHaskellDepends = [ + base directory filepath process split transformers + ]; + executableHaskellDepends = [ base filepath transformers ]; + doHaddock = false; + doCheck = false; + homepage = "http://twitter.com/khibino/"; + description = "Debian package build sequence tools"; + license = stdenv.lib.licenses.bsd3; + }) {}; + "debug" = callPackage + ({ mkDerivation, aeson, base, bytestring, clock, containers + , deepseq, directory, extra, filepath, ghc-prim, hashable, Hoed + , libgraph, open-browser, prettyprinter + , prettyprinter-compat-ansi-wl-pprint, stdenv, template-haskell + , text, uniplate, unordered-containers, vector, yaml + }: + mkDerivation { + pname = "debug"; + version = "0.1.1"; + sha256 = "330f44c6341833c5e0cccf08fa7674dd54f14a843a2b5703e25ce08ffed49248"; + isLibrary = true; + isExecutable = true; + enableSeparateDataOutput = true; + libraryHaskellDepends = [ + aeson base bytestring clock containers deepseq directory extra + ghc-prim hashable Hoed libgraph open-browser prettyprinter + prettyprinter-compat-ansi-wl-pprint template-haskell text uniplate + unordered-containers vector + ]; + executableHaskellDepends = [ aeson base directory filepath yaml ]; + doHaddock = false; + doCheck = false; + homepage = "https://github.com/ndmitchell/debug"; + description = "Simple trace-based debugger"; + license = stdenv.lib.licenses.bsd3; + }) {}; + "debug-trace-var" = callPackage + ({ mkDerivation, base, stdenv, template-haskell, unicode-show }: + mkDerivation { + pname = "debug-trace-var"; + version = "0.2.0"; + sha256 = "174f79d31d905c99adc880dd79899b3f335e1a7c552a7bcff8664abbffb6b489"; + libraryHaskellDepends = [ base template-haskell unicode-show ]; + doHaddock = false; + doCheck = false; + homepage = "https://github.com/ncaq/debug-trace-var#readme"; + description = "You do not have to write variable names twice in Debug.Trace"; + license = stdenv.lib.licenses.mit; + }) {}; + "declarative" = callPackage + ({ mkDerivation, base, hasty-hamiltonian, kan-extensions, lens + , mcmc-types, mighty-metropolis, mwc-probability, pipes, primitive + , speedy-slice, stdenv, transformers + }: + mkDerivation { + pname = "declarative"; + version = "0.5.2"; + sha256 = "1ea8cf5eb0283ed9d9a7e1d46e5386960587c1671f7ce568d6eaf1d1b8ba9a04"; + libraryHaskellDepends = [ + base hasty-hamiltonian kan-extensions lens mcmc-types + mighty-metropolis mwc-probability pipes primitive speedy-slice + transformers + ]; + doHaddock = false; + doCheck = false; + homepage = "http://github.com/jtobin/declarative"; + description = "DIY Markov Chains"; + license = stdenv.lib.licenses.mit; + }) {}; + "deepseq-generics" = callPackage + ({ mkDerivation, base, deepseq, ghc-prim, stdenv }: + mkDerivation { + pname = "deepseq-generics"; + version = "0.2.0.0"; + sha256 = "b0b3ef5546c0768ef9194519a90c629f8f2ba0348487e620bb89d512187c7c9d"; + revision = "3"; + editedCabalFile = "0734x6dm7ny1422n5ik4agzmjybvd3yybj1mnrc8z0kb89xdprcs"; + libraryHaskellDepends = [ base deepseq ghc-prim ]; + doHaddock = false; + doCheck = false; + homepage = "https://github.com/hvr/deepseq-generics"; + description = "GHC.Generics-based Control.DeepSeq.rnf implementation"; + license = stdenv.lib.licenses.bsd3; + }) {}; + "dejafu" = callPackage + ({ mkDerivation, base, concurrency, containers, contravariant + , deepseq, exceptions, leancheck, profunctors, random, stdenv + , transformers + }: + mkDerivation { + pname = "dejafu"; + version = "1.11.0.3"; + sha256 = "dd2e23a975eddc01d4f281f6c9c19a0e815ed39dd1546a8a9661b62936074aa4"; + libraryHaskellDepends = [ + base concurrency containers contravariant deepseq exceptions + leancheck profunctors random transformers + ]; + doHaddock = false; + doCheck = false; + homepage = "https://github.com/barrucadu/dejafu"; + description = "A library for unit-testing concurrent programs"; + license = stdenv.lib.licenses.mit; + }) {}; + "dependent-map" = callPackage + ({ mkDerivation, base, containers, dependent-sum, stdenv }: + mkDerivation { + pname = "dependent-map"; + version = "0.2.4.0"; + sha256 = "5db396bdb5d156434af920c074316c3b84b4d39ba8e1cd349c7bb6679cb28246"; + libraryHaskellDepends = [ base containers dependent-sum ]; + doHaddock = false; + doCheck = false; + homepage = "https://github.com/mokus0/dependent-map"; + description = "Dependent finite maps (partial dependent products)"; + license = "unknown"; + }) {}; + "dependent-sum" = callPackage + ({ mkDerivation, base, stdenv }: + mkDerivation { + pname = "dependent-sum"; + version = "0.4"; + sha256 = "a8deecb4153a1878173f8d0a18de0378ab068bc15e5035b9e4cb478e8e4e1a1e"; + libraryHaskellDepends = [ base ]; + doHaddock = false; + doCheck = false; + homepage = "https://github.com/mokus0/dependent-sum"; + description = "Dependent sum type"; + license = stdenv.lib.licenses.publicDomain; + }) {}; + "dependent-sum-template" = callPackage + ({ mkDerivation, base, dependent-sum, stdenv, template-haskell + , th-extras + }: + mkDerivation { + pname = "dependent-sum-template"; + version = "0.0.0.6"; + sha256 = "994cb4891949cad1b9ca268052377c58c174f77a469cae44742ac83727be91ad"; + libraryHaskellDepends = [ + base dependent-sum template-haskell th-extras + ]; + doHaddock = false; + doCheck = false; + homepage = "/dev/null"; + description = "Template Haskell code to generate instances of classes in dependent-sum package"; + license = stdenv.lib.licenses.publicDomain; + }) {}; + "deque" = callPackage + ({ mkDerivation, base, stdenv }: + mkDerivation { + pname = "deque"; + version = "0.2.1"; + sha256 = "019d197e306724f1a09ad53ab9309cee1cfbbf5456f2956d3ab52a59fe523264"; + libraryHaskellDepends = [ base ]; + doHaddock = false; + doCheck = false; + homepage = "https://github.com/nikita-volkov/deque"; + description = "Double-ended queue"; + license = stdenv.lib.licenses.mit; + }) {}; + "deriving-compat" = callPackage + ({ mkDerivation, base, containers, ghc-boot-th, ghc-prim, stdenv + , template-haskell, th-abstraction, transformers + , transformers-compat + }: + mkDerivation { + pname = "deriving-compat"; + version = "0.5.1"; + sha256 = "7e17ab1664c32026059f35776d2f8b57fc5386b254d8b67e00061e122aafb3a2"; + libraryHaskellDepends = [ + base containers ghc-boot-th ghc-prim template-haskell + th-abstraction transformers transformers-compat + ]; + doHaddock = false; + doCheck = false; + homepage = "https://github.com/haskell-compat/deriving-compat"; + description = "Backports of GHC deriving extensions"; + license = stdenv.lib.licenses.bsd3; + }) {}; + "derulo" = callPackage + ({ mkDerivation, base, stdenv }: + mkDerivation { + pname = "derulo"; + version = "1.0.3"; + sha256 = "758ccf8f017acc7c1c3cf7e1e603c79cf85827e0f807cd9bed82287308d95efc"; + isLibrary = true; + isExecutable = true; + libraryHaskellDepends = [ base ]; + executableHaskellDepends = [ base ]; + doHaddock = false; + doCheck = false; + homepage = "https://github.com/tfausak/derulo#readme"; + description = "Parse and render JSON simply"; + license = stdenv.lib.licenses.mit; + }) {}; + "detour-via-sci" = callPackage + ({ mkDerivation, aeson, base, cassava, newtype, scientific + , siggy-chardust, stdenv, template-haskell + }: + mkDerivation { + pname = "detour-via-sci"; + version = "1.0.0"; + sha256 = "451e1194f7bf6a7dea02379679c790313cc20423271fd8e98f164c942e3d81e4"; + revision = "1"; + editedCabalFile = "00dj8vf9gg9ww37sir6mblf3xhcpam8qgfz5bfana23arhf2cixj"; + libraryHaskellDepends = [ + aeson base cassava newtype scientific siggy-chardust + template-haskell + ]; + doHaddock = false; + doCheck = false; + homepage = "https://github.com/blockscope/flare-timing/tree/master/detour-via-sci#readme"; + description = "JSON and CSV encoding for rationals as decimal point numbers"; + license = stdenv.lib.licenses.mpl20; + }) {}; + "df1" = callPackage + ({ mkDerivation, attoparsec, base, bytestring, containers, stdenv + , text, time + }: + mkDerivation { + pname = "df1"; + version = "0.1.1"; + sha256 = "362409d7f47f69f9afc746b87c2380bc6d1536c1e9d1b8b77963b83504722fe3"; + libraryHaskellDepends = [ + attoparsec base bytestring containers text time + ]; + doHaddock = false; + doCheck = false; + homepage = "https://github.com/k0001/di"; + description = "Type, render and parse the df1 hierarchical structured log format"; + license = stdenv.lib.licenses.bsd3; + }) {}; + "dhall" = callPackage + ({ mkDerivation, ansi-terminal, base, bytestring, case-insensitive + , containers, contravariant, cryptonite, Diff, directory + , exceptions, filepath, haskeline, http-client, http-client-tls + , insert-ordered-containers, lens-family-core, megaparsec, memory + , mtl, optparse-applicative, parsers, prettyprinter + , prettyprinter-ansi-terminal, repline, scientific, stdenv + , template-haskell, text, transformers, unordered-containers + , vector + }: + mkDerivation { + pname = "dhall"; + version = "1.15.1"; + sha256 = "ea3bb3b6a006b82e0286d72757ba9969f6ee292ef12eea2376939ba219c88e30"; + isLibrary = true; + isExecutable = true; + libraryHaskellDepends = [ + ansi-terminal base bytestring case-insensitive containers + contravariant cryptonite Diff directory exceptions filepath + haskeline http-client http-client-tls insert-ordered-containers + lens-family-core megaparsec memory mtl optparse-applicative parsers + prettyprinter prettyprinter-ansi-terminal repline scientific + template-haskell text transformers unordered-containers vector + ]; + executableHaskellDepends = [ base ]; + doHaddock = false; + doCheck = false; + description = "A configuration language guaranteed to terminate"; + license = stdenv.lib.licenses.bsd3; + }) {}; + "dhall-bash" = callPackage + ({ mkDerivation, base, bytestring, containers, dhall + , insert-ordered-containers, neat-interpolation, optparse-generic + , shell-escape, stdenv, text + }: + mkDerivation { + pname = "dhall-bash"; + version = "1.0.14"; + sha256 = "8d20a586afffc2e1b1470168743ead24387e2cc5149e8f63e799220c6da5b8ff"; + revision = "1"; + editedCabalFile = "1ih8w5q0gnys02hv7hnjxxapfqw4gqmd9xfxn7a05cg2gb30mapr"; + isLibrary = true; + isExecutable = true; + libraryHaskellDepends = [ + base bytestring containers dhall insert-ordered-containers + neat-interpolation shell-escape text + ]; + executableHaskellDepends = [ + base bytestring dhall optparse-generic text + ]; + doHaddock = false; + doCheck = false; + description = "Compile Dhall to Bash"; + license = stdenv.lib.licenses.bsd3; + }) {}; + "dhall-json" = callPackage + ({ mkDerivation, aeson, aeson-pretty, base, bytestring, dhall + , insert-ordered-containers, optparse-applicative, stdenv, text + , unordered-containers, yaml + }: + mkDerivation { + pname = "dhall-json"; + version = "1.2.1"; + sha256 = "999cd25e03d9c859a7df53b535ca59a1a2cdc1b728162c87d23f3b08fc45c87d"; + revision = "1"; + editedCabalFile = "06dr99jwvkabav7krb2dj0c037rdrv5mmm9p8ycvx4b7a1zd86h3"; + isLibrary = true; + isExecutable = true; + libraryHaskellDepends = [ + aeson base dhall insert-ordered-containers optparse-applicative + text unordered-containers + ]; + executableHaskellDepends = [ + aeson aeson-pretty base bytestring dhall optparse-applicative text + yaml + ]; + doHaddock = false; + doCheck = false; + description = "Compile Dhall to JSON or YAML"; + license = stdenv.lib.licenses.bsd3; + }) {}; + "dhall-text" = callPackage + ({ mkDerivation, base, dhall, optparse-applicative, stdenv, text }: + mkDerivation { + pname = "dhall-text"; + version = "1.0.11"; + sha256 = "61817e1b8c6c0e77a042cadc119c59b94c4577906d35e34738a332c86ac97a7d"; + revision = "1"; + editedCabalFile = "0lrp1aknia3y4cz87vh14ns3f273lbca09ssz138wlf3266ka613"; + isLibrary = false; + isExecutable = true; + executableHaskellDepends = [ + base dhall optparse-applicative text + ]; + doHaddock = false; + doCheck = false; + description = "Template text using Dhall"; + license = stdenv.lib.licenses.bsd3; + }) {}; + "di" = callPackage + ({ mkDerivation, base, df1, di-core, di-df1, di-handle, di-monad + , exceptions, stdenv + }: + mkDerivation { + pname = "di"; + version = "1.0.1"; + sha256 = "2913ed3a7b8db8d9160a6aec510a35e5f8199c962c0e115f84c0c88d8236ec40"; + libraryHaskellDepends = [ + base df1 di-core di-df1 di-handle di-monad exceptions + ]; + doHaddock = false; + doCheck = false; + homepage = "https://github.com/k0001/di"; + description = "Typeful hierarchical structured logging using di, mtl and df1"; + license = stdenv.lib.licenses.bsd3; + }) {}; + "di-core" = callPackage + ({ mkDerivation, base, containers, exceptions, stdenv, stm, time }: + mkDerivation { + pname = "di-core"; + version = "1.0"; + sha256 = "d2e872efbc661be995c220d7f3cf839438b045e86848e0ecaf0a61c1c27e8f6a"; + libraryHaskellDepends = [ base containers exceptions stm time ]; + doHaddock = false; + doCheck = false; + homepage = "https://github.com/k0001/di"; + description = "Typeful hierarchical structured logging without monad towers"; + license = stdenv.lib.licenses.bsd3; + }) {}; + "di-df1" = callPackage + ({ mkDerivation, base, df1, di-core, di-handle, di-monad, stdenv + , stm + }: + mkDerivation { + pname = "di-df1"; + version = "1.0.2"; + sha256 = "d0518d17165c6f9baa60772526f263b11128a17edd1f214c91f0e42aad11b3c6"; + libraryHaskellDepends = [ + base df1 di-core di-handle di-monad stm + ]; + doHaddock = false; + doCheck = false; + homepage = "https://github.com/k0001/di"; + description = "Write logs in the df1 format using the di logging framework"; + license = stdenv.lib.licenses.bsd3; + }) {}; + "di-handle" = callPackage + ({ mkDerivation, base, bytestring, di-core, exceptions, stdenv + , unix + }: + mkDerivation { + pname = "di-handle"; + version = "1.0"; + sha256 = "cd081f53824a173b30550ae9dbea744a2e7ac8931092d1f1b246b9bd5bb092ec"; + libraryHaskellDepends = [ + base bytestring di-core exceptions unix + ]; + doHaddock = false; + doCheck = false; + homepage = "https://github.com/k0001/di"; + description = "IO support for file handles in di-core"; + license = stdenv.lib.licenses.bsd3; + }) {}; + "di-monad" = callPackage + ({ mkDerivation, base, containers, di-core, exceptions, mtl, pipes + , stdenv, stm, transformers + }: + mkDerivation { + pname = "di-monad"; + version = "1.0.2"; + sha256 = "b84d79e180778720b6aa31bf5e7f72db809378f92c97c391828639c876164ee8"; + libraryHaskellDepends = [ + base containers di-core exceptions mtl pipes stm transformers + ]; + doHaddock = false; + doCheck = false; + homepage = "https://github.com/k0001/di"; + description = "mtl flavoured typeful hierarchical structured logging for di-core"; + license = stdenv.lib.licenses.bsd3; + }) {}; + "diagrams" = callPackage + ({ mkDerivation, diagrams-contrib, diagrams-core, diagrams-lib + , diagrams-svg, stdenv + }: + mkDerivation { + pname = "diagrams"; + version = "1.4"; + sha256 = "8608f6fa682b8c43b9fbe7c42c033c7a6de0680bd7383f6a81ea8bca37999139"; + libraryHaskellDepends = [ + diagrams-contrib diagrams-core diagrams-lib diagrams-svg + ]; + doHaddock = false; + doCheck = false; + homepage = "http://projects.haskell.org/diagrams"; + description = "Embedded domain-specific language for declarative vector graphics"; + license = stdenv.lib.licenses.bsd3; + }) {}; + "diagrams-builder" = callPackage + ({ mkDerivation, base, base-orphans, bytestring, cmdargs + , diagrams-cairo, diagrams-lib, diagrams-postscript + , diagrams-rasterific, diagrams-svg, directory, exceptions + , filepath, hashable, haskell-src-exts, haskell-src-exts-simple + , hint, JuicyPixels, lens, mtl, split, stdenv, svg-builder + , transformers + }: + mkDerivation { + pname = "diagrams-builder"; + version = "0.8.0.3"; + sha256 = "3a80ac090b73838de3d2a9d006d128cb7903852b2f8df24db30855f729b30abd"; + revision = "1"; + editedCabalFile = "0cdnriavw7y0cr12n60vd0hwcyi09vkx5zjr47af3bj00lq1v9hk"; + configureFlags = [ "-fcairo" "-fps" "-frasterific" "-fsvg" ]; + isLibrary = true; + isExecutable = true; + libraryHaskellDepends = [ + base base-orphans cmdargs diagrams-lib directory exceptions + filepath hashable haskell-src-exts haskell-src-exts-simple hint + lens mtl split transformers + ]; + executableHaskellDepends = [ + base bytestring cmdargs diagrams-cairo diagrams-lib + diagrams-postscript diagrams-rasterific diagrams-svg directory + filepath JuicyPixels lens svg-builder + ]; + doHaddock = false; + doCheck = false; + homepage = "http://projects.haskell.org/diagrams"; + description = "hint-based build service for the diagrams graphics EDSL"; + license = stdenv.lib.licenses.bsd3; + }) {}; + "diagrams-cairo" = callPackage + ({ mkDerivation, array, base, bytestring, cairo, colour, containers + , data-default-class, diagrams-core, diagrams-lib, filepath + , hashable, JuicyPixels, lens, mtl, optparse-applicative, pango + , split, statestack, stdenv, transformers, unix, vector + }: + mkDerivation { + pname = "diagrams-cairo"; + version = "1.4.1"; + sha256 = "df64fd41f4c8eb37e2edcc458c4d49c574d22cf7ca2ef7ceb5de4a79f6436658"; + libraryHaskellDepends = [ + array base bytestring cairo colour containers data-default-class + diagrams-core diagrams-lib filepath hashable JuicyPixels lens mtl + optparse-applicative pango split statestack transformers unix + vector + ]; + doHaddock = false; + doCheck = false; + homepage = "http://projects.haskell.org/diagrams"; + description = "Cairo backend for diagrams drawing EDSL"; + license = stdenv.lib.licenses.bsd3; + }) {}; + "diagrams-canvas" = callPackage + ({ mkDerivation, base, blank-canvas, cmdargs, containers + , data-default-class, diagrams-core, diagrams-lib, lens, mtl + , NumInstances, optparse-applicative, statestack, stdenv, text + }: + mkDerivation { + pname = "diagrams-canvas"; + version = "1.4.1"; + sha256 = "92def277f039ab95428bb3339f66e6068dd6c1699f24a4c76ca8894004d915c6"; + libraryHaskellDepends = [ + base blank-canvas cmdargs containers data-default-class + diagrams-core diagrams-lib lens mtl NumInstances + optparse-applicative statestack text + ]; + doHaddock = false; + doCheck = false; + homepage = "http://projects.haskell.org/diagrams/"; + description = "HTML5 canvas backend for diagrams drawing EDSL"; + license = stdenv.lib.licenses.bsd3; + }) {}; + "diagrams-contrib" = callPackage + ({ mkDerivation, base, circle-packing, colour, containers + , cubicbezier, data-default, data-default-class, diagrams-core + , diagrams-lib, diagrams-solve, force-layout, hashable, lens + , linear, mfsolve, MonadRandom, monoid-extras, mtl, mtl-compat + , parsec, random, semigroups, split, stdenv, text + }: + mkDerivation { + pname = "diagrams-contrib"; + version = "1.4.3"; + sha256 = "65fba87bb7752b1053fb3ab8e4ae30d5920208ff48441c4d8969cdbe73402007"; + revision = "1"; + editedCabalFile = "16ici9kx7cnva1ihhin5nyc1icif17yks3nwcxxzqxjjw556vpig"; + libraryHaskellDepends = [ + base circle-packing colour containers cubicbezier data-default + data-default-class diagrams-core diagrams-lib diagrams-solve + force-layout hashable lens linear mfsolve MonadRandom monoid-extras + mtl mtl-compat parsec random semigroups split text + ]; + doHaddock = false; + doCheck = false; + homepage = "http://projects.haskell.org/diagrams/"; + description = "Collection of user contributions to diagrams EDSL"; + license = stdenv.lib.licenses.bsd3; + }) {}; + "diagrams-core" = callPackage + ({ mkDerivation, adjunctions, base, containers, distributive + , dual-tree, lens, linear, monoid-extras, mtl, profunctors + , semigroups, stdenv, unordered-containers + }: + mkDerivation { + pname = "diagrams-core"; + version = "1.4.1.1"; + sha256 = "a182e9f99e3664efdfa5e18f4b403703112fba33c5b877a91c9eabed1d8bb682"; + revision = "2"; + editedCabalFile = "1lf7xcq42l4hjksgp1nhj7600shvw9q5a27bh729fyfphmvv3xkf"; + libraryHaskellDepends = [ + adjunctions base containers distributive dual-tree lens linear + monoid-extras mtl profunctors semigroups unordered-containers + ]; + doHaddock = false; + doCheck = false; + homepage = "http://projects.haskell.org/diagrams"; + description = "Core libraries for diagrams EDSL"; + license = stdenv.lib.licenses.bsd3; + }) {}; + "diagrams-gtk" = callPackage + ({ mkDerivation, base, cairo, diagrams-cairo, diagrams-lib, gtk + , stdenv + }: + mkDerivation { + pname = "diagrams-gtk"; + version = "1.4"; + sha256 = "b66bde621a09b79b99185af50b2d1ed0b2bd3988c95ed27c7e92e5383917eae9"; + revision = "2"; + editedCabalFile = "0hblrqvwk1pbssaci97v36r71kpm7kkcghh5ijmq52lmjfq72jqm"; + libraryHaskellDepends = [ + base cairo diagrams-cairo diagrams-lib gtk + ]; + doHaddock = false; + doCheck = false; + homepage = "http://projects.haskell.org/diagrams/"; + description = "Backend for rendering diagrams directly to GTK windows"; + license = stdenv.lib.licenses.bsd3; + }) {}; + "diagrams-html5" = callPackage + ({ mkDerivation, base, cmdargs, containers, data-default-class + , diagrams-core, diagrams-lib, lens, mtl, NumInstances + , optparse-applicative, split, statestack, static-canvas, stdenv + , text + }: + mkDerivation { + pname = "diagrams-html5"; + version = "1.4.1"; + sha256 = "e8eed3f8ae1176099c96806281262227618d9e9f40512a430fc9379af44ce96e"; + libraryHaskellDepends = [ + base cmdargs containers data-default-class diagrams-core + diagrams-lib lens mtl NumInstances optparse-applicative split + statestack static-canvas text + ]; + doHaddock = false; + doCheck = false; + homepage = "http://projects.haskell.org/diagrams/"; + description = "HTML5 canvas backend for diagrams drawing EDSL"; + license = stdenv.lib.licenses.bsd3; + }) {}; + "diagrams-lib" = callPackage + ({ mkDerivation, active, adjunctions, array, base, bytestring + , cereal, colour, containers, data-default-class, diagrams-core + , diagrams-solve, directory, distributive, dual-tree, exceptions + , filepath, fingertree, fsnotify, hashable, intervals, JuicyPixels + , lens, linear, monoid-extras, mtl, optparse-applicative, process + , profunctors, semigroups, stdenv, tagged, text, transformers + , unordered-containers + }: + mkDerivation { + pname = "diagrams-lib"; + version = "1.4.2.3"; + sha256 = "25a7adccbe3175cdb081a3824413ba431e561026c6ddd9a647cd133e4bfcbe9c"; + revision = "1"; + editedCabalFile = "0zsigisgn6sjpfy2hm31zddnsyqm2a046nxb5drjqm7r0aa3vjff"; + libraryHaskellDepends = [ + active adjunctions array base bytestring cereal colour containers + data-default-class diagrams-core diagrams-solve directory + distributive dual-tree exceptions filepath fingertree fsnotify + hashable intervals JuicyPixels lens linear monoid-extras mtl + optparse-applicative process profunctors semigroups tagged text + transformers unordered-containers + ]; + doHaddock = false; + doCheck = false; + homepage = "http://projects.haskell.org/diagrams"; + description = "Embedded domain-specific language for declarative graphics"; + license = stdenv.lib.licenses.bsd3; + }) {}; + "diagrams-postscript" = callPackage + ({ mkDerivation, base, containers, data-default-class + , diagrams-core, diagrams-lib, dlist, hashable, lens, monoid-extras + , mtl, semigroups, split, statestack, stdenv + }: + mkDerivation { + pname = "diagrams-postscript"; + version = "1.4.1"; + sha256 = "a758191d99c30bd663dc0df2dedef13cd735a33c143e77906aa88baceb282c9c"; + revision = "1"; + editedCabalFile = "0z0rh7lwyr3vx6llq6q9s5f1vzqk4zxpcg5ibfn5jdp274kfd7r1"; + libraryHaskellDepends = [ + base containers data-default-class diagrams-core diagrams-lib dlist + hashable lens monoid-extras mtl semigroups split statestack + ]; + doHaddock = false; + doCheck = false; + homepage = "http://projects.haskell.org/diagrams/"; + description = "Postscript backend for diagrams drawing EDSL"; + license = stdenv.lib.licenses.bsd3; + }) {}; + "diagrams-rasterific" = callPackage + ({ mkDerivation, base, bytestring, containers, data-default-class + , diagrams-core, diagrams-lib, file-embed, filepath, FontyFruity + , hashable, JuicyPixels, lens, mtl, optparse-applicative + , Rasterific, stdenv + }: + mkDerivation { + pname = "diagrams-rasterific"; + version = "1.4.1"; + sha256 = "30c66148a7411f23067930a090431a91e5251043e5acf8ff644fa6635fad977e"; + enableSeparateDataOutput = true; + libraryHaskellDepends = [ + base bytestring containers data-default-class diagrams-core + diagrams-lib file-embed filepath FontyFruity hashable JuicyPixels + lens mtl optparse-applicative Rasterific + ]; + doHaddock = false; + doCheck = false; + homepage = "http://projects.haskell.org/diagrams/"; + description = "Rasterific backend for diagrams"; + license = stdenv.lib.licenses.bsd3; + }) {}; + "diagrams-solve" = callPackage + ({ mkDerivation, base, stdenv }: + mkDerivation { + pname = "diagrams-solve"; + version = "0.1.1"; + sha256 = "a41f5f410b10f162b1e5c07bd4ca3305544870ff1314ae4f5824c83a31644f9d"; + revision = "3"; + editedCabalFile = "13vfs5k09c16q3dvqzgfca1kd93pgc4ll8mfl3wracanm5mn5rx7"; + libraryHaskellDepends = [ base ]; + doHaddock = false; + doCheck = false; + homepage = "http://projects.haskell.org/diagrams"; + description = "Pure Haskell solver routines used by diagrams"; + license = stdenv.lib.licenses.bsd3; + }) {}; + "diagrams-svg" = callPackage + ({ mkDerivation, base, base64-bytestring, bytestring, colour + , containers, diagrams-core, diagrams-lib, filepath, hashable + , JuicyPixels, lens, monoid-extras, mtl, optparse-applicative + , semigroups, split, stdenv, svg-builder, text + }: + mkDerivation { + pname = "diagrams-svg"; + version = "1.4.2"; + sha256 = "5455b68d92826a5405d51490976870cc0fa5b8b56aef0a8f56982b5f48efded2"; + revision = "2"; + editedCabalFile = "15sn85xaachw4cj56w61bjcwrbf4qmnkfl8mbgdapxi5k0y4f2qv"; + libraryHaskellDepends = [ + base base64-bytestring bytestring colour containers diagrams-core + diagrams-lib filepath hashable JuicyPixels lens monoid-extras mtl + optparse-applicative semigroups split svg-builder text + ]; + doHaddock = false; + doCheck = false; + homepage = "http://projects.haskell.org/diagrams/"; + description = "SVG backend for diagrams drawing EDSL"; + license = stdenv.lib.licenses.bsd3; + }) {}; + "dictionary-sharing" = callPackage + ({ mkDerivation, base, containers, stdenv }: + mkDerivation { + pname = "dictionary-sharing"; + version = "0.1.0.0"; + sha256 = "8c3b5184d5d6056433d51a49c5402e4ab7b0260073d5342685b8e141d2be5a01"; + revision = "3"; + editedCabalFile = "1mn7jcc7h3b8f1pn9zigqp6mc2n0qb66lms5qnrx4zswdv5w9439"; + libraryHaskellDepends = [ base containers ]; + doHaddock = false; + doCheck = false; + description = "Sharing/memoization of class members"; + license = stdenv.lib.licenses.bsd3; + }) {}; + "digest" = callPackage + ({ mkDerivation, base, bytestring, stdenv, zlib }: + mkDerivation { + pname = "digest"; + version = "0.0.1.2"; + sha256 = "641717eb16392abf8965986a9e8dc21eebf1d97775bbb6923c7b7f8fee17fe11"; + libraryHaskellDepends = [ base bytestring ]; + librarySystemDepends = [ zlib ]; + doHaddock = false; + doCheck = false; + description = "Various cryptographic hashes for bytestrings; CRC32 and Adler32 for now"; + license = stdenv.lib.licenses.bsd3; + }) {inherit (pkgs) zlib;}; + "digits" = callPackage + ({ mkDerivation, base, QuickCheck, stdenv }: + mkDerivation { + pname = "digits"; + version = "0.3.1"; + sha256 = "a8499c9745dcf8a4e6c48594f555e6c6276e8d91c457dcc562a370ccadcd6a2c"; + libraryHaskellDepends = [ base QuickCheck ]; + doHaddock = false; + doCheck = false; + description = "Converts integers to lists of digits and back"; + license = stdenv.lib.licenses.bsd3; + }) {}; + "dimensional" = callPackage + ({ mkDerivation, base, deepseq, exact-pi, ieee754, numtype-dk + , semigroups, stdenv, vector + }: + mkDerivation { + pname = "dimensional"; + version = "1.1"; + sha256 = "3a25889c1c67966a2739a9c1ccd040278c89e10823a1b2463fbf571b74075e16"; + libraryHaskellDepends = [ + base deepseq exact-pi ieee754 numtype-dk semigroups vector + ]; + doHaddock = false; + doCheck = false; + homepage = "https://github.com/bjornbm/dimensional/"; + description = "Statically checked physical dimensions, using Type Families and Data Kinds"; + license = stdenv.lib.licenses.bsd3; + }) {}; + "direct-sqlite" = callPackage + ({ mkDerivation, base, bytestring, semigroups, stdenv, text }: + mkDerivation { + pname = "direct-sqlite"; + version = "2.3.23"; + sha256 = "1fdb6f6ea34ac978e72f61a845786e4b4b945014ccc64ddb07ddcafa1254937b"; + libraryHaskellDepends = [ base bytestring semigroups text ]; + doHaddock = false; + doCheck = false; + homepage = "https://github.com/IreneKnapp/direct-sqlite"; + description = "Low-level binding to SQLite3. Includes UTF8 and BLOB support."; + license = stdenv.lib.licenses.bsd3; + }) {}; + "directory-tree" = callPackage + ({ mkDerivation, base, directory, filepath, stdenv }: + mkDerivation { + pname = "directory-tree"; + version = "0.12.1"; + sha256 = "e2084495b3a226cf54d949635c86fc14e89daa09d86cce39e3c3cf898ae6e517"; + libraryHaskellDepends = [ base directory filepath ]; + doHaddock = false; + doCheck = false; + homepage = "http://brandon.si/code/directory-tree-module-released/"; + description = "A simple directory-like tree datatype, with useful IO functions"; + license = stdenv.lib.licenses.bsd3; + }) {}; + "discount" = callPackage + ({ mkDerivation, base, bytestring, markdown, stdenv, text }: + mkDerivation { + pname = "discount"; + version = "0.1.1"; + sha256 = "e99cb7fdd1896dd1e525616597f936c1305a657cea1ef82cc0b3dcfe5afa34e0"; + libraryHaskellDepends = [ base bytestring text ]; + librarySystemDepends = [ markdown ]; + doHaddock = false; + doCheck = false; + homepage = "http://github.com/lightquake/discount"; + description = "Haskell bindings to the discount Markdown library"; + license = stdenv.lib.licenses.mit; + }) {inherit (pkgs) markdown;}; + "discrimination" = callPackage + ({ mkDerivation, array, base, containers, contravariant, deepseq + , ghc-prim, hashable, primitive, profunctors, promises, semigroups + , stdenv, transformers, transformers-compat, vector, void + }: + mkDerivation { + pname = "discrimination"; + version = "0.3"; + sha256 = "d6d4b285783e66446a8f798b3a440b1020bdc681285b05794d3ec84d96dc4ca3"; + libraryHaskellDepends = [ + array base containers contravariant deepseq ghc-prim hashable + primitive profunctors promises semigroups transformers + transformers-compat vector void + ]; + doHaddock = false; + doCheck = false; + homepage = "http://github.com/ekmett/discrimination/"; + description = "Fast generic linear-time sorting, joins and container construction"; + license = stdenv.lib.licenses.bsd3; + }) {}; + "disk-free-space" = callPackage + ({ mkDerivation, base, stdenv }: + mkDerivation { + pname = "disk-free-space"; + version = "0.1.0.1"; + sha256 = "f17a4f9c3b41083ccbb6c11b2debdbc705f86097b7459ff0f46cc01d2692381f"; + revision = "3"; + editedCabalFile = "0x0wjycr3rhw9vcq51b4sz8cf7mcvx7whhywv72y25r9385lxb3i"; + libraryHaskellDepends = [ base ]; + doHaddock = false; + doCheck = false; + homepage = "https://github.com/redneb/disk-free-space"; + description = "Retrieve information about disk space usage"; + license = stdenv.lib.licenses.bsd3; + }) {}; + "distributed-closure" = callPackage + ({ mkDerivation, base, binary, bytestring, constraints, stdenv, syb + , template-haskell + }: + mkDerivation { + pname = "distributed-closure"; + version = "0.4.0"; + sha256 = "d56abae0390d30ca6adf9a2e84e770aa92e5b147e547d245fa3a56506dad5ee4"; + libraryHaskellDepends = [ + base binary bytestring constraints syb template-haskell + ]; + doHaddock = false; + doCheck = false; + homepage = "https://github.com/tweag/distributed-closure"; + description = "Serializable closures for distributed programming"; + license = stdenv.lib.licenses.bsd3; + }) {}; + "distributed-static" = callPackage + ({ mkDerivation, base, binary, bytestring, containers, deepseq + , rank1dynamic, stdenv + }: + mkDerivation { + pname = "distributed-static"; + version = "0.3.8"; + sha256 = "954bf65722b662794990c81ba31a7fdbccd9d233af9212896443aa5ab9d4ffc2"; + libraryHaskellDepends = [ + base binary bytestring containers deepseq rank1dynamic + ]; + doHaddock = false; + doCheck = false; + homepage = "http://haskell-distributed.github.com"; + description = "Compositional, type-safe, polymorphic static values and closures"; + license = stdenv.lib.licenses.bsd3; + }) {}; + "distribution-nixpkgs" = callPackage + ({ mkDerivation, aeson, base, bytestring, Cabal, containers + , deepseq, language-nix, lens, pretty, process, split, stdenv + }: + mkDerivation { + pname = "distribution-nixpkgs"; + version = "1.1.1"; + sha256 = "55eb858a98995f4f2b2eec5fcbc44ba1901284e915ef5e18609e253a5a662499"; + libraryHaskellDepends = [ + aeson base bytestring Cabal containers deepseq language-nix lens + pretty process split + ]; + doHaddock = false; + doCheck = false; + homepage = "https://github.com/peti/distribution-nixpkgs#readme"; + description = "Types and functions to manipulate the Nixpkgs distribution"; + license = stdenv.lib.licenses.bsd3; + }) {}; + "distributive" = callPackage + ({ mkDerivation, base, base-orphans, Cabal, cabal-doctest, stdenv + , tagged, transformers, transformers-compat + }: + mkDerivation { + pname = "distributive"; + version = "0.5.3"; + sha256 = "9173805b9c941bda1f37e5aeb68ae30f57a12df9b17bd2aa86db3b7d5236a678"; + revision = "6"; + editedCabalFile = "06bd38rf31yrvvy989r44pm0id3dsxwcp6nxg7wk6ccj3n2b8rzk"; + setupHaskellDepends = [ base Cabal cabal-doctest ]; + libraryHaskellDepends = [ + base base-orphans tagged transformers transformers-compat + ]; + doHaddock = false; + doCheck = false; + homepage = "http://github.com/ekmett/distributive/"; + description = "Distributive functors -- Dual to Traversable"; + license = stdenv.lib.licenses.bsd3; + }) {}; + "dlist" = callPackage + ({ mkDerivation, base, deepseq, stdenv }: + mkDerivation { + pname = "dlist"; + version = "0.8.0.4"; + sha256 = "acf1867b80cdd618b8d904e89eea33be60d3c4c3aeb80d61f29229a301cc397a"; + libraryHaskellDepends = [ base deepseq ]; + doHaddock = false; + doCheck = false; + homepage = "https://github.com/spl/dlist"; + description = "Difference lists"; + license = stdenv.lib.licenses.bsd3; + }) {}; + "dlist-instances" = callPackage + ({ mkDerivation, base, dlist, semigroups, stdenv }: + mkDerivation { + pname = "dlist-instances"; + version = "0.1.1.1"; + sha256 = "d14a10c06f52fb412b2c1066d729f5534aa43204221e7ba7d81d935c44ce4f5b"; + libraryHaskellDepends = [ base dlist semigroups ]; + doHaddock = false; + doCheck = false; + homepage = "https://github.com/gregwebs/dlist-instances"; + description = "Difference lists instances"; + license = stdenv.lib.licenses.bsd3; + }) {}; + "dlist-nonempty" = callPackage + ({ mkDerivation, base, base-compat, deepseq, dlist, semigroupoids + , stdenv + }: + mkDerivation { + pname = "dlist-nonempty"; + version = "0.1.1"; + sha256 = "40e8a64c979ca07b4f67a38878d1d13c1127fe2d1ad6b2b4daff0ee2dbd54b33"; + revision = "4"; + editedCabalFile = "10kkj4sf1bn87z6744p9gn6mkciqri2d3l9vmg9ylpi8g7priil2"; + libraryHaskellDepends = [ + base base-compat deepseq dlist semigroupoids + ]; + doHaddock = false; + doCheck = false; + homepage = "https://github.com/phadej/dlist-nonempty"; + description = "Non-empty difference lists"; + license = stdenv.lib.licenses.bsd3; + }) {}; + "dns" = callPackage + ({ mkDerivation, async, attoparsec, auto-update, base + , base64-bytestring, binary, bytestring, containers, cryptonite + , iproute, mtl, network, psqueues, safe, stdenv, time + }: + mkDerivation { + pname = "dns"; + version = "3.0.4"; + sha256 = "7b3433b536b7d225914d7b8495c7af1927d9554538d7d86c2644ccf9d3fa44a9"; + libraryHaskellDepends = [ + async attoparsec auto-update base base64-bytestring binary + bytestring containers cryptonite iproute mtl network psqueues safe + time + ]; + doHaddock = false; + doCheck = false; + testTarget = "spec"; + description = "DNS library in Haskell"; + license = stdenv.lib.licenses.bsd3; + }) {}; + "do-list" = callPackage + ({ mkDerivation, base, stdenv }: + mkDerivation { + pname = "do-list"; + version = "1.0.1"; + sha256 = "b377193461b0ad7a81f9e66bcf10f8838b6f1e39f4a5de3b2e2f45c749c5b694"; + libraryHaskellDepends = [ base ]; + doHaddock = false; + doCheck = false; + homepage = "https://github.com/tserduke/do-list#readme"; + description = "Do notation for free"; + license = stdenv.lib.licenses.bsd3; + }) {}; + "docker" = callPackage + ({ mkDerivation, aeson, base, blaze-builder, bytestring, conduit + , conduit-combinators, conduit-extra, containers + , data-default-class, directory, exceptions, filemanip, filepath + , http-client, http-conduit, http-types, monad-control, mtl + , network, resourcet, scientific, stdenv, tar, temporary, text + , time, tls, transformers, transformers-base, unliftio-core + , unordered-containers, uuid, vector, x509, x509-store, x509-system + , zlib + }: + mkDerivation { + pname = "docker"; + version = "0.6.0.0"; + sha256 = "4d3a00300abc09c2f9214f03d2d16fb51aa5b2f182aa6c4de69a3017e4b42045"; + libraryHaskellDepends = [ + aeson base blaze-builder bytestring conduit conduit-combinators + conduit-extra containers data-default-class directory exceptions + filemanip filepath http-client http-conduit http-types + monad-control mtl network resourcet scientific tar temporary text + time tls transformers transformers-base unliftio-core + unordered-containers uuid vector x509 x509-store x509-system zlib + ]; + doHaddock = false; + doCheck = false; + homepage = "https://github.com/denibertovic/docker-hs"; + description = "An API client for docker written in Haskell"; + license = stdenv.lib.licenses.bsd3; + }) {}; + "dockerfile" = callPackage + ({ mkDerivation, base, stdenv }: + mkDerivation { + pname = "dockerfile"; + version = "0.1.0.1"; + sha256 = "294ac0b6c0546da15bf5453d6006979aeb6f6b36f0566be75767f5021de00025"; + libraryHaskellDepends = [ base ]; + doHaddock = false; + doCheck = false; + description = "A simple DSL for describing and generating Dockerfile containers in Haskell"; + license = stdenv.lib.licenses.mit; + }) {}; + "docopt" = callPackage + ({ mkDerivation, base, containers, parsec, stdenv, template-haskell + , th-lift + }: + mkDerivation { + pname = "docopt"; + version = "0.7.0.5"; + sha256 = "15790808a4896bbf0748c1c0f3ab63c07aea4621d95b93a39886813f829d05ee"; + enableSeparateDataOutput = true; + libraryHaskellDepends = [ + base containers parsec template-haskell th-lift + ]; + doHaddock = false; + doCheck = false; + homepage = "https://github.com/docopt/docopt.hs"; + description = "A command-line interface parser that will make you smile"; + license = stdenv.lib.licenses.mit; + }) {}; + "doctemplates" = callPackage + ({ mkDerivation, aeson, base, blaze-html, blaze-markup, bytestring + , containers, parsec, scientific, stdenv, text + , unordered-containers, vector + }: + mkDerivation { + pname = "doctemplates"; + version = "0.2.2.1"; + sha256 = "6b0cfb565fc7fa90d71ac56b83aedecf670678e6f1441278877fbf399e9bccbf"; + enableSeparateDataOutput = true; + libraryHaskellDepends = [ + aeson base blaze-html blaze-markup bytestring containers parsec + scientific text unordered-containers vector + ]; + doHaddock = false; + doCheck = false; + homepage = "https://github.com/jgm/doctemplates#readme"; + description = "Pandoc-style document templates"; + license = stdenv.lib.licenses.bsd3; + }) {}; + "doctest" = callPackage + ({ mkDerivation, base, base-compat, code-page, deepseq, directory + , filepath, ghc, ghc-paths, process, stdenv, syb, transformers + }: + mkDerivation { + pname = "doctest"; + version = "0.16.0"; + sha256 = "bb49a6781b6deda4eaa9cc3e3b515f245e4b23c4eb403316b873e86220636c42"; + isLibrary = true; + isExecutable = true; + libraryHaskellDepends = [ + base base-compat code-page deepseq directory filepath ghc ghc-paths + process syb transformers + ]; + executableHaskellDepends = [ + base base-compat code-page deepseq directory filepath ghc ghc-paths + process syb transformers + ]; + doHaddock = false; + doCheck = false; + homepage = "https://github.com/sol/doctest#readme"; + description = "Test interactive Haskell examples"; + license = stdenv.lib.licenses.mit; + }) {}; + "doctest-discover" = callPackage + ({ mkDerivation, aeson, base, bytestring, directory, doctest + , filepath, stdenv + }: + mkDerivation { + pname = "doctest-discover"; + version = "0.1.0.9"; + sha256 = "6790bb2df19b692131dca9f910a789884c2d4361a25f812f5bcb8803033799b2"; + isLibrary = true; + isExecutable = true; + libraryHaskellDepends = [ + aeson base bytestring directory doctest filepath + ]; + executableHaskellDepends = [ + aeson base bytestring directory doctest filepath + ]; + doHaddock = false; + doCheck = false; + homepage = "http://github.com/karun012/doctest-discover"; + description = "Easy way to run doctests via cabal"; + license = stdenv.lib.licenses.publicDomain; + }) {}; + "doctest-driver-gen" = callPackage + ({ mkDerivation, base, doctest, stdenv }: + mkDerivation { + pname = "doctest-driver-gen"; + version = "0.2.0.3"; + sha256 = "06b366890573c253a150eb11d782fa9bb91ec50f02cec7a739b439513dcfa9ee"; + isLibrary = true; + isExecutable = true; + libraryHaskellDepends = [ base doctest ]; + executableHaskellDepends = [ base ]; + doHaddock = false; + doCheck = false; + homepage = "https://github.com/Hexirp/doctest-driver-gen#readme"; + description = "Generate driver file for doctest's cabal integration"; + license = stdenv.lib.licenses.bsd3; + }) {}; + "dom-parser" = callPackage + ({ mkDerivation, base, case-insensitive, containers, lens, mtl + , scientific, semigroups, stdenv, text, transformers, xml-conduit + , xml-lens + }: + mkDerivation { + pname = "dom-parser"; + version = "3.1.0"; + sha256 = "d7e15cae0b27d708389160517b1616343da1911baf95f2c97e213732a0262ac3"; + libraryHaskellDepends = [ + base case-insensitive containers lens mtl scientific semigroups + text transformers xml-conduit xml-lens + ]; + doHaddock = false; + doCheck = false; + homepage = "https://github.com/typeable/dom-parser"; + description = "Simple monadic DOM parser"; + license = stdenv.lib.licenses.mit; + }) {}; + "dotenv" = callPackage + ({ mkDerivation, base, base-compat, directory, exceptions + , megaparsec, optparse-applicative, process, stdenv, text + , transformers, yaml + }: + mkDerivation { + pname = "dotenv"; + version = "0.5.2.5"; + sha256 = "a197bf60643fc4dea5acd71b03b71cb89e8df91d55cc400b2ada5e79b4b6f4e1"; + isLibrary = true; + isExecutable = true; + enableSeparateDataOutput = true; + libraryHaskellDepends = [ + base base-compat directory exceptions megaparsec process text + transformers yaml + ]; + executableHaskellDepends = [ + base base-compat megaparsec optparse-applicative process text + transformers yaml + ]; + doHaddock = false; + doCheck = false; + homepage = "https://github.com/stackbuilders/dotenv-hs"; + description = "Loads environment variables from dotenv files"; + license = stdenv.lib.licenses.mit; + }) {}; + "dotnet-timespan" = callPackage + ({ mkDerivation, base, stdenv }: + mkDerivation { + pname = "dotnet-timespan"; + version = "0.0.1.0"; + sha256 = "d8ca8dffbc916ff5139d6f0df4a22c947ab5f996c376f1ab8c2e120789209ac3"; + libraryHaskellDepends = [ base ]; + doHaddock = false; + doCheck = false; + homepage = "http://github.com/YoEight/dotnet-timespan"; + description = ".NET TimeSpan"; + license = stdenv.lib.licenses.bsd3; + }) {}; + "double-conversion" = callPackage + ({ mkDerivation, base, bytestring, ghc-prim, stdenv, text }: + mkDerivation { + pname = "double-conversion"; + version = "2.0.2.0"; + sha256 = "44cde172395401169e844d6791b6eb0ef2c2e55a08de8dda96551cfe029ba26b"; + libraryHaskellDepends = [ base bytestring ghc-prim text ]; + doHaddock = false; + doCheck = false; + homepage = "https://github.com/bos/double-conversion"; + description = "Fast conversion between double precision floating point and text"; + license = stdenv.lib.licenses.bsd3; + }) {}; + "download" = callPackage + ({ mkDerivation, base, bytestring, feed, stdenv, tagsoup, xml }: + mkDerivation { + pname = "download"; + version = "0.3.2.6"; + sha256 = "a06d401a2ca58b6ee494ce462c753939ef0a2d11b4d475ae40848884fb44eef2"; + libraryHaskellDepends = [ base bytestring feed tagsoup xml ]; + doHaddock = false; + doCheck = false; + homepage = "https://github.com/psibi/download"; + description = "High-level file download based on URLs"; + license = stdenv.lib.licenses.bsd3; + }) {}; + "drawille" = callPackage + ({ mkDerivation, base, containers, stdenv }: + mkDerivation { + pname = "drawille"; + version = "0.1.2.0"; + sha256 = "b8188ee87a06c168974c9655188450eb86c331c556decb31cf084efa846237df"; + isLibrary = true; + isExecutable = true; + libraryHaskellDepends = [ base containers ]; + doHaddock = false; + doCheck = false; + homepage = "https://github.com/yamadapc/haskell-drawille#readme"; + description = "A port of asciimoo's drawille to haskell"; + license = stdenv.lib.licenses.gpl3; + }) {}; + "drifter" = callPackage + ({ mkDerivation, base, containers, fgl, stdenv, text }: + mkDerivation { + pname = "drifter"; + version = "0.2.3"; + sha256 = "df539d47e47a6064997619079cde28cc0ae039cbda1915cec447380736d92638"; + libraryHaskellDepends = [ base containers fgl text ]; + doHaddock = false; + doCheck = false; + homepage = "https://github.com/AndrewRademacher/drifter"; + description = "Simple schema management for arbitrary databases"; + license = stdenv.lib.licenses.mit; + }) {}; + "drifter-postgresql" = callPackage + ({ mkDerivation, base, containers, drifter, mtl, postgresql-simple + , stdenv, time, transformers, transformers-compat + }: + mkDerivation { + pname = "drifter-postgresql"; + version = "0.2.1"; + sha256 = "93320177ec9aab96799623ccc274f5b069500587f002f5f415c24159dd6eed5c"; + libraryHaskellDepends = [ + base containers drifter mtl postgresql-simple time transformers + transformers-compat + ]; + doHaddock = false; + doCheck = false; + homepage = "http://github.com/michaelxavier/drifter-postgresql"; + description = "PostgreSQL support for the drifter schema migration tool"; + license = stdenv.lib.licenses.mit; + }) {}; + "dsp" = callPackage + ({ mkDerivation, array, base, containers, random, stdenv }: + mkDerivation { + pname = "dsp"; + version = "0.2.4"; + sha256 = "fee4dff51d372ae9fd7ceaa0b885b1dfdf396ebddbc56076a529ecdf95589b2f"; + isLibrary = true; + isExecutable = true; + libraryHaskellDepends = [ array base containers random ]; + doHaddock = false; + doCheck = false; + homepage = "http://www.haskell.org/haskellwiki/DSP"; + description = "Haskell Digital Signal Processing"; + license = "GPL"; + }) {}; + "dual-tree" = callPackage + ({ mkDerivation, base, monoid-extras, newtype-generics, semigroups + , stdenv + }: + mkDerivation { + pname = "dual-tree"; + version = "0.2.2"; + sha256 = "7412d70cf239da98b5a21df1cbbeab7319fd23d757427d4f5ce71b907dbaa9eb"; + revision = "2"; + editedCabalFile = "0r8idr1haqixa9nlp8db5iw9vr9sdk6rcargkr7w7s6i99lm6jmh"; + libraryHaskellDepends = [ + base monoid-extras newtype-generics semigroups + ]; + doHaddock = false; + doCheck = false; + description = "Rose trees with cached and accumulating monoidal annotations"; + license = stdenv.lib.licenses.bsd3; + }) {}; + "dublincore-xml-conduit" = callPackage + ({ mkDerivation, base, conduit, conduit-combinators + , safe-exceptions, stdenv, text, time, timerep, uri-bytestring + , xml-conduit, xml-types + }: + mkDerivation { + pname = "dublincore-xml-conduit"; + version = "0.1.0.2"; + sha256 = "d47a8dcb21d1866f0229168d11d1da136da3028a2f4252bee61d219988f45f9e"; + revision = "1"; + editedCabalFile = "1rljgmi4jb6yhigfy394jb64q5f5qx7i1g68pw6zgq9ziz91p321"; + libraryHaskellDepends = [ + base conduit conduit-combinators safe-exceptions text time timerep + uri-bytestring xml-conduit xml-types + ]; + doHaddock = false; + doCheck = false; + homepage = "https://github.com/k0ral/dublincore-xml-conduit"; + description = "XML streaming parser/renderer for the Dublin Core standard elements"; + license = stdenv.lib.licenses.publicDomain; + }) {}; + "dunai" = callPackage + ({ mkDerivation, base, MonadRandom, stdenv, transformers + , transformers-base + }: + mkDerivation { + pname = "dunai"; + version = "0.4.0.0"; + sha256 = "d6f48393ed9ed584eafe2393c848b78288fca1db5c504ed4749f9f0efe82b817"; + libraryHaskellDepends = [ + base MonadRandom transformers transformers-base + ]; + doHaddock = false; + doCheck = false; + homepage = "https://github.com/ivanperez-keera/dunai"; + description = "Generalised reactive framework supporting classic, arrowized and monadic FRP"; + license = stdenv.lib.licenses.bsd3; + }) {}; + "dvorak" = callPackage + ({ mkDerivation, base, containers, stdenv }: + mkDerivation { + pname = "dvorak"; + version = "0.1.0.0"; + sha256 = "afc8ba89415a01039ccdc719b875826b6b12befb4a6a97bcd7544f22eaffb6cf"; + libraryHaskellDepends = [ base containers ]; + doHaddock = false; + doCheck = false; + homepage = "https://github.com/kvanberendonck/codec-dvorak"; + description = "Dvorak encoding for Haskell"; + license = stdenv.lib.licenses.bsd3; + }) {}; + "dynamic-state" = callPackage + ({ mkDerivation, base, binary, bytestring, hashable, stdenv + , unordered-containers + }: + mkDerivation { + pname = "dynamic-state"; + version = "0.3.1"; + sha256 = "c4d50bdf03e7b2af05ee2b78fdd5dd5d16e72ef5edf78cada60bf4cdc6a23537"; + libraryHaskellDepends = [ + base binary bytestring hashable unordered-containers + ]; + doHaddock = false; + doCheck = false; + description = "Optionally serializable dynamic state keyed by type"; + license = stdenv.lib.licenses.gpl2; + }) {}; + "dyre" = callPackage + ({ mkDerivation, base, binary, directory, executable-path, filepath + , ghc-paths, io-storage, process, stdenv, time, unix, xdg-basedir + }: + mkDerivation { + pname = "dyre"; + version = "0.8.12"; + sha256 = "e224305cc6b38b4143f49489931c2ea94b326915206d34eddf5b2ee2b5a71682"; + libraryHaskellDepends = [ + base binary directory executable-path filepath ghc-paths io-storage + process time unix xdg-basedir + ]; + doHaddock = false; + doCheck = false; + homepage = "http://github.com/willdonnelly/dyre"; + description = "Dynamic reconfiguration in Haskell"; + license = stdenv.lib.licenses.bsd3; + }) {}; + "easy-file" = callPackage + ({ mkDerivation, base, directory, filepath, stdenv, time, unix }: + mkDerivation { + pname = "easy-file"; + version = "0.2.2"; + sha256 = "52f52e72ba48d60935932401c233a72bf45c582871238aecc5a18021ce67b47e"; + libraryHaskellDepends = [ base directory filepath time unix ]; + doHaddock = false; + doCheck = false; + homepage = "http://github.com/kazu-yamamoto/easy-file"; + description = "Cross-platform File handling"; + license = stdenv.lib.licenses.bsd3; + }) {}; + "easytest" = callPackage + ({ mkDerivation, async, base, call-stack, containers, mtl, random + , stdenv, stm, text, transformers + }: + mkDerivation { + pname = "easytest"; + version = "0.2"; + sha256 = "0b486487a566f838cf448b46cc7215230f020fb4756bd362dfb5a66f6ee1a9e9"; + revision = "1"; + editedCabalFile = "1kgijad57iyhn6w096zr3n2gi1g7y3dc4qxy6v14dq96xjjym5ga"; + libraryHaskellDepends = [ + async base call-stack containers mtl random stm text transformers + ]; + doHaddock = false; + doCheck = false; + homepage = "https://github.com/joelburget/easytest"; + description = "Simple, expressive testing library"; + license = stdenv.lib.licenses.mit; + }) {}; + "echo" = callPackage + ({ mkDerivation, base, process, stdenv }: + mkDerivation { + pname = "echo"; + version = "0.1.3"; + sha256 = "704f07310f8272d170f8ab7fb2a2c13f15d8501ef8310801e36964c8eff485ef"; + revision = "1"; + editedCabalFile = "0br8wfiybcw5hand4imiw0i5hacdmrax1dv8g95f35gazffbx42l"; + isLibrary = true; + isExecutable = true; + libraryHaskellDepends = [ base process ]; + doHaddock = false; + doCheck = false; + homepage = "https://github.com/RyanGlScott/echo"; + description = "A cross-platform, cross-console way to handle echoing terminal input"; + license = stdenv.lib.licenses.bsd3; + }) {}; + "ed25519" = callPackage + ({ mkDerivation, base, bytestring, ghc-prim, stdenv }: + mkDerivation { + pname = "ed25519"; + version = "0.0.5.0"; + sha256 = "d8a5958ebfa9309790efade64275dc5c441b568645c45ceed1b0c6ff36d6156d"; + revision = "2"; + editedCabalFile = "1cq6h3jqkb1kvd9fjfhsllg5gq78sdiyf2gy9862xhlbv6wil19f"; + libraryHaskellDepends = [ base bytestring ghc-prim ]; + doHaddock = false; + doCheck = false; + homepage = "http://thoughtpolice.github.com/hs-ed25519"; + description = "Ed25519 cryptographic signatures"; + license = stdenv.lib.licenses.mit; + }) {}; + "edit-distance" = callPackage + ({ mkDerivation, array, base, containers, random, stdenv }: + mkDerivation { + pname = "edit-distance"; + version = "0.2.2.1"; + sha256 = "3e8885ee2f56ad4da940f043ae8f981ee2fe336b5e8e4ba3f7436cff4f526c4a"; + revision = "1"; + editedCabalFile = "1vjn4ryzdilz7l1ad7czh11nw48h5mj8if7ij3q0mmc3sffa8csd"; + libraryHaskellDepends = [ array base containers random ]; + doHaddock = false; + doCheck = false; + homepage = "http://github.com/phadej/edit-distance"; + description = "Levenshtein and restricted Damerau-Levenshtein edit distances"; + license = stdenv.lib.licenses.bsd3; + }) {}; + "edit-distance-vector" = callPackage + ({ mkDerivation, base, stdenv, vector }: + mkDerivation { + pname = "edit-distance-vector"; + version = "1.0.0.4"; + sha256 = "b7dfddd86d315ef1b0c86415f321efc04b4a1b47a7b13edafc73a6e81b620f1f"; + libraryHaskellDepends = [ base vector ]; + doHaddock = false; + doCheck = false; + homepage = "https://github.com/thsutton/edit-distance-vector"; + description = "Calculate edit distances and edit scripts between vectors"; + license = stdenv.lib.licenses.bsd3; + }) {}; + "editor-open" = callPackage + ({ mkDerivation, base, bytestring, conduit, conduit-extra + , directory, process, resourcet, stdenv, temporary, transformers + , unix + }: + mkDerivation { + pname = "editor-open"; + version = "0.6.0.0"; + sha256 = "2fc5d19bce2d477935202a5a4522671529d0352a0ee28be1307f8ab391065265"; + isLibrary = true; + isExecutable = true; + enableSeparateDataOutput = true; + libraryHaskellDepends = [ + base bytestring conduit conduit-extra directory process resourcet + temporary transformers unix + ]; + executableHaskellDepends = [ + base bytestring conduit conduit-extra resourcet + ]; + doHaddock = false; + doCheck = false; + homepage = "https://github.com/pharpend/editor-open"; + description = "Open the user's $VISUAL or $EDITOR for text input"; + license = stdenv.lib.licenses.asl20; + }) {}; + "either" = callPackage + ({ mkDerivation, base, bifunctors, mtl, profunctors, semigroupoids + , semigroups, stdenv + }: + mkDerivation { + pname = "either"; + version = "5.0.1"; + sha256 = "6cb6eb3f60223f5ffedfcd749589e870a81d272e130cafd1d17fb6d3a8939018"; + revision = "1"; + editedCabalFile = "1kf0dy6nki64kkmjw8214jz3n086g1pghfm26f012b6qv0iakzca"; + libraryHaskellDepends = [ + base bifunctors mtl profunctors semigroupoids semigroups + ]; + doHaddock = false; + doCheck = false; + homepage = "http://github.com/ekmett/either/"; + description = "Combinators for working with sums"; + license = stdenv.lib.licenses.bsd3; + }) {}; + "either-unwrap" = callPackage + ({ mkDerivation, base, stdenv }: + mkDerivation { + pname = "either-unwrap"; + version = "1.1"; + sha256 = "ccabd6f87118abc8dcba481b316c76b8195ac9e8a8f3ddb478de5eb64e2d2e3c"; + libraryHaskellDepends = [ base ]; + doHaddock = false; + doCheck = false; + homepage = "http://github.com/gcross/either-unwrap"; + description = "Functions for probing and unwrapping values inside of Either"; + license = stdenv.lib.licenses.bsd3; + }) {}; + "ekg" = callPackage + ({ mkDerivation, aeson, base, bytestring, ekg-core, ekg-json + , filepath, network, snap-core, snap-server, stdenv, text, time + , transformers, unordered-containers + }: + mkDerivation { + pname = "ekg"; + version = "0.4.0.15"; + sha256 = "482ae3be495cfe4f03332ad1c79ce8b5ad4f9c8eec824980c664808ae32c6dcc"; + revision = "4"; + editedCabalFile = "17b68p16hsh79jaya1jfncml5cjf8y1jbr8827r42acnf9jk4s23"; + enableSeparateDataOutput = true; + libraryHaskellDepends = [ + aeson base bytestring ekg-core ekg-json filepath network snap-core + snap-server text time transformers unordered-containers + ]; + doHaddock = false; + doCheck = false; + homepage = "https://github.com/tibbe/ekg"; + description = "Remote monitoring of processes"; + license = stdenv.lib.licenses.bsd3; + }) {}; + "ekg-core" = callPackage + ({ mkDerivation, base, containers, ghc-prim, stdenv, text + , unordered-containers + }: + mkDerivation { + pname = "ekg-core"; + version = "0.1.1.4"; + sha256 = "66d89acca05c1c91dc57a9c4b3f62d25ccd0c04bb2bfd46d5947f9b8cd8ee937"; + revision = "3"; + editedCabalFile = "1s3545x9w01rrwzchb4f91ck0n6dc7gf0zwkryqx1b2c95ni5qa8"; + libraryHaskellDepends = [ + base containers ghc-prim text unordered-containers + ]; + doHaddock = false; + doCheck = false; + homepage = "https://github.com/tibbe/ekg-core"; + description = "Tracking of system metrics"; + license = stdenv.lib.licenses.bsd3; + }) {}; + "ekg-json" = callPackage + ({ mkDerivation, aeson, base, ekg-core, stdenv, text + , unordered-containers + }: + mkDerivation { + pname = "ekg-json"; + version = "0.1.0.6"; + sha256 = "1e6a80aa0a28bbf41c9c6364cbb5731160d14fa54145f27a82d0b3467a04dd47"; + revision = "3"; + editedCabalFile = "0d029nmwpln8iqqj1l5pz41l4gpbgk6n9gmlwnhnq2cm7ih6gzad"; + libraryHaskellDepends = [ + aeson base ekg-core text unordered-containers + ]; + doHaddock = false; + doCheck = false; + homepage = "https://github.com/tibbe/ekg-json"; + description = "JSON encoding of ekg metrics"; + license = stdenv.lib.licenses.bsd3; + }) {}; + "ekg-statsd" = callPackage + ({ mkDerivation, base, bytestring, ekg-core, network, stdenv, text + , time, unordered-containers + }: + mkDerivation { + pname = "ekg-statsd"; + version = "0.2.3.0"; + sha256 = "aeead4a98b467a5fcdbd0646db583843ec14a8985f1a1fbf45cf5c0d969f8a16"; + revision = "1"; + editedCabalFile = "1k4sndkjg1prvzhiii9gcgkx8zfkk9c4nf548x0hrbmj1laj8d62"; + libraryHaskellDepends = [ + base bytestring ekg-core network text time unordered-containers + ]; + doHaddock = false; + doCheck = false; + homepage = "https://github.com/tibbe/ekg-statsd"; + description = "Push metrics to statsd"; + license = stdenv.lib.licenses.bsd3; + }) {}; + "ekg-wai" = callPackage + ({ mkDerivation, aeson, base, bytestring, ekg-core, ekg-json + , filepath, http-types, network, stdenv, text, time, transformers + , unordered-containers, wai, wai-app-static, warp + }: + mkDerivation { + pname = "ekg-wai"; + version = "0.1.0.3"; + sha256 = "bfd35917b663da0c1354339dd30837eee6ddf0d42cf57442fd916a42c977a2e9"; + revision = "2"; + editedCabalFile = "17kca2wzlcv8nxyq096fv57jfklhz4ibnvf5nqqdszczb03j3dnn"; + enableSeparateDataOutput = true; + libraryHaskellDepends = [ + aeson base bytestring ekg-core ekg-json filepath http-types network + text time transformers unordered-containers wai wai-app-static warp + ]; + doHaddock = false; + doCheck = false; + homepage = "https://github.com/tvh/ekg-wai"; + description = "Remote monitoring of processes"; + license = stdenv.lib.licenses.bsd3; + }) {}; + "elerea" = callPackage + ({ mkDerivation, base, containers, stdenv, transformers + , transformers-base + }: + mkDerivation { + pname = "elerea"; + version = "2.9.0"; + sha256 = "901221660b32597803b20fe2e78bb6f1f60f064d04671fb3f0baa05c87446681"; + libraryHaskellDepends = [ + base containers transformers transformers-base + ]; + doHaddock = false; + doCheck = false; + description = "A minimalistic FRP library"; + license = stdenv.lib.licenses.bsd3; + }) {}; + "elf" = callPackage + ({ mkDerivation, base, binary, bytestring, stdenv }: + mkDerivation { + pname = "elf"; + version = "0.29"; + sha256 = "426509f12279bdc5a0228f74edef86997dbb47fddc19d83e9815dd301d4a8fac"; + libraryHaskellDepends = [ base binary bytestring ]; + doHaddock = false; + doCheck = false; + homepage = "https://github.com/wangbj/elf"; + description = "An Elf parser"; + license = stdenv.lib.licenses.bsd3; + }) {}; + "eliminators" = callPackage + ({ mkDerivation, base, extra, singleton-nats, singletons, stdenv + , template-haskell, th-abstraction, th-desugar + }: + mkDerivation { + pname = "eliminators"; + version = "0.4.1"; + sha256 = "3becae7b9634055dd02c3908d800dd12b3335b524299e033215a38cfe51b1d00"; + libraryHaskellDepends = [ + base extra singleton-nats singletons template-haskell + th-abstraction th-desugar + ]; + doHaddock = false; + doCheck = false; + homepage = "https://github.com/RyanGlScott/eliminators"; + description = "Dependently typed elimination functions using singletons"; + license = stdenv.lib.licenses.bsd3; + }) {}; + "elm-core-sources" = callPackage + ({ mkDerivation, base, bytestring, containers, file-embed, stdenv + , template-haskell + }: + mkDerivation { + pname = "elm-core-sources"; + version = "1.0.0"; + sha256 = "a403505d50cd6ff0d21243db55c6decc6dde14b88a6a393e2b6243f09f6620fb"; + libraryHaskellDepends = [ + base bytestring containers file-embed template-haskell + ]; + doHaddock = false; + doCheck = false; + homepage = "http://github.com/JoeyEremondi/elm-build-lib"; + description = "Source files for the Elm runtime and standard libraries"; + license = stdenv.lib.licenses.bsd3; + }) {}; + "elm-export" = callPackage + ({ mkDerivation, base, bytestring, containers, directory + , formatting, mtl, stdenv, text, time, wl-pprint-text + }: + mkDerivation { + pname = "elm-export"; + version = "0.6.0.1"; + sha256 = "bf9862015918c72b54b421efcd9d858969dcd94ef0a3d0cb92d9bc0c4363f9d5"; + libraryHaskellDepends = [ + base bytestring containers directory formatting mtl text time + wl-pprint-text + ]; + doHaddock = false; + doCheck = false; + homepage = "http://github.com/krisajenkins/elm-export"; + description = "A library to generate Elm types from Haskell source"; + license = "unknown"; + }) {}; + "email-validate" = callPackage + ({ mkDerivation, attoparsec, base, bytestring, stdenv + , template-haskell + }: + mkDerivation { + pname = "email-validate"; + version = "2.3.2.6"; + sha256 = "45dd526e69abfe166e046e4d03c5f3c793adcbbb75b53c46bab076c436f50f32"; + libraryHaskellDepends = [ + attoparsec base bytestring template-haskell + ]; + doHaddock = false; + doCheck = false; + homepage = "https://github.com/Porges/email-validate-hs"; + description = "Email address validation"; + license = stdenv.lib.licenses.bsd3; + }) {}; + "enclosed-exceptions" = callPackage + ({ mkDerivation, base, deepseq, lifted-base, monad-control, stdenv + , transformers, transformers-base + }: + mkDerivation { + pname = "enclosed-exceptions"; + version = "1.0.3"; + sha256 = "af6d93f113ac92b89a32af1fed52f445f492afcc0be93980cbadc5698f94f0b9"; + libraryHaskellDepends = [ + base deepseq lifted-base monad-control transformers + transformers-base + ]; + doHaddock = false; + doCheck = false; + homepage = "https://github.com/jcristovao/enclosed-exceptions"; + description = "Catching all exceptions from within an enclosed computation"; + license = stdenv.lib.licenses.mit; + }) {}; + "entropy" = callPackage + ({ mkDerivation, base, bytestring, Cabal, directory, filepath + , process, stdenv, unix + }: + mkDerivation { + pname = "entropy"; + version = "0.4.1.1"; + sha256 = "8efd7084237dcda2a444a6c7be0e4b298e5084b20514df4657da5044c22b1faa"; + setupHaskellDepends = [ base Cabal directory filepath process ]; + libraryHaskellDepends = [ base bytestring unix ]; + doHaddock = false; + doCheck = false; + homepage = "https://github.com/TomMD/entropy"; + description = "A platform independent entropy source"; + license = stdenv.lib.licenses.bsd3; + }) {}; + "enum-subset-generate" = callPackage + ({ mkDerivation, base, microlens, stdenv, template-haskell }: + mkDerivation { + pname = "enum-subset-generate"; + version = "0.1.0.0"; + sha256 = "dd07c2089495ee5b07bdb371bc10004341edb58cbc287d4862ee96b797b14581"; + libraryHaskellDepends = [ base microlens template-haskell ]; + doHaddock = false; + doCheck = false; + homepage = "https://github.com/0xd34df00d/enum-subset-generate#readme"; + description = "Generate an ADT being a subset of another ADT, and the corresponding mappings"; + license = stdenv.lib.licenses.bsd3; + }) {}; + "enummapset" = callPackage + ({ mkDerivation, base, containers, deepseq, semigroups, stdenv }: + mkDerivation { + pname = "enummapset"; + version = "0.5.2.2"; + sha256 = "792fdbdf387de02580accb3ad49a6f5191b24eb2283ef141355eacfd328cce74"; + libraryHaskellDepends = [ base containers deepseq semigroups ]; + doHaddock = false; + doCheck = false; + homepage = "https://github.com/michalt/enummapset"; + description = "IntMap and IntSet with Enum keys/elements"; + license = stdenv.lib.licenses.bsd3; + }) {}; + "enumset" = callPackage + ({ mkDerivation, base, data-accessor, semigroups, stdenv + , storable-record + }: + mkDerivation { + pname = "enumset"; + version = "0.0.4.1"; + sha256 = "5f9d115f7f2b2d4dba290f9d62cd7e9f52f6f6f8235ac5ed9bbf6e982a51d054"; + libraryHaskellDepends = [ + base data-accessor semigroups storable-record + ]; + doHaddock = false; + doCheck = false; + description = "Sets of enumeration values represented by machine words"; + license = stdenv.lib.licenses.bsd3; + }) {}; + "envelope" = callPackage + ({ mkDerivation, aeson, base, http-api-data, mtl, stdenv, text }: + mkDerivation { + pname = "envelope"; + version = "0.2.2.0"; + sha256 = "cf4d6fe3f906e859ec3c16684a8dafb349e77f0fa4f21b7090ca33e707867ef9"; + libraryHaskellDepends = [ aeson base http-api-data mtl text ]; + doHaddock = false; + doCheck = false; + homepage = "https://github.com/cdepillabout/envelope#readme"; + description = "Defines generic 'Envelope' type to wrap reponses from a JSON API"; + license = stdenv.lib.licenses.bsd3; + }) {}; + "envy" = callPackage + ({ mkDerivation, base, bytestring, containers, mtl, stdenv, text + , time, transformers + }: + mkDerivation { + pname = "envy"; + version = "1.5.0.0"; + sha256 = "cdc099b3ae0c61007d07642c8e4811d29dfe3977b49595e21e03a1e29f741fbf"; + libraryHaskellDepends = [ + base bytestring containers mtl text time transformers + ]; + doHaddock = false; + doCheck = false; + description = "An environmentally friendly way to deal with environment variables"; + license = stdenv.lib.licenses.bsd3; + }) {}; + "epub-metadata" = callPackage + ({ mkDerivation, base, bytestring, containers, directory, filepath + , hxt, mtl, regex-compat-tdfa, stdenv, utf8-string, zip-archive + }: + mkDerivation { + pname = "epub-metadata"; + version = "4.5"; + sha256 = "19ae3914df5936908c8d7264ae5f1e310262fa06bd7e4390838892840e4c0349"; + isLibrary = true; + isExecutable = true; + libraryHaskellDepends = [ + base bytestring containers directory filepath hxt mtl + regex-compat-tdfa utf8-string zip-archive + ]; + executableHaskellDepends = [ base mtl ]; + doHaddock = false; + doCheck = false; + homepage = "http://hub.darcs.net/dino/epub-metadata"; + description = "Library for parsing epub document metadata"; + license = stdenv.lib.licenses.bsd3; + }) {}; + "eq" = callPackage + ({ mkDerivation, base, semigroupoids, stdenv }: + mkDerivation { + pname = "eq"; + version = "4.2"; + sha256 = "4160703a06af1c7518b8ff3244a04013fc7c04a012637dd26be31308e23970e8"; + libraryHaskellDepends = [ base semigroupoids ]; + doHaddock = false; + doCheck = false; + homepage = "http://github.com/ekmett/eq/"; + description = "Leibnizian equality"; + license = stdenv.lib.licenses.bsd3; + }) {}; + "equal-files" = callPackage + ({ mkDerivation, base, bytestring, explicit-exception, filemanip + , stdenv, transformers, utility-ht + }: + mkDerivation { + pname = "equal-files"; + version = "0.0.5.3"; + sha256 = "e5b785c286c557c57dba7107d913b220781aa2549ba4b7685da494b20a0172aa"; + isLibrary = false; + isExecutable = true; + executableHaskellDepends = [ + base bytestring explicit-exception filemanip transformers + utility-ht + ]; + doHaddock = false; + doCheck = false; + homepage = "http://code.haskell.org/~thielema/equal-files/"; + description = "Shell command for finding equal files"; + license = "GPL"; + }) {}; + "equivalence" = callPackage + ({ mkDerivation, base, containers, mtl, stdenv, STMonadTrans + , transformers, transformers-compat + }: + mkDerivation { + pname = "equivalence"; + version = "0.3.2"; + sha256 = "7da21ed5f980caa18c995190dd527c69822050390e4237c92f1acbed7d5b0529"; + revision = "1"; + editedCabalFile = "010n0gpk2rpninggdnnx0j7fys6hzn80s789b16iw0a55h4z0gn8"; + libraryHaskellDepends = [ + base containers mtl STMonadTrans transformers transformers-compat + ]; + doHaddock = false; + doCheck = false; + homepage = "https://github.com/pa-ba/equivalence"; + description = "Maintaining an equivalence relation implemented as union-find using STT"; + license = stdenv.lib.licenses.bsd3; + }) {}; + "erf" = callPackage + ({ mkDerivation, base, stdenv }: + mkDerivation { + pname = "erf"; + version = "2.0.0.0"; + sha256 = "24f0b79c7e1d25cb2cd44c2258d7a464bf6db8079775b50b60b54a254616b337"; + libraryHaskellDepends = [ base ]; + doHaddock = false; + doCheck = false; + description = "The error function, erf, and related functions"; + license = stdenv.lib.licenses.bsd3; + }) {}; + "error-util" = callPackage + ({ mkDerivation, base, stdenv, transformers }: + mkDerivation { + pname = "error-util"; + version = "0.0.1.2"; + sha256 = "df1916a2de007697b7b1a9f83eacab4588d8dc472fd0f21395dce83b085e4e06"; + libraryHaskellDepends = [ base transformers ]; + doHaddock = false; + doCheck = false; + homepage = "http://github.com/pmlodawski/error-util"; + description = "Set of utils and operators for error handling"; + license = stdenv.lib.licenses.mit; + }) {}; + "errors" = callPackage + ({ mkDerivation, base, exceptions, safe, stdenv, text, transformers + , transformers-compat + }: + mkDerivation { + pname = "errors"; + version = "2.3.0"; + sha256 = "6772e5689f07e82077ffe3339bc672934d83d83a97a7d4f1349de1302cb71f75"; + libraryHaskellDepends = [ + base exceptions safe text transformers transformers-compat + ]; + doHaddock = false; + doCheck = false; + description = "Simplified error-handling"; + license = stdenv.lib.licenses.bsd3; + }) {}; + "errors-ext" = callPackage + ({ mkDerivation, base, errors, exceptions, monad-control, mtl + , stdenv, transformers + }: + mkDerivation { + pname = "errors-ext"; + version = "0.4.1"; + sha256 = "b0ac78b09e0d5b856e91bfc59a2d91aef487807a2bbd1f562575e235df459ef6"; + libraryHaskellDepends = [ + base errors exceptions monad-control mtl transformers + ]; + doHaddock = false; + doCheck = false; + homepage = "https://github.com/A1-Triard/errors-ext#readme"; + description = "`bracket`-like functions for `ExceptT` over `IO` monad"; + license = stdenv.lib.licenses.asl20; + }) {}; + "ersatz" = callPackage + ({ mkDerivation, array, attoparsec, base, bytestring, Cabal + , cabal-doctest, containers, data-default, lens, mtl, parsec + , process, semigroups, stdenv, temporary, transformers + , unordered-containers + }: + mkDerivation { + pname = "ersatz"; + version = "0.4.3"; + sha256 = "d6c9672ec9a05bc8e7546d1479404b9028ff00e3bd78780f9902194106cc1e30"; + isLibrary = true; + isExecutable = true; + enableSeparateDataOutput = true; + setupHaskellDepends = [ base Cabal cabal-doctest ]; + libraryHaskellDepends = [ + array attoparsec base bytestring containers data-default lens mtl + process semigroups temporary transformers unordered-containers + ]; + executableHaskellDepends = [ + array base containers lens mtl parsec semigroups + ]; + doHaddock = false; + doCheck = false; + homepage = "http://github.com/ekmett/ersatz"; + description = "A monad for expressing SAT or QSAT problems using observable sharing"; + license = stdenv.lib.licenses.bsd3; + }) {}; + "etc" = callPackage + ({ mkDerivation, aeson, base, hashable, rio, stdenv, text + , typed-process, unliftio + }: + mkDerivation { + pname = "etc"; + version = "0.4.0.3"; + sha256 = "834fdec224481159f13dc6c177534978bbf245d2d4dc9ed94c808096772dd576"; + enableSeparateDataOutput = true; + libraryHaskellDepends = [ + aeson base hashable rio text typed-process unliftio + ]; + doHaddock = false; + doCheck = false; + homepage = "https://github.com/roman/Haskell-etc"; + description = "Declarative configuration spec for Haskell projects"; + license = stdenv.lib.licenses.mit; + }) {}; + "event" = callPackage + ({ mkDerivation, base, containers, semigroups, stdenv, transformers + }: + mkDerivation { + pname = "event"; + version = "0.1.4"; + sha256 = "6791d1402b4d77a11407ab592f65cb61ee60c5a80b99751c5d775afcc9d1824a"; + libraryHaskellDepends = [ + base containers semigroups transformers + ]; + doHaddock = false; + doCheck = false; + description = "Monoidal, monadic and first-class events"; + license = stdenv.lib.licenses.bsd3; + }) {}; + "event-list" = callPackage + ({ mkDerivation, base, non-negative, QuickCheck, semigroups, stdenv + , transformers, utility-ht + }: + mkDerivation { + pname = "event-list"; + version = "0.1.2"; + sha256 = "624e30b876e0acdaea895efbb2000bbbec2d5be0743ecac9805655ae634af89c"; + libraryHaskellDepends = [ + base non-negative QuickCheck semigroups transformers utility-ht + ]; + doHaddock = false; + doCheck = false; + homepage = "http://code.haskell.org/~thielema/event-list/"; + description = "Event lists with relative or absolute time stamps"; + license = "GPL"; + }) {}; + "eventful-core" = callPackage + ({ mkDerivation, aeson, base, containers, contravariant + , http-api-data, path-pieces, stdenv, sum-type-boilerplate + , template-haskell, text, transformers, uuid + }: + mkDerivation { + pname = "eventful-core"; + version = "0.2.0"; + sha256 = "e0f55e7498d8e48232ce2d5194c69f635beaeb322cb64753766076d7b35c9019"; + libraryHaskellDepends = [ + aeson base containers contravariant http-api-data path-pieces + sum-type-boilerplate template-haskell text transformers uuid + ]; + doHaddock = false; + doCheck = false; + homepage = "https://github.com/jdreaver/eventful#readme"; + description = "Core module for eventful"; + license = stdenv.lib.licenses.mit; + }) {}; + "eventful-memory" = callPackage + ({ mkDerivation, base, containers, eventful-core, mtl, safe, stdenv + , stm + }: + mkDerivation { + pname = "eventful-memory"; + version = "0.2.0"; + sha256 = "6a7c3e0a12e3c4e572927929020ad92075933e5d3c66ea61ff615a3ac217adb9"; + libraryHaskellDepends = [ + base containers eventful-core mtl safe stm + ]; + doHaddock = false; + doCheck = false; + homepage = "https://github.com/jdreaver/eventful#readme"; + description = "In-memory implementations for eventful"; + license = stdenv.lib.licenses.mit; + }) {}; + "eventful-sql-common" = callPackage + ({ mkDerivation, aeson, base, bytestring, eventful-core, mtl + , persistent, persistent-template, stdenv, text, uuid + }: + mkDerivation { + pname = "eventful-sql-common"; + version = "0.2.0"; + sha256 = "a46ea18cbbb5bd04b3a6846273e8161b7e4208660d0abf5a401192b07636aebc"; + libraryHaskellDepends = [ + aeson base bytestring eventful-core mtl persistent + persistent-template text uuid + ]; + doHaddock = false; + doCheck = false; + homepage = "https://github.com/jdreaver/eventful#readme"; + description = "Common library for SQL event stores"; + license = stdenv.lib.licenses.mit; + }) {}; + "eventful-sqlite" = callPackage + ({ mkDerivation, aeson, base, bytestring, eventful-core + , eventful-sql-common, mtl, persistent, stdenv, text, uuid + }: + mkDerivation { + pname = "eventful-sqlite"; + version = "0.2.0"; + sha256 = "c0bbea0ebd1f0a4891a74b190f499caf85ac026f49b9401fc76f181b0041dfef"; + libraryHaskellDepends = [ + aeson base bytestring eventful-core eventful-sql-common mtl + persistent text uuid + ]; + doHaddock = false; + doCheck = false; + homepage = "https://github.com/jdreaver/eventful#readme"; + description = "SQLite implementations for eventful"; + license = stdenv.lib.licenses.mit; + }) {}; + "eventful-test-helpers" = callPackage + ({ mkDerivation, aeson, aeson-casing, base, eventful-core, extra + , hspec, monad-logger, stdenv, text + }: + mkDerivation { + pname = "eventful-test-helpers"; + version = "0.2.0"; + sha256 = "a99f9d0cde3926add542c4fc59e079da7d71f2b40e2251b7d79777585c4ebfe0"; + libraryHaskellDepends = [ + aeson aeson-casing base eventful-core extra hspec monad-logger text + ]; + doHaddock = false; + doCheck = false; + homepage = "https://github.com/jdreaver/eventful#readme"; + description = "Common module used for eventful tests"; + license = stdenv.lib.licenses.mit; + }) {}; + "eventstore" = callPackage + ({ mkDerivation, aeson, array, base, bifunctors, bytestring, cereal + , clock, connection, containers, dns, dotnet-timespan, ekg-core + , exceptions, fast-logger, hashable, http-client, interpolate + , lifted-async, lifted-base, machines, monad-control, monad-logger + , mono-traversable, mtl, protobuf, random, safe-exceptions + , semigroups, stdenv, stm, stm-chans, text, time, transformers-base + , unordered-containers, uuid + }: + mkDerivation { + pname = "eventstore"; + version = "1.1.5"; + sha256 = "a8cf2f7063970532ffb26cd72696b610f92f1df3eecaed0b6cb4ea41128e11b1"; + libraryHaskellDepends = [ + aeson array base bifunctors bytestring cereal clock connection + containers dns dotnet-timespan ekg-core exceptions fast-logger + hashable http-client interpolate lifted-async lifted-base machines + monad-control monad-logger mono-traversable mtl protobuf random + safe-exceptions semigroups stm stm-chans text time + transformers-base unordered-containers uuid + ]; + doHaddock = false; + doCheck = false; + homepage = "https://code.coppermine.io/eventsourcing/haskell-ges"; + description = "EventStore TCP Client"; + license = stdenv.lib.licenses.bsd3; + platforms = [ "x86_64-darwin" "x86_64-linux" ]; + }) {}; + "every" = callPackage + ({ mkDerivation, async, base, stdenv, stm }: + mkDerivation { + pname = "every"; + version = "0.0.1"; + sha256 = "5d0ff0e4cefb094c44b55defa283146b16b925722a2eb244a5ef4364737980e5"; + libraryHaskellDepends = [ async base stm ]; + doHaddock = false; + doCheck = false; + homepage = "https://github.com/athanclark/every#readme"; + description = "Run a process every so often"; + license = stdenv.lib.licenses.bsd3; + }) {}; + "exact-combinatorics" = callPackage + ({ mkDerivation, base, stdenv }: + mkDerivation { + pname = "exact-combinatorics"; + version = "0.2.0.8"; + sha256 = "32a822b109ab6e9f62fe23d76bd5af593c20ba0e589005d3985ccda00dd4475e"; + libraryHaskellDepends = [ base ]; + doHaddock = false; + doCheck = false; + homepage = "http://code.haskell.org/~wren/"; + description = "Efficient exact computation of combinatoric functions"; + license = stdenv.lib.licenses.bsd3; + }) {}; + "exact-pi" = callPackage + ({ mkDerivation, base, numtype-dk, semigroups, stdenv }: + mkDerivation { + pname = "exact-pi"; + version = "0.4.1.3"; + sha256 = "4e9e87c653aa619b92e0f7c8e7d737cdc2610f0804bf619b47786165be972ce4"; + libraryHaskellDepends = [ base numtype-dk semigroups ]; + doHaddock = false; + doCheck = false; + homepage = "https://github.com/dmcclean/exact-pi/"; + description = "Exact rational multiples of pi (and integer powers of pi)"; + license = stdenv.lib.licenses.mit; + }) {}; + "exception-hierarchy" = callPackage + ({ mkDerivation, base, stdenv, template-haskell }: + mkDerivation { + pname = "exception-hierarchy"; + version = "0.1.0.1"; + sha256 = "a9424dc79f08bc98bf49353550101495c9a72ad67ba7c302388f64eed03760fe"; + libraryHaskellDepends = [ base template-haskell ]; + doHaddock = false; + doCheck = false; + homepage = "yet"; + description = "Exception type hierarchy with TemplateHaskell"; + license = stdenv.lib.licenses.bsd3; + }) {}; + "exception-mtl" = callPackage + ({ mkDerivation, base, exception-transformers, mtl, stdenv + , transformers + }: + mkDerivation { + pname = "exception-mtl"; + version = "0.4.0.1"; + sha256 = "ec13bcbae6cdde218a7118a2bd3058493af09a330b86e28469a278c9b2cea134"; + libraryHaskellDepends = [ + base exception-transformers mtl transformers + ]; + doHaddock = false; + doCheck = false; + description = "Exception monad transformer instances for mtl classes"; + license = stdenv.lib.licenses.bsd3; + }) {}; + "exception-transformers" = callPackage + ({ mkDerivation, base, stdenv, stm, transformers + , transformers-compat + }: + mkDerivation { + pname = "exception-transformers"; + version = "0.4.0.7"; + sha256 = "925b61eb3d19148a521e79f8b4c8ac097f6e0dea6a09cc2f533279f3abf1f2ef"; + revision = "1"; + editedCabalFile = "0sahi93f75acvmqagkjc1lcwx31crja6z9hyww9abj85x45pqa6f"; + libraryHaskellDepends = [ + base stm transformers transformers-compat + ]; + doHaddock = false; + doCheck = false; + description = "Type classes and monads for unchecked extensible exceptions"; + license = stdenv.lib.licenses.bsd3; + }) {}; + "exceptional" = callPackage + ({ mkDerivation, base, exceptions, stdenv }: + mkDerivation { + pname = "exceptional"; + version = "0.3.0.0"; + sha256 = "da866ed28ea14d245cc065271f4ddd6da0a91b83e8d83daddcd1ef0623e99f06"; + libraryHaskellDepends = [ base exceptions ]; + doHaddock = false; + doCheck = false; + homepage = "https://github.com/"; + description = "Essentially the Maybe type with error messages"; + license = stdenv.lib.licenses.bsd2; + }) {}; + "exceptions" = callPackage + ({ mkDerivation, base, mtl, stdenv, stm, template-haskell + , transformers, transformers-compat + }: + mkDerivation { + pname = "exceptions"; + version = "0.10.0"; + sha256 = "1edd912e5ea5cbda37941b06738597d35214dc247d332b1bfffc82adadfa49d7"; + revision = "2"; + editedCabalFile = "0aiihbjfrlmxzw9q8idvr6mihhs7kbx9s3w1vj8x3pz27p0ncq7g"; + libraryHaskellDepends = [ + base mtl stm template-haskell transformers transformers-compat + ]; + doHaddock = false; + doCheck = false; + homepage = "http://github.com/ekmett/exceptions/"; + description = "Extensible optionally-pure exceptions"; + license = stdenv.lib.licenses.bsd3; + }) {}; + "executable-hash" = callPackage + ({ mkDerivation, base, bytestring, Cabal, cryptohash, directory + , executable-path, file-embed, filepath, stdenv, template-haskell + }: + mkDerivation { + pname = "executable-hash"; + version = "0.2.0.4"; + sha256 = "34eaf5662d90d3b7841f66b322ac5bc54900b0e3cb06792852b08b3c05a42ba4"; + isLibrary = true; + isExecutable = true; + setupHaskellDepends = [ + base bytestring Cabal cryptohash directory file-embed filepath + template-haskell + ]; + libraryHaskellDepends = [ + base bytestring cryptohash directory executable-path file-embed + template-haskell + ]; + executableHaskellDepends = [ base ]; + doHaddock = false; + doCheck = false; + homepage = "http://github.com/fpco/executable-hash"; + description = "Provides the SHA1 hash of the program executable"; + license = stdenv.lib.licenses.mit; + }) {}; + "executable-path" = callPackage + ({ mkDerivation, base, directory, filepath, stdenv, unix }: + mkDerivation { + pname = "executable-path"; + version = "0.0.3.1"; + sha256 = "9cc742b6d40a487b3af38dca6852ca3b50a0db94d42fe819576c84beb5adbc6f"; + libraryHaskellDepends = [ base directory filepath unix ]; + doHaddock = false; + doCheck = false; + homepage = "http://code.haskell.org/~bkomuves/"; + description = "Finding out the full path of the executable"; + license = stdenv.lib.licenses.publicDomain; + }) {}; + "exinst" = callPackage + ({ mkDerivation, aeson, base, binary, bytes, cborg, cereal + , constraints, deepseq, hashable, profunctors, QuickCheck + , serialise, singletons, stdenv + }: + mkDerivation { + pname = "exinst"; + version = "0.6"; + sha256 = "e906a149bfe195c16c25a5ab9ec2116e2577e5a10de134c17dff2be2c17c925e"; + libraryHaskellDepends = [ + aeson base binary bytes cborg cereal constraints deepseq hashable + profunctors QuickCheck serialise singletons + ]; + doHaddock = false; + doCheck = false; + homepage = "https://github.com/k0001/exinst"; + description = "Dependent pairs and their instances"; + license = stdenv.lib.licenses.bsd3; + }) {}; + "exomizer" = callPackage + ({ mkDerivation, base, bytestring, c2hs, stdenv }: + mkDerivation { + pname = "exomizer"; + version = "1.0.0"; + sha256 = "94c24d436d12666d16cb7171c83cedec449b992dc3aeaaa6decdc0faf8e2cfd2"; + enableSeparateDataOutput = true; + libraryHaskellDepends = [ base bytestring ]; + libraryToolDepends = [ c2hs ]; + doHaddock = false; + doCheck = false; + homepage = "https://github.com/alexkazik/exomizer#readme"; + description = "Compression and decompression in the exomizer format"; + license = "unknown"; + }) {}; + "exp-pairs" = callPackage + ({ mkDerivation, base, containers, deepseq, ghc-prim, prettyprinter + , stdenv + }: + mkDerivation { + pname = "exp-pairs"; + version = "0.1.6.0"; + sha256 = "e63ad90fcd292a9a31bd42b94408930c7cdf06700c9879453e61423a89a75be3"; + revision = "1"; + editedCabalFile = "1zbsjlj6wavz9ysfzjqb4ng7688crlfvsbyj4li84khc1jp71xj3"; + libraryHaskellDepends = [ + base containers deepseq ghc-prim prettyprinter + ]; + doHaddock = false; + doCheck = false; + homepage = "https://github.com/Bodigrim/exp-pairs"; + description = "Linear programming over exponent pairs"; + license = stdenv.lib.licenses.gpl3; + }) {}; + "expiring-cache-map" = callPackage + ({ mkDerivation, base, containers, hashable, stdenv + , unordered-containers + }: + mkDerivation { + pname = "expiring-cache-map"; + version = "0.0.6.1"; + sha256 = "0e3bc294978b46ee59bf0b4a7e7a5bd7ed5da7bc261ffebdb0cb1b60353c64b9"; + libraryHaskellDepends = [ + base containers hashable unordered-containers + ]; + doHaddock = false; + doCheck = false; + homepage = "https://github.com/elblake/expiring-cache-map"; + description = "General purpose simple caching"; + license = stdenv.lib.licenses.bsd3; + }) {}; + "explicit-exception" = callPackage + ({ mkDerivation, base, deepseq, semigroups, stdenv, transformers }: + mkDerivation { + pname = "explicit-exception"; + version = "0.1.9.2"; + sha256 = "60f6029777f80ec958e28cef19a15723242987a01f09f6bfef252f24207649f6"; + isLibrary = true; + isExecutable = true; + libraryHaskellDepends = [ base deepseq semigroups transformers ]; + doHaddock = false; + doCheck = false; + homepage = "http://www.haskell.org/haskellwiki/Exception"; + description = "Exceptions which are explicit in the type signature"; + license = stdenv.lib.licenses.bsd3; + }) {}; + "extensible" = callPackage + ({ mkDerivation, aeson, base, bytestring, cassava, comonad + , constraints, deepseq, ghc-prim, hashable, monad-skeleton, mtl + , prettyprinter, primitive, profunctors, QuickCheck, semigroups + , StateVar, stdenv, tagged, template-haskell, text, th-lift + , transformers, unordered-containers, vector + }: + mkDerivation { + pname = "extensible"; + version = "0.4.9"; + sha256 = "b752ea6f45ff57e2994e12af911c92977b54246756c5181e376e09fd28f93e86"; + libraryHaskellDepends = [ + aeson base bytestring cassava comonad constraints deepseq ghc-prim + hashable monad-skeleton mtl prettyprinter primitive profunctors + QuickCheck semigroups StateVar tagged template-haskell text th-lift + transformers unordered-containers vector + ]; + doHaddock = false; + doCheck = false; + homepage = "https://github.com/fumieval/extensible"; + description = "Extensible, efficient, optics-friendly data types and effects"; + license = stdenv.lib.licenses.bsd3; + }) {}; + "extensible-exceptions" = callPackage + ({ mkDerivation, base, stdenv }: + mkDerivation { + pname = "extensible-exceptions"; + version = "0.1.1.4"; + sha256 = "6ce5e8801760385a408dab71b53550f87629e661b260bdc2cd41c6a439b6e388"; + libraryHaskellDepends = [ base ]; + doHaddock = false; + doCheck = false; + description = "Extensible exceptions"; + license = stdenv.lib.licenses.bsd3; + }) {}; + "extra" = callPackage + ({ mkDerivation, base, clock, directory, filepath, process, stdenv + , time, unix + }: + mkDerivation { + pname = "extra"; + version = "1.6.9"; + sha256 = "2bc8cf7bd00e08f99cd6e55f7405f1b9d3950d84ef28e32b4b91bf0bc0baac77"; + libraryHaskellDepends = [ + base clock directory filepath process time unix + ]; + doHaddock = false; + doCheck = false; + homepage = "https://github.com/ndmitchell/extra#readme"; + description = "Extra functions I use"; + license = stdenv.lib.licenses.bsd3; + }) {}; + "extractable-singleton" = callPackage + ({ mkDerivation, base, stdenv, transformers }: + mkDerivation { + pname = "extractable-singleton"; + version = "0.0.1"; + sha256 = "e8da1928d98c57ef3d1bab7deb1378f51fa496721495777233663dd0b1b2c0ad"; + libraryHaskellDepends = [ base transformers ]; + doHaddock = false; + doCheck = false; + homepage = "https://github.com/athanclark/extractable-singleton#readme"; + description = "A functor, where the \"stored\" value is isomorphic to Identity"; + license = stdenv.lib.licenses.bsd3; + }) {}; + "extrapolate" = callPackage + ({ mkDerivation, base, leancheck, speculate, stdenv + , template-haskell + }: + mkDerivation { + pname = "extrapolate"; + version = "0.3.1"; + sha256 = "c4aea5df7abd2d267e012e8e4fde00eb0e7fc3aa18670ff196c433ad5a1de0c3"; + libraryHaskellDepends = [ + base leancheck speculate template-haskell + ]; + doHaddock = false; + doCheck = false; + homepage = "https://github.com/rudymatela/extrapolate#readme"; + description = "generalize counter-examples of test properties"; + license = stdenv.lib.licenses.bsd3; + }) {}; + "facts" = callPackage + ({ mkDerivation, base, exceptions, mtl, stdenv, template-haskell }: + mkDerivation { + pname = "facts"; + version = "0.0.1.0"; + sha256 = "dde59212abc383920c5ac5c5a0b5253f4a309d14ebbb21b45310d5b78d922e8a"; + revision = "1"; + editedCabalFile = "03v6p3vlilz6vk5xlvw3r31cqicx3m1xjii9shcqpacxvlh2zzlp"; + libraryHaskellDepends = [ base exceptions mtl template-haskell ]; + doHaddock = false; + doCheck = false; + homepage = "https://github.com/mrkkrp/facts"; + description = "Refined types"; + license = stdenv.lib.licenses.bsd3; + }) {}; + "fail" = callPackage + ({ mkDerivation, stdenv }: + mkDerivation { + pname = "fail"; + version = "4.9.0.0"; + sha256 = "6d5cdb1a5c539425a9665f740e364722e1d9d6ae37fbc55f30fe3dbbbb91d4a2"; + doHaddock = false; + doCheck = false; + homepage = "https://prime.haskell.org/wiki/Libraries/Proposals/MonadFail"; + description = "Forward-compatible MonadFail class"; + license = stdenv.lib.licenses.bsd3; + }) {}; + "farmhash" = callPackage + ({ mkDerivation, base, bytestring, stdenv }: + mkDerivation { + pname = "farmhash"; + version = "0.1.0.5"; + sha256 = "0e685a5445f7bce88682d209bccb47d03f06065a627475df44a8e2af8bc20fa1"; + libraryHaskellDepends = [ base bytestring ]; + doHaddock = false; + doCheck = false; + homepage = "https://github.com/abhinav/farmhash"; + description = "Fast hash functions"; + license = stdenv.lib.licenses.bsd3; + }) {}; + "fast-digits" = callPackage + ({ mkDerivation, base, integer-gmp, stdenv }: + mkDerivation { + pname = "fast-digits"; + version = "0.2.1.0"; + sha256 = "ec84576e479202de8257c7c499b66e91bcf18444f7683475d74b575e166dd83b"; + libraryHaskellDepends = [ base integer-gmp ]; + doHaddock = false; + doCheck = false; + homepage = "https://github.com/Bodigrim/fast-digits"; + description = "The fast library for integer-to-digits conversion"; + license = stdenv.lib.licenses.gpl3; + }) {}; + "fast-logger" = callPackage + ({ mkDerivation, array, auto-update, base, bytestring, directory + , easy-file, filepath, stdenv, text, unix, unix-time + }: + mkDerivation { + pname = "fast-logger"; + version = "2.4.11"; + sha256 = "bbe5deab58f435754dbe938cf0ddf26fc21f317c35fb3431d4bdb96809dea2a9"; + libraryHaskellDepends = [ + array auto-update base bytestring directory easy-file filepath text + unix unix-time + ]; + doHaddock = false; + doCheck = false; + homepage = "https://github.com/kazu-yamamoto/logger"; + description = "A fast logging system"; + license = stdenv.lib.licenses.bsd3; + }) {}; + "fast-math" = callPackage + ({ mkDerivation, base, stdenv }: + mkDerivation { + pname = "fast-math"; + version = "1.0.2"; + sha256 = "45101ddc8b86402e866ec029bcfbc2662779e578e43b40acd971a9f411e2be95"; + libraryHaskellDepends = [ base ]; + doHaddock = false; + doCheck = false; + description = "Non IEEE-754 compliant compile-time floating-point optimisations"; + license = stdenv.lib.licenses.bsd3; + }) {}; + "fay" = callPackage + ({ mkDerivation, aeson, base, base-compat, bytestring, Cabal + , containers, data-default, data-lens-light, directory, filepath + , ghc-paths, haskell-src-exts, language-ecmascript, mtl, mtl-compat + , optparse-applicative, process, safe, shakespeare, sourcemap + , split, spoon, stdenv, syb, text, time, transformers + , transformers-compat, traverse-with-class, uniplate + , unordered-containers, utf8-string, vector + }: + mkDerivation { + pname = "fay"; + version = "0.24.0.1"; + sha256 = "a26ef27237670a6dccbc566a649fb9e137dc736a61e65c05814b381fb86fe817"; + isLibrary = true; + isExecutable = true; + enableSeparateDataOutput = true; + setupHaskellDepends = [ base Cabal ]; + libraryHaskellDepends = [ + aeson base base-compat bytestring containers data-default + data-lens-light directory filepath ghc-paths haskell-src-exts + language-ecmascript mtl mtl-compat process safe shakespeare + sourcemap split spoon syb text time transformers + transformers-compat traverse-with-class uniplate + unordered-containers utf8-string vector + ]; + executableHaskellDepends = [ base mtl optparse-applicative split ]; + doHaddock = false; + doCheck = false; + homepage = "https://github.com/faylang/fay/wiki"; + description = "A compiler for Fay, a Haskell subset that compiles to JavaScript"; + license = stdenv.lib.licenses.bsd3; + }) {}; + "fay-base" = callPackage + ({ mkDerivation, base, fay, stdenv }: + mkDerivation { + pname = "fay-base"; + version = "0.21.1.0"; + sha256 = "5f94e3657276c5d15fcec039e8fa28f4f0d923aab17069518f6a7ca208c029c4"; + enableSeparateDataOutput = true; + libraryHaskellDepends = [ base fay ]; + doHaddock = false; + doCheck = false; + homepage = "https://github.com/faylang/fay/"; + description = "The base package for Fay"; + license = stdenv.lib.licenses.bsd3; + }) {}; + "fay-dom" = callPackage + ({ mkDerivation, fay-base, stdenv }: + mkDerivation { + pname = "fay-dom"; + version = "0.5.0.1"; + sha256 = "e0f2e4dc11a13c4a9c43d707a3cf24bc1badb585540d24b29e8a6bc6ace1a6fe"; + revision = "1"; + editedCabalFile = "1lhmkf2n7prv6w51bl3szz4g9cn2dkhb873m7f568nnwysqibv8b"; + enableSeparateDataOutput = true; + libraryHaskellDepends = [ fay-base ]; + doHaddock = false; + doCheck = false; + homepage = "https://github.com/faylang/fay-dom"; + description = "DOM FFI wrapper library for Fay"; + license = stdenv.lib.licenses.bsd3; + }) {}; + "fb" = callPackage + ({ mkDerivation, aeson, attoparsec, base, base16-bytestring + , base64-bytestring, bytestring, cereal, conduit, conduit-extra + , crypto-api, cryptohash, cryptohash-cryptoapi, data-default + , http-client, http-conduit, http-types, monad-logger, old-locale + , resourcet, stdenv, text, time, transformers, transformers-base + , unliftio, unliftio-core, unordered-containers + }: + mkDerivation { + pname = "fb"; + version = "1.2.1"; + sha256 = "a9d670a763e2ccf3e457e6b310769d5d8977cb1c00a78c8825861999da055d15"; + libraryHaskellDepends = [ + aeson attoparsec base base16-bytestring base64-bytestring + bytestring cereal conduit conduit-extra crypto-api cryptohash + cryptohash-cryptoapi data-default http-client http-conduit + http-types monad-logger old-locale resourcet text time transformers + transformers-base unliftio unliftio-core unordered-containers + ]; + doHaddock = false; + doCheck = false; + homepage = "https://github.com/psibi/fb"; + description = "Bindings to Facebook's API"; + license = stdenv.lib.licenses.bsd3; + }) {}; + "fclabels" = callPackage + ({ mkDerivation, base, mtl, stdenv, template-haskell, transformers + }: + mkDerivation { + pname = "fclabels"; + version = "2.0.3.3"; + sha256 = "9a9472a46dc23b5acc0545d345ecd708f7b003f72ab212e2d12125b902b9c2e0"; + revision = "3"; + editedCabalFile = "1wncfnvh4mv87gh0ddhiqf839d63rqs1qzi3y386y6r8hfnvra0l"; + libraryHaskellDepends = [ base mtl template-haskell transformers ]; + doHaddock = false; + doCheck = false; + homepage = "https://github.com/sebastiaanvisser/fclabels"; + description = "First class accessor labels implemented as lenses"; + license = stdenv.lib.licenses.bsd3; + }) {}; + "feature-flags" = callPackage + ({ mkDerivation, base, stdenv, text }: + mkDerivation { + pname = "feature-flags"; + version = "0.1.0.1"; + sha256 = "0e4cf7db6791b0875975dfa001d71bf31797b2edbfd2424f6b6202ace7935ad3"; + libraryHaskellDepends = [ base text ]; + doHaddock = false; + doCheck = false; + homepage = "https://github.com/iand675/feature-flags"; + description = "A simple library for dynamically enabling and disabling functionality"; + license = stdenv.lib.licenses.mit; + }) {}; + "fedora-haskell-tools" = callPackage + ({ mkDerivation, base, directory, filepath, process, stdenv, time + , unix + }: + mkDerivation { + pname = "fedora-haskell-tools"; + version = "0.5.1"; + sha256 = "b9a9119aace941ff5860c02462bf340c6f3cce29f7bdcb42af98dedfa9888394"; + isLibrary = false; + isExecutable = true; + executableHaskellDepends = [ + base directory filepath process time unix + ]; + doHaddock = false; + doCheck = false; + homepage = "https://github.com/fedora-haskell/fedora-haskell-tools"; + description = "Building and managing tools for Fedora Haskell"; + license = stdenv.lib.licenses.gpl3; + }) {}; + "feed" = callPackage + ({ mkDerivation, base, base-compat, bytestring, old-locale + , old-time, safe, stdenv, text, time, time-locale-compat + , utf8-string, xml-conduit, xml-types + }: + mkDerivation { + pname = "feed"; + version = "1.0.0.0"; + sha256 = "9359a12d3da138ba50fecfc31eed7f92438a6417e9fc3aa17b95a014fa792f17"; + revision = "4"; + editedCabalFile = "0baavcavm3ywykcr9cm07aqr7sna98jba2n68lyn3kany8ri214d"; + enableSeparateDataOutput = true; + libraryHaskellDepends = [ + base base-compat bytestring old-locale old-time safe text time + time-locale-compat utf8-string xml-conduit xml-types + ]; + doHaddock = false; + doCheck = false; + homepage = "https://github.com/bergmark/feed"; + description = "Interfacing with RSS (v 0.9x, 2.x, 1.0) + Atom feeds."; + license = stdenv.lib.licenses.bsd3; + }) {}; + "fft" = callPackage + ({ mkDerivation, array, base, carray, fftw, fftwFloat, ix-shapable + , stdenv, storable-complex, syb, transformers + }: + mkDerivation { + pname = "fft"; + version = "0.1.8.6"; + sha256 = "2ed8d8301903283c9a62eda1f1cf49db0c471c4c128fbfdef562d598401e5b42"; + libraryHaskellDepends = [ + array base carray ix-shapable storable-complex syb transformers + ]; + libraryPkgconfigDepends = [ fftw fftwFloat ]; + doHaddock = false; + doCheck = false; + description = "Bindings to the FFTW library"; + license = stdenv.lib.licenses.bsd3; + }) {inherit (pkgs) fftw; inherit (pkgs) fftwFloat;}; + "fgl" = callPackage + ({ mkDerivation, array, base, containers, deepseq, stdenv + , transformers + }: + mkDerivation { + pname = "fgl"; + version = "5.6.0.0"; + sha256 = "94722e1eb3dca66069e26a2d4b072c558bc896816ee016fc99521f3e16b9ccc4"; + revision = "1"; + editedCabalFile = "17r5p1c6srgyzpdkqkjcl9k3ax9c82lvps1kqjhxpdzypsnzns70"; + libraryHaskellDepends = [ + array base containers deepseq transformers + ]; + doHaddock = false; + doCheck = false; + description = "Martin Erwig's Functional Graph Library"; + license = stdenv.lib.licenses.bsd3; + }) {}; + "file-embed" = callPackage + ({ mkDerivation, base, bytestring, directory, filepath, stdenv + , template-haskell + }: + mkDerivation { + pname = "file-embed"; + version = "0.0.10.1"; + sha256 = "33cdeb44e8fa1ca8ade64e2b8d0924ea8c70b2b521455a0f22cde36f19314152"; + libraryHaskellDepends = [ + base bytestring directory filepath template-haskell + ]; + doHaddock = false; + doCheck = false; + homepage = "https://github.com/snoyberg/file-embed"; + description = "Use Template Haskell to embed file contents directly"; + license = stdenv.lib.licenses.bsd3; + }) {}; + "file-embed-lzma" = callPackage + ({ mkDerivation, base, base-compat, bytestring, directory, filepath + , lzma, stdenv, template-haskell, text, th-lift-instances + , transformers + }: + mkDerivation { + pname = "file-embed-lzma"; + version = "0"; + sha256 = "e86cf44f747cf403898158e9fdf9342871e293097a29679fcf587aed497f0c77"; + revision = "2"; + editedCabalFile = "0dmg69gsj2k9lf112bvqw6z2w8hl0p1lx5zxdvlvk85bb3qz6304"; + libraryHaskellDepends = [ + base base-compat bytestring directory filepath lzma + template-haskell text th-lift-instances transformers + ]; + doHaddock = false; + doCheck = false; + homepage = "https://github.com/phadej/file-embed-lzma"; + description = "Use Template Haskell to embed (LZMA compressed) data"; + license = stdenv.lib.licenses.bsd3; + }) {}; + "file-modules" = callPackage + ({ mkDerivation, async, base, directory, filepath, haskell-src-exts + , MissingH, regex-compat, regex-pcre, stdenv + }: + mkDerivation { + pname = "file-modules"; + version = "0.1.2.4"; + sha256 = "ffea2dbd51f77ed76f8559d8519674a1210611a35e2dbea72dfb41d7d5f0f235"; + isLibrary = true; + isExecutable = true; + libraryHaskellDepends = [ + async base directory filepath haskell-src-exts MissingH + regex-compat regex-pcre + ]; + executableHaskellDepends = [ + async base directory filepath haskell-src-exts MissingH + regex-compat regex-pcre + ]; + doHaddock = false; + doCheck = false; + homepage = "https://github.com/yamadapc/stack-run-auto"; + description = "Takes a Haskell source-code file and outputs its modules"; + license = stdenv.lib.licenses.mit; + }) {}; + "filecache" = callPackage + ({ mkDerivation, base, containers, directory, exceptions, filepath + , fsnotify, mtl, stdenv, stm, strict-base-types, time + }: + mkDerivation { + pname = "filecache"; + version = "0.4.0"; + sha256 = "cd088db62e75138e877a88b31cf44dfa8773dc30c4a431e6b0663b6e3a764e74"; + libraryHaskellDepends = [ + base containers directory exceptions filepath fsnotify mtl stm + strict-base-types time + ]; + doHaddock = false; + doCheck = false; + homepage = "http://lpuppet.banquise.net/"; + description = "A cache system associating values to files"; + license = stdenv.lib.licenses.bsd3; + }) {}; + "filelock" = callPackage + ({ mkDerivation, base, stdenv, unix }: + mkDerivation { + pname = "filelock"; + version = "0.1.1.2"; + sha256 = "0ff1dcb13ec619f72496035e2a1298ef9dc6a814ba304d882cd9b145eae3203d"; + libraryHaskellDepends = [ base unix ]; + doHaddock = false; + doCheck = false; + homepage = "http://github.com/takano-akio/filelock"; + description = "Portable interface to file locking (flock / LockFileEx)"; + license = stdenv.lib.licenses.publicDomain; + }) {}; + "filemanip" = callPackage + ({ mkDerivation, base, bytestring, directory, filepath, mtl, stdenv + , unix-compat + }: + mkDerivation { + pname = "filemanip"; + version = "0.3.6.3"; + sha256 = "8836da17baaaf02ca080c9990ece4e0b0c8d6a128f458f8b64fd07b225ca9846"; + libraryHaskellDepends = [ + base bytestring directory filepath mtl unix-compat + ]; + doHaddock = false; + doCheck = false; + homepage = "https://github.com/bos/filemanip"; + description = "Expressive file and directory manipulation for Haskell"; + license = stdenv.lib.licenses.bsd3; + }) {}; + "fileplow" = callPackage + ({ mkDerivation, base, binary-search, bytestring, stdenv, vector }: + mkDerivation { + pname = "fileplow"; + version = "0.1.0.0"; + sha256 = "9ddc7db62c97fa4413ff2435c96aac9f6f716e2f6bc7a71aa4db25c3871bee04"; + libraryHaskellDepends = [ base binary-search bytestring vector ]; + doHaddock = false; + doCheck = false; + homepage = "https://github.com/agrafix/fileplow#readme"; + description = "Library to process and search large files or a collection of files"; + license = stdenv.lib.licenses.bsd3; + }) {}; + "filter-logger" = callPackage + ({ mkDerivation, aeson, aeson-pretty, ansi-terminal, base + , bytestring, data-default, fast-logger, http-types, scotty + , semigroups, stdenv, time, wai, wai-extra, wai-logger + }: + mkDerivation { + pname = "filter-logger"; + version = "0.6.0.0"; + sha256 = "7884124056950a7f7ff393ebb7d1622695f9b66f898c60aeb8bc991c73642f21"; + isLibrary = true; + isExecutable = true; + libraryHaskellDepends = [ + aeson aeson-pretty ansi-terminal base bytestring data-default + fast-logger http-types semigroups time wai wai-extra wai-logger + ]; + executableHaskellDepends = [ aeson base bytestring scotty ]; + doHaddock = false; + doCheck = false; + homepage = "https://github.com/caneroj1/filter-logger#readme"; + description = "Filterable request logging wai middleware. Change how data is logged and when."; + license = stdenv.lib.licenses.mit; + }) {}; + "filtrable" = callPackage + ({ mkDerivation, base, stdenv }: + mkDerivation { + pname = "filtrable"; + version = "0.1.1.0"; + sha256 = "d6a53889a7d114a7ea411026b994c9f73ebfeffe68ea338ce2abf9dc977e363c"; + libraryHaskellDepends = [ base ]; + doHaddock = false; + doCheck = false; + homepage = "https://github.com/strake/filtrable.hs"; + description = "Class of filtrable containers"; + license = stdenv.lib.licenses.bsd3; + }) {}; + "fin" = callPackage + ({ mkDerivation, base, deepseq, hashable, stdenv }: + mkDerivation { + pname = "fin"; + version = "0.0.1"; + sha256 = "34d28a951f2899f1d27bfb75d53818204d6d7e5aeaaef1a326c50ae915361a57"; + revision = "1"; + editedCabalFile = "056d22f1j1xv5ka2qr7a3z5ad5w1im76qdf77v6dqdi4vaz52vd1"; + libraryHaskellDepends = [ base deepseq hashable ]; + doHaddock = false; + doCheck = false; + homepage = "https://github.com/phadej/vec"; + description = "Nat and Fin: peano naturals and finite numbers"; + license = stdenv.lib.licenses.bsd3; + }) {}; + "find-clumpiness" = callPackage + ({ mkDerivation, aeson, base, BiobaseNewick, bytestring, clumpiness + , containers, hierarchical-clustering, listsafe, mtl + , optparse-applicative, stdenv, text, text-show, tree-fun + , unordered-containers, vector + }: + mkDerivation { + pname = "find-clumpiness"; + version = "0.2.3.1"; + sha256 = "089e55641eedd12ab16ae5e81cbd2c6c0375801c01fc17fb2ce23354a0ec2c2a"; + isLibrary = true; + isExecutable = true; + libraryHaskellDepends = [ + aeson base BiobaseNewick bytestring clumpiness containers + hierarchical-clustering listsafe mtl text text-show tree-fun + unordered-containers vector + ]; + executableHaskellDepends = [ + aeson base BiobaseNewick bytestring clumpiness containers + optparse-applicative text tree-fun unordered-containers + ]; + doHaddock = false; + doCheck = false; + homepage = "http://github.com/GregorySchwartz/find-clumpiness#readme"; + description = "Find the clumpiness of labels in a tree"; + license = stdenv.lib.licenses.gpl3; + }) {}; + "fingertree" = callPackage + ({ mkDerivation, base, stdenv }: + mkDerivation { + pname = "fingertree"; + version = "0.1.4.1"; + sha256 = "9778dc162963c376f02239183e782673729d01a2e1e1dbf81924d80bf6f74ea4"; + libraryHaskellDepends = [ base ]; + doHaddock = false; + doCheck = false; + description = "Generic finger-tree structure, with example instances"; + license = stdenv.lib.licenses.bsd3; + }) {}; + "finite-typelits" = callPackage + ({ mkDerivation, base, deepseq, stdenv }: + mkDerivation { + pname = "finite-typelits"; + version = "0.1.4.2"; + sha256 = "d207a46c911b69ecc1f7c50d9d65ea1aca6c6efacec6342bc3294ed1bc4bd747"; + libraryHaskellDepends = [ base deepseq ]; + doHaddock = false; + doCheck = false; + homepage = "https://github.com/mniip/finite-typelits"; + description = "A type inhabited by finitely many values, indexed by type-level naturals"; + license = stdenv.lib.licenses.bsd3; + }) {}; + "first-class-patterns" = callPackage + ({ mkDerivation, base, stdenv, transformers }: + mkDerivation { + pname = "first-class-patterns"; + version = "0.3.2.4"; + sha256 = "3bf42829097277a89043021d02b82bde24950de9c30d19b33c0ffa5e1f2482b5"; + libraryHaskellDepends = [ base transformers ]; + doHaddock = false; + doCheck = false; + homepage = "https://github.com/kowainik/first-class-patterns"; + description = "First class patterns and pattern matching, using type families"; + license = stdenv.lib.licenses.bsd3; + }) {}; + "fixed" = callPackage + ({ mkDerivation, base, stdenv }: + mkDerivation { + pname = "fixed"; + version = "0.2.1.1"; + sha256 = "24a9e1e251998c9d06037bb771d9eab2980a91132de59a19d0166a1c51e715e2"; + libraryHaskellDepends = [ base ]; + doHaddock = false; + doCheck = false; + homepage = "http://github.com/ekmett/fixed"; + description = "Signed 15.16 precision fixed point arithmetic"; + license = stdenv.lib.licenses.bsd3; + }) {}; + "fixed-length" = callPackage + ({ mkDerivation, base, non-empty, stdenv, tfp, utility-ht }: + mkDerivation { + pname = "fixed-length"; + version = "0.2"; + sha256 = "3171f2d443171a8e92733b3935805c7d5b54eae1f39f9fd729a766f887a6389b"; + libraryHaskellDepends = [ base non-empty tfp utility-ht ]; + doHaddock = false; + doCheck = false; + homepage = "http://hub.darcs.net/thielema/fixed-length/"; + description = "Lists with statically known length based on non-empty package"; + license = stdenv.lib.licenses.bsd3; + }) {}; + "fixed-vector" = callPackage + ({ mkDerivation, base, deepseq, primitive, stdenv }: + mkDerivation { + pname = "fixed-vector"; + version = "1.1.0.0"; + sha256 = "1ed0bef94b0fead859ad2aea0b73bf1bd3686a6c1faafc75e321fbd9c3ae94c5"; + libraryHaskellDepends = [ base deepseq primitive ]; + doHaddock = false; + doCheck = false; + description = "Generic vectors with statically known size"; + license = stdenv.lib.licenses.bsd3; + }) {}; + "fixed-vector-hetero" = callPackage + ({ mkDerivation, base, deepseq, fixed-vector, primitive, stdenv }: + mkDerivation { + pname = "fixed-vector-hetero"; + version = "0.5.0.0"; + sha256 = "a3f25968b260c953c6ad4ec75ba5211238b2bb07185fe1f33fb98301a4ee8690"; + libraryHaskellDepends = [ base deepseq fixed-vector primitive ]; + doHaddock = false; + doCheck = false; + homepage = "http://github.org/Shimuuar/fixed-vector-hetero"; + description = "Generic heterogeneous vectors"; + license = stdenv.lib.licenses.bsd3; + }) {}; + "flac" = callPackage + ({ mkDerivation, base, bytestring, containers, data-default-class + , directory, exceptions, filepath, FLAC, mtl, stdenv, text + , transformers, vector, wave + }: + mkDerivation { + pname = "flac"; + version = "0.1.2"; + sha256 = "5692b3dfc561cbeed25b1cf9280705f58eadd8c400aa2e6a725fd5562042ac29"; + revision = "4"; + editedCabalFile = "0bmhd56fg4idz62maig3kykk7dyqy9dpm27fdljqg8jccl0vbwbm"; + enableSeparateDataOutput = true; + libraryHaskellDepends = [ + base bytestring containers data-default-class directory exceptions + filepath mtl text transformers vector wave + ]; + librarySystemDepends = [ FLAC ]; + doHaddock = false; + doCheck = false; + homepage = "https://github.com/mrkkrp/flac"; + description = "Complete high-level binding to libFLAC"; + license = stdenv.lib.licenses.bsd3; + }) {inherit (pkgs) FLAC;}; + "flac-picture" = callPackage + ({ mkDerivation, base, bytestring, flac, JuicyPixels, stdenv }: + mkDerivation { + pname = "flac-picture"; + version = "0.1.1"; + sha256 = "3c1cf80c48521370ce6351d4b544c14891442bfe47c65e5bf436fe58f6fec1ce"; + revision = "1"; + editedCabalFile = "02vdh61nzig0yrv6ja6fjlgfcznj5k4iqh3i5f9g5p078ycqb17w"; + enableSeparateDataOutput = true; + libraryHaskellDepends = [ base bytestring flac JuicyPixels ]; + doHaddock = false; + doCheck = false; + homepage = "https://github.com/mrkkrp/flac-picture"; + description = "Support for writing picture to FLAC metadata blocks with JuicyPixels"; + license = stdenv.lib.licenses.bsd3; + }) {}; + "flat-mcmc" = callPackage + ({ mkDerivation, base, formatting, mcmc-types, monad-par + , monad-par-extras, mwc-probability, pipes, primitive, stdenv, text + , transformers, vector + }: + mkDerivation { + pname = "flat-mcmc"; + version = "1.5.0"; + sha256 = "87cea9deac6e2d32d9984741ba222ccb2fb0d5f8c58e843684476bfe7632f1fd"; + revision = "1"; + editedCabalFile = "1pjkyvs4c6yx6jva08zw2b1qfhhv9q71sy806f5lddjsknnym2fn"; + libraryHaskellDepends = [ + base formatting mcmc-types monad-par monad-par-extras + mwc-probability pipes primitive text transformers vector + ]; + doHaddock = false; + doCheck = false; + homepage = "https://github.com/jtobin/flat-mcmc"; + description = "Painless general-purpose sampling"; + license = stdenv.lib.licenses.mit; + }) {}; + "flay" = callPackage + ({ mkDerivation, base, constraints, stdenv, transformers }: + mkDerivation { + pname = "flay"; + version = "0.4"; + sha256 = "01ff3e642eab48807e4369fd8c1336e22d7abdcf4374cd1322b1fe259c9413ef"; + libraryHaskellDepends = [ base constraints transformers ]; + doHaddock = false; + doCheck = false; + homepage = "https://github.com/k0001/flay"; + description = "Work generically on your datatype without knowing its shape nor its contents"; + license = stdenv.lib.licenses.bsd3; + }) {}; + "flexible-defaults" = callPackage + ({ mkDerivation, base, containers, stdenv, template-haskell + , th-extras, transformers + }: + mkDerivation { + pname = "flexible-defaults"; + version = "0.0.2"; + sha256 = "f3d5d41a6dd69dbb585dd10fe6b7fe9023bc4308bac1320a55b62758acc18a64"; + libraryHaskellDepends = [ + base containers template-haskell th-extras transformers + ]; + doHaddock = false; + doCheck = false; + homepage = "https://github.com/peti/flexible-defaults"; + description = "Generate default function implementations for complex type classes"; + license = stdenv.lib.licenses.publicDomain; + }) {}; + "floatshow" = callPackage + ({ mkDerivation, array, base, integer-gmp, stdenv }: + mkDerivation { + pname = "floatshow"; + version = "0.2.4"; + sha256 = "0c4e9494df46120942b2078db53c16200b46eff603fca5ab85775a541f975dff"; + libraryHaskellDepends = [ array base integer-gmp ]; + doHaddock = false; + doCheck = false; + homepage = "https://bitbucket.org/dafis/floatshow"; + description = "Alternative faster String representations for Double and Float, String representations for more general numeric types"; + license = stdenv.lib.licenses.bsd3; + }) {}; + "flow" = callPackage + ({ mkDerivation, base, stdenv }: + mkDerivation { + pname = "flow"; + version = "1.0.14"; + sha256 = "08cc6d05a0b27941ca2a0e0f8e7e7a623cbbfc53814aa1e5be4e643a6005d24c"; + libraryHaskellDepends = [ base ]; + doHaddock = false; + doCheck = false; + homepage = "https://github.com/tfausak/flow#readme"; + description = "Write more understandable Haskell"; + license = stdenv.lib.licenses.mit; + }) {}; + "fmlist" = callPackage + ({ mkDerivation, base, stdenv }: + mkDerivation { + pname = "fmlist"; + version = "0.9.2"; + sha256 = "8fc4b55d04e7f216740a01acd2f38293e3bd9409a9495e6042a162580c420609"; + libraryHaskellDepends = [ base ]; + doHaddock = false; + doCheck = false; + homepage = "https://github.com/sjoerdvisscher/fmlist"; + description = "FoldMap lists"; + license = stdenv.lib.licenses.bsd3; + }) {}; + "fn" = callPackage + ({ mkDerivation, base, blaze-builder, bytestring, directory + , filepath, http-types, resourcet, stdenv, text + , unordered-containers, wai, wai-extra + }: + mkDerivation { + pname = "fn"; + version = "0.3.0.2"; + sha256 = "1e34b017aa13f60464ec06dfbae970c3c0f01f2160f5001a4e84c8179de7ae5f"; + libraryHaskellDepends = [ + base blaze-builder bytestring directory filepath http-types + resourcet text unordered-containers wai wai-extra + ]; + doHaddock = false; + doCheck = false; + homepage = "http://github.com/positiondev/fn#readme"; + description = "A functional web framework"; + license = stdenv.lib.licenses.isc; + }) {}; + "focus" = callPackage + ({ mkDerivation, base, stdenv }: + mkDerivation { + pname = "focus"; + version = "0.1.5.2"; + sha256 = "c2988d48c2bc6861a00be4e02161df96abcbf6c80e801676cee39b7628715cb7"; + libraryHaskellDepends = [ base ]; + doHaddock = false; + doCheck = false; + homepage = "https://github.com/nikita-volkov/focus"; + description = "A general abstraction for manipulating elements of container data structures"; + license = stdenv.lib.licenses.mit; + }) {}; + "fold-debounce" = callPackage + ({ mkDerivation, base, data-default-class, stdenv, stm, stm-delay + , time + }: + mkDerivation { + pname = "fold-debounce"; + version = "0.2.0.7"; + sha256 = "ff7ec4537a04beaae6926387f49dbfd98b6b6e5344e9d435503be7f2aca1c68f"; + libraryHaskellDepends = [ + base data-default-class stm stm-delay time + ]; + doHaddock = false; + doCheck = false; + homepage = "https://github.com/debug-ito/fold-debounce"; + description = "Fold multiple events that happen in a given period of time"; + license = stdenv.lib.licenses.bsd3; + }) {}; + "fold-debounce-conduit" = callPackage + ({ mkDerivation, base, conduit, fold-debounce, resourcet, stdenv + , stm, transformers, transformers-base + }: + mkDerivation { + pname = "fold-debounce-conduit"; + version = "0.2.0.1"; + sha256 = "5f98432d8d0a193ec1287c438fe53f8bd1ec4d5446aa64914f2f353f44e8500b"; + libraryHaskellDepends = [ + base conduit fold-debounce resourcet stm transformers + transformers-base + ]; + doHaddock = false; + doCheck = false; + homepage = "https://github.com/debug-ito/fold-debounce-conduit"; + description = "Regulate input traffic from conduit Source with Control.FoldDebounce"; + license = stdenv.lib.licenses.bsd3; + }) {}; + "foldl" = callPackage + ({ mkDerivation, base, bytestring, comonad, containers + , contravariant, hashable, mwc-random, primitive, profunctors + , semigroupoids, semigroups, stdenv, text, transformers + , unordered-containers, vector, vector-builder + }: + mkDerivation { + pname = "foldl"; + version = "1.4.2"; + sha256 = "89c1479e075cfe692ffbf87bdde76ca10bbe9644b36677e33e7b987db5608c91"; + revision = "1"; + editedCabalFile = "1ansz13mjgdg50x3aa9l543vkbyxncz0x0p57rhv80573skiqcmc"; + libraryHaskellDepends = [ + base bytestring comonad containers contravariant hashable + mwc-random primitive profunctors semigroupoids semigroups text + transformers unordered-containers vector vector-builder + ]; + doHaddock = false; + doCheck = false; + description = "Composable, streaming, and efficient left folds"; + license = stdenv.lib.licenses.bsd3; + }) {}; + "folds" = callPackage + ({ mkDerivation, adjunctions, base, bifunctors, Cabal + , cabal-doctest, comonad, constraints, contravariant, data-reify + , distributive, lens, mtl, pointed, profunctors, reflection + , semigroupoids, stdenv, transformers, unordered-containers, vector + }: + mkDerivation { + pname = "folds"; + version = "0.7.4"; + sha256 = "5c6e6f7c9c852cbe3d5372f93ed99f82400d15ae99ecf8e9e005481647734572"; + configureFlags = [ "-f-test-hlint" ]; + setupHaskellDepends = [ base Cabal cabal-doctest ]; + libraryHaskellDepends = [ + adjunctions base bifunctors comonad constraints contravariant + data-reify distributive lens mtl pointed profunctors reflection + semigroupoids transformers unordered-containers vector + ]; + doHaddock = false; + doCheck = false; + homepage = "http://github.com/ekmett/folds"; + description = "Beautiful Folding"; + license = stdenv.lib.licenses.bsd3; + }) {}; + "force-layout" = callPackage + ({ mkDerivation, base, containers, data-default-class, lens, linear + , stdenv + }: + mkDerivation { + pname = "force-layout"; + version = "0.4.0.6"; + sha256 = "f7729855b1b14e0b255325faaca9f4834004e02bd21def6a865d2c55c734259d"; + revision = "4"; + editedCabalFile = "0hpr1z68lflgcdl9gbmva0i52wbgfhh4qj3iwdvzipsp8mwav7s7"; + libraryHaskellDepends = [ + base containers data-default-class lens linear + ]; + doHaddock = false; + doCheck = false; + description = "Simple force-directed layout"; + license = stdenv.lib.licenses.bsd3; + }) {}; + "foreign-store" = callPackage + ({ mkDerivation, base, stdenv }: + mkDerivation { + pname = "foreign-store"; + version = "0.2"; + sha256 = "06718a214d068eaa494cc82376f23b2059a141b01048cd7efcf2176a6c3383dc"; + libraryHaskellDepends = [ base ]; + doHaddock = false; + doCheck = false; + homepage = "https://github.com/chrisdone/foreign-store"; + description = "Store a stable pointer in a foreign context to be retrieved later"; + license = stdenv.lib.licenses.bsd3; + }) {}; + "forkable-monad" = callPackage + ({ mkDerivation, base, stdenv, transformers }: + mkDerivation { + pname = "forkable-monad"; + version = "0.2.0.3"; + sha256 = "571e33effa5baaef4e2dc910010e2b02c01d8b8e06f051e96906f288f71ad462"; + libraryHaskellDepends = [ base transformers ]; + doHaddock = false; + doCheck = false; + homepage = "https://github.com/System-Indystress/ForkableMonad#readme"; + description = "An implementation of forkIO for monad stacks"; + license = stdenv.lib.licenses.bsd3; + }) {}; + "forma" = callPackage + ({ mkDerivation, aeson, base, containers, mtl, stdenv, text + , unordered-containers + }: + mkDerivation { + pname = "forma"; + version = "1.1.0"; + sha256 = "b7dc7270e0a294cdaf40e99f067928411d82ed50af4dad51a6088830d539c325"; + revision = "2"; + editedCabalFile = "1yc9gv1rjbl4lsxscp5idfpn7jp27c38j6gm9v7isxgyaih0j4v4"; + libraryHaskellDepends = [ + aeson base containers mtl text unordered-containers + ]; + doHaddock = false; + doCheck = false; + homepage = "https://github.com/mrkkrp/forma"; + description = "Parse and validate forms in JSON format"; + license = stdenv.lib.licenses.bsd3; + }) {}; + "format-numbers" = callPackage + ({ mkDerivation, base, stdenv, text }: + mkDerivation { + pname = "format-numbers"; + version = "0.1.0.0"; + sha256 = "0ca4561b55c888552f7bf0eb68e97b62acedcb0d5e5e1cc4afd94402d01231a6"; + libraryHaskellDepends = [ base text ]; + doHaddock = false; + doCheck = false; + homepage = "https://github.com/agrafix/format-numbers#readme"; + description = "Various number formatting functions"; + license = stdenv.lib.licenses.mit; + }) {}; + "formatting" = callPackage + ({ mkDerivation, array, base, bytestring, clock, ghc-prim + , integer-gmp, old-locale, scientific, semigroups, stdenv, text + , time, transformers + }: + mkDerivation { + pname = "formatting"; + version = "6.3.6"; + sha256 = "6a28db7625f912dfa0075d4376b6f1b7f84d139defda53c90e440dcf74aad31a"; + revision = "1"; + editedCabalFile = "0vw77ji2d7rhwhq2g7dmln9ifsghgzdlnxg4wjipb128f6gwclh7"; + libraryHaskellDepends = [ + array base bytestring clock ghc-prim integer-gmp old-locale + scientific semigroups text time transformers + ]; + doHaddock = false; + doCheck = false; + description = "Combinator-based type-safe formatting (like printf() or FORMAT)"; + license = stdenv.lib.licenses.bsd3; + }) {}; + "foundation" = callPackage + ({ mkDerivation, base, basement, ghc-prim, stdenv }: + mkDerivation { + pname = "foundation"; + version = "0.0.21"; + sha256 = "4ed3a0e7f8052b52d27c9806eff3bea51acc2587f74f81db4b8e03e938f283e0"; + revision = "1"; + editedCabalFile = "07mzfc75wl7kn2lr2gmbx4i0a5gxyi9b066rz0x2pqxqav3fwqs0"; + libraryHaskellDepends = [ base basement ghc-prim ]; + doHaddock = false; + doCheck = false; + homepage = "https://github.com/haskell-foundation/foundation"; + description = "Alternative prelude with batteries and no dependencies"; + license = stdenv.lib.licenses.bsd3; + }) {}; + "free" = callPackage + ({ mkDerivation, base, bifunctors, comonad, containers + , distributive, exceptions, mtl, profunctors, semigroupoids + , semigroups, stdenv, template-haskell, transformers + , transformers-base, transformers-compat + }: + mkDerivation { + pname = "free"; + version = "5.0.2"; + sha256 = "ef05eb1c8e69742a4f962c573ef362e44ad48772940f1ef69fe39f0f77b2a396"; + libraryHaskellDepends = [ + base bifunctors comonad containers distributive exceptions mtl + profunctors semigroupoids semigroups template-haskell transformers + transformers-base transformers-compat + ]; + doHaddock = false; + doCheck = false; + homepage = "http://github.com/ekmett/free/"; + description = "Monads for free"; + license = stdenv.lib.licenses.bsd3; + }) {}; + "free-vl" = callPackage + ({ mkDerivation, base, stdenv }: + mkDerivation { + pname = "free-vl"; + version = "0.1.4"; + sha256 = "57f63ed35b42fc54fefb3cc183d0655e0d6c4a28d5371dba00fc9c9d3fa602bf"; + revision = "1"; + editedCabalFile = "1711k76b6w7gfqvc8z9jnylj4hhk3rvx7ap31y1mmq4g2a4s82qm"; + isLibrary = true; + isExecutable = true; + libraryHaskellDepends = [ base ]; + executableHaskellDepends = [ base ]; + doHaddock = false; + doCheck = false; + homepage = "http://github.com/aaronlevin/free-vl"; + description = "van Laarhoven encoded Free Monad with Extensible Effects"; + license = stdenv.lib.licenses.bsd3; + }) {}; + "freenect" = callPackage + ({ mkDerivation, base, freenect, freenect_sync, libfreenect, stdenv + , vector + }: + mkDerivation { + pname = "freenect"; + version = "1.2.1"; + sha256 = "fca7aa958ec04396334b101679f8603850d7c6629770d5206d774e115cd70759"; + libraryHaskellDepends = [ base vector ]; + librarySystemDepends = [ freenect freenect_sync ]; + libraryPkgconfigDepends = [ libfreenect ]; + doHaddock = false; + doCheck = false; + homepage = "https://github.com/chrisdone/freenect"; + description = "Interface to the Kinect device"; + license = stdenv.lib.licenses.bsd3; + }) {inherit (pkgs) freenect; inherit (pkgs) freenect_sync; +inherit (pkgs) libfreenect;}; + "freer-simple" = callPackage + ({ mkDerivation, base, natural-transformation, stdenv + , transformers-base + }: + mkDerivation { + pname = "freer-simple"; + version = "1.1.0.0"; + sha256 = "2198cdb1f6206b192bed553757cfc145485ee86be7261878bf44bc0e84b1bb01"; + isLibrary = true; + isExecutable = true; + libraryHaskellDepends = [ + base natural-transformation transformers-base + ]; + executableHaskellDepends = [ base ]; + doHaddock = false; + doCheck = false; + homepage = "https://github.com/lexi-lambda/freer-simple#readme"; + description = "Implementation of a friendly effect system for Haskell"; + license = stdenv.lib.licenses.bsd3; + }) {}; + "freetype2" = callPackage + ({ mkDerivation, base, stdenv }: + mkDerivation { + pname = "freetype2"; + version = "0.1.2"; + sha256 = "517e80298890e903b03134d7840d3d1a517bfdad53127ed57c2fdd18cbfae302"; + isLibrary = true; + isExecutable = true; + libraryHaskellDepends = [ base ]; + doHaddock = false; + doCheck = false; + description = "Haskell binding for FreeType 2 library"; + license = stdenv.lib.licenses.bsd3; + }) {}; + "friday" = callPackage + ({ mkDerivation, base, containers, convertible, deepseq, primitive + , ratio-int, stdenv, transformers, vector + }: + mkDerivation { + pname = "friday"; + version = "0.2.3.1"; + sha256 = "0827492c1a6116baa5c4866539a4cfa0f6d81bf31f6573616bf5ac4484199613"; + revision = "1"; + editedCabalFile = "0n1f4plvrmad6gm8dbsi6g5ghahdwwy2fhgippmnp1ixb65x7d58"; + libraryHaskellDepends = [ + base containers convertible deepseq primitive ratio-int + transformers vector + ]; + doHaddock = false; + doCheck = false; + homepage = "https://github.com/RaphaelJ/friday"; + description = "A functional image processing library for Haskell"; + license = stdenv.lib.licenses.lgpl3; + }) {}; + "friday-juicypixels" = callPackage + ({ mkDerivation, base, friday, JuicyPixels, stdenv, vector }: + mkDerivation { + pname = "friday-juicypixels"; + version = "0.1.2.4"; + sha256 = "6d59828fe700ddd0777d180551c5f62444c18fd0b27ae3a675ad185efa90ae3f"; + libraryHaskellDepends = [ base friday JuicyPixels vector ]; + doHaddock = false; + doCheck = false; + homepage = "github.com/TomMD/friday-juicypixels"; + description = "Converts between the Friday and JuicyPixels image types"; + license = stdenv.lib.licenses.bsd3; + }) {}; + "friendly-time" = callPackage + ({ mkDerivation, base, old-locale, stdenv, time }: + mkDerivation { + pname = "friendly-time"; + version = "0.4.1"; + sha256 = "9af3443227c3f271f5d11ed8c3c15c77a59de3ab82d87d93ac1f8455a54393c8"; + revision = "1"; + editedCabalFile = "096nfaqxavi6xblqh4q5dxks824liz75b4rm2la2hlkkn5mhqdgs"; + libraryHaskellDepends = [ base old-locale time ]; + doHaddock = false; + doCheck = false; + description = "Print time information in friendly ways"; + license = stdenv.lib.licenses.bsd3; + }) {}; + "frisby" = callPackage + ({ mkDerivation, array, base, containers, mtl, semigroups, stdenv + }: + mkDerivation { + pname = "frisby"; + version = "0.2.2"; + sha256 = "c1b318dbf54d56e1012955cc47a1633af5fd77facc128c725353718c0663b6d5"; + libraryHaskellDepends = [ array base containers mtl semigroups ]; + doHaddock = false; + doCheck = false; + homepage = "http://repetae.net/computer/frisby/"; + description = "Linear time composable parser for PEG grammars"; + license = stdenv.lib.licenses.bsd3; + }) {}; + "from-sum" = callPackage + ({ mkDerivation, base, mtl, stdenv }: + mkDerivation { + pname = "from-sum"; + version = "0.2.1.0"; + sha256 = "a1ed8a433b98df8a70be2f9199abae3e5ed7fb4c2f2b3fb1268b6b588f326667"; + libraryHaskellDepends = [ base mtl ]; + doHaddock = false; + doCheck = false; + homepage = "https://github.com/cdepillabout/from-sum"; + description = "Canonical fromMaybeM and fromEitherM functions"; + license = stdenv.lib.licenses.bsd3; + }) {}; + "frontmatter" = callPackage + ({ mkDerivation, attoparsec, base, bytestring, stdenv, yaml }: + mkDerivation { + pname = "frontmatter"; + version = "0.1.0.2"; + sha256 = "66eb97b0d5097397f0238b9af764a8c6ea2bb9a4a16cd1214051719fc313b99d"; + libraryHaskellDepends = [ attoparsec base bytestring yaml ]; + doHaddock = false; + doCheck = false; + homepage = "https://github.com/yamadapc/haskell-frontmatter"; + description = "Parses frontmatter as used in Jekyll markdown files"; + license = stdenv.lib.licenses.mit; + }) {}; + "fsnotify" = callPackage + ({ mkDerivation, async, base, bytestring, containers, directory + , filepath, hinotify, shelly, stdenv, text, time, unix, unix-compat + }: + mkDerivation { + pname = "fsnotify"; + version = "0.3.0.1"; + sha256 = "ded2165f72a2b4971f941cb83ef7f58b200e3e04159be78da55ba6c5d35f6da5"; + revision = "1"; + editedCabalFile = "1pa9pa0kflkqlb4dysagy0aihn452hmf6wwlsr7fp4ygg86m7fsq"; + libraryHaskellDepends = [ + async base bytestring containers directory filepath hinotify shelly + text time unix unix-compat + ]; + doHaddock = false; + doCheck = false; + homepage = "https://github.com/haskell-fswatch/hfsnotify"; + description = "Cross platform library for file change notification"; + license = stdenv.lib.licenses.bsd3; + }) {}; + "fsnotify-conduit" = callPackage + ({ mkDerivation, base, conduit, directory, filepath, fsnotify + , resourcet, stdenv, transformers + }: + mkDerivation { + pname = "fsnotify-conduit"; + version = "0.1.1.1"; + sha256 = "03990f311f7d66a6996b88722602b6058fbae7ad33e74073875ef0466ef001ce"; + libraryHaskellDepends = [ + base conduit directory filepath fsnotify resourcet transformers + ]; + doHaddock = false; + doCheck = false; + homepage = "https://github.com/fpco/fsnotify-conduit#readme"; + description = "Get filesystem notifications as a stream of events"; + license = stdenv.lib.licenses.mit; + }) {}; + "funcmp" = callPackage + ({ mkDerivation, base, filepath, pretty, process, stdenv }: + mkDerivation { + pname = "funcmp"; + version = "1.9"; + sha256 = "08b2b982fc301af160ae5f2ab5d01e850b4ed177963fb19b4d4b2a28e7bdaab4"; + enableSeparateDataOutput = true; + libraryHaskellDepends = [ base filepath pretty process ]; + doHaddock = false; + doCheck = false; + homepage = "https://github.com/peti/funcmp"; + description = "Functional MetaPost is a Haskell frontend to the MetaPost language"; + license = stdenv.lib.licenses.gpl3; + }) {}; + "functor-classes-compat" = callPackage + ({ mkDerivation, base, containers, hashable, stdenv + , unordered-containers, vector + }: + mkDerivation { + pname = "functor-classes-compat"; + version = "1"; + sha256 = "ef11f94f44a74d6657ee61dcd2cfbc6d0889d233a2fb4caae6a29d9c59a1366f"; + revision = "3"; + editedCabalFile = "1jx552ysdnxvd8wdvsf4bgxlsgldpb7a8zi54abyjmxv6mkp98ys"; + libraryHaskellDepends = [ + base containers hashable unordered-containers vector + ]; + doHaddock = false; + doCheck = false; + homepage = "https://github.com/phadej/functor-classes-compat#readme"; + description = "Data.Functor.Classes instances for core packages"; + license = stdenv.lib.licenses.bsd3; + }) {}; + "fuzzcheck" = callPackage + ({ mkDerivation, base, lifted-base, monad-control, QuickCheck + , random, stdenv, transformers + }: + mkDerivation { + pname = "fuzzcheck"; + version = "0.1.1"; + sha256 = "ecd664796e9cf5c608ca904897dd9ec18b471a86fcfb4216328382b28023d961"; + libraryHaskellDepends = [ + base lifted-base monad-control QuickCheck random transformers + ]; + doHaddock = false; + doCheck = false; + homepage = "https://github.com/fpco/fuzzcheck"; + description = "A simple checker for stress testing monadic code"; + license = stdenv.lib.licenses.bsd3; + }) {}; + "fuzzy-dates" = callPackage + ({ mkDerivation, base, hourglass, hspec, lens, parsec, stdenv }: + mkDerivation { + pname = "fuzzy-dates"; + version = "0.1.1.1"; + sha256 = "e33406933fbb45172f5ee9b10194397333effecc3ce5f1495521bc903faf56c1"; + libraryHaskellDepends = [ base hourglass hspec lens parsec ]; + doHaddock = false; + doCheck = false; + homepage = "https://github.com/ReedOei/fuzzy-dates#readme"; + description = "Libary for parsing dates in strings in varied formats"; + license = stdenv.lib.licenses.bsd3; + }) {}; + "fuzzyset" = callPackage + ({ mkDerivation, base, base-unicode-symbols, data-default, lens + , stdenv, text, text-metrics, unordered-containers, vector + }: + mkDerivation { + pname = "fuzzyset"; + version = "0.1.0.6"; + sha256 = "731ae813678de30bbccac03760f7bb0baed5cc8d91ed21e871b1f8d7aafe61a3"; + libraryHaskellDepends = [ + base base-unicode-symbols data-default lens text text-metrics + unordered-containers vector + ]; + doHaddock = false; + doCheck = false; + homepage = "https://github.com/laserpants/fuzzyset-haskell"; + description = "Fuzzy set for approximate string matching"; + license = stdenv.lib.licenses.bsd3; + }) {}; + "gauge" = callPackage + ({ mkDerivation, base, basement, deepseq, directory, process + , stdenv, vector + }: + mkDerivation { + pname = "gauge"; + version = "0.2.3"; + sha256 = "5a4edf8971eda80524cad65c5ecc0d4dbe65a4f38d0bdfa7823ed92f768d9a6a"; + libraryHaskellDepends = [ + base basement deepseq directory process vector + ]; + doHaddock = false; + doCheck = false; + homepage = "https://github.com/vincenthz/hs-gauge"; + description = "small framework for performance measurement and analysis"; + license = stdenv.lib.licenses.bsd3; + }) {}; + "gc" = callPackage + ({ mkDerivation, base, Cabal, cabal-doctest, stdenv }: + mkDerivation { + pname = "gc"; + version = "0.0.2"; + sha256 = "39cc5ac887319aeb184ee0d6ddb5b5a34e3f3d38c3fdf3ecc60bdf31a53dc30c"; + setupHaskellDepends = [ base Cabal cabal-doctest ]; + libraryHaskellDepends = [ base ]; + doHaddock = false; + doCheck = false; + homepage = "http://github.com/ekmett/gc/"; + description = "Poor Richard's Memory Manager"; + license = stdenv.lib.licenses.bsd3; + }) {}; + "gd" = callPackage + ({ mkDerivation, base, bytestring, expat, fontconfig, freetype, gd + , libjpeg, libpng, stdenv, zlib + }: + mkDerivation { + pname = "gd"; + version = "3000.7.3"; + sha256 = "14aecb600d9a058b1905dfdef3d51a1eb11fb92f804fbaaa041103a0bfd97fb6"; + libraryHaskellDepends = [ base bytestring ]; + librarySystemDepends = [ + expat fontconfig freetype gd libjpeg libpng zlib + ]; + doHaddock = false; + doCheck = false; + description = "A Haskell binding to a subset of the GD graphics library"; + license = stdenv.lib.licenses.bsd3; + }) {inherit (pkgs) expat; inherit (pkgs) fontconfig; +inherit (pkgs) freetype; inherit (pkgs) gd; +inherit (pkgs) libjpeg; inherit (pkgs) libpng; inherit (pkgs) zlib;}; + "gdax" = callPackage + ({ mkDerivation, aeson, aeson-casing, aeson-pretty, base + , base64-bytestring, byteable, bytestring, containers, cryptohash + , exceptions, hashable, http-client, http-client-tls, lens + , lens-aeson, mtl, regex-tdfa, regex-tdfa-text, scientific, stdenv + , text, time, unordered-containers, uuid, vector, websockets, wreq + , wuss + }: + mkDerivation { + pname = "gdax"; + version = "0.6.0.0"; + sha256 = "deb8efce5e4deb5b45c0d66d23eac65224c3d560d7ac67da6d3616cd5a916721"; + isLibrary = true; + isExecutable = true; + libraryHaskellDepends = [ + aeson aeson-casing base base64-bytestring byteable bytestring + containers cryptohash exceptions hashable http-client + http-client-tls lens lens-aeson mtl regex-tdfa regex-tdfa-text + scientific text time unordered-containers uuid vector websockets + wreq wuss + ]; + executableHaskellDepends = [ + aeson aeson-pretty base base64-bytestring bytestring text vector + websockets wuss + ]; + doHaddock = false; + doCheck = false; + homepage = "https://github.com/AndrewRademacher/gdax"; + description = "API Wrapping for Coinbase's GDAX exchange"; + license = stdenv.lib.licenses.mit; + }) {}; + "gdp" = callPackage + ({ mkDerivation, base, lawful, stdenv }: + mkDerivation { + pname = "gdp"; + version = "0.0.0.2"; + sha256 = "214fff5ae2e4952cb8f15e7209be125e760b6d97fac4cd99b2e0592f790a1abf"; + isLibrary = true; + isExecutable = true; + libraryHaskellDepends = [ base lawful ]; + executableHaskellDepends = [ base ]; + doHaddock = false; + doCheck = false; + homepage = "https://github.com/githubuser/gdp#readme"; + description = "Reason about invariants and preconditions with ghosts of departed proofs"; + license = stdenv.lib.licenses.bsd3; + }) {}; + "general-games" = callPackage + ({ mkDerivation, base, monad-loops, MonadRandom, random + , random-shuffle, stdenv + }: + mkDerivation { + pname = "general-games"; + version = "1.1.1"; + sha256 = "8b8e9e3546738b55a74589cf76ebe46c3a2f2fd346a853f9dbbf8bd0563350c0"; + libraryHaskellDepends = [ + base monad-loops MonadRandom random random-shuffle + ]; + doHaddock = false; + doCheck = false; + homepage = "https://github.com/cgorski/general-games"; + description = "Library supporting simulation of a number of games"; + license = stdenv.lib.licenses.mit; + }) {}; + "generic-aeson" = callPackage + ({ mkDerivation, aeson, attoparsec, base, generic-deriving, mtl + , stdenv, tagged, text, unordered-containers, vector + }: + mkDerivation { + pname = "generic-aeson"; + version = "0.2.0.9"; + sha256 = "34c13f91ffa72a1f6d7f43b84fdd19b20db547045eb6164a4119f9a95dcd84cb"; + revision = "4"; + editedCabalFile = "0m2m2wfv9nhq8m7xl1nrmj4wy3yip3s31b4448za58ryrwkdgjzd"; + libraryHaskellDepends = [ + aeson attoparsec base generic-deriving mtl tagged text + unordered-containers vector + ]; + doHaddock = false; + doCheck = false; + description = "Derivation of Aeson instances using GHC generics"; + license = stdenv.lib.licenses.bsd3; + }) {}; + "generic-arbitrary" = callPackage + ({ mkDerivation, base, QuickCheck, stdenv }: + mkDerivation { + pname = "generic-arbitrary"; + version = "0.1.0"; + sha256 = "69f30a54e7a3d0a45288778e22e6d0d03cfc3b525dfe0a663cd4f559a619bcc6"; + libraryHaskellDepends = [ base QuickCheck ]; + doHaddock = false; + doCheck = false; + description = "Generic implementation for QuickCheck's Arbitrary"; + license = stdenv.lib.licenses.mit; + }) {}; + "generic-deriving" = callPackage + ({ mkDerivation, base, containers, ghc-prim, stdenv + , template-haskell, th-abstraction + }: + mkDerivation { + pname = "generic-deriving"; + version = "1.12.2"; + sha256 = "5688b85ff1e3484e3f6073a52f99624a41c8b01ddaab9fcec20afa242f33edc4"; + revision = "1"; + editedCabalFile = "0gr20ypr6s0183wmrhmia0zvpbn4dmfyr3wksrkrqj4i8nhj42fz"; + libraryHaskellDepends = [ + base containers ghc-prim template-haskell th-abstraction + ]; + doHaddock = false; + doCheck = false; + homepage = "https://github.com/dreixel/generic-deriving"; + description = "Generic programming library for generalised deriving"; + license = stdenv.lib.licenses.bsd3; + }) {}; + "generic-lens" = callPackage + ({ mkDerivation, base, profunctors, stdenv, tagged }: + mkDerivation { + pname = "generic-lens"; + version = "1.0.0.1"; + sha256 = "08a1fa26ee3f784b9fa4a107995aec119fe254a27252335eba5d39fc9ef50349"; + libraryHaskellDepends = [ base profunctors tagged ]; + doHaddock = false; + doCheck = false; + homepage = "https://github.com/kcsongor/generic-lens"; + description = "Generically derive traversals, lenses and prisms"; + license = stdenv.lib.licenses.bsd3; + }) {}; + "generic-random" = callPackage + ({ mkDerivation, base, QuickCheck, stdenv }: + mkDerivation { + pname = "generic-random"; + version = "1.2.0.0"; + sha256 = "9b1e00d2f06b582695a34cfdb2d8b62b32f64152c6ed43f5c2d776e6e9aa148c"; + revision = "1"; + editedCabalFile = "1d0hx41r7yq2a86ydnfh2fv540ah8cz05l071s2z4wxcjw0ymyn4"; + libraryHaskellDepends = [ base QuickCheck ]; + doHaddock = false; + doCheck = false; + homepage = "http://github.com/lysxia/generic-random"; + description = "Generic random generators"; + license = stdenv.lib.licenses.mit; + }) {}; + "generic-xmlpickler" = callPackage + ({ mkDerivation, base, generic-deriving, hxt, stdenv, text }: + mkDerivation { + pname = "generic-xmlpickler"; + version = "0.1.0.5"; + sha256 = "d51760f5650051eebe561f2b18670657e8398014fa2a623c0e0169bfeca336af"; + revision = "8"; + editedCabalFile = "1hpcglml4b5yv192syxazminr5v7qjrgqwb2wk0cf7f0sjpm5d0q"; + libraryHaskellDepends = [ base generic-deriving hxt text ]; + doHaddock = false; + doCheck = false; + homepage = "http://github.com/silkapp/generic-xmlpickler"; + description = "Generic generation of HXT XmlPickler instances using GHC Generics"; + license = stdenv.lib.licenses.bsd3; + }) {}; + "generics-eot" = callPackage + ({ mkDerivation, base, stdenv }: + mkDerivation { + pname = "generics-eot"; + version = "0.4"; + sha256 = "5abedc86df738c8ff7a8c6ca9ee97605406a1b6fadd4924fa93f7aacd2fece9b"; + libraryHaskellDepends = [ base ]; + doHaddock = false; + doCheck = false; + homepage = "https://generics-eot.readthedocs.io/"; + description = "A library for generic programming that aims to be easy to understand"; + license = stdenv.lib.licenses.bsd3; + }) {}; + "generics-sop" = callPackage + ({ mkDerivation, base, deepseq, ghc-prim, stdenv, template-haskell + }: + mkDerivation { + pname = "generics-sop"; + version = "0.3.2.0"; + sha256 = "3060ecd09ccbd27ecf825bb89af0af9cfcadd16f747ce5964c501682a2301b99"; + revision = "3"; + editedCabalFile = "0lw5n8npdrdd1h7j000flaig4z30b8pig4q52sj34zhwccjkdzq2"; + libraryHaskellDepends = [ base deepseq ghc-prim template-haskell ]; + doHaddock = false; + doCheck = false; + description = "Generic Programming using True Sums of Products"; + license = stdenv.lib.licenses.bsd3; + }) {}; + "generics-sop-lens" = callPackage + ({ mkDerivation, base, generics-sop, lens, stdenv }: + mkDerivation { + pname = "generics-sop-lens"; + version = "0.1.2.1"; + sha256 = "4e49d4cc580d45e25e0abdeee12b1191ae75937af1c7ca03333979584a8a525c"; + revision = "6"; + editedCabalFile = "0j4j3kk2nsl5n5gp0vrzqdc5y9ly31b4nvhq0bpgcpzibvik7ssw"; + libraryHaskellDepends = [ base generics-sop lens ]; + doHaddock = false; + doCheck = false; + homepage = "https://github.com/phadej/generics-sop-lens#readme"; + description = "Lenses for types in generics-sop"; + license = stdenv.lib.licenses.bsd3; + }) {}; + "geniplate-mirror" = callPackage + ({ mkDerivation, base, mtl, stdenv, template-haskell }: + mkDerivation { + pname = "geniplate-mirror"; + version = "0.7.6"; + sha256 = "4b6b82d0348e79ae4a5e1deac029441251ae87ec15a7667cf0a1de5ff80215f8"; + revision = "1"; + editedCabalFile = "1pyz2vdkr5w9wadmb5v4alx408dqamny3mkvl4x8v2pf549qn37k"; + libraryHaskellDepends = [ base mtl template-haskell ]; + doHaddock = false; + doCheck = false; + homepage = "https://github.com/danr/geniplate"; + description = "Use Template Haskell to generate Uniplate-like functions"; + license = stdenv.lib.licenses.bsd3; + }) {}; + "genvalidity" = callPackage + ({ mkDerivation, base, QuickCheck, stdenv, validity }: + mkDerivation { + pname = "genvalidity"; + version = "0.5.1.0"; + sha256 = "402ad5193fefdec24c7a0c62386f764a356bfc93e5e36672fc54a824d1c0d39f"; + libraryHaskellDepends = [ base QuickCheck validity ]; + doHaddock = false; + doCheck = false; + homepage = "https://github.com/NorfairKing/validity#readme"; + description = "Testing utilities for the validity library"; + license = stdenv.lib.licenses.mit; + }) {}; + "genvalidity-aeson" = callPackage + ({ mkDerivation, aeson, base, genvalidity, genvalidity-scientific + , genvalidity-text, genvalidity-unordered-containers + , genvalidity-vector, QuickCheck, stdenv, validity, validity-aeson + }: + mkDerivation { + pname = "genvalidity-aeson"; + version = "0.2.0.2"; + sha256 = "d1244fea0a0a7cad4f783a72b9ff98c606131445a3f2fe9bced5194ff8a2e7b0"; + libraryHaskellDepends = [ + aeson base genvalidity genvalidity-scientific genvalidity-text + genvalidity-unordered-containers genvalidity-vector QuickCheck + validity validity-aeson + ]; + doHaddock = false; + doCheck = false; + homepage = "https://github.com/NorfairKing/validity#readme"; + description = "GenValidity support for aeson"; + license = stdenv.lib.licenses.mit; + }) {}; + "genvalidity-bytestring" = callPackage + ({ mkDerivation, base, bytestring, genvalidity, QuickCheck, stdenv + , validity, validity-bytestring + }: + mkDerivation { + pname = "genvalidity-bytestring"; + version = "0.2.0.2"; + sha256 = "43b9051401d59714766d96d48435ee01016454e524af54be51427dcf804cc1e3"; + libraryHaskellDepends = [ + base bytestring genvalidity QuickCheck validity validity-bytestring + ]; + doHaddock = false; + doCheck = false; + homepage = "https://github.com/NorfairKing/validity#readme"; + description = "GenValidity support for ByteString"; + license = stdenv.lib.licenses.mit; + }) {}; + "genvalidity-containers" = callPackage + ({ mkDerivation, base, containers, genvalidity, QuickCheck, stdenv + , validity, validity-containers + }: + mkDerivation { + pname = "genvalidity-containers"; + version = "0.5.0.0"; + sha256 = "798592f343e6f0727e11dab07946adaf0fcc276380d4d1b8239c73d6aae658e2"; + libraryHaskellDepends = [ + base containers genvalidity QuickCheck validity validity-containers + ]; + doHaddock = false; + doCheck = false; + homepage = "https://github.com/NorfairKing/validity#readme"; + description = "GenValidity support for containers"; + license = stdenv.lib.licenses.mit; + }) {}; + "genvalidity-hspec" = callPackage + ({ mkDerivation, base, genvalidity, genvalidity-property, hspec + , hspec-core, QuickCheck, stdenv, transformers, validity + }: + mkDerivation { + pname = "genvalidity-hspec"; + version = "0.6.1.1"; + sha256 = "7a93a3c060bb8754d633bdfd29128dbb693adb5099c6f25322ff9ba7a8d60d4b"; + libraryHaskellDepends = [ + base genvalidity genvalidity-property hspec hspec-core QuickCheck + transformers validity + ]; + doHaddock = false; + doCheck = false; + homepage = "https://github.com/NorfairKing/validity#readme"; + description = "Standard spec's for GenValidity instances"; + license = stdenv.lib.licenses.mit; + }) {}; + "genvalidity-hspec-aeson" = callPackage + ({ mkDerivation, aeson, base, bytestring, deepseq, genvalidity + , genvalidity-hspec, hspec, QuickCheck, stdenv + }: + mkDerivation { + pname = "genvalidity-hspec-aeson"; + version = "0.3.0.0"; + sha256 = "b0e772bf802a4a70c7e52947d8fe301622cc7ffccf465f780042c8671075122f"; + libraryHaskellDepends = [ + aeson base bytestring deepseq genvalidity genvalidity-hspec hspec + QuickCheck + ]; + doHaddock = false; + doCheck = false; + homepage = "http://cs-syd.eu"; + description = "Standard spec's for aeson-related instances"; + license = stdenv.lib.licenses.mit; + }) {}; + "genvalidity-hspec-binary" = callPackage + ({ mkDerivation, base, binary, deepseq, genvalidity + , genvalidity-hspec, hspec, QuickCheck, stdenv + }: + mkDerivation { + pname = "genvalidity-hspec-binary"; + version = "0.2.0.2"; + sha256 = "210868b5ce59fc20c406c452970003f332298bcdf900ed736975e0592a5824c0"; + libraryHaskellDepends = [ + base binary deepseq genvalidity genvalidity-hspec hspec QuickCheck + ]; + doHaddock = false; + doCheck = false; + homepage = "https://github.com/NorfairKing/validity#readme"; + description = "Standard spec's for binary-related Instances"; + license = stdenv.lib.licenses.mit; + }) {}; + "genvalidity-hspec-cereal" = callPackage + ({ mkDerivation, base, cereal, deepseq, genvalidity + , genvalidity-hspec, hspec, QuickCheck, stdenv + }: + mkDerivation { + pname = "genvalidity-hspec-cereal"; + version = "0.2.0.2"; + sha256 = "e150f686eb9c161b4386d1515bd0dd12724b8d5593dbe2ebda2eca9c667a249b"; + libraryHaskellDepends = [ + base cereal deepseq genvalidity genvalidity-hspec hspec QuickCheck + ]; + doHaddock = false; + doCheck = false; + homepage = "http://cs-syd.eu"; + description = "Standard spec's for cereal-related instances"; + license = stdenv.lib.licenses.mit; + }) {}; + "genvalidity-hspec-hashable" = callPackage + ({ mkDerivation, base, genvalidity, genvalidity-hspec + , genvalidity-property, hashable, hspec, QuickCheck, stdenv + , validity + }: + mkDerivation { + pname = "genvalidity-hspec-hashable"; + version = "0.2.0.2"; + sha256 = "3c1e48c842ced9e86c3978c61062f6afcfada9d08786e0a7368c745fc92c9f68"; + libraryHaskellDepends = [ + base genvalidity genvalidity-hspec genvalidity-property hashable + hspec QuickCheck validity + ]; + doHaddock = false; + doCheck = false; + homepage = "https://github.com/NorfairKing/validity#readme"; + description = "Standard spec's for Hashable instances"; + license = stdenv.lib.licenses.mit; + }) {}; + "genvalidity-path" = callPackage + ({ mkDerivation, base, genvalidity, path, QuickCheck, stdenv + , validity-path + }: + mkDerivation { + pname = "genvalidity-path"; + version = "0.3.0.2"; + sha256 = "00fc6d2f4d54cda700ad4af04efea62db002cab4fbb3ca8da4d20b1a03a340ba"; + libraryHaskellDepends = [ + base genvalidity path QuickCheck validity-path + ]; + doHaddock = false; + doCheck = false; + homepage = "https://github.com/NorfairKing/validity#readme"; + description = "GenValidity support for Path"; + license = stdenv.lib.licenses.mit; + }) {}; + "genvalidity-property" = callPackage + ({ mkDerivation, base, genvalidity, hspec, QuickCheck, stdenv + , validity + }: + mkDerivation { + pname = "genvalidity-property"; + version = "0.2.1.0"; + sha256 = "35b7401c1c8bb0a715e22cfd7172bf546f8d74efca256523a5acd39e2d179877"; + libraryHaskellDepends = [ + base genvalidity hspec QuickCheck validity + ]; + doHaddock = false; + doCheck = false; + homepage = "https://github.com/NorfairKing/validity#readme"; + description = "Standard properties for functions on `Validity` types"; + license = stdenv.lib.licenses.mit; + }) {}; + "genvalidity-scientific" = callPackage + ({ mkDerivation, base, genvalidity, QuickCheck, scientific, stdenv + , validity, validity-scientific + }: + mkDerivation { + pname = "genvalidity-scientific"; + version = "0.2.0.1"; + sha256 = "f67d54a949756d64f04c14b62a65d16dbe0b0f0656fee2f0a7332e06eb65b9f3"; + libraryHaskellDepends = [ + base genvalidity QuickCheck scientific validity validity-scientific + ]; + doHaddock = false; + doCheck = false; + homepage = "https://github.com/NorfairKing/validity#readme"; + description = "GenValidity support for Scientific"; + license = stdenv.lib.licenses.mit; + }) {}; + "genvalidity-text" = callPackage + ({ mkDerivation, array, base, genvalidity, QuickCheck, stdenv, text + , validity, validity-text + }: + mkDerivation { + pname = "genvalidity-text"; + version = "0.5.0.2"; + sha256 = "1db3f2a225ab60f3b6afc92984deb1725a1f85313144a98a12a2148f8e2825b5"; + libraryHaskellDepends = [ + array base genvalidity QuickCheck text validity validity-text + ]; + doHaddock = false; + doCheck = false; + homepage = "https://github.com/NorfairKing/validity#readme"; + description = "GenValidity support for Text"; + license = stdenv.lib.licenses.mit; + }) {}; + "genvalidity-time" = callPackage + ({ mkDerivation, base, genvalidity, QuickCheck, stdenv, time + , validity-time + }: + mkDerivation { + pname = "genvalidity-time"; + version = "0.2.1.0"; + sha256 = "fa3ca51cd13fd54b7ef7f8e11ac77020d36e545220c2e6d887a153aed29348e4"; + libraryHaskellDepends = [ + base genvalidity QuickCheck time validity-time + ]; + doHaddock = false; + doCheck = false; + homepage = "https://github.com/NorfairKing/validity#readme"; + description = "GenValidity support for time"; + license = stdenv.lib.licenses.mit; + }) {}; + "genvalidity-unordered-containers" = callPackage + ({ mkDerivation, base, genvalidity, hashable, QuickCheck, stdenv + , unordered-containers, validity, validity-unordered-containers + }: + mkDerivation { + pname = "genvalidity-unordered-containers"; + version = "0.2.0.3"; + sha256 = "ada97e40d4a68fcfa7fe90b431ba9684bdc34fa7c7c566dc06f528b375bc0965"; + libraryHaskellDepends = [ + base genvalidity hashable QuickCheck unordered-containers validity + validity-unordered-containers + ]; + doHaddock = false; + doCheck = false; + homepage = "https://github.com/NorfairKing/validity#readme"; + description = "GenValidity support for unordered-containers"; + license = stdenv.lib.licenses.mit; + }) {}; + "genvalidity-uuid" = callPackage + ({ mkDerivation, base, genvalidity, QuickCheck, stdenv, uuid + , validity, validity-uuid + }: + mkDerivation { + pname = "genvalidity-uuid"; + version = "0.1.0.2"; + sha256 = "d1354bdfc0a75a1f228cfed22cd0edb0cc13a925e4b2514a634d56eb5b53f412"; + libraryHaskellDepends = [ + base genvalidity QuickCheck uuid validity validity-uuid + ]; + doHaddock = false; + doCheck = false; + homepage = "https://github.com/NorfairKing/validity#readme"; + description = "GenValidity support for UUID"; + license = stdenv.lib.licenses.mit; + }) {}; + "genvalidity-vector" = callPackage + ({ mkDerivation, base, genvalidity, QuickCheck, stdenv, validity + , validity-vector, vector + }: + mkDerivation { + pname = "genvalidity-vector"; + version = "0.2.0.2"; + sha256 = "11d2988f3256eeedef0d5be4e5e9c7883fd4f86fde08eda6e2559ab86f673e38"; + libraryHaskellDepends = [ + base genvalidity QuickCheck validity validity-vector vector + ]; + doHaddock = false; + doCheck = false; + homepage = "https://github.com/NorfairKing/validity#readme"; + description = "GenValidity support for vector"; + license = stdenv.lib.licenses.mit; + }) {}; + "geodetics" = callPackage + ({ mkDerivation, array, base, dimensional, stdenv }: + mkDerivation { + pname = "geodetics"; + version = "0.0.6"; + sha256 = "e21dbbd01fac330a542fba24d6dedc6c3b46a4bf43e7fa6181417e6daab9e542"; + enableSeparateDataOutput = true; + libraryHaskellDepends = [ array base dimensional ]; + doHaddock = false; + doCheck = false; + homepage = "https://github.com/PaulJohnson/geodetics"; + description = "Terrestrial coordinate systems and geodetic calculations"; + license = stdenv.lib.licenses.bsd3; + }) {}; + "getopt-generics" = callPackage + ({ mkDerivation, base, base-compat, base-orphans, generics-sop + , stdenv, tagged + }: + mkDerivation { + pname = "getopt-generics"; + version = "0.13.0.2"; + sha256 = "e604aa25d7843a175ec8803e2d60eb6c959fbb4cc7fb0d8321f315ff8671600c"; + libraryHaskellDepends = [ + base base-compat base-orphans generics-sop tagged + ]; + doHaddock = false; + doCheck = false; + homepage = "https://github.com/soenkehahn/getopt-generics#readme"; + description = "Create command line interfaces with ease"; + license = stdenv.lib.licenses.bsd3; + }) {}; + "ghc-core" = callPackage + ({ mkDerivation, base, colorize-haskell, directory, filepath + , pcre-light, process, stdenv + }: + mkDerivation { + pname = "ghc-core"; + version = "0.5.6"; + sha256 = "ec34f3e5892be7c2b52945875cd330397eca3904ae1d9574559855817b8b7e85"; + isLibrary = false; + isExecutable = true; + executableHaskellDepends = [ + base colorize-haskell directory filepath pcre-light process + ]; + doHaddock = false; + doCheck = false; + homepage = "https://github.com/shachaf/ghc-core"; + description = "Display GHC's core and assembly output in a pager"; + license = stdenv.lib.licenses.bsd3; + }) {}; + "ghc-exactprint" = callPackage + ({ mkDerivation, base, bytestring, containers, directory, filepath + , free, ghc, ghc-boot, ghc-paths, mtl, stdenv, syb + }: + mkDerivation { + pname = "ghc-exactprint"; + version = "0.5.6.1"; + sha256 = "07fd206d597631d7d8a78fb34423eb436f434a2477c69317c9a002ed23363390"; + isLibrary = true; + isExecutable = true; + libraryHaskellDepends = [ + base bytestring containers directory filepath free ghc ghc-boot + ghc-paths mtl syb + ]; + doHaddock = false; + doCheck = false; + description = "ExactPrint for GHC"; + license = stdenv.lib.licenses.bsd3; + }) {}; + "ghc-parser" = callPackage + ({ mkDerivation, base, cpphs, ghc, happy, stdenv }: + mkDerivation { + pname = "ghc-parser"; + version = "0.2.0.2"; + sha256 = "bb74cc64ff8fd3d10447075d5982c7c684210762faa15226415d0ed7da756084"; + libraryHaskellDepends = [ base ghc ]; + libraryToolDepends = [ cpphs happy ]; + doHaddock = false; + doCheck = false; + homepage = "https://github.com/gibiansky/IHaskell"; + description = "Haskell source parser from GHC"; + license = stdenv.lib.licenses.mit; + }) {}; + "ghc-paths" = callPackage + ({ mkDerivation, base, Cabal, directory, stdenv }: + mkDerivation { + pname = "ghc-paths"; + version = "0.1.0.9"; + sha256 = "afa68fb86123004c37c1dc354286af2d87a9dcfb12ddcb80e8bd0cd55bc87945"; + revision = "4"; + editedCabalFile = "1fp0jyvi6prqsv0dxn010c7q4mmiwlcy1xk6ppd4d539adxxy67d"; + setupHaskellDepends = [ base Cabal directory ]; + libraryHaskellDepends = [ base ]; + doHaddock = false; + doCheck = false; + description = "Knowledge of GHC's installation directories"; + license = stdenv.lib.licenses.bsd3; + }) {}; + "ghc-prof" = callPackage + ({ mkDerivation, attoparsec, base, containers, scientific, stdenv + , text, time + }: + mkDerivation { + pname = "ghc-prof"; + version = "1.4.1.3"; + sha256 = "99361f883b9942a8593d3593347877367fc5f2b313d6a2269c07cfdb28999399"; + isLibrary = true; + isExecutable = true; + libraryHaskellDepends = [ + attoparsec base containers scientific text time + ]; + doHaddock = false; + doCheck = false; + homepage = "https://github.com/maoe/ghc-prof"; + description = "Library for parsing GHC time and allocation profiling reports"; + license = stdenv.lib.licenses.bsd3; + }) {}; + "ghc-syntax-highlighter" = callPackage + ({ mkDerivation, base, ghc, stdenv, text }: + mkDerivation { + pname = "ghc-syntax-highlighter"; + version = "0.0.2.0"; + sha256 = "cf335c2d5c789dd6dac948edba4cef89b3b8595b5150c21ee735c82b97868dbd"; + enableSeparateDataOutput = true; + libraryHaskellDepends = [ base ghc text ]; + doHaddock = false; + doCheck = false; + homepage = "https://github.com/mrkkrp/ghc-syntax-highlighter"; + description = "Syntax highlighter for Haskell using lexer of GHC itself"; + license = stdenv.lib.licenses.bsd3; + }) {}; + "ghc-tcplugins-extra" = callPackage + ({ mkDerivation, base, ghc, stdenv }: + mkDerivation { + pname = "ghc-tcplugins-extra"; + version = "0.3"; + sha256 = "30acfd21d590809c16d990512fc8fcb98361ec540a76438233bd8aa23e82374c"; + revision = "1"; + editedCabalFile = "0x2d4bp5lhyfrqjshmgbirdn2ihc057a8a6khqmz91jj9zlhf7vb"; + libraryHaskellDepends = [ base ghc ]; + doHaddock = false; + doCheck = false; + homepage = "http://github.com/clash-lang/ghc-tcplugins-extra"; + description = "Utilities for writing GHC type-checker plugins"; + license = stdenv.lib.licenses.bsd2; + }) {}; + "ghc-typelits-extra" = callPackage + ({ mkDerivation, base, ghc, ghc-prim, ghc-tcplugins-extra + , ghc-typelits-knownnat, ghc-typelits-natnormalise, integer-gmp + , stdenv, transformers + }: + mkDerivation { + pname = "ghc-typelits-extra"; + version = "0.2.6"; + sha256 = "958d3c44543c75fabfe2f0a0db9d9cd3182bb748af9223e9c498ce4bcdcca637"; + libraryHaskellDepends = [ + base ghc ghc-prim ghc-tcplugins-extra ghc-typelits-knownnat + ghc-typelits-natnormalise integer-gmp transformers + ]; + doHaddock = false; + doCheck = false; + homepage = "http://www.clash-lang.org/"; + description = "Additional type-level operations on GHC.TypeLits.Nat"; + license = stdenv.lib.licenses.bsd2; + }) {}; + "ghc-typelits-knownnat" = callPackage + ({ mkDerivation, base, ghc, ghc-tcplugins-extra + , ghc-typelits-natnormalise, stdenv, template-haskell, transformers + }: + mkDerivation { + pname = "ghc-typelits-knownnat"; + version = "0.5.1"; + sha256 = "5b94c42dac0ae7fe381019d77afa9fe9b290b0ab7a2d9d6e20357381fc586d7b"; + libraryHaskellDepends = [ + base ghc ghc-tcplugins-extra ghc-typelits-natnormalise + template-haskell transformers + ]; + doHaddock = false; + doCheck = false; + homepage = "http://clash-lang.org/"; + description = "Derive KnownNat constraints from other KnownNat constraints"; + license = stdenv.lib.licenses.bsd2; + }) {}; + "ghc-typelits-natnormalise" = callPackage + ({ mkDerivation, base, ghc, ghc-tcplugins-extra, integer-gmp + , stdenv, transformers + }: + mkDerivation { + pname = "ghc-typelits-natnormalise"; + version = "0.6.2"; + sha256 = "801ceb41442dfa992fad04c64f2989d1d701bcfe0874a55aa8d250e63c1a4311"; + libraryHaskellDepends = [ + base ghc ghc-tcplugins-extra integer-gmp transformers + ]; + doHaddock = false; + doCheck = false; + homepage = "http://www.clash-lang.org/"; + description = "GHC typechecker plugin for types of kind GHC.TypeLits.Nat"; + license = stdenv.lib.licenses.bsd2; + }) {}; + "ghcid" = callPackage + ({ mkDerivation, ansi-terminal, base, cmdargs, containers + , directory, extra, filepath, fsnotify, process, stdenv + , terminal-size, time, unix + }: + mkDerivation { + pname = "ghcid"; + version = "0.7"; + sha256 = "0f4bda82d39bc62b7a8906439a3dd281b7859cba1efd45ae0dbc7039b7089db5"; + isLibrary = true; + isExecutable = true; + libraryHaskellDepends = [ + ansi-terminal base cmdargs directory extra filepath process time + ]; + executableHaskellDepends = [ + ansi-terminal base cmdargs containers directory extra filepath + fsnotify process terminal-size time unix + ]; + doHaddock = false; + doCheck = false; + homepage = "https://github.com/ndmitchell/ghcid#readme"; + description = "GHCi based bare bones IDE"; + license = stdenv.lib.licenses.bsd3; + }) {}; + "ghcjs-base-stub" = callPackage + ({ mkDerivation, aeson, attoparsec, base, containers, deepseq + , ghc-prim, primitive, scientific, stdenv, text, transformers + , unordered-containers, vector + }: + mkDerivation { + pname = "ghcjs-base-stub"; + version = "0.2.0.0"; + sha256 = "67bb7c931d1dc6cf2023fd8b7db126e3cd52772e5039bc3fd24585278d4a6516"; + revision = "1"; + editedCabalFile = "0hvmgwyhv28d39was8bm52anwqh6x4mbd1mzzqxazlm0d0l8bpwp"; + libraryHaskellDepends = [ + aeson attoparsec base containers deepseq ghc-prim primitive + scientific text transformers unordered-containers vector + ]; + doHaddock = false; + doCheck = false; + homepage = "https://github.com/louispan/javascript-stub#readme"; + description = "Allow GHCJS projects to compile under GHC and develop using intero"; + license = stdenv.lib.licenses.bsd3; + }) {}; + "ghcjs-codemirror" = callPackage + ({ mkDerivation, base, stdenv }: + mkDerivation { + pname = "ghcjs-codemirror"; + version = "0.0.0.2"; + sha256 = "6cbb2c649f6d4a874eb7486a2dd33db2ed0f138f1f8289a6447460d39b4b2097"; + enableSeparateDataOutput = true; + libraryHaskellDepends = [ base ]; + doHaddock = false; + doCheck = false; + homepage = "https://github.com/ghcjs/CodeMirror"; + description = "Installs CodeMirror JavaScript files"; + license = stdenv.lib.licenses.mit; + }) {}; + "ghost-buster" = callPackage + ({ mkDerivation, base, stdenv }: + mkDerivation { + pname = "ghost-buster"; + version = "0.1.1.0"; + sha256 = "02d0930ee77838e7f5a04ebc0a74f62b15218b8ace4a5b88510d9a6b56dbf6d6"; + libraryHaskellDepends = [ base ]; + doHaddock = false; + doCheck = false; + homepage = "https://github.com/Lazersmoke/ghost-buster#readme"; + description = "Existential type utilites"; + license = stdenv.lib.licenses.bsd3; + }) {}; + "gi-atk" = callPackage + ({ mkDerivation, atk, base, bytestring, Cabal, containers, gi-glib + , gi-gobject, haskell-gi, haskell-gi-base, haskell-gi-overloading + , stdenv, text, transformers + }: + mkDerivation { + pname = "gi-atk"; + version = "2.0.15"; + sha256 = "89753b4517e77ea956dcfd1294b4b98032c6e50df912e28c9a796d2b825fbfee"; + setupHaskellDepends = [ base Cabal haskell-gi ]; + libraryHaskellDepends = [ + base bytestring containers gi-glib gi-gobject haskell-gi + haskell-gi-base haskell-gi-overloading text transformers + ]; + libraryPkgconfigDepends = [ atk ]; + doHaddock = false; + doCheck = false; + homepage = "https://github.com/haskell-gi/haskell-gi"; + description = "Atk bindings"; + license = stdenv.lib.licenses.lgpl21; + }) {inherit (pkgs) atk;}; + "gi-cairo" = callPackage + ({ mkDerivation, base, bytestring, Cabal, cairo, containers + , haskell-gi, haskell-gi-base, haskell-gi-overloading, stdenv, text + , transformers + }: + mkDerivation { + pname = "gi-cairo"; + version = "1.0.17"; + sha256 = "5dbda70a038a93cb07130597407de9cde1436603beca3f2a0a6b43953c55a7ab"; + setupHaskellDepends = [ base Cabal haskell-gi ]; + libraryHaskellDepends = [ + base bytestring containers haskell-gi haskell-gi-base + haskell-gi-overloading text transformers + ]; + libraryPkgconfigDepends = [ cairo ]; + doHaddock = false; + doCheck = false; + preCompileBuildDriver = '' + PKG_CONFIG_PATH+=":${cairo}/lib/pkgconfig" + setupCompileFlags+=" $(pkg-config --libs cairo-gobject)" + ''; + homepage = "https://github.com/haskell-gi/haskell-gi"; + description = "Cairo bindings"; + license = stdenv.lib.licenses.lgpl21; + }) {inherit (pkgs) cairo;}; + "gi-gdk" = callPackage + ({ mkDerivation, base, bytestring, Cabal, containers, gi-cairo + , gi-gdkpixbuf, gi-gio, gi-glib, gi-gobject, gi-pango, gtk3 + , haskell-gi, haskell-gi-base, haskell-gi-overloading, stdenv, text + , transformers + }: + mkDerivation { + pname = "gi-gdk"; + version = "3.0.16"; + sha256 = "7eb0aa493d268cd040c7ff70ad09d7bf7787e0e7619617ba220b88eafe68e34a"; + setupHaskellDepends = [ base Cabal haskell-gi ]; + libraryHaskellDepends = [ + base bytestring containers gi-cairo gi-gdkpixbuf gi-gio gi-glib + gi-gobject gi-pango haskell-gi haskell-gi-base + haskell-gi-overloading text transformers + ]; + libraryPkgconfigDepends = [ gtk3 ]; + doHaddock = false; + doCheck = false; + homepage = "https://github.com/haskell-gi/haskell-gi"; + description = "Gdk bindings"; + license = stdenv.lib.licenses.lgpl21; + }) {gtk3 = pkgs.gnome3.gtk;}; + "gi-gdkpixbuf" = callPackage + ({ mkDerivation, base, bytestring, Cabal, containers, gdk_pixbuf + , gi-gio, gi-glib, gi-gobject, haskell-gi, haskell-gi-base + , haskell-gi-overloading, stdenv, text, transformers + }: + mkDerivation { + pname = "gi-gdkpixbuf"; + version = "2.0.16"; + sha256 = "fdbb5f12ecd3a419a345919913e659f90000b38b973ce79fb6e9ba05f5d4166f"; + setupHaskellDepends = [ base Cabal haskell-gi ]; + libraryHaskellDepends = [ + base bytestring containers gi-gio gi-glib gi-gobject haskell-gi + haskell-gi-base haskell-gi-overloading text transformers + ]; + libraryPkgconfigDepends = [ gdk_pixbuf ]; + doHaddock = false; + doCheck = false; + homepage = "https://github.com/haskell-gi/haskell-gi"; + description = "GdkPixbuf bindings"; + license = stdenv.lib.licenses.lgpl21; + }) {inherit (pkgs) gdk_pixbuf;}; + "gi-gio" = callPackage + ({ mkDerivation, base, bytestring, Cabal, containers, gi-glib + , gi-gobject, glib, haskell-gi, haskell-gi-base + , haskell-gi-overloading, stdenv, text, transformers + }: + mkDerivation { + pname = "gi-gio"; + version = "2.0.18"; + sha256 = "13ebcd9c5d804de97db1f0ce7de520a73ba2eed950cbf5be84950fe33a8ef440"; + setupHaskellDepends = [ base Cabal haskell-gi ]; + libraryHaskellDepends = [ + base bytestring containers gi-glib gi-gobject haskell-gi + haskell-gi-base haskell-gi-overloading text transformers + ]; + libraryPkgconfigDepends = [ glib ]; + doHaddock = false; + doCheck = false; + homepage = "https://github.com/haskell-gi/haskell-gi"; + description = "Gio bindings"; + license = stdenv.lib.licenses.lgpl21; + }) {inherit (pkgs) glib;}; + "gi-glib" = callPackage + ({ mkDerivation, base, bytestring, Cabal, containers, glib + , haskell-gi, haskell-gi-base, haskell-gi-overloading, stdenv, text + , transformers + }: + mkDerivation { + pname = "gi-glib"; + version = "2.0.17"; + sha256 = "9d7abe0a9d66689c5102629edb43a2336d1bb8dc805f0cbe214e5a4e799eab67"; + setupHaskellDepends = [ base Cabal haskell-gi ]; + libraryHaskellDepends = [ + base bytestring containers haskell-gi haskell-gi-base + haskell-gi-overloading text transformers + ]; + libraryPkgconfigDepends = [ glib ]; + doHaddock = false; + doCheck = false; + homepage = "https://github.com/haskell-gi/haskell-gi"; + description = "GLib bindings"; + license = stdenv.lib.licenses.lgpl21; + }) {inherit (pkgs) glib;}; + "gi-gobject" = callPackage + ({ mkDerivation, base, bytestring, Cabal, containers, gi-glib, glib + , haskell-gi, haskell-gi-base, haskell-gi-overloading, stdenv, text + , transformers + }: + mkDerivation { + pname = "gi-gobject"; + version = "2.0.16"; + sha256 = "c57844d5b9566834ece584bfbbdff1c3ef2de5aa67c711c406fe92d4b927f6ad"; + setupHaskellDepends = [ base Cabal haskell-gi ]; + libraryHaskellDepends = [ + base bytestring containers gi-glib haskell-gi haskell-gi-base + haskell-gi-overloading text transformers + ]; + libraryPkgconfigDepends = [ glib ]; + doHaddock = false; + doCheck = false; + homepage = "https://github.com/haskell-gi/haskell-gi"; + description = "GObject bindings"; + license = stdenv.lib.licenses.lgpl21; + }) {inherit (pkgs) glib;}; + "gi-gtk" = callPackage + ({ mkDerivation, base, bytestring, Cabal, containers, gi-atk + , gi-cairo, gi-gdk, gi-gdkpixbuf, gi-gio, gi-glib, gi-gobject + , gi-pango, gtk3, haskell-gi, haskell-gi-base + , haskell-gi-overloading, stdenv, text, transformers + }: + mkDerivation { + pname = "gi-gtk"; + version = "3.0.23"; + sha256 = "93e8211564ebd62e580ac8ce6c224c8e1f489965cd31cc2f6c193675d0443152"; + setupHaskellDepends = [ base Cabal haskell-gi ]; + libraryHaskellDepends = [ + base bytestring containers gi-atk gi-cairo gi-gdk gi-gdkpixbuf + gi-gio gi-glib gi-gobject gi-pango haskell-gi haskell-gi-base + haskell-gi-overloading text transformers + ]; + libraryPkgconfigDepends = [ gtk3 ]; + doHaddock = false; + doCheck = false; + homepage = "https://github.com/haskell-gi/haskell-gi"; + description = "Gtk bindings"; + license = stdenv.lib.licenses.lgpl21; + }) {gtk3 = pkgs.gnome3.gtk;}; + "gi-gtk-hs" = callPackage + ({ mkDerivation, base, base-compat, containers, gi-gdk + , gi-gdkpixbuf, gi-glib, gi-gobject, gi-gtk, haskell-gi-base, mtl + , stdenv, text, transformers + }: + mkDerivation { + pname = "gi-gtk-hs"; + version = "0.3.6.1"; + sha256 = "9cb25b6585f20ab8593fd3ca544c0193d1c86d1e1bd8d8d43ae412f2c78b4161"; + libraryHaskellDepends = [ + base base-compat containers gi-gdk gi-gdkpixbuf gi-glib gi-gobject + gi-gtk haskell-gi-base mtl text transformers + ]; + doHaddock = false; + doCheck = false; + homepage = "https://github.com/haskell-gi/gi-gtk-hs"; + description = "A wrapper for gi-gtk, adding a few more idiomatic API parts on top"; + license = stdenv.lib.licenses.lgpl21; + }) {}; + "gi-gtksource" = callPackage + ({ mkDerivation, base, bytestring, Cabal, containers, gi-atk + , gi-cairo, gi-gdk, gi-gdkpixbuf, gi-gio, gi-glib, gi-gobject + , gi-gtk, gi-pango, gtksourceview3, haskell-gi, haskell-gi-base + , haskell-gi-overloading, stdenv, text, transformers + }: + mkDerivation { + pname = "gi-gtksource"; + version = "3.0.16"; + sha256 = "97b91b9f48b9e0c65a3936beb6e814ac5a55ab20aefbd9a167313982bd5da53a"; + setupHaskellDepends = [ base Cabal haskell-gi ]; + libraryHaskellDepends = [ + base bytestring containers gi-atk gi-cairo gi-gdk gi-gdkpixbuf + gi-gio gi-glib gi-gobject gi-gtk gi-pango haskell-gi + haskell-gi-base haskell-gi-overloading text transformers + ]; + libraryPkgconfigDepends = [ gtksourceview3 ]; + doHaddock = false; + doCheck = false; + homepage = "https://github.com/haskell-gi/haskell-gi"; + description = "GtkSource bindings"; + license = stdenv.lib.licenses.lgpl21; + }) {gtksourceview3 = pkgs.gnome3.gtksourceview;}; + "gi-javascriptcore" = callPackage + ({ mkDerivation, base, bytestring, Cabal, containers, haskell-gi + , haskell-gi-base, haskell-gi-overloading, stdenv, text + , transformers, webkitgtk + }: + mkDerivation { + pname = "gi-javascriptcore"; + version = "4.0.15"; + sha256 = "03ea9ef17c74bbb57d2b6260a8f46b6e91b22de20788c53de823e9a8e32cbf1d"; + setupHaskellDepends = [ base Cabal haskell-gi ]; + libraryHaskellDepends = [ + base bytestring containers haskell-gi haskell-gi-base + haskell-gi-overloading text transformers + ]; + libraryPkgconfigDepends = [ webkitgtk ]; + doHaddock = false; + doCheck = false; + homepage = "https://github.com/haskell-gi/haskell-gi"; + description = "JavaScriptCore bindings"; + license = stdenv.lib.licenses.lgpl21; + }) {inherit (pkgs) webkitgtk;}; + "gi-pango" = callPackage + ({ mkDerivation, base, bytestring, Cabal, cairo, containers + , gi-glib, gi-gobject, haskell-gi, haskell-gi-base + , haskell-gi-overloading, pango, stdenv, text, transformers + }: + mkDerivation { + pname = "gi-pango"; + version = "1.0.16"; + sha256 = "a7bcc68413d7f7479e9b746eacf08b0c29a93b7c8af17005d96607ce090e78f4"; + setupHaskellDepends = [ base Cabal haskell-gi ]; + libraryHaskellDepends = [ + base bytestring containers gi-glib gi-gobject haskell-gi + haskell-gi-base haskell-gi-overloading text transformers + ]; + libraryPkgconfigDepends = [ cairo pango ]; + doHaddock = false; + doCheck = false; + preCompileBuildDriver = '' + PKG_CONFIG_PATH+=":${cairo}/lib/pkgconfig" + setupCompileFlags+=" $(pkg-config --libs cairo-gobject)" + ''; + homepage = "https://github.com/haskell-gi/haskell-gi"; + description = "Pango bindings"; + license = stdenv.lib.licenses.lgpl21; + }) {inherit (pkgs) cairo; inherit (pkgs) pango;}; + "gio" = callPackage + ({ mkDerivation, array, base, bytestring, Cabal, containers, glib + , gtk2hs-buildtools, mtl, stdenv, system-glib + }: + mkDerivation { + pname = "gio"; + version = "0.13.5.0"; + sha256 = "5c761423e947c02181721bdac7c11293d1bd31515fabe969e7e4ac9fd7e7355c"; + enableSeparateDataOutput = true; + setupHaskellDepends = [ base Cabal gtk2hs-buildtools ]; + libraryHaskellDepends = [ + array base bytestring containers glib mtl + ]; + libraryPkgconfigDepends = [ system-glib ]; + doHaddock = false; + doCheck = false; + homepage = "http://projects.haskell.org/gtk2hs/"; + description = "Binding to GIO"; + license = stdenv.lib.licenses.lgpl21; + }) {system-glib = pkgs.glib;}; + "giphy-api" = callPackage + ({ mkDerivation, aeson, base, containers, http-api-data + , http-client, http-client-tls, microlens, microlens-th, mtl + , network-uri, servant, servant-client, stdenv, text, transformers + }: + mkDerivation { + pname = "giphy-api"; + version = "0.6.0.1"; + sha256 = "8ddfb5005bc26553850366c527c0a1a93e6b1efaf4334f195a4f5ab647408604"; + isLibrary = true; + isExecutable = true; + libraryHaskellDepends = [ + aeson base containers http-api-data http-client http-client-tls + microlens microlens-th mtl network-uri servant servant-client text + transformers + ]; + doHaddock = false; + doCheck = false; + homepage = "http://github.com/passy/giphy-api#readme"; + description = "Giphy HTTP API wrapper and CLI search tool"; + license = stdenv.lib.licenses.bsd3; + }) {}; + "git-vogue" = callPackage + ({ mkDerivation, base, bifunctors, containers, cpphs, Diff + , directory, filepath, formatting, haskell-src-exts, hlint + , hscolour, optparse-applicative, process, split, stdenv, strict + , stylish-haskell, temporary, text, transformers, unix + }: + mkDerivation { + pname = "git-vogue"; + version = "0.3.0.2"; + sha256 = "b41669f86776dd8fc56bec61f96f14b1fa0fc6720eaf3ed0559db97b4020705c"; + isLibrary = true; + isExecutable = true; + enableSeparateDataOutput = true; + libraryHaskellDepends = [ + base containers directory filepath formatting optparse-applicative + process split temporary text transformers unix + ]; + executableHaskellDepends = [ + base bifunctors cpphs Diff directory haskell-src-exts hlint + hscolour optparse-applicative process strict stylish-haskell text + ]; + doHaddock = false; + doCheck = false; + homepage = "https://github.com/christian-marie/git-vogue"; + description = "A framework for pre-commit checks"; + license = stdenv.lib.licenses.bsd3; + }) {}; + "github" = callPackage + ({ mkDerivation, aeson, aeson-compat, base, base-compat + , base16-bytestring, binary, binary-orphans, byteable, bytestring + , containers, cryptohash, deepseq, deepseq-generics, exceptions + , hashable, http-client, http-client-tls, http-link-header + , http-types, iso8601-time, mtl, network-uri, semigroups, stdenv + , text, time, tls, transformers, transformers-compat + , unordered-containers, vector, vector-instances + }: + mkDerivation { + pname = "github"; + version = "0.19"; + sha256 = "f0ea9b57cd21645bba40e37e5e7c83ad78469cc3e32526b15e9a4bb2b3b84394"; + revision = "3"; + editedCabalFile = "0s3zmkzgfbh1mc0492i7rjiawxkzg0im8z2p10niv5ff58m87yri"; + libraryHaskellDepends = [ + aeson aeson-compat base base-compat base16-bytestring binary + binary-orphans byteable bytestring containers cryptohash deepseq + deepseq-generics exceptions hashable http-client http-client-tls + http-link-header http-types iso8601-time mtl network-uri semigroups + text time tls transformers transformers-compat unordered-containers + vector vector-instances + ]; + doHaddock = false; + doCheck = false; + homepage = "https://github.com/phadej/github"; + description = "Access to the GitHub API, v3"; + license = stdenv.lib.licenses.bsd3; + }) {}; + "github-release" = callPackage + ({ mkDerivation, aeson, base, bytestring, http-client + , http-client-tls, http-types, mime-types, optparse-generic, stdenv + , text, unordered-containers, uri-templater + }: + mkDerivation { + pname = "github-release"; + version = "1.2.2"; + sha256 = "0684e7279625b654221e61ec0a95128e0aec0be810181699e1ca46902e92d356"; + isLibrary = true; + isExecutable = true; + libraryHaskellDepends = [ + aeson base bytestring http-client http-client-tls http-types + mime-types optparse-generic text unordered-containers uri-templater + ]; + executableHaskellDepends = [ + aeson base bytestring http-client http-client-tls http-types + mime-types optparse-generic text unordered-containers uri-templater + ]; + doHaddock = false; + doCheck = false; + homepage = "https://github.com/tfausak/github-release#readme"; + description = "Upload files to GitHub releases"; + license = stdenv.lib.licenses.mit; + }) {}; + "github-types" = callPackage + ({ mkDerivation, aeson, base, stdenv, text, time }: + mkDerivation { + pname = "github-types"; + version = "0.2.1"; + sha256 = "cce4ea461b3ea7c92d130181244cfe7f29c10aecc7e7a980ee6722b6d6af7867"; + libraryHaskellDepends = [ aeson base text time ]; + doHaddock = false; + doCheck = false; + description = "Type definitions for objects used by the GitHub v3 API"; + license = "unknown"; + }) {}; + "github-webhooks" = callPackage + ({ mkDerivation, aeson, base, base16-bytestring, bytestring + , cryptonite, deepseq, deepseq-generics, memory, stdenv, text, time + , vector + }: + mkDerivation { + pname = "github-webhooks"; + version = "0.10.0"; + sha256 = "084a8aa9cc71f89a47a0c8cdb1d0f9eac79fb7d4360ed224efd8443f0c7271df"; + libraryHaskellDepends = [ + aeson base base16-bytestring bytestring cryptonite deepseq + deepseq-generics memory text time vector + ]; + doHaddock = false; + doCheck = false; + homepage = "https://github.com/onrock-eng/github-webhooks#readme"; + description = "Aeson instances for GitHub Webhook payloads"; + license = stdenv.lib.licenses.mit; + }) {}; + "gitrev" = callPackage + ({ mkDerivation, base, base-compat, directory, filepath, process + , stdenv, template-haskell + }: + mkDerivation { + pname = "gitrev"; + version = "1.3.1"; + sha256 = "a89964db24f56727b0e7b10c98fe7c116d721d8c46f52d6e77088669aaa38332"; + libraryHaskellDepends = [ + base base-compat directory filepath process template-haskell + ]; + doHaddock = false; + doCheck = false; + homepage = "https://github.com/acfoltzer/gitrev"; + description = "Compile git revision info into Haskell projects"; + license = stdenv.lib.licenses.bsd3; + }) {}; + "gl" = callPackage + ({ mkDerivation, base, Cabal, containers, directory, filepath + , fixed, half, hxt, libGL, stdenv, transformers + }: + mkDerivation { + pname = "gl"; + version = "0.8.0"; + sha256 = "aa4d2838157c86da920bda651458a4266fccc7c291ea93a69558ab02540e1439"; + revision = "2"; + editedCabalFile = "0zbpf559ajlcwnylpbm6dbi4m3g3s08fciqfp5am3i2vrmw0wpi9"; + setupHaskellDepends = [ + base Cabal containers directory filepath hxt transformers + ]; + libraryHaskellDepends = [ + base containers fixed half transformers + ]; + librarySystemDepends = [ libGL ]; + doHaddock = false; + doCheck = false; + description = "Complete OpenGL raw bindings"; + license = stdenv.lib.licenses.bsd3; + }) {inherit (pkgs) libGL;}; + "glabrous" = callPackage + ({ mkDerivation, aeson, aeson-pretty, attoparsec, base, bytestring + , cereal, cereal-text, either, stdenv, text, unordered-containers + }: + mkDerivation { + pname = "glabrous"; + version = "0.3.6"; + sha256 = "3113326be49f4e1276ad6e61d47cac07768985d7203cb718c7dd60f76cd541ad"; + libraryHaskellDepends = [ + aeson aeson-pretty attoparsec base bytestring cereal cereal-text + either text unordered-containers + ]; + doHaddock = false; + doCheck = false; + homepage = "https://github.com/MichelBoucey/glabrous"; + description = "A template DSL library"; + license = stdenv.lib.licenses.bsd3; + }) {}; + "glaze" = callPackage + ({ mkDerivation, base, lens, stdenv }: + mkDerivation { + pname = "glaze"; + version = "0.3.0.1"; + sha256 = "bbb184408bcf24e8c4f89a960cf7a69ab0c51e98bf84c5fa9901aae1702e22a1"; + libraryHaskellDepends = [ base lens ]; + doHaddock = false; + doCheck = false; + homepage = "https://github.com/louispan/glaze#readme"; + description = "Framework for rendering things with metadata/headers and values"; + license = stdenv.lib.licenses.bsd3; + }) {}; + "glazier" = callPackage + ({ mkDerivation, alternators, base, data-diverse, data-diverse-lens + , dlist, lens, mtl, stdenv, transformers, unliftio, unliftio-core + }: + mkDerivation { + pname = "glazier"; + version = "1.0.0.0"; + sha256 = "e9c56250e48b99bfe6280c58d1458c5d35203bf3676705355a4d0bd89c7b71a4"; + libraryHaskellDepends = [ + alternators base data-diverse data-diverse-lens dlist lens mtl + transformers unliftio unliftio-core + ]; + doHaddock = false; + doCheck = false; + homepage = "https://github.com/louispan/glazier#readme"; + description = "Extensible effects using ContT, State and variants"; + license = stdenv.lib.licenses.bsd3; + }) {}; + "glib" = callPackage + ({ mkDerivation, base, bytestring, Cabal, containers, glib + , gtk2hs-buildtools, stdenv, text, utf8-string + }: + mkDerivation { + pname = "glib"; + version = "0.13.6.0"; + sha256 = "4e71062c6a458440294d820e21449aa4666deed2ea233ef5915da7c1d4aee8eb"; + setupHaskellDepends = [ base Cabal gtk2hs-buildtools ]; + libraryHaskellDepends = [ + base bytestring containers text utf8-string + ]; + libraryPkgconfigDepends = [ glib ]; + doHaddock = false; + doCheck = false; + homepage = "http://projects.haskell.org/gtk2hs/"; + description = "Binding to the GLIB library for Gtk2Hs"; + license = stdenv.lib.licenses.lgpl21; + }) {inherit (pkgs) glib;}; + "gloss" = callPackage + ({ mkDerivation, base, bmp, bytestring, containers, ghc-prim + , gloss-rendering, GLUT, OpenGL, stdenv + }: + mkDerivation { + pname = "gloss"; + version = "1.12.0.0"; + sha256 = "6906d8ad72f094f16c27f19a4836e770cdae08dd90537239b067d5ddebdeac4b"; + libraryHaskellDepends = [ + base bmp bytestring containers ghc-prim gloss-rendering GLUT OpenGL + ]; + doHaddock = false; + doCheck = false; + homepage = "http://gloss.ouroborus.net"; + description = "Painless 2D vector graphics, animations and simulations"; + license = stdenv.lib.licenses.mit; + }) {}; + "gloss-raster" = callPackage + ({ mkDerivation, base, containers, ghc-prim, gloss, gloss-rendering + , repa, stdenv + }: + mkDerivation { + pname = "gloss-raster"; + version = "1.12.0.0"; + sha256 = "c89f496a397f168f020ad69742da21a7c54265e0b5144f3224d7912a15c34191"; + libraryHaskellDepends = [ + base containers ghc-prim gloss gloss-rendering repa + ]; + doHaddock = false; + doCheck = false; + homepage = "http://gloss.ouroborus.net"; + description = "Parallel rendering of raster images"; + license = stdenv.lib.licenses.mit; + }) {}; + "gloss-rendering" = callPackage + ({ mkDerivation, base, bmp, bytestring, containers, GLUT, OpenGL + , stdenv + }: + mkDerivation { + pname = "gloss-rendering"; + version = "1.12.0.0"; + sha256 = "60d90b9729b8f6c8715d621aec8a9ded3f8f95bcb0877391d39a8e303de5c4bc"; + libraryHaskellDepends = [ + base bmp bytestring containers GLUT OpenGL + ]; + doHaddock = false; + doCheck = false; + description = "Gloss picture data types and rendering functions"; + license = stdenv.lib.licenses.mit; + }) {}; + "gnuplot" = callPackage + ({ mkDerivation, array, base, containers, data-accessor + , data-accessor-transformers, deepseq, filepath, process + , semigroups, stdenv, temporary, time, transformers, utility-ht + }: + mkDerivation { + pname = "gnuplot"; + version = "0.5.5.2"; + sha256 = "b69a2c3173f6c495937b8e73d9c7f265f8cd89f6cd376a5cfdf2f91198bd97d6"; + isLibrary = true; + isExecutable = true; + enableSeparateDataOutput = true; + libraryHaskellDepends = [ + array base containers data-accessor data-accessor-transformers + deepseq filepath process semigroups temporary time transformers + utility-ht + ]; + doHaddock = false; + doCheck = false; + homepage = "http://www.haskell.org/haskellwiki/Gnuplot"; + description = "2D and 3D plots using gnuplot"; + license = stdenv.lib.licenses.bsd3; + }) {}; + "goggles" = callPackage + ({ mkDerivation, aeson, attoparsec, base, base64-bytestring, binary + , bytestring, containers, cryptonite, exceptions, filepath + , http-client, http-client-tls, http-types, memory, mtl, pem, req + , scientific, stdenv, stm, text, time, transformers, unix-time + , x509, x509-store + }: + mkDerivation { + pname = "goggles"; + version = "0.3.2"; + sha256 = "a64d25c6506b172ec6f3b8a55f7934c23ccedc66c1acfb62432063dff743e93c"; + libraryHaskellDepends = [ + aeson attoparsec base base64-bytestring binary bytestring + containers cryptonite exceptions filepath http-client + http-client-tls http-types memory mtl pem req scientific stm text + time transformers unix-time x509 x509-store + ]; + doHaddock = false; + doCheck = false; + homepage = "https://github.com/ocramz/goggles"; + description = "Extensible interface to Web APIs"; + license = stdenv.lib.licenses.bsd3; + }) {}; + "google-oauth2-jwt" = callPackage + ({ mkDerivation, base, base64-bytestring, bytestring, HsOpenSSL + , RSA, stdenv, text, unix-time + }: + mkDerivation { + pname = "google-oauth2-jwt"; + version = "0.3.0"; + sha256 = "72fd0f2fa82b734bc099c108ab0f168b1faaf6fb855d4dfb1df6348167ab27d6"; + libraryHaskellDepends = [ + base base64-bytestring bytestring HsOpenSSL RSA text unix-time + ]; + doHaddock = false; + doCheck = false; + homepage = "https://github.com/MichelBoucey/google-oauth2-jwt"; + description = "Get a signed JWT for Google Service Accounts"; + license = stdenv.lib.licenses.bsd3; + }) {}; + "gpolyline" = callPackage + ({ mkDerivation, base, split, stdenv }: + mkDerivation { + pname = "gpolyline"; + version = "0.1.0.1"; + sha256 = "28b3a644853ba6f0a7d6465d8d62646a10c995008a799ae67e728c8cf4a17a05"; + libraryHaskellDepends = [ base split ]; + doHaddock = false; + doCheck = false; + homepage = "https://github.com/fegu/gpolyline"; + description = "Pure module for encoding/decoding Google Polyline"; + license = stdenv.lib.licenses.bsd3; + }) {}; + "graph-core" = callPackage + ({ mkDerivation, base, containers, deepseq, hashable, mtl, safe + , stdenv, unordered-containers, vector + }: + mkDerivation { + pname = "graph-core"; + version = "0.3.0.0"; + sha256 = "378f0baa40ebbb78e8c389f79e363eb573cdf182f799684d2f3d6ac51b10e854"; + libraryHaskellDepends = [ + base containers deepseq hashable mtl safe unordered-containers + vector + ]; + doHaddock = false; + doCheck = false; + homepage = "https://github.com/factisresearch/graph-core"; + description = "Fast, memory efficient and persistent graph implementation"; + license = stdenv.lib.licenses.mit; + }) {}; + "graph-wrapper" = callPackage + ({ mkDerivation, array, base, containers, stdenv }: + mkDerivation { + pname = "graph-wrapper"; + version = "0.2.5.1"; + sha256 = "8361853fca2d2251bd233e18393053dd391d21ca6f210b2bc861b0e0f4c2e113"; + libraryHaskellDepends = [ array base containers ]; + doHaddock = false; + doCheck = false; + homepage = "https://github.com/soenkehahn/graph-wrapper"; + description = "A wrapper around the standard Data.Graph with a less awkward interface"; + license = stdenv.lib.licenses.bsd3; + }) {}; + "graphs" = callPackage + ({ mkDerivation, array, base, containers, stdenv, transformers + , transformers-compat, void + }: + mkDerivation { + pname = "graphs"; + version = "0.7.1"; + sha256 = "acd37a7ba5dd02f24131ac8971a5f8639cc0e9db687e7d6790a84af4af0ce209"; + revision = "1"; + editedCabalFile = "1cjyxswlkachki6l4mcaffwpjajyx86jzipzlqjg7c080vwvb19g"; + libraryHaskellDepends = [ + array base containers transformers transformers-compat void + ]; + doHaddock = false; + doCheck = false; + homepage = "http://github.com/ekmett/graphs"; + description = "A simple monadic graph library"; + license = stdenv.lib.licenses.bsd3; + }) {}; + "graphviz" = callPackage + ({ mkDerivation, base, bytestring, colour, containers, directory + , dlist, fgl, filepath, mtl, polyparse, process, stdenv, temporary + , text, wl-pprint-text + }: + mkDerivation { + pname = "graphviz"; + version = "2999.20.0.2"; + sha256 = "e7662eb82d1e5b22b467fb6e9094b65731036ae04c5374058e3b52fbc055474e"; + isLibrary = true; + isExecutable = true; + libraryHaskellDepends = [ + base bytestring colour containers directory dlist fgl filepath mtl + polyparse process temporary text wl-pprint-text + ]; + doHaddock = false; + doCheck = false; + homepage = "http://projects.haskell.org/graphviz/"; + description = "Bindings to Graphviz for graph visualisation"; + license = stdenv.lib.licenses.bsd3; + }) {}; + "gravatar" = callPackage + ({ mkDerivation, base, bytestring, data-default, HTTP, pureMD5 + , stdenv, text + }: + mkDerivation { + pname = "gravatar"; + version = "0.8.0"; + sha256 = "6f6000acaea47f3fc8711f5a2a62d5fbe96f5bb698fcb997f9f07ffe3102f4d7"; + libraryHaskellDepends = [ + base bytestring data-default HTTP pureMD5 text + ]; + doHaddock = false; + doCheck = false; + description = "Generate Gravatar image URLs"; + license = stdenv.lib.licenses.mit; + }) {}; + "graylog" = callPackage + ({ mkDerivation, aeson, aeson-casing, base, bytestring, network + , random, scientific, stdenv, text, time, vector + }: + mkDerivation { + pname = "graylog"; + version = "0.1.0.1"; + sha256 = "2d8173e61da8d02c39cb95e6ccea8a167c792f682a496aed5fe4edfd0e6a0082"; + libraryHaskellDepends = [ + aeson aeson-casing base bytestring network random scientific text + time vector + ]; + doHaddock = false; + doCheck = false; + homepage = "https://github.com/AndrewRademacher/haskell-graylog"; + description = "Support for graylog output"; + license = "unknown"; + }) {}; + "greskell" = callPackage + ({ mkDerivation, aeson, base, greskell-core, semigroups, stdenv + , text, transformers, unordered-containers, vector + }: + mkDerivation { + pname = "greskell"; + version = "0.2.0.2"; + sha256 = "70c45b76aa802d0cd567f026bf2ceb5bb360fc7e2fd9180fba445207a6c7df06"; + libraryHaskellDepends = [ + aeson base greskell-core semigroups text transformers + unordered-containers vector + ]; + doHaddock = false; + doCheck = false; + homepage = "https://github.com/debug-ito/greskell/"; + description = "Haskell binding for Gremlin graph query language"; + license = stdenv.lib.licenses.bsd3; + }) {}; + "greskell-core" = callPackage + ({ mkDerivation, aeson, base, containers, hashable, scientific + , semigroups, stdenv, text, unordered-containers, uuid, vector + }: + mkDerivation { + pname = "greskell-core"; + version = "0.1.2.1"; + sha256 = "1a1664043ceafdc6b6bc0a64eb104e9f03740cb9ea9249c6d9c2b496e7fb79f0"; + libraryHaskellDepends = [ + aeson base containers hashable scientific semigroups text + unordered-containers uuid vector + ]; + doHaddock = false; + doCheck = false; + homepage = "https://github.com/debug-ito/greskell/"; + description = "Haskell binding for Gremlin graph query language - core data types and tools"; + license = stdenv.lib.licenses.bsd3; + }) {}; + "greskell-websocket" = callPackage + ({ mkDerivation, aeson, async, base, base64-bytestring, bytestring + , greskell-core, hashtables, safe-exceptions, stdenv, stm, text + , unordered-containers, uuid, vector, websockets + }: + mkDerivation { + pname = "greskell-websocket"; + version = "0.1.0.0"; + sha256 = "b806936a188fceff94e37c43f015761a3da20c6bc0642c81ac736bda0ec8379c"; + libraryHaskellDepends = [ + aeson async base base64-bytestring bytestring greskell-core + hashtables safe-exceptions stm text unordered-containers uuid + vector websockets + ]; + doHaddock = false; + doCheck = false; + homepage = "https://github.com/debug-ito/greskell/"; + description = "Haskell client for Gremlin Server using WebSocket serializer"; + license = stdenv.lib.licenses.bsd3; + }) {}; + "groom" = callPackage + ({ mkDerivation, base, haskell-src-exts, stdenv }: + mkDerivation { + pname = "groom"; + version = "0.1.2.1"; + sha256 = "a6b4a4d3af1b26f63039f04bd4176493f8dd4f6a9ab281f0e33c0151c20de59d"; + isLibrary = true; + isExecutable = true; + libraryHaskellDepends = [ base haskell-src-exts ]; + executableHaskellDepends = [ base ]; + doHaddock = false; + doCheck = false; + description = "Pretty printing for well-behaved Show instances"; + license = stdenv.lib.licenses.bsd3; + }) {}; + "groups" = callPackage + ({ mkDerivation, base, stdenv }: + mkDerivation { + pname = "groups"; + version = "0.4.1.0"; + sha256 = "dd4588b71dfff42b9a30cb40304912742b95db964b20f51951aff0eee7f3f33d"; + libraryHaskellDepends = [ base ]; + doHaddock = false; + doCheck = false; + description = "Haskell 98 groups"; + license = stdenv.lib.licenses.bsd3; + }) {}; + "gtk" = callPackage + ({ mkDerivation, array, base, bytestring, Cabal, cairo, containers + , gio, glib, gtk2, gtk2hs-buildtools, mtl, pango, stdenv, text + }: + mkDerivation { + pname = "gtk"; + version = "0.14.10"; + sha256 = "28e1671eeb216335c7615513ba285a0c538d6747e38eb9acb64a5641f2650633"; + enableSeparateDataOutput = true; + setupHaskellDepends = [ base Cabal gtk2hs-buildtools ]; + libraryHaskellDepends = [ + array base bytestring cairo containers gio glib mtl pango text + ]; + libraryPkgconfigDepends = [ gtk2 ]; + doHaddock = false; + doCheck = false; + homepage = "http://projects.haskell.org/gtk2hs/"; + description = "Binding to the Gtk+ graphical user interface library"; + license = stdenv.lib.licenses.lgpl21; + }) {gtk2 = pkgs.gnome2.gtk;}; + "gtk2hs-buildtools" = callPackage + ({ mkDerivation, alex, array, base, Cabal, containers, directory + , filepath, happy, hashtables, pretty, process, random, stdenv + }: + mkDerivation { + pname = "gtk2hs-buildtools"; + version = "0.13.4.0"; + sha256 = "0f3e6ba90839efd43efe8cecbddb6478a55e2ce7788c57a0add4df477dede679"; + revision = "1"; + editedCabalFile = "0nbghg11y4nvxjxrvdm4a7fzj8z12fr12hkj4b7p27imlryg3m10"; + isLibrary = true; + isExecutable = true; + enableSeparateDataOutput = true; + libraryHaskellDepends = [ + array base Cabal containers directory filepath hashtables pretty + process random + ]; + libraryToolDepends = [ alex happy ]; + executableHaskellDepends = [ base ]; + doHaddock = false; + doCheck = false; + homepage = "http://projects.haskell.org/gtk2hs/"; + description = "Tools to build the Gtk2Hs suite of User Interface libraries"; + license = stdenv.lib.licenses.gpl2; + }) {}; + "gtk3" = callPackage + ({ mkDerivation, array, base, bytestring, Cabal, cairo, containers + , gio, glib, gtk2hs-buildtools, gtk3, mtl, pango, stdenv, text + }: + mkDerivation { + pname = "gtk3"; + version = "0.14.9"; + sha256 = "48e14ac9180fb090718fdaa5ec8f345173edbe5fdbebd6151f0a64804d0796e5"; + isLibrary = true; + isExecutable = true; + enableSeparateDataOutput = true; + setupHaskellDepends = [ base Cabal gtk2hs-buildtools ]; + libraryHaskellDepends = [ + array base bytestring cairo containers gio glib mtl pango text + ]; + libraryPkgconfigDepends = [ gtk3 ]; + doHaddock = false; + doCheck = false; + homepage = "http://projects.haskell.org/gtk2hs/"; + description = "Binding to the Gtk+ 3 graphical user interface library"; + license = stdenv.lib.licenses.lgpl21; + }) {inherit (pkgs) gtk3;}; + "gym-http-api" = callPackage + ({ mkDerivation, aeson, base, exceptions, http-client, servant + , servant-client, servant-lucid, stdenv, text, unordered-containers + }: + mkDerivation { + pname = "gym-http-api"; + version = "0.1.0.1"; + sha256 = "2c3fd9b261cd7bc3a004d41f582cd6c629956c78f7236eb91d615ca0c9b0c910"; + isLibrary = true; + isExecutable = true; + libraryHaskellDepends = [ + aeson base servant servant-client servant-lucid text + unordered-containers + ]; + executableHaskellDepends = [ + base exceptions http-client servant-client + ]; + doHaddock = false; + doCheck = false; + homepage = "https://github.com/stites/gym-http-api#readme"; + description = "REST client to the gym-http-api project"; + license = stdenv.lib.licenses.mit; + }) {}; + "h2c" = callPackage + ({ mkDerivation, base, bytestring, mtl, resourcet, stdenv }: + mkDerivation { + pname = "h2c"; + version = "1.0.0"; + sha256 = "4be2c9d54084175777624770640850aba33d7e4a31e2dc8096c122f737965499"; + libraryHaskellDepends = [ base bytestring mtl resourcet ]; + doHaddock = false; + doCheck = false; + homepage = "https://bitbucket.org/fmapE/h2c"; + description = "Bindings to Linux I2C with support for repeated-start transactions"; + license = stdenv.lib.licenses.mit; + }) {}; + "hOpenPGP" = callPackage + ({ mkDerivation, aeson, asn1-encoding, attoparsec, base + , base16-bytestring, base64-bytestring, bifunctors, binary + , binary-conduit, bytestring, bzlib, conduit, conduit-extra + , containers, crypto-cipher-types, cryptonite, errors, hashable + , incremental-parser, ixset-typed, lens, memory, monad-loops + , nettle, network-uri, newtype, openpgp-asciiarmor, prettyprinter + , resourcet, semigroups, split, stdenv, text, time + , time-locale-compat, transformers, unliftio-core + , unordered-containers, zlib + }: + mkDerivation { + pname = "hOpenPGP"; + version = "2.7.1"; + sha256 = "25d5c55287841e02da98b93d7e4503d6141e4bc8f8c241f5ce69fdd26fd1dc0a"; + libraryHaskellDepends = [ + aeson asn1-encoding attoparsec base base16-bytestring + base64-bytestring bifunctors binary binary-conduit bytestring bzlib + conduit conduit-extra containers crypto-cipher-types cryptonite + errors hashable incremental-parser ixset-typed lens memory + monad-loops nettle network-uri newtype openpgp-asciiarmor + prettyprinter resourcet semigroups split text time + time-locale-compat transformers unliftio-core unordered-containers + zlib + ]; + doHaddock = false; + doCheck = false; + homepage = "https://salsa.debian.org/clint/hOpenPGP"; + description = "native Haskell implementation of OpenPGP (RFC4880)"; + license = stdenv.lib.licenses.mit; + }) {}; + "hackage-db" = callPackage + ({ mkDerivation, aeson, base, bytestring, Cabal, containers + , directory, filepath, stdenv, tar, time, utf8-string + }: + mkDerivation { + pname = "hackage-db"; + version = "2.0.1"; + sha256 = "f0aac1af6d8d29b7fc2ffd43efaf5a7a5b00f2ead8dacff180bc3714c591ef8d"; + isLibrary = true; + isExecutable = true; + libraryHaskellDepends = [ + aeson base bytestring Cabal containers directory filepath tar time + utf8-string + ]; + doHaddock = false; + doCheck = false; + homepage = "https://github.com/peti/hackage-db#readme"; + description = "Access Hackage's package database via Data.Map"; + license = stdenv.lib.licenses.bsd3; + }) {}; + "hackage-security" = callPackage + ({ mkDerivation, base, base16-bytestring, base64-bytestring + , bytestring, Cabal, containers, cryptohash-sha256, directory + , ed25519, filepath, ghc-prim, mtl, network, network-uri, parsec + , pretty, stdenv, tar, template-haskell, time, transformers, zlib + }: + mkDerivation { + pname = "hackage-security"; + version = "0.5.3.0"; + sha256 = "db986e17e9265aa9e40901690815b890b97d53159eb24d0a6cafaa7c18577c21"; + revision = "3"; + editedCabalFile = "07h13j203wafvimfhswpjl2a43iaavy9579hm16z5m565m7f8hwy"; + libraryHaskellDepends = [ + base base16-bytestring base64-bytestring bytestring Cabal + containers cryptohash-sha256 directory ed25519 filepath ghc-prim + mtl network network-uri parsec pretty tar template-haskell time + transformers zlib + ]; + doHaddock = false; + doCheck = false; + homepage = "https://github.com/haskell/hackage-security"; + description = "Hackage security library"; + license = stdenv.lib.licenses.bsd3; + }) {}; + "haddock-library" = callPackage + ({ mkDerivation, base, bytestring, containers, deepseq, stdenv + , transformers + }: + mkDerivation { + pname = "haddock-library"; + version = "1.5.0.1"; + sha256 = "ff2c10f043524135c809303c0d81c7f27a954f0174784e59a497e75e287aabb2"; + libraryHaskellDepends = [ + base bytestring containers deepseq transformers + ]; + doHaddock = false; + doCheck = false; + homepage = "http://www.haskell.org/haddock/"; + description = "Library exposing some functionality of Haddock"; + license = stdenv.lib.licenses.bsd3; + }) {}; + "hailgun" = callPackage + ({ mkDerivation, aeson, base, bytestring, email-validate + , exceptions, filepath, http-client, http-client-tls, http-types + , stdenv, tagsoup, text, time, transformers + }: + mkDerivation { + pname = "hailgun"; + version = "0.4.1.8"; + sha256 = "9dcc7367afec6605045246d4959f27a29a54bbdbcec543e6f5ae59b048e2dcc3"; + libraryHaskellDepends = [ + aeson base bytestring email-validate exceptions filepath + http-client http-client-tls http-types tagsoup text time + transformers + ]; + doHaddock = false; + doCheck = false; + homepage = "https://bitbucket.org/robertmassaioli/hailgun"; + description = "Mailgun REST api interface for Haskell"; + license = stdenv.lib.licenses.mit; + }) {}; + "hakyll" = callPackage + ({ mkDerivation, base, binary, blaze-html, blaze-markup, bytestring + , containers, cryptohash, data-default, deepseq, directory + , file-embed, filepath, fsnotify, http-conduit, http-types + , lrucache, mtl, network-uri, optparse-applicative, pandoc + , pandoc-citeproc, parsec, process, random, regex-tdfa, resourcet + , scientific, stdenv, tagsoup, text, time, time-locale-compat + , unordered-containers, vector, wai, wai-app-static, warp, yaml + }: + mkDerivation { + pname = "hakyll"; + version = "4.12.3.0"; + sha256 = "a472dc12e18415c0d8bab788334d753233789f2fd58a8f70de57172814639fb1"; + isLibrary = true; + isExecutable = true; + enableSeparateDataOutput = true; + libraryHaskellDepends = [ + base binary blaze-html blaze-markup bytestring containers + cryptohash data-default deepseq directory file-embed filepath + fsnotify http-conduit http-types lrucache mtl network-uri + optparse-applicative pandoc pandoc-citeproc parsec process random + regex-tdfa resourcet scientific tagsoup text time + time-locale-compat unordered-containers vector wai wai-app-static + warp yaml + ]; + executableHaskellDepends = [ base directory filepath ]; + doHaddock = false; + doCheck = false; + homepage = "http://jaspervdj.be/hakyll"; + description = "A static website compiler library"; + license = stdenv.lib.licenses.bsd3; + }) {}; + "half" = callPackage + ({ mkDerivation, base, deepseq, stdenv, template-haskell }: + mkDerivation { + pname = "half"; + version = "0.3"; + sha256 = "06b26fb062a55fa8f5df1cc2fddc47e5303f09977279f05f62d1950a51b72093"; + libraryHaskellDepends = [ base deepseq template-haskell ]; + doHaddock = false; + doCheck = false; + homepage = "http://github.com/ekmett/half"; + description = "Half-precision floating-point"; + license = stdenv.lib.licenses.bsd3; + }) {}; + "hamilton" = callPackage + ({ mkDerivation, ad, ansi-wl-pprint, base, containers + , finite-typelits, ghc-typelits-knownnat, hmatrix, hmatrix-gsl + , hmatrix-vector-sized, optparse-applicative, stdenv + , typelits-witnesses, vector, vector-sized, vty + }: + mkDerivation { + pname = "hamilton"; + version = "0.1.0.3"; + sha256 = "3c7623217c8e49cabc6620835e53609e7b7339f39a1523da2467076252addb1b"; + isLibrary = true; + isExecutable = true; + libraryHaskellDepends = [ + ad base hmatrix hmatrix-gsl hmatrix-vector-sized typelits-witnesses + vector-sized + ]; + executableHaskellDepends = [ + ansi-wl-pprint base containers finite-typelits + ghc-typelits-knownnat hmatrix optparse-applicative vector + vector-sized vty + ]; + doHaddock = false; + doCheck = false; + homepage = "https://github.com/mstksg/hamilton#readme"; + description = "Physics on generalized coordinate systems using Hamiltonian Mechanics and AD"; + license = stdenv.lib.licenses.bsd3; + }) {}; + "hamtsolo" = callPackage + ({ mkDerivation, async, attoparsec, attoparsec-binary, base, binary + , bytestring, conduit, conduit-combinators, conduit-extra + , exceptions, gitrev, optparse-applicative, resourcet, stdenv + , stm-conduit, unix + }: + mkDerivation { + pname = "hamtsolo"; + version = "1.0.3"; + sha256 = "d0deda06a582db978a417d8eed9e403c339a54c4bc9c2b6c6cdee8555dbb7035"; + isLibrary = false; + isExecutable = true; + executableHaskellDepends = [ + async attoparsec attoparsec-binary base binary bytestring conduit + conduit-combinators conduit-extra exceptions gitrev + optparse-applicative resourcet stm-conduit unix + ]; + doHaddock = false; + doCheck = false; + homepage = "https://github.com/tfc/hamtsolo#readme"; + description = "Intel AMT serial-over-lan (SOL) client"; + license = stdenv.lib.licenses.bsd3; + }) {}; + "handwriting" = callPackage + ({ mkDerivation, aeson, base, bytestring, containers, directory + , filepath, lens, lens-aeson, random, split, stdenv, text + , transformers, wreq + }: + mkDerivation { + pname = "handwriting"; + version = "0.1.0.3"; + sha256 = "7e1b406d19b2f39b34910462dce214c7ca91bb9d78bf9fafb9f906dd44d5beaa"; + isLibrary = true; + isExecutable = true; + libraryHaskellDepends = [ + aeson base bytestring containers lens lens-aeson split text + transformers wreq + ]; + executableHaskellDepends = [ + base bytestring directory filepath random text + ]; + doHaddock = false; + doCheck = false; + homepage = "http://github.com/ismailmustafa/handwriting-haskell#readme"; + description = "API Client for the handwriting.io API."; + license = stdenv.lib.licenses.bsd3; + }) {}; + "hapistrano" = callPackage + ({ mkDerivation, aeson, async, base, filepath, formatting, gitrev + , mtl, optparse-applicative, path, path-io, process, stdenv, stm + , time, transformers, yaml + }: + mkDerivation { + pname = "hapistrano"; + version = "0.3.5.8"; + sha256 = "ff945ebe45c1c4120a5673ebe5d7f7871c597996d132d71371d2cd4adee3e179"; + isLibrary = true; + isExecutable = true; + enableSeparateDataOutput = true; + libraryHaskellDepends = [ + base filepath formatting gitrev mtl path process time transformers + ]; + executableHaskellDepends = [ + aeson async base formatting gitrev optparse-applicative path + path-io stm yaml + ]; + doHaddock = false; + doCheck = false; + homepage = "https://github.com/stackbuilders/hapistrano"; + description = "A deployment library for Haskell applications"; + license = stdenv.lib.licenses.mit; + }) {}; + "happstack-server" = callPackage + ({ mkDerivation, base, base64-bytestring, blaze-html, bytestring + , containers, directory, exceptions, extensible-exceptions + , filepath, hslogger, html, monad-control, mtl, network + , network-uri, old-locale, parsec, process, semigroups, sendfile + , stdenv, syb, system-filepath, template-haskell, text, threads + , time, time-compat, transformers, transformers-base + , transformers-compat, unix, utf8-string, xhtml, zlib + }: + mkDerivation { + pname = "happstack-server"; + version = "7.5.1.1"; + sha256 = "614a65dd721bfa74ff4e0090e70c4b5c7dfb1fdb6485218b4ce1c5d50509fd61"; + libraryHaskellDepends = [ + base base64-bytestring blaze-html bytestring containers directory + exceptions extensible-exceptions filepath hslogger html + monad-control mtl network network-uri old-locale parsec process + semigroups sendfile syb system-filepath template-haskell text + threads time time-compat transformers transformers-base + transformers-compat unix utf8-string xhtml zlib + ]; + doHaddock = false; + doCheck = false; + homepage = "http://happstack.com"; + description = "Web related tools and services"; + license = stdenv.lib.licenses.bsd3; + }) {}; + "happy" = callPackage + ({ mkDerivation, array, base, Cabal, containers, directory + , filepath, mtl, stdenv + }: + mkDerivation { + pname = "happy"; + version = "1.19.9"; + sha256 = "3e81a3e813acca3aae52721c412cde18b7b7c71ecbacfaeaa5c2f4b35abf1d8d"; + revision = "3"; + editedCabalFile = "0kwlh964nyqvfbm02np8vpc28gbhsby0r65jhz1918rm0wip9izq"; + isLibrary = false; + isExecutable = true; + setupHaskellDepends = [ base Cabal directory filepath ]; + executableHaskellDepends = [ array base containers mtl ]; + doHaddock = false; + doCheck = false; + homepage = "https://www.haskell.org/happy/"; + description = "Happy is a parser generator for Haskell"; + license = stdenv.lib.licenses.bsd2; + }) {}; + "hasbolt" = callPackage + ({ mkDerivation, base, binary, bytestring, connection, containers + , data-binary-ieee754, data-default, hex, network, stdenv, text + , transformers + }: + mkDerivation { + pname = "hasbolt"; + version = "0.1.3.0"; + sha256 = "fd6fc49f57e8c03087103f733c130739a046398b5118b078aad2def31059665d"; + revision = "3"; + editedCabalFile = "0j9njdb6x5ibx113bprsq2i0jmrigdli23pjabxam9q07979c9ac"; + libraryHaskellDepends = [ + base binary bytestring connection containers data-binary-ieee754 + data-default hex network text transformers + ]; + doHaddock = false; + doCheck = false; + homepage = "https://github.com/zmactep/hasbolt#readme"; + description = "Haskell driver for Neo4j 3+ (BOLT protocol)"; + license = stdenv.lib.licenses.bsd3; + }) {}; + "hashable" = callPackage + ({ mkDerivation, base, bytestring, deepseq, ghc-prim, integer-gmp + , stdenv, text + }: + mkDerivation { + pname = "hashable"; + version = "1.2.7.0"; + sha256 = "ecb5efc0586023f5a0dc861100621c1dbb4cbb2f0516829a16ebac39f0432abf"; + revision = "1"; + editedCabalFile = "197063dpl0wn67dp7a06yc2hxp81n24ykk7klbjx0fndm5n87dh3"; + isLibrary = true; + isExecutable = true; + libraryHaskellDepends = [ + base bytestring deepseq ghc-prim integer-gmp text + ]; + doHaddock = false; + doCheck = false; + homepage = "http://github.com/tibbe/hashable"; + description = "A class for types that can be converted to a hash value"; + license = stdenv.lib.licenses.bsd3; + }) {}; + "hashids" = callPackage + ({ mkDerivation, base, bytestring, containers, split, stdenv }: + mkDerivation { + pname = "hashids"; + version = "1.0.2.4"; + sha256 = "27991fc8a6debe76a086af80f6b72a5d451e7f1466b79cb0df973b98a2f5f3cf"; + libraryHaskellDepends = [ base bytestring containers split ]; + doHaddock = false; + doCheck = false; + homepage = "http://hashids.org/"; + description = "Hashids generates short, unique, non-sequential ids from numbers"; + license = stdenv.lib.licenses.mit; + }) {}; + "hashmap" = callPackage + ({ mkDerivation, base, containers, deepseq, hashable, stdenv }: + mkDerivation { + pname = "hashmap"; + version = "1.3.3"; + sha256 = "dc06b57cd1bcd656d4602df7705a3f11a54ae65f664e9be472d42a9bdcd64755"; + libraryHaskellDepends = [ base containers deepseq hashable ]; + doHaddock = false; + doCheck = false; + homepage = "https://github.com/foxik/hashmap"; + description = "Persistent containers Map and Set based on hashing"; + license = stdenv.lib.licenses.bsd3; + }) {}; + "hashtables" = callPackage + ({ mkDerivation, base, ghc-prim, hashable, primitive, stdenv + , vector + }: + mkDerivation { + pname = "hashtables"; + version = "1.2.3.1"; + sha256 = "8fd1c7c77c267eae6af01f1d9ca427754fb092cfffc8041cd50764a9144b3cbe"; + libraryHaskellDepends = [ + base ghc-prim hashable primitive vector + ]; + doHaddock = false; + doCheck = false; + homepage = "http://github.com/gregorycollins/hashtables"; + description = "Mutable hash tables in the ST monad"; + license = stdenv.lib.licenses.bsd3; + }) {}; + "haskeline" = callPackage + ({ mkDerivation, base, bytestring, containers, directory, filepath + , process, stdenv, stm, terminfo, transformers, unix + }: + mkDerivation { + pname = "haskeline"; + version = "0.7.4.3"; + sha256 = "046d0930bc2dbc57a7cd9ddb5d1e92c7fdb71c6b91b2bbf673f5406843d6b679"; + configureFlags = [ "-fterminfo" ]; + libraryHaskellDepends = [ + base bytestring containers directory filepath process stm terminfo + transformers unix + ]; + doHaddock = false; + doCheck = false; + homepage = "https://github.com/judah/haskeline"; + description = "A command-line interface for user input, written in Haskell"; + license = stdenv.lib.licenses.bsd3; + }) {}; + "haskell-gi" = callPackage + ({ mkDerivation, attoparsec, base, bytestring, Cabal, containers + , directory, filepath, glib, gobjectIntrospection, haskell-gi-base + , mtl, pretty-show, process, regex-tdfa, safe, stdenv, text + , transformers, xdg-basedir, xml-conduit + }: + mkDerivation { + pname = "haskell-gi"; + version = "0.21.3"; + sha256 = "c0ae6687f2402742109c3c5dab03d17ca96dfce0680624ea595ee269deb75527"; + isLibrary = true; + isExecutable = true; + libraryHaskellDepends = [ + attoparsec base bytestring Cabal containers directory filepath + haskell-gi-base mtl pretty-show process regex-tdfa safe text + transformers xdg-basedir xml-conduit + ]; + libraryPkgconfigDepends = [ glib gobjectIntrospection ]; + executableHaskellDepends = [ + base containers directory filepath haskell-gi-base pretty-show text + ]; + doHaddock = false; + doCheck = false; + homepage = "https://github.com/haskell-gi/haskell-gi"; + description = "Generate Haskell bindings for GObject Introspection capable libraries"; + license = stdenv.lib.licenses.lgpl21; + }) {inherit (pkgs) glib; inherit (pkgs) gobjectIntrospection;}; + "haskell-gi-base" = callPackage + ({ mkDerivation, base, bytestring, containers, glib, stdenv, text + }: + mkDerivation { + pname = "haskell-gi-base"; + version = "0.21.1"; + sha256 = "667cf211eb6ce1e3e84fc2126670847228b4cb4211dd7d7f4ae627ef6f15295d"; + libraryHaskellDepends = [ base bytestring containers text ]; + libraryPkgconfigDepends = [ glib ]; + doHaddock = false; + doCheck = false; + homepage = "https://github.com/haskell-gi/haskell-gi-base"; + description = "Foundation for libraries generated by haskell-gi"; + license = stdenv.lib.licenses.lgpl21; + }) {inherit (pkgs) glib;}; + "haskell-gi-overloading" = callPackage + ({ mkDerivation, stdenv }: + mkDerivation { + pname = "haskell-gi-overloading"; + version = "1.0"; + sha256 = "3ed797f8dd8d3535640b1ca99851bbc5968817c25a80fc499af42715d371682a"; + doHaddock = false; + doCheck = false; + homepage = "https://github.com/haskell-gi/haskell-gi"; + description = "Overloading support for haskell-gi"; + license = stdenv.lib.licenses.bsd3; + }) {}; + "haskell-lexer" = callPackage + ({ mkDerivation, base, stdenv }: + mkDerivation { + pname = "haskell-lexer"; + version = "1.0.1"; + sha256 = "d7d42ab3c4bc2f0232ede8b005fb9de57f862ee4c1c83aa61e1022346fc84366"; + libraryHaskellDepends = [ base ]; + doHaddock = false; + doCheck = false; + description = "A fully compliant Haskell 98 lexer"; + license = stdenv.lib.licenses.bsd3; + }) {}; + "haskell-lsp" = callPackage + ({ mkDerivation, aeson, base, bytestring, containers, data-default + , directory, filepath, hashable, haskell-lsp-types, hslogger, lens + , mtl, network-uri, parsec, sorted-list, stdenv, stm, text, time + , transformers, unordered-containers, vector, yi-rope + }: + mkDerivation { + pname = "haskell-lsp"; + version = "0.2.2.0"; + sha256 = "adfb9231a1580ff7586130f513dc2d4436d3fc0315f0eeca60e283081a5f71c0"; + revision = "1"; + editedCabalFile = "0bdgpj5cj4qwp31glmilp1gqdm8c3fkqvgw18aqv8pz2wg39x23y"; + isLibrary = true; + isExecutable = true; + libraryHaskellDepends = [ + aeson base bytestring containers data-default directory filepath + hashable haskell-lsp-types hslogger lens mtl network-uri parsec + sorted-list stm text time unordered-containers yi-rope + ]; + executableHaskellDepends = [ + aeson base bytestring containers data-default directory filepath + hslogger lens mtl network-uri parsec stm text time transformers + unordered-containers vector yi-rope + ]; + doHaddock = false; + doCheck = false; + homepage = "https://github.com/alanz/haskell-lsp"; + description = "Haskell library for the Microsoft Language Server Protocol"; + license = stdenv.lib.licenses.mit; + }) {}; + "haskell-lsp-types" = callPackage + ({ mkDerivation, aeson, base, bytestring, data-default, filepath + , hashable, lens, network-uri, stdenv, text, unordered-containers + }: + mkDerivation { + pname = "haskell-lsp-types"; + version = "0.2.2.0"; + sha256 = "bd7a5a259daa504154c701d84d0b1176b46cbfbe46342341d2a0909631f29071"; + libraryHaskellDepends = [ + aeson base bytestring data-default filepath hashable lens + network-uri text unordered-containers + ]; + doHaddock = false; + doCheck = false; + homepage = "https://github.com/alanz/haskell-lsp"; + description = "Haskell library for the Microsoft Language Server Protocol, data types"; + license = stdenv.lib.licenses.mit; + }) {}; + "haskell-spacegoo" = callPackage + ({ mkDerivation, aeson, base, bytestring, conduit, conduit-extra + , mtl, pretty, pretty-show, stdenv, text, vector, vector-space + }: + mkDerivation { + pname = "haskell-spacegoo"; + version = "0.2.0.1"; + sha256 = "1eb3faa9a7f6a5870337eeb0bb3ad915f58987dfe4643fe95c91cbb2738ddd3c"; + libraryHaskellDepends = [ + aeson base bytestring conduit conduit-extra mtl pretty pretty-show + text vector vector-space + ]; + doHaddock = false; + doCheck = false; + description = "Client API for Rocket Scissor Spacegoo"; + license = stdenv.lib.licenses.mit; + }) {}; + "haskell-src" = callPackage + ({ mkDerivation, array, base, happy, pretty, stdenv, syb }: + mkDerivation { + pname = "haskell-src"; + version = "1.0.3.0"; + sha256 = "b4b4941e8883da32c3f2b93f3ecdd5cff82ff9304cb91e89850b19095c908dbc"; + libraryHaskellDepends = [ array base pretty syb ]; + libraryToolDepends = [ happy ]; + doHaddock = false; + doCheck = false; + description = "Support for manipulating Haskell source code"; + license = stdenv.lib.licenses.bsd3; + }) {}; + "haskell-src-exts" = callPackage + ({ mkDerivation, array, base, cpphs, ghc-prim, happy, pretty + , stdenv + }: + mkDerivation { + pname = "haskell-src-exts"; + version = "1.20.2"; + sha256 = "9f6686e8bc8b849991207304e524747b0d1dcedfea351ac073ce971b36f9a3ea"; + revision = "1"; + editedCabalFile = "0gxpxs3p4qvky6m8g3fjj09hx7nkg28b9a4999ca7afz359si3r9"; + libraryHaskellDepends = [ array base cpphs ghc-prim pretty ]; + libraryToolDepends = [ happy ]; + doHaddock = false; + doCheck = false; + homepage = "https://github.com/haskell-suite/haskell-src-exts"; + description = "Manipulating Haskell source: abstract syntax, lexer, parser, and pretty-printer"; + license = stdenv.lib.licenses.bsd3; + }) {}; + "haskell-src-exts-simple" = callPackage + ({ mkDerivation, base, haskell-src-exts, stdenv }: + mkDerivation { + pname = "haskell-src-exts-simple"; + version = "1.20.0.0"; + sha256 = "b305be88204f70af3b7f2e1feb972cf38f3feafb82781e94909484c5ebbde95c"; + libraryHaskellDepends = [ base haskell-src-exts ]; + doHaddock = false; + doCheck = false; + homepage = "https://github.com/int-e/haskell-src-exts-simple"; + description = "A simplified view on the haskell-src-exts AST"; + license = stdenv.lib.licenses.mit; + }) {}; + "haskell-src-exts-util" = callPackage + ({ mkDerivation, base, containers, data-default, haskell-src-exts + , semigroups, stdenv, transformers, uniplate + }: + mkDerivation { + pname = "haskell-src-exts-util"; + version = "0.2.3"; + sha256 = "e833ef33423645fee4a300ff4e1354618a0d115a954cd62e72096175513803a0"; + libraryHaskellDepends = [ + base containers data-default haskell-src-exts semigroups + transformers uniplate + ]; + doHaddock = false; + doCheck = false; + homepage = "https://github.com/pepeiborra/haskell-src-exts-util"; + description = "Helper functions for working with haskell-src-exts trees"; + license = stdenv.lib.licenses.bsd3; + }) {}; + "haskell-src-meta" = callPackage + ({ mkDerivation, base, haskell-src-exts, pretty, stdenv, syb + , template-haskell, th-orphans + }: + mkDerivation { + pname = "haskell-src-meta"; + version = "0.8.0.3"; + sha256 = "8473e3555080860c2043581b398dbab67319584a568463b074a092fd4d095822"; + revision = "2"; + editedCabalFile = "0dp5v0yd0wgijzaggr22glgjswpa65hy84h8awdzd9d78g2fjz6c"; + libraryHaskellDepends = [ + base haskell-src-exts pretty syb template-haskell th-orphans + ]; + doHaddock = false; + doCheck = false; + description = "Parse source to template-haskell abstract syntax"; + license = stdenv.lib.licenses.bsd3; + }) {}; + "haskell-tools-ast" = callPackage + ({ mkDerivation, base, classyplate, ghc, mtl, pretty, references + , stdenv, template-haskell, uniplate + }: + mkDerivation { + pname = "haskell-tools-ast"; + version = "1.1.0.2"; + sha256 = "2cf0f51aa551c896634ee2649782ee8994bed7088a14e03961b4bf2a5e6d0149"; + libraryHaskellDepends = [ + base classyplate ghc mtl pretty references template-haskell + uniplate + ]; + doHaddock = false; + doCheck = false; + homepage = "https://github.com/nboldi/haskell-tools"; + description = "Haskell AST for efficient tooling"; + license = stdenv.lib.licenses.bsd3; + }) {}; + "haskell-tools-backend-ghc" = callPackage + ({ mkDerivation, base, bytestring, containers, ghc, ghc-boot-th + , haskell-tools-ast, mtl, references, safe, split, stdenv + , template-haskell, transformers, uniplate + }: + mkDerivation { + pname = "haskell-tools-backend-ghc"; + version = "1.1.0.2"; + sha256 = "14fe9a12005f05fac32be4c973e4b08c223bf0d6b2a879e92e190d6bf7230530"; + libraryHaskellDepends = [ + base bytestring containers ghc ghc-boot-th haskell-tools-ast mtl + references safe split template-haskell transformers uniplate + ]; + doHaddock = false; + doCheck = false; + homepage = "https://github.com/nboldi/haskell-tools"; + description = "Creating the Haskell-Tools AST from GHC's representations"; + license = stdenv.lib.licenses.bsd3; + }) {}; + "haskell-tools-builtin-refactorings" = callPackage + ({ mkDerivation, aeson, base, Cabal, classyplate, containers + , deepseq, directory, filepath, ghc, ghc-paths, haskell-tools-ast + , haskell-tools-backend-ghc, haskell-tools-prettyprint + , haskell-tools-refactor, haskell-tools-rewrite, minisat-solver + , mtl, portable-lines, references, split, stdenv, template-haskell + , transformers, uniplate + }: + mkDerivation { + pname = "haskell-tools-builtin-refactorings"; + version = "1.1.0.2"; + sha256 = "8916acba20c47d3091272458a131e38cb8edb26f5dd44cb7793f12ce8661a7f2"; + libraryHaskellDepends = [ + aeson base Cabal classyplate containers deepseq directory filepath + ghc ghc-paths haskell-tools-ast haskell-tools-backend-ghc + haskell-tools-prettyprint haskell-tools-refactor + haskell-tools-rewrite minisat-solver mtl portable-lines references + split template-haskell transformers uniplate + ]; + doHaddock = false; + doCheck = false; + homepage = "https://github.com/haskell-tools/haskell-tools"; + description = "Refactoring Tool for Haskell"; + license = stdenv.lib.licenses.bsd3; + }) {}; + "haskell-tools-debug" = callPackage + ({ mkDerivation, base, classyplate, criterion, filepath, ghc + , ghc-paths, haskell-tools-ast, haskell-tools-backend-ghc + , haskell-tools-builtin-refactorings, haskell-tools-prettyprint + , haskell-tools-refactor, mtl, references, split, stdenv + , template-haskell, uniplate + }: + mkDerivation { + pname = "haskell-tools-debug"; + version = "1.1.0.2"; + sha256 = "14da03518f3ea1cf1778cbf7f157437a899b86bf06b99b74f8e01502894cdbd2"; + isLibrary = true; + isExecutable = true; + libraryHaskellDepends = [ + base classyplate criterion filepath ghc ghc-paths haskell-tools-ast + haskell-tools-backend-ghc haskell-tools-builtin-refactorings + haskell-tools-prettyprint haskell-tools-refactor mtl references + split template-haskell uniplate + ]; + executableHaskellDepends = [ base ]; + doHaddock = false; + doCheck = false; + homepage = "https://github.com/haskell-tools/haskell-tools"; + description = "Debugging Tools for Haskell-tools"; + license = stdenv.lib.licenses.bsd3; + }) {}; + "haskell-tools-demo" = callPackage + ({ mkDerivation, aeson, base, bytestring, containers, directory + , filepath, ghc, ghc-paths, haskell-tools-ast + , haskell-tools-backend-ghc, haskell-tools-builtin-refactorings + , haskell-tools-prettyprint, haskell-tools-refactor, http-types + , mtl, references, stdenv, transformers, wai, wai-websockets, warp + , websockets + }: + mkDerivation { + pname = "haskell-tools-demo"; + version = "1.1.0.2"; + sha256 = "7deec5cfae29cecb99ee6b57cfd9d37deb0a2f2546263bbc4a5d08ca70375530"; + isLibrary = true; + isExecutable = true; + libraryHaskellDepends = [ + aeson base bytestring containers directory filepath ghc ghc-paths + haskell-tools-ast haskell-tools-backend-ghc + haskell-tools-builtin-refactorings haskell-tools-prettyprint + haskell-tools-refactor http-types mtl references transformers wai + wai-websockets warp websockets + ]; + executableHaskellDepends = [ base ]; + doHaddock = false; + doCheck = false; + homepage = "https://github.com/haskell-tools/haskell-tools"; + description = "A web-based demo for Haskell-tools Refactor"; + license = stdenv.lib.licenses.bsd3; + }) {}; + "haskell-tools-prettyprint" = callPackage + ({ mkDerivation, base, containers, ghc, haskell-tools-ast, mtl + , references, split, stdenv, text, uniplate + }: + mkDerivation { + pname = "haskell-tools-prettyprint"; + version = "1.1.0.2"; + sha256 = "78396c1ac41c5810a0013077738a5ce7bf958201f6703689c0f0746ca3084206"; + libraryHaskellDepends = [ + base containers ghc haskell-tools-ast mtl references split text + uniplate + ]; + doHaddock = false; + doCheck = false; + homepage = "https://github.com/haskell-tools/haskell-tools"; + description = "Pretty printing of Haskell-Tools AST"; + license = stdenv.lib.licenses.bsd3; + }) {}; + "haskell-tools-refactor" = callPackage + ({ mkDerivation, aeson, base, Cabal, containers, directory + , filepath, ghc, ghc-paths, haskell-tools-ast + , haskell-tools-backend-ghc, haskell-tools-prettyprint + , haskell-tools-rewrite, mtl, references, split, stdenv + , template-haskell, transformers, uniplate + }: + mkDerivation { + pname = "haskell-tools-refactor"; + version = "1.1.0.2"; + sha256 = "f833e8ca1af652c68b3e3f3f5c3714c509d9748585a004a3c4764f61a2acf389"; + libraryHaskellDepends = [ + aeson base Cabal containers directory filepath ghc ghc-paths + haskell-tools-ast haskell-tools-backend-ghc + haskell-tools-prettyprint haskell-tools-rewrite mtl references + split template-haskell transformers uniplate + ]; + doHaddock = false; + doCheck = false; + homepage = "https://github.com/haskell-tools/haskell-tools"; + description = "Refactoring Tool for Haskell"; + license = stdenv.lib.licenses.bsd3; + }) {}; + "haskell-tools-rewrite" = callPackage + ({ mkDerivation, base, containers, ghc, haskell-tools-ast + , haskell-tools-prettyprint, mtl, references, stdenv + }: + mkDerivation { + pname = "haskell-tools-rewrite"; + version = "1.1.0.2"; + sha256 = "a50009039c4428744f63905b0e3ca599aa4362dbe5c887deb15745bd8848e7ab"; + libraryHaskellDepends = [ + base containers ghc haskell-tools-ast haskell-tools-prettyprint mtl + references + ]; + doHaddock = false; + doCheck = false; + homepage = "https://github.com/haskell-tools/haskell-tools"; + description = "Facilities for generating new parts of the Haskell-Tools AST"; + license = stdenv.lib.licenses.bsd3; + }) {}; + "haskey" = callPackage + ({ mkDerivation, base, binary, bytestring, containers, directory + , exceptions, filepath, focus, haskey-btree, list-t, lz4, mtl + , semigroups, stdenv, stm, stm-containers, transformers, unix + , xxhash-ffi + }: + mkDerivation { + pname = "haskey"; + version = "0.3.0.2"; + sha256 = "901c08a8155d8e394a868fe5a4b7318912afda8f91349f870c4384c5ab9944e8"; + libraryHaskellDepends = [ + base binary bytestring containers directory exceptions filepath + focus haskey-btree list-t lz4 mtl semigroups stm stm-containers + transformers unix xxhash-ffi + ]; + doHaddock = false; + doCheck = false; + homepage = "https://github.com/haskell-haskey"; + description = "A transactional, ACID compliant, embeddable key-value store"; + license = stdenv.lib.licenses.bsd3; + }) {}; + "haskey-btree" = callPackage + ({ mkDerivation, base, binary, bytestring, containers, hashable + , mtl, semigroups, stdenv, text, transformers, vector + }: + mkDerivation { + pname = "haskey-btree"; + version = "0.3.0.0"; + sha256 = "90387d9a8e2afb22f9a4ace4b8f3b1a2045b955c1283c70a614abeff2294465a"; + libraryHaskellDepends = [ + base binary bytestring containers hashable mtl semigroups text + transformers vector + ]; + doHaddock = false; + doCheck = false; + homepage = "https://github.com/haskell-haskey/haskey-btree"; + description = "B+-tree implementation in Haskell"; + license = stdenv.lib.licenses.bsd3; + }) {}; + "haskey-mtl" = callPackage + ({ mkDerivation, base, exceptions, haskey, haskey-btree + , monad-control, mtl, stdenv, transformers, transformers-base + }: + mkDerivation { + pname = "haskey-mtl"; + version = "0.3.1.0"; + sha256 = "1ffb00a2901dc19edeeb18299dd1a52a49ca8c25bc04e87555c1bcec90b79294"; + libraryHaskellDepends = [ + base exceptions haskey haskey-btree monad-control mtl transformers + transformers-base + ]; + doHaddock = false; + doCheck = false; + homepage = "https://github.com/haskell-haskey"; + description = "A monad transformer supporting Haskey transactions"; + license = stdenv.lib.licenses.bsd3; + }) {}; + "haskintex" = callPackage + ({ mkDerivation, base, binary, bytestring, containers, directory + , filepath, haskell-src-exts, HaTeX, hint, parsec, process, stdenv + , text, transformers + }: + mkDerivation { + pname = "haskintex"; + version = "0.8.0.0"; + sha256 = "9d4974112f33baf47124a56f87b96892a0a37c10587098f851c71256d15cddd8"; + isLibrary = true; + isExecutable = true; + libraryHaskellDepends = [ + base binary bytestring containers directory filepath + haskell-src-exts HaTeX hint parsec process text transformers + ]; + executableHaskellDepends = [ base ]; + doHaddock = false; + doCheck = false; + homepage = "http://daniel-diaz.github.io/projects/haskintex"; + description = "Haskell Evaluation inside of LaTeX code"; + license = stdenv.lib.licenses.bsd3; + }) {}; + "hasql" = callPackage + ({ mkDerivation, attoparsec, base, base-prelude, bytestring + , bytestring-strict-builder, contravariant, contravariant-extras + , data-default-class, dlist, hashable, hashtables, loch-th, mtl + , placeholders, postgresql-binary, postgresql-libpq, profunctors + , stdenv, text, text-builder, transformers, vector + }: + mkDerivation { + pname = "hasql"; + version = "1.3.0.2"; + sha256 = "15415132a2cc533fba7db0a3f6c13ab456eaf04b979169938ace64523c02b88b"; + libraryHaskellDepends = [ + attoparsec base base-prelude bytestring bytestring-strict-builder + contravariant contravariant-extras data-default-class dlist + hashable hashtables loch-th mtl placeholders postgresql-binary + postgresql-libpq profunctors text text-builder transformers vector + ]; + doHaddock = false; + doCheck = false; + homepage = "https://github.com/nikita-volkov/hasql"; + description = "An efficient PostgreSQL driver and a flexible mapping API"; + license = stdenv.lib.licenses.mit; + }) {}; + "hasql-optparse-applicative" = callPackage + ({ mkDerivation, base-prelude, hasql, hasql-pool + , optparse-applicative, stdenv + }: + mkDerivation { + pname = "hasql-optparse-applicative"; + version = "0.3.0.3"; + sha256 = "63b4c3da21434bac9a98521cdcfda7815bcebb8829feb889f4050fffd7f06334"; + libraryHaskellDepends = [ + base-prelude hasql hasql-pool optparse-applicative + ]; + doHaddock = false; + doCheck = false; + homepage = "https://github.com/sannsyn/hasql-optparse-applicative"; + description = "\"optparse-applicative\" parsers for \"hasql\""; + license = stdenv.lib.licenses.mit; + }) {}; + "hasql-pool" = callPackage + ({ mkDerivation, base-prelude, hasql, resource-pool, stdenv, time + }: + mkDerivation { + pname = "hasql-pool"; + version = "0.5"; + sha256 = "3a33cdfc9ae253f193afb824c9488051103b4c71316b6db39d51dce27c825d2f"; + libraryHaskellDepends = [ base-prelude hasql resource-pool time ]; + doHaddock = false; + doCheck = false; + homepage = "https://github.com/nikita-volkov/hasql-pool"; + description = "A pool of connections for Hasql"; + license = stdenv.lib.licenses.mit; + }) {}; + "hasql-transaction" = callPackage + ({ mkDerivation, base, base-prelude, bytestring + , bytestring-tree-builder, contravariant, contravariant-extras + , hasql, mtl, stdenv, transformers + }: + mkDerivation { + pname = "hasql-transaction"; + version = "0.7"; + sha256 = "decb3c5b08f710413ee65861c30766c53dc79d05f388fab6f8e1105e4d907fcf"; + libraryHaskellDepends = [ + base base-prelude bytestring bytestring-tree-builder contravariant + contravariant-extras hasql mtl transformers + ]; + doHaddock = false; + doCheck = false; + homepage = "https://github.com/nikita-volkov/hasql-transaction"; + description = "A composable abstraction over the retryable transactions for Hasql"; + license = stdenv.lib.licenses.mit; + }) {}; + "hasty-hamiltonian" = callPackage + ({ mkDerivation, base, kan-extensions, lens, mcmc-types + , mwc-probability, pipes, primitive, stdenv, transformers + }: + mkDerivation { + pname = "hasty-hamiltonian"; + version = "1.3.2"; + sha256 = "e6299d72e145cfabea798e2088284580fc65f01638e3562e1f01cf9df018cc9e"; + libraryHaskellDepends = [ + base kan-extensions lens mcmc-types mwc-probability pipes primitive + transformers + ]; + doHaddock = false; + doCheck = false; + homepage = "http://github.com/jtobin/hasty-hamiltonian"; + description = "Speedy traversal through parameter space"; + license = stdenv.lib.licenses.mit; + }) {}; + "haxl" = callPackage + ({ mkDerivation, aeson, base, binary, bytestring, containers + , deepseq, exceptions, filepath, ghc-prim, hashable, pretty, stdenv + , stm, text, time, transformers, unordered-containers, vector + }: + mkDerivation { + pname = "haxl"; + version = "2.0.1.0"; + sha256 = "cd259814d7e358a2a19c4060114b00f0dc891028ad4b89241e8ab2b67197431f"; + revision = "1"; + editedCabalFile = "04k5q5hvnbw1shrb8pqw3nwsylpb78fi802xzfq2gcmrnl6hy58p"; + isLibrary = true; + isExecutable = true; + libraryHaskellDepends = [ + aeson base binary bytestring containers deepseq exceptions filepath + ghc-prim hashable pretty stm text time transformers + unordered-containers vector + ]; + doHaddock = false; + doCheck = false; + homepage = "https://github.com/facebook/Haxl"; + description = "A Haskell library for efficient, concurrent, and concise data access"; + license = stdenv.lib.licenses.bsd3; + }) {}; + "hbeanstalk" = callPackage + ({ mkDerivation, attoparsec, base, blaze-builder, bytestring + , containers, network, stdenv + }: + mkDerivation { + pname = "hbeanstalk"; + version = "0.2.4"; + sha256 = "feaf97fd18fedb3e5abf337e61c98a03108d917d9f87f885c8d02b6b838aac8f"; + libraryHaskellDepends = [ + attoparsec base blaze-builder bytestring containers network + ]; + doHaddock = false; + doCheck = false; + homepage = "http://github.com/scsibug/hbeanstalk/"; + description = "Client for the beanstalkd workqueue service"; + license = stdenv.lib.licenses.bsd3; + }) {}; + "hdaemonize" = callPackage + ({ mkDerivation, base, bytestring, extensible-exceptions, filepath + , hsyslog, mtl, stdenv, unix + }: + mkDerivation { + pname = "hdaemonize"; + version = "0.5.5"; + sha256 = "d250cb0c066ec45aa9b8e9e0df094677f9e7788b01eaf51ab5bc9bbd52fe029f"; + libraryHaskellDepends = [ + base bytestring extensible-exceptions filepath hsyslog mtl unix + ]; + doHaddock = false; + doCheck = false; + homepage = "http://github.com/greydot/hdaemonize"; + description = "Library to handle the details of writing daemons for UNIX"; + license = stdenv.lib.licenses.bsd3; + }) {}; + "heap" = callPackage + ({ mkDerivation, base, stdenv }: + mkDerivation { + pname = "heap"; + version = "1.0.4"; + sha256 = "a4c2489e1031e9e8d96dff61ac8c15e5fcd3541080d81e0e47e298b3aad3172a"; + libraryHaskellDepends = [ base ]; + doHaddock = false; + doCheck = false; + description = "Heaps in Haskell"; + license = stdenv.lib.licenses.bsd3; + }) {}; + "heaps" = callPackage + ({ mkDerivation, base, Cabal, cabal-doctest, stdenv }: + mkDerivation { + pname = "heaps"; + version = "0.3.6"; + sha256 = "181c3cd7f2be698f903dc9649e5ec9311245ad2b9fed91b61f05d0dd7b7dddb2"; + revision = "3"; + editedCabalFile = "0k6wsm1hwn3vaxdvw8p7cidxg7p8zply2ig4w4qrbpyjhl6dj9x9"; + setupHaskellDepends = [ base Cabal cabal-doctest ]; + libraryHaskellDepends = [ base ]; + doHaddock = false; + doCheck = false; + homepage = "http://github.com/ekmett/heaps/"; + description = "Asymptotically optimal Brodal/Okasaki heaps"; + license = stdenv.lib.licenses.bsd3; + }) {}; + "hebrew-time" = callPackage + ({ mkDerivation, base, stdenv, time }: + mkDerivation { + pname = "hebrew-time"; + version = "0.1.1"; + sha256 = "c7997ee86df43d5d734df63c5e091543bb7fd75a93d530c1857067e27a8b7932"; + libraryHaskellDepends = [ base time ]; + doHaddock = false; + doCheck = false; + homepage = "https://github.com/snoyberg/hebrew-time"; + description = "Hebrew dates and prayer times"; + license = stdenv.lib.licenses.mit; + }) {}; + "hedgehog" = callPackage + ({ mkDerivation, ansi-terminal, async, base, bytestring + , concurrent-output, containers, directory, exceptions + , lifted-async, mmorph, monad-control, mtl, pretty-show, primitive + , random, resourcet, semigroups, stdenv, stm, template-haskell + , text, th-lift, time, transformers, transformers-base, unix + , wl-pprint-annotated + }: + mkDerivation { + pname = "hedgehog"; + version = "0.6"; + sha256 = "b86ffe3cf523d40e77f1547ef79d45edb62762e15328e8152959c440f7237e30"; + libraryHaskellDepends = [ + ansi-terminal async base bytestring concurrent-output containers + directory exceptions lifted-async mmorph monad-control mtl + pretty-show primitive random resourcet semigroups stm + template-haskell text th-lift time transformers transformers-base + unix wl-pprint-annotated + ]; + doHaddock = false; + doCheck = false; + homepage = "https://hedgehog.qa"; + description = "Hedgehog will eat all your bugs"; + license = stdenv.lib.licenses.bsd3; + }) {}; + "hedgehog-corpus" = callPackage + ({ mkDerivation, base, stdenv }: + mkDerivation { + pname = "hedgehog-corpus"; + version = "0.1.0"; + sha256 = "c3569cd8316770115871acf334587350e887b046e35abc0d52a90dd0e6d719f2"; + libraryHaskellDepends = [ base ]; + doHaddock = false; + doCheck = false; + homepage = "https://github.com/tmcgilchrist/hedgehog-corpus"; + description = "hedgehog-corpus"; + license = stdenv.lib.licenses.bsd3; + }) {}; + "hedis" = callPackage + ({ mkDerivation, async, base, bytestring, bytestring-lexing + , deepseq, errors, HTTP, mtl, network, network-uri, resource-pool + , scanner, stdenv, stm, text, time, tls, unordered-containers + , vector + }: + mkDerivation { + pname = "hedis"; + version = "0.10.2"; + sha256 = "1c99bd415a3bdc241a8a3ea6397b6fff10ed3b099de79e46ffe435ad89aa7615"; + libraryHaskellDepends = [ + async base bytestring bytestring-lexing deepseq errors HTTP mtl + network network-uri resource-pool scanner stm text time tls + unordered-containers vector + ]; + doHaddock = false; + doCheck = false; + homepage = "https://github.com/informatikr/hedis"; + description = "Client library for the Redis datastore: supports full command set, pipelining"; + license = stdenv.lib.licenses.bsd3; + }) {}; + "here" = callPackage + ({ mkDerivation, base, haskell-src-meta, mtl, parsec, stdenv + , template-haskell + }: + mkDerivation { + pname = "here"; + version = "1.2.13"; + sha256 = "406f9c27ba1e59cd662d078d81dcf2908840a77df15aed31d75dd017b7773c00"; + libraryHaskellDepends = [ + base haskell-src-meta mtl parsec template-haskell + ]; + doHaddock = false; + doCheck = false; + homepage = "https://github.com/tmhedberg/here"; + description = "Here docs & interpolated strings via quasiquotation"; + license = stdenv.lib.licenses.bsd3; + }) {}; + "heredoc" = callPackage + ({ mkDerivation, base, stdenv, template-haskell }: + mkDerivation { + pname = "heredoc"; + version = "0.2.0.0"; + sha256 = "c90d9fc61cb8cd812be510845493b6a6eddcc4b772581fd40a9433ed8f130f40"; + libraryHaskellDepends = [ base template-haskell ]; + doHaddock = false; + doCheck = false; + homepage = "http://hackage.haskell.org/package/heredoc"; + description = "multi-line string / here document using QuasiQuotes"; + license = stdenv.lib.licenses.publicDomain; + }) {}; + "heterocephalus" = callPackage + ({ mkDerivation, base, blaze-html, blaze-markup, containers, dlist + , mtl, parsec, shakespeare, stdenv, template-haskell, text + , transformers + }: + mkDerivation { + pname = "heterocephalus"; + version = "1.0.5.2"; + sha256 = "50b829508715ba246f095accd1b49f7c5f67380948d349df355bac39f4155923"; + libraryHaskellDepends = [ + base blaze-html blaze-markup containers dlist mtl parsec + shakespeare template-haskell text transformers + ]; + doHaddock = false; + doCheck = false; + homepage = "https://github.com/arowM/heterocephalus#readme"; + description = "A type-safe template engine for working with popular front end development tools"; + license = stdenv.lib.licenses.mit; + }) {}; + "hex" = callPackage + ({ mkDerivation, base, bytestring, stdenv }: + mkDerivation { + pname = "hex"; + version = "0.1.2"; + sha256 = "12ee1243edd80570a486521565fb0c9b5e39374f21a12f050636e71d55ec61ec"; + libraryHaskellDepends = [ base bytestring ]; + doHaddock = false; + doCheck = false; + description = "Convert strings into hexadecimal and back"; + license = stdenv.lib.licenses.bsd3; + }) {}; + "hexml" = callPackage + ({ mkDerivation, base, bytestring, extra, stdenv }: + mkDerivation { + pname = "hexml"; + version = "0.3.3"; + sha256 = "c4edcc6087df13ad9d9c30de9c1e8be527add3835cb94d59c32b1c5dce861cd2"; + libraryHaskellDepends = [ base bytestring extra ]; + doHaddock = false; + doCheck = false; + homepage = "https://github.com/ndmitchell/hexml#readme"; + description = "XML subset DOM parser"; + license = stdenv.lib.licenses.bsd3; + }) {}; + "hexml-lens" = callPackage + ({ mkDerivation, base, bytestring, contravariant, foundation, hexml + , lens, profunctors, stdenv, text + }: + mkDerivation { + pname = "hexml-lens"; + version = "0.2.1"; + sha256 = "baa34ef7206ff924b2559a83da8f8f07bf970e9993a171c956b8de7b70cc496b"; + libraryHaskellDepends = [ + base bytestring contravariant foundation hexml lens profunctors + text + ]; + doHaddock = false; + doCheck = false; + homepage = "https://github.com/pepeiborra/hexml-lens#readme"; + description = "Lenses for the hexml package"; + license = stdenv.lib.licenses.bsd3; + }) {}; + "hexpat" = callPackage + ({ mkDerivation, base, bytestring, containers, deepseq, expat, List + , stdenv, text, transformers, utf8-string + }: + mkDerivation { + pname = "hexpat"; + version = "0.20.13"; + sha256 = "46e1a0e651c1603c1f064c6ca8d4c66cb27e7a66974bfb45ecaa8f9ccc753fd1"; + libraryHaskellDepends = [ + base bytestring containers deepseq List text transformers + utf8-string + ]; + librarySystemDepends = [ expat ]; + doHaddock = false; + doCheck = false; + homepage = "http://haskell.org/haskellwiki/Hexpat/"; + description = "XML parser/formatter based on expat"; + license = stdenv.lib.licenses.bsd3; + }) {inherit (pkgs) expat;}; + "hexstring" = callPackage + ({ mkDerivation, aeson, base, base16-bytestring, binary, bytestring + , stdenv, text + }: + mkDerivation { + pname = "hexstring"; + version = "0.11.1"; + sha256 = "40d8dbfe22f572ffdb73f28c448b228a75008e83cc3bf78e939add0c9d800914"; + enableSeparateDataOutput = true; + libraryHaskellDepends = [ + aeson base base16-bytestring binary bytestring text + ]; + doHaddock = false; + doCheck = false; + homepage = "http://www.leonmergen.com/opensource.html"; + description = "Fast and safe representation of a hex string"; + license = stdenv.lib.licenses.mit; + }) {}; + "hfsevents" = callPackage + ({ mkDerivation, base, bytestring, cereal, Cocoa, CoreServices, mtl + , stdenv, text + }: + mkDerivation { + pname = "hfsevents"; + version = "0.1.6"; + sha256 = "74c3f3f3a5e55fff320c352a2d481069ff915860a0ab970864c6a0e6b65d3f05"; + libraryHaskellDepends = [ base bytestring cereal mtl text ]; + librarySystemDepends = [ Cocoa ]; + libraryToolDepends = [ CoreServices ]; + doHaddock = false; + doCheck = false; + homepage = "http://github.com/luite/hfsevents"; + description = "File/folder watching for OS X"; + license = stdenv.lib.licenses.bsd3; + platforms = [ "x86_64-darwin" ]; + }) {inherit (pkgs.darwin.apple_sdk.frameworks) Cocoa;}; + "hidapi" = callPackage + ({ mkDerivation, base, bytestring, deepseq, deepseq-generics + , stdenv, systemd + }: + mkDerivation { + pname = "hidapi"; + version = "0.1.4"; + sha256 = "fc40ea58320f9f1459a8da6463419bb15930d2e6d8273d5592cde509d4c96a75"; + libraryHaskellDepends = [ + base bytestring deepseq deepseq-generics + ]; + librarySystemDepends = [ systemd ]; + doHaddock = false; + doCheck = false; + homepage = "https://github.com/vahokif/haskell-hidapi"; + description = "Haskell bindings to HIDAPI"; + license = stdenv.lib.licenses.mit; + }) {inherit (pkgs) systemd;}; + "hidden-char" = callPackage + ({ mkDerivation, base, stdenv }: + mkDerivation { + pname = "hidden-char"; + version = "0.1.0.2"; + sha256 = "ea909372a7cc06cda7ee8e9c1a6a5c16be19fef256ad4bd2c0b39e61d940f498"; + revision = "2"; + editedCabalFile = "1d0k297hxff31k0x5xbli6l7c151d2y9wq4w0x0prgagjc0l7z5n"; + libraryHaskellDepends = [ base ]; + doHaddock = false; + doCheck = false; + homepage = "https://github.com/rcook/hidden-char#readme"; + description = "Provides cross-platform getHiddenChar function"; + license = stdenv.lib.licenses.mit; + }) {}; + "hierarchical-clustering" = callPackage + ({ mkDerivation, array, base, containers, stdenv }: + mkDerivation { + pname = "hierarchical-clustering"; + version = "0.4.6"; + sha256 = "75f17f09b9c38d51a208edee10da2f4706ee784b5cdfe8efc31f7f86bbcdccb1"; + libraryHaskellDepends = [ array base containers ]; + doHaddock = false; + doCheck = false; + description = "Fast algorithms for single, average/UPGMA and complete linkage clustering"; + license = stdenv.lib.licenses.bsd3; + }) {}; + "hierarchy" = callPackage + ({ mkDerivation, base, exceptions, free, mmorph, monad-control, mtl + , stdenv, transformers, transformers-base, transformers-compat + }: + mkDerivation { + pname = "hierarchy"; + version = "1.0.2"; + sha256 = "25f90eff98036266e279d5730297e24bdfe27b3151cf155d29415cf7d07b1318"; + libraryHaskellDepends = [ + base exceptions free mmorph monad-control mtl transformers + transformers-base transformers-compat + ]; + doHaddock = false; + doCheck = false; + homepage = "https://github.com/jwiegley/hierarchy#readme"; + description = "Predicated traversal of generated trees"; + license = stdenv.lib.licenses.bsd3; + }) {}; + "higher-leveldb" = callPackage + ({ mkDerivation, base, bytestring, cereal, data-default, exceptions + , leveldb-haskell, mtl, resourcet, stdenv, transformers + , transformers-base, unliftio-core + }: + mkDerivation { + pname = "higher-leveldb"; + version = "0.5.0.1"; + sha256 = "44fc8de63416b7878e67d8c93f0ae25e3cba4a7fad2149bb5eac34d2b8d2f95c"; + libraryHaskellDepends = [ + base bytestring cereal data-default exceptions leveldb-haskell mtl + resourcet transformers transformers-base unliftio-core + ]; + doHaddock = false; + doCheck = false; + homepage = "https://github.com/jeremyjh/higher-leveldb"; + description = "A rich monadic API for working with leveldb databases"; + license = stdenv.lib.licenses.bsd3; + }) {}; + "highlighting-kate" = callPackage + ({ mkDerivation, base, blaze-html, bytestring, containers, mtl + , parsec, pcre-light, stdenv, utf8-string + }: + mkDerivation { + pname = "highlighting-kate"; + version = "0.6.4"; + sha256 = "d8b83385f5da2ea7aa59f28eb860fd7eba0d35a4c36192a5044ee7ea1e001baf"; + configureFlags = [ "-fpcre-light" ]; + isLibrary = true; + isExecutable = true; + libraryHaskellDepends = [ + base blaze-html bytestring containers mtl parsec pcre-light + utf8-string + ]; + doHaddock = false; + doCheck = false; + homepage = "http://github.com/jgm/highlighting-kate"; + description = "Syntax highlighting"; + license = "GPL"; + }) {}; + "hinotify" = callPackage + ({ mkDerivation, async, base, bytestring, containers, stdenv, unix + }: + mkDerivation { + pname = "hinotify"; + version = "0.3.10"; + sha256 = "af2b7d5733ab52ca38f0d9aed1ec37304f1d6964caa0fb556b8215858c1d5d9d"; + revision = "1"; + editedCabalFile = "07z0n5rvki3w0kjr190bwv7sq8p3myspv8999ilz9rlsqf5a0324"; + libraryHaskellDepends = [ async base bytestring containers unix ]; + doHaddock = false; + doCheck = false; + homepage = "https://github.com/kolmodin/hinotify.git"; + description = "Haskell binding to inotify"; + license = stdenv.lib.licenses.bsd3; + }) {}; + "hint" = callPackage + ({ mkDerivation, base, directory, exceptions, filepath, ghc + , ghc-boot, ghc-paths, mtl, random, stdenv, temporary, unix + }: + mkDerivation { + pname = "hint"; + version = "0.8.0"; + sha256 = "2e702d62c8f56b799d767f3d3707bec12597bc529a051ad90bd5840581551c41"; + libraryHaskellDepends = [ + base directory exceptions filepath ghc ghc-boot ghc-paths mtl + random temporary unix + ]; + doHaddock = false; + doCheck = false; + homepage = "https://github.com/mvdan/hint"; + description = "Runtime Haskell interpreter (GHC API wrapper)"; + license = stdenv.lib.licenses.bsd3; + }) {}; + "histogram-fill" = callPackage + ({ mkDerivation, base, deepseq, ghc-prim, primitive, stdenv, vector + }: + mkDerivation { + pname = "histogram-fill"; + version = "0.9.0.0"; + sha256 = "a6d078059b6b839e6785443f28e224b20a0b3a72a17354028dbc68e031b34402"; + revision = "1"; + editedCabalFile = "0l2s51hjk3fn670k5q56fz4wh8h3fwickkxhxgwnaycr9jjmi1dd"; + libraryHaskellDepends = [ base deepseq ghc-prim primitive vector ]; + doHaddock = false; + doCheck = false; + homepage = "https://github.com/Shimuuar/histogram-fill/"; + description = "Library for histograms creation"; + license = stdenv.lib.licenses.bsd3; + }) {}; + "hjsmin" = callPackage + ({ mkDerivation, base, blaze-builder, bytestring, containers + , language-javascript, optparse-applicative, stdenv, text + }: + mkDerivation { + pname = "hjsmin"; + version = "0.2.0.2"; + sha256 = "bec153d2396962c63998eb12d0a2c7c9f7df6f774cb00e41b6cdb1f5a4905484"; + isLibrary = true; + isExecutable = true; + libraryHaskellDepends = [ + base blaze-builder bytestring containers language-javascript text + ]; + executableHaskellDepends = [ + base blaze-builder bytestring containers language-javascript + optparse-applicative text + ]; + doHaddock = false; + doCheck = false; + homepage = "http://github.com/erikd/hjsmin"; + description = "Haskell implementation of a javascript minifier"; + license = stdenv.lib.licenses.bsd3; + }) {}; + "hledger" = callPackage + ({ mkDerivation, ansi-terminal, base, base-compat-batteries + , bytestring, cmdargs, containers, csv, data-default, Decimal, Diff + , directory, file-embed, filepath, hashable, haskeline, here + , hledger-lib, HUnit, lucid, megaparsec, mtl, mtl-compat, old-time + , parsec, pretty-show, process, regex-tdfa, safe, shakespeare + , split, stdenv, tabular, temporary, terminfo, text, time + , transformers, unordered-containers, utf8-string, utility-ht + , wizards + }: + mkDerivation { + pname = "hledger"; + version = "1.10"; + sha256 = "f64420f852502e84dfa9374ace1d00a06ecf1641ad9fd3b22d7c2c48c1d5c4d3"; + revision = "1"; + editedCabalFile = "1kj1by80j7f6rzwfccwl2cp53bb3lyivh8a8xnawdyxab1pkyz34"; + isLibrary = true; + isExecutable = true; + libraryHaskellDepends = [ + ansi-terminal base base-compat-batteries bytestring cmdargs + containers csv data-default Decimal Diff directory file-embed + filepath hashable haskeline here hledger-lib HUnit lucid megaparsec + mtl mtl-compat old-time parsec pretty-show process regex-tdfa safe + shakespeare split tabular temporary terminfo text time transformers + unordered-containers utf8-string utility-ht wizards + ]; + executableHaskellDepends = [ + ansi-terminal base base-compat-batteries bytestring cmdargs + containers csv data-default Decimal directory file-embed filepath + haskeline here hledger-lib HUnit megaparsec mtl mtl-compat old-time + parsec pretty-show process regex-tdfa safe shakespeare split + tabular temporary terminfo text time transformers + unordered-containers utf8-string utility-ht wizards + ]; + doHaddock = false; + doCheck = false; + homepage = "http://hledger.org"; + description = "Command-line interface for the hledger accounting tool"; + license = stdenv.lib.licenses.gpl3; + }) {}; + "hledger-api" = callPackage + ({ mkDerivation, aeson, base, bytestring, containers, data-default + , Decimal, docopt, either, hledger, hledger-lib, microlens + , microlens-platform, safe, servant-server, servant-swagger, stdenv + , swagger2, text, transformers, wai, wai-extra, warp + }: + mkDerivation { + pname = "hledger-api"; + version = "1.10"; + sha256 = "6e51bf6eb84d600777e4008bc53cea8ab08b103d720c23e04a9954836fbcacab"; + isLibrary = false; + isExecutable = true; + executableHaskellDepends = [ + aeson base bytestring containers data-default Decimal docopt either + hledger hledger-lib microlens microlens-platform safe + servant-server servant-swagger swagger2 text transformers wai + wai-extra warp + ]; + doHaddock = false; + doCheck = false; + homepage = "http://hledger.org"; + description = "Web API server for the hledger accounting tool"; + license = stdenv.lib.licenses.gpl3; + }) {}; + "hledger-interest" = callPackage + ({ mkDerivation, base, Cabal, Decimal, hledger-lib, mtl, stdenv + , text, time + }: + mkDerivation { + pname = "hledger-interest"; + version = "1.5.2"; + sha256 = "78b588a37cb4d46d93b864ad8e104d954eaa118b47327457a7bef364da109381"; + isLibrary = false; + isExecutable = true; + executableHaskellDepends = [ + base Cabal Decimal hledger-lib mtl text time + ]; + doHaddock = false; + doCheck = false; + homepage = "http://github.com/peti/hledger-interest"; + description = "computes interest for a given account"; + license = stdenv.lib.licenses.bsd3; + }) {}; + "hledger-lib" = callPackage + ({ mkDerivation, ansi-terminal, array, base, base-compat-batteries + , blaze-markup, bytestring, cmdargs, containers, csv, data-default + , Decimal, deepseq, directory, extra, filepath, hashtables, HUnit + , megaparsec, mtl, mtl-compat, old-time, parsec, parser-combinators + , pretty-show, regex-tdfa, safe, split, stdenv, tabular, text, time + , transformers, uglymemo, utf8-string + }: + mkDerivation { + pname = "hledger-lib"; + version = "1.10"; + sha256 = "e18aaf23705f46c432519113148229ff78ddae3dcf41ef784e032bf5cc1943ce"; + revision = "1"; + editedCabalFile = "1b6hj4w1qfh1q8c3ikx5sn8z70cfdmqi4iy3a3l64q4x1j4jgyic"; + libraryHaskellDepends = [ + ansi-terminal array base base-compat-batteries blaze-markup + bytestring cmdargs containers csv data-default Decimal deepseq + directory extra filepath hashtables HUnit megaparsec mtl mtl-compat + old-time parsec parser-combinators pretty-show regex-tdfa safe + split tabular text time transformers uglymemo utf8-string + ]; + doHaddock = false; + doCheck = false; + homepage = "http://hledger.org"; + description = "Core data types, parsers and functionality for the hledger accounting tools"; + license = stdenv.lib.licenses.gpl3; + }) {}; + "hledger-ui" = callPackage + ({ mkDerivation, ansi-terminal, async, base, base-compat-batteries + , brick, cmdargs, containers, data-default, directory, filepath + , fsnotify, hledger, hledger-lib, HUnit, megaparsec, microlens + , microlens-platform, pretty-show, process, safe, split, stdenv + , text, text-zipper, time, transformers, vector, vty + }: + mkDerivation { + pname = "hledger-ui"; + version = "1.10.1"; + sha256 = "c7d41f9d2c9f486ab25a9cdb4d89759eae3974f8c4991bf46e3e5ea9bc8690c0"; + revision = "1"; + editedCabalFile = "1xvppxdkrk64mpqb64r016xshxqq25zzflbysmldgiqm1ibngy1g"; + isLibrary = false; + isExecutable = true; + executableHaskellDepends = [ + ansi-terminal async base base-compat-batteries brick cmdargs + containers data-default directory filepath fsnotify hledger + hledger-lib HUnit megaparsec microlens microlens-platform + pretty-show process safe split text text-zipper time transformers + vector vty + ]; + doHaddock = false; + doCheck = false; + homepage = "http://hledger.org"; + description = "Curses-style user interface for the hledger accounting tool"; + license = stdenv.lib.licenses.gpl3; + }) {}; + "hledger-web" = callPackage + ({ mkDerivation, base, blaze-html, blaze-markup, bytestring + , case-insensitive, clientsession, cmdargs, conduit, conduit-extra + , data-default, directory, filepath, hjsmin, hledger, hledger-lib + , http-client, http-conduit, HUnit, json, megaparsec, mtl + , semigroups, shakespeare, stdenv, template-haskell, text, time + , transformers, wai, wai-extra, wai-handler-launch, warp, yaml + , yesod, yesod-core, yesod-form, yesod-static + }: + mkDerivation { + pname = "hledger-web"; + version = "1.10"; + sha256 = "c9dfd130a2430a09672121d8c2e769358c9bc78e7e68118aaf8c2638f24cd4c1"; + revision = "1"; + editedCabalFile = "0zzgc6mjia06fwvjwpzzczh0p9k0a6bi2lib6zq5k1briq4gqblm"; + isLibrary = true; + isExecutable = true; + libraryHaskellDepends = [ + base blaze-html blaze-markup bytestring case-insensitive + clientsession cmdargs conduit conduit-extra data-default directory + filepath hjsmin hledger hledger-lib http-client http-conduit HUnit + json megaparsec mtl semigroups shakespeare template-haskell text + time transformers wai wai-extra wai-handler-launch warp yaml yesod + yesod-core yesod-form yesod-static + ]; + executableHaskellDepends = [ base ]; + doHaddock = false; + doCheck = false; + homepage = "http://hledger.org"; + description = "Web interface for the hledger accounting tool"; + license = stdenv.lib.licenses.gpl3; + }) {}; + "hlibgit2" = callPackage + ({ mkDerivation, base, bindings-DSL, openssl, stdenv, zlib }: + mkDerivation { + pname = "hlibgit2"; + version = "0.18.0.16"; + sha256 = "199e4027faafe0a39d18ca3168923d44c57b386b960c72398df1c0fb7eff8e5e"; + libraryHaskellDepends = [ base bindings-DSL zlib ]; + librarySystemDepends = [ openssl ]; + doHaddock = false; + doCheck = false; + description = "Low-level bindings to libgit2"; + license = stdenv.lib.licenses.mit; + }) {inherit (pkgs) openssl;}; + "hlibsass" = callPackage + ({ mkDerivation, base, Cabal, directory, libsass, stdenv }: + mkDerivation { + pname = "hlibsass"; + version = "0.1.7.0"; + sha256 = "62a75c444d8771303c6712e6fd3b3b5fd988773ec61ff06b4ed7e9d92c1c9f6d"; + configureFlags = [ "-fexternalLibsass" ]; + setupHaskellDepends = [ base Cabal directory ]; + libraryHaskellDepends = [ base ]; + librarySystemDepends = [ libsass ]; + doHaddock = false; + doCheck = false; + homepage = "https://github.com/jakubfijalkowski/hlibsass"; + description = "Low-level bindings to Libsass"; + license = stdenv.lib.licenses.mit; + }) {inherit (pkgs) libsass;}; + "hlint" = callPackage + ({ mkDerivation, aeson, ansi-terminal, base, bytestring, cmdargs + , containers, cpphs, data-default, directory, extra, filepath + , haskell-src-exts, haskell-src-exts-util, hscolour, process + , refact, stdenv, text, transformers, uniplate + , unordered-containers, vector, yaml + }: + mkDerivation { + pname = "hlint"; + version = "2.1.8"; + sha256 = "9713ebf3d0ae16c169d0e02486ba93bfdc6349d9b82dccf8a19a58c1177e75ce"; + isLibrary = true; + isExecutable = true; + enableSeparateDataOutput = true; + libraryHaskellDepends = [ + aeson ansi-terminal base bytestring cmdargs containers cpphs + data-default directory extra filepath haskell-src-exts + haskell-src-exts-util hscolour process refact text transformers + uniplate unordered-containers vector yaml + ]; + executableHaskellDepends = [ base ]; + doHaddock = false; + doCheck = false; + homepage = "https://github.com/ndmitchell/hlint#readme"; + description = "Source code suggestions"; + license = stdenv.lib.licenses.bsd3; + }) {}; + "hmatrix" = callPackage + ({ mkDerivation, array, base, binary, bytestring, deepseq + , openblasCompat, random, semigroups, split, stdenv + , storable-complex, vector + }: + mkDerivation { + pname = "hmatrix"; + version = "0.19.0.0"; + sha256 = "52eb2e42edc5839bfd9d2dec6c4fb29997eca737537a06df7b2d09bf6c324d82"; + revision = "1"; + editedCabalFile = "0krx0ds5mcj28y6zpg0r50lljn8681wi4c5lqcdz2c71nhixfq8h"; + configureFlags = [ "-fdisable-default-paths" "-fopenblas" ]; + libraryHaskellDepends = [ + array base binary bytestring deepseq random semigroups split + storable-complex vector + ]; + librarySystemDepends = [ openblasCompat ]; + doHaddock = false; + doCheck = false; + homepage = "https://github.com/albertoruiz/hmatrix"; + description = "Numeric Linear Algebra"; + license = stdenv.lib.licenses.bsd3; + }) {inherit (pkgs) openblasCompat;}; + "hmatrix-backprop" = callPackage + ({ mkDerivation, backprop, base, ghc-typelits-knownnat + , ghc-typelits-natnormalise, hmatrix, hmatrix-vector-sized + , microlens, stdenv, vector, vector-sized + }: + mkDerivation { + pname = "hmatrix-backprop"; + version = "0.1.2.3"; + sha256 = "bd12d7feec08e396f4174dfc35f808bfbf096370fc75aee185827d86881a03f5"; + revision = "1"; + editedCabalFile = "03zrx1kvyz8gn2w2ygd7ql98yimsm3kyrnrr1cc99mz1cm0phnrv"; + libraryHaskellDepends = [ + backprop base ghc-typelits-knownnat ghc-typelits-natnormalise + hmatrix hmatrix-vector-sized microlens vector vector-sized + ]; + doHaddock = false; + doCheck = false; + homepage = "https://github.com/mstksg/hmatrix-backprop#readme"; + description = "hmatrix operations lifted for backprop"; + license = stdenv.lib.licenses.bsd3; + }) {}; + "hmatrix-gsl" = callPackage + ({ mkDerivation, array, base, gsl, hmatrix, process, random, stdenv + , vector + }: + mkDerivation { + pname = "hmatrix-gsl"; + version = "0.19.0.1"; + sha256 = "157637d336c72cded119127cc3631a569018284ea8ca54b0e29e742388a2cd6c"; + libraryHaskellDepends = [ + array base hmatrix process random vector + ]; + libraryPkgconfigDepends = [ gsl ]; + doHaddock = false; + doCheck = false; + homepage = "https://github.com/albertoruiz/hmatrix"; + description = "Numerical computation"; + license = stdenv.lib.licenses.gpl3; + }) {inherit (pkgs) gsl;}; + "hmatrix-gsl-stats" = callPackage + ({ mkDerivation, base, binary, gsl, hmatrix, stdenv + , storable-complex, vector + }: + mkDerivation { + pname = "hmatrix-gsl-stats"; + version = "0.4.1.7"; + sha256 = "4a0f8b6ea1caefebd30f1e726c94f238d96c0f873bdeb5d920367e8aca7c54bf"; + libraryHaskellDepends = [ + base binary hmatrix storable-complex vector + ]; + libraryPkgconfigDepends = [ gsl ]; + doHaddock = false; + doCheck = false; + homepage = "http://code.haskell.org/hmatrix-gsl-stats"; + description = "GSL Statistics interface"; + license = stdenv.lib.licenses.bsd3; + }) {inherit (pkgs) gsl;}; + "hmatrix-morpheus" = callPackage + ({ mkDerivation, base, blas, hmatrix, liblapack, stdenv }: + mkDerivation { + pname = "hmatrix-morpheus"; + version = "0.1.1.2"; + sha256 = "f2f3ee02607096a56c7c5c7f1ddff2f7f91ee05211ec2bd659add8208b1505a7"; + libraryHaskellDepends = [ base hmatrix ]; + librarySystemDepends = [ blas liblapack ]; + doHaddock = false; + doCheck = false; + homepage = "https://github.com/aligusnet/morpheus/tree/master/hmatrix-morpheus"; + description = "Low-level machine learning auxiliary functions"; + license = stdenv.lib.licenses.bsd3; + }) {inherit (pkgs) blas; inherit (pkgs) liblapack;}; + "hmatrix-special" = callPackage + ({ mkDerivation, base, hmatrix, hmatrix-gsl, stdenv }: + mkDerivation { + pname = "hmatrix-special"; + version = "0.19.0.0"; + sha256 = "1f1f8c7f1700cea53132daecc53ca1a9733d4beac91ae1dcd2a2a03c83c9dcd7"; + libraryHaskellDepends = [ base hmatrix hmatrix-gsl ]; + doHaddock = false; + doCheck = false; + homepage = "https://github.com/albertoruiz/hmatrix"; + description = "Interface to GSL special functions"; + license = stdenv.lib.licenses.gpl3; + }) {}; + "hmatrix-vector-sized" = callPackage + ({ mkDerivation, base, hmatrix, stdenv, vector, vector-sized }: + mkDerivation { + pname = "hmatrix-vector-sized"; + version = "0.1.1.0"; + sha256 = "8b4edc591aa301ee2c4d2f5894ad690db8d88c9d48754f6d13c30d3eacc03b1d"; + libraryHaskellDepends = [ base hmatrix vector vector-sized ]; + doHaddock = false; + doCheck = false; + homepage = "https://github.com/mstksg/hmatrix-vector-sized#readme"; + description = "Conversions between hmatrix and vector-sized types"; + license = stdenv.lib.licenses.bsd3; + }) {}; + "hmpfr" = callPackage + ({ mkDerivation, base, integer-gmp, mpfr, stdenv }: + mkDerivation { + pname = "hmpfr"; + version = "0.4.4"; + sha256 = "2badebf032a24f6ab3bde068d5246bc9cc00bf5a8ac17da8cc0bd45c882816f5"; + enableSeparateDataOutput = true; + libraryHaskellDepends = [ base integer-gmp ]; + librarySystemDepends = [ mpfr ]; + doHaddock = false; + doCheck = false; + homepage = "https://github.com/michalkonecny/hmpfr"; + description = "Haskell binding to the MPFR library"; + license = stdenv.lib.licenses.bsd3; + }) {inherit (pkgs) mpfr;}; + "hoogle" = callPackage + ({ mkDerivation, aeson, base, binary, bytestring, cmdargs, conduit + , conduit-extra, connection, containers, deepseq, directory, extra + , filepath, haskell-src-exts, http-conduit, http-types, js-flot + , js-jquery, mmap, network, network-uri, old-locale, process-extras + , QuickCheck, resourcet, stdenv, storable-tuple, tar + , template-haskell, text, time, transformers, uniplate, utf8-string + , vector, wai, wai-logger, warp, warp-tls, zlib + }: + mkDerivation { + pname = "hoogle"; + version = "5.0.17.3"; + sha256 = "66bebaf75600fef1c5fc0613ccc55c137aaed4c8f69653cf903f4fb003b98f9c"; + isLibrary = true; + isExecutable = true; + enableSeparateDataOutput = true; + libraryHaskellDepends = [ + aeson base binary bytestring cmdargs conduit conduit-extra + connection containers deepseq directory extra filepath + haskell-src-exts http-conduit http-types js-flot js-jquery mmap + network network-uri old-locale process-extras QuickCheck resourcet + storable-tuple tar template-haskell text time transformers uniplate + utf8-string vector wai wai-logger warp warp-tls zlib + ]; + executableHaskellDepends = [ base ]; + doHaddock = false; + doCheck = false; + testTarget = "--test-option=--no-net"; + homepage = "http://hoogle.haskell.org/"; + description = "Haskell API Search"; + license = stdenv.lib.licenses.bsd3; + }) {}; + "hoopl" = callPackage + ({ mkDerivation, base, containers, stdenv }: + mkDerivation { + pname = "hoopl"; + version = "3.10.2.2"; + sha256 = "097b1316d5f1c8ffe71133223209eb2b095fe13f43dc01d1fe43fd8a545a2b97"; + revision = "2"; + editedCabalFile = "0j6pz4jzhvviyrhhn1j22ikmjvzrg60nzvq26lbpkcb6y4q6rlyx"; + libraryHaskellDepends = [ base containers ]; + doHaddock = false; + doCheck = false; + homepage = "https://github.com/haskell/hoopl"; + description = "A library to support dataflow analysis and optimization"; + license = stdenv.lib.licenses.bsd3; + }) {}; + "hopenpgp-tools" = callPackage + ({ mkDerivation, aeson, alex, array, attoparsec, base + , base16-bytestring, binary, binary-conduit, bytestring, conduit + , conduit-extra, containers, crypto-pubkey, cryptohash, directory + , errors, fgl, graphviz, happy, hOpenPGP, http-client + , http-client-tls, http-types, ixset-typed, lens, monad-loops + , openpgp-asciiarmor, optparse-applicative, prettyprinter + , prettyprinter-ansi-terminal, prettyprinter-convert-ansi-wl-pprint + , resourcet, stdenv, text, time, time-locale-compat, transformers + , unordered-containers, yaml + }: + mkDerivation { + pname = "hopenpgp-tools"; + version = "0.21.1"; + sha256 = "8a17a224c21115134c02844e12fa1e6c5eb5070d761fcf32d48415138b8dc77f"; + isLibrary = false; + isExecutable = true; + executableHaskellDepends = [ + aeson array attoparsec base base16-bytestring binary binary-conduit + bytestring conduit conduit-extra containers crypto-pubkey + cryptohash directory errors fgl graphviz hOpenPGP http-client + http-client-tls http-types ixset-typed lens monad-loops + openpgp-asciiarmor optparse-applicative prettyprinter + prettyprinter-ansi-terminal prettyprinter-convert-ansi-wl-pprint + resourcet text time time-locale-compat transformers + unordered-containers yaml + ]; + executableToolDepends = [ alex happy ]; + doHaddock = false; + doCheck = false; + homepage = "https://salsa.debian.org/clint/hOpenPGP"; + description = "hOpenPGP-based command-line tools"; + license = stdenv.lib.licenses.agpl3; + }) {}; + "hopenssl" = callPackage + ({ mkDerivation, base, bytestring, Cabal, cabal-doctest, openssl + , stdenv + }: + mkDerivation { + pname = "hopenssl"; + version = "2.2.1"; + sha256 = "7031aac15f132057f8013f819774081cd8fc4a14fb076bc3dffb478d66d0abdf"; + setupHaskellDepends = [ base Cabal cabal-doctest ]; + libraryHaskellDepends = [ base bytestring ]; + librarySystemDepends = [ openssl ]; + doHaddock = false; + doCheck = false; + homepage = "http://github.com/peti/hopenssl"; + description = "FFI Bindings to OpenSSL's EVP Digest Interface"; + license = stdenv.lib.licenses.bsd3; + }) {inherit (pkgs) openssl;}; + "hopfli" = callPackage + ({ mkDerivation, base, bytestring, stdenv, zlib }: + mkDerivation { + pname = "hopfli"; + version = "0.2.2.1"; + sha256 = "4d71dc0f599c87445c22403b447ce310bf8567d6b10cc82efbdd00a4d4d12a18"; + revision = "1"; + editedCabalFile = "116jns5im51sb9xiwpx308wz3pr67335633anrf8f704pz8vwjka"; + libraryHaskellDepends = [ base bytestring zlib ]; + doHaddock = false; + doCheck = false; + homepage = "https://github.com/ananthakumaran/hopfli"; + description = "Bidings to Google's Zopfli compression library"; + license = stdenv.lib.licenses.asl20; + }) {}; + "hostname" = callPackage + ({ mkDerivation, base, stdenv }: + mkDerivation { + pname = "hostname"; + version = "1.0"; + sha256 = "9b43dab1b6da521f35685b20555da00738c8e136eb972458c786242406a9cf5c"; + libraryHaskellDepends = [ base ]; + doHaddock = false; + doCheck = false; + description = "A very simple package providing a cross-platform means of determining the hostname"; + license = stdenv.lib.licenses.bsd3; + }) {}; + "hostname-validate" = callPackage + ({ mkDerivation, attoparsec, base, bytestring, stdenv }: + mkDerivation { + pname = "hostname-validate"; + version = "1.0.0"; + sha256 = "7fafb1e0cfe19d453030754962e74cdb8f3e791ec5b974623cbf26872779c857"; + libraryHaskellDepends = [ attoparsec base bytestring ]; + doHaddock = false; + doCheck = false; + description = "Validate hostnames e.g. localhost or foo.co.uk."; + license = stdenv.lib.licenses.bsd3; + }) {}; + "hourglass" = callPackage + ({ mkDerivation, base, deepseq, stdenv }: + mkDerivation { + pname = "hourglass"; + version = "0.2.11"; + sha256 = "18a6bb303fc055275cca45aaffc17b6a04b2e9d7509aa5aa5bb9d9239f4e4f51"; + libraryHaskellDepends = [ base deepseq ]; + doHaddock = false; + doCheck = false; + homepage = "https://github.com/vincenthz/hs-hourglass"; + description = "simple performant time related library"; + license = stdenv.lib.licenses.bsd3; + }) {}; + "hourglass-orphans" = callPackage + ({ mkDerivation, aeson, base, hourglass, stdenv }: + mkDerivation { + pname = "hourglass-orphans"; + version = "0.1.0.0"; + sha256 = "9f0ba9f3b3cdd391b26daf3dce0bac44ab1f9dd883eaff063af9ebfb0b373d64"; + libraryHaskellDepends = [ aeson base hourglass ]; + doHaddock = false; + doCheck = false; + homepage = "https://github.com/psibi/hourglass-orphans#readme"; + description = "Orphan Aeson instances to hourglass"; + license = stdenv.lib.licenses.bsd3; + }) {}; + "hp2pretty" = callPackage + ({ mkDerivation, array, attoparsec, base, containers, filepath + , floatshow, mtl, optparse-applicative, semigroups, stdenv, text + }: + mkDerivation { + pname = "hp2pretty"; + version = "0.8.0.2"; + sha256 = "2fd19796845be73b605ee8830704a6f1f23a80f43731cd36a216fb2b3bb179c8"; + isLibrary = false; + isExecutable = true; + executableHaskellDepends = [ + array attoparsec base containers filepath floatshow mtl + optparse-applicative semigroups text + ]; + doHaddock = false; + doCheck = false; + homepage = "https://code.mathr.co.uk/hp2pretty"; + description = "generate pretty graphs from heap profiles"; + license = stdenv.lib.licenses.bsd3; + }) {}; + "hpack" = callPackage + ({ mkDerivation, aeson, base, bifunctors, bytestring, Cabal + , containers, cryptonite, deepseq, directory, filepath, Glob + , http-client, http-client-tls, http-types, pretty, scientific + , stdenv, text, transformers, unordered-containers, vector, yaml + }: + mkDerivation { + pname = "hpack"; + version = "0.28.2"; + sha256 = "b9601332bbac2f042947be1f7478ed0c72367e4caa211b779a75dc26cd8180a3"; + isLibrary = true; + isExecutable = true; + libraryHaskellDepends = [ + aeson base bifunctors bytestring Cabal containers cryptonite + deepseq directory filepath Glob http-client http-client-tls + http-types pretty scientific text transformers unordered-containers + vector yaml + ]; + executableHaskellDepends = [ + aeson base bifunctors bytestring Cabal containers cryptonite + deepseq directory filepath Glob http-client http-client-tls + http-types pretty scientific text transformers unordered-containers + vector yaml + ]; + doHaddock = false; + doCheck = false; + homepage = "https://github.com/sol/hpack#readme"; + description = "An alternative format for Haskell packages"; + license = stdenv.lib.licenses.mit; + }) {}; + "hpqtypes" = callPackage + ({ mkDerivation, aeson, async, base, bytestring, Cabal, containers + , data-default-class, directory, exceptions, filepath, lifted-base + , monad-control, mtl, postgresql, resource-pool, semigroups, stdenv + , text, text-show, time, transformers, transformers-base, vector + }: + mkDerivation { + pname = "hpqtypes"; + version = "1.5.3.0"; + sha256 = "ff25807beee2ce9fa59b823313b6e2fdbd6e575e6e91d885ddee0ebf8b92ffc5"; + setupHaskellDepends = [ base Cabal directory filepath ]; + libraryHaskellDepends = [ + aeson async base bytestring containers data-default-class + exceptions lifted-base monad-control mtl resource-pool semigroups + text text-show time transformers transformers-base vector + ]; + librarySystemDepends = [ postgresql ]; + doHaddock = false; + doCheck = false; + homepage = "https://github.com/scrive/hpqtypes"; + description = "Haskell bindings to libpqtypes"; + license = stdenv.lib.licenses.bsd3; + }) {inherit (pkgs) postgresql;}; + "hprotoc" = callPackage + ({ mkDerivation, alex, array, base, binary, bytestring, containers + , directory, filepath, haskell-src-exts, mtl, parsec + , protocol-buffers, protocol-buffers-descriptor, stdenv + , utf8-string + }: + mkDerivation { + pname = "hprotoc"; + version = "2.4.11"; + sha256 = "93f2e87e8d6fb85464162183b7c9fa4bac09676058f9f7e29cdac63706f3801c"; + isLibrary = true; + isExecutable = true; + libraryHaskellDepends = [ + array base binary bytestring containers directory filepath + haskell-src-exts mtl parsec protocol-buffers + protocol-buffers-descriptor utf8-string + ]; + libraryToolDepends = [ alex ]; + executableHaskellDepends = [ + array base binary bytestring containers directory filepath + haskell-src-exts mtl parsec protocol-buffers + protocol-buffers-descriptor utf8-string + ]; + executableToolDepends = [ alex ]; + doHaddock = false; + doCheck = false; + homepage = "https://github.com/k-bx/protocol-buffers"; + description = "Parse Google Protocol Buffer specifications"; + license = stdenv.lib.licenses.bsd3; + }) {}; + "hquantlib" = callPackage + ({ mkDerivation, base, containers, hmatrix, hmatrix-gsl + , hmatrix-special, mersenne-random-pure64, parallel, random + , statistics, stdenv, time, vector, vector-algorithms + }: + mkDerivation { + pname = "hquantlib"; + version = "0.0.4.0"; + sha256 = "b7b2b9ce5e8113dd2d54a1dfce34b661620bd5e0dd43516604395276d7c44474"; + revision = "2"; + editedCabalFile = "1wx32kkv1as3rras5b1y3v77abx0sqsam6ssa5s7vm83pncx38y4"; + isLibrary = true; + isExecutable = true; + libraryHaskellDepends = [ + base containers hmatrix hmatrix-gsl hmatrix-special + mersenne-random-pure64 parallel random statistics time vector + vector-algorithms + ]; + executableHaskellDepends = [ + base containers mersenne-random-pure64 parallel time + ]; + doHaddock = false; + doCheck = false; + homepage = "http://github.com/paulrzcz/hquantlib.git"; + description = "HQuantLib is a port of essencial parts of QuantLib to Haskell"; + license = "LGPL"; + }) {}; + "hreader" = callPackage + ({ mkDerivation, base, exceptions, hset, mmorph, monad-control, mtl + , stdenv, tagged, transformers, transformers-base + }: + mkDerivation { + pname = "hreader"; + version = "1.1.0"; + sha256 = "2a2b02c059b343ab7ff0d340b6545a003b0d563fb8a1ad2d53d6c2f4759a7d3a"; + revision = "1"; + editedCabalFile = "0kz3yzah7m4c2r9yaawhljcgb579masx3lx4mrr4lmqy39kmsvcb"; + libraryHaskellDepends = [ + base exceptions hset mmorph monad-control mtl tagged transformers + transformers-base + ]; + doHaddock = false; + doCheck = false; + homepage = "https://bitbucket.org/s9gf4ult/hreader"; + description = "Generalization of MonadReader and ReaderT using hset"; + license = stdenv.lib.licenses.bsd3; + }) {}; + "hreader-lens" = callPackage + ({ mkDerivation, base, comonad, hreader, hset, lens, lens-action + , profunctors, stdenv + }: + mkDerivation { + pname = "hreader-lens"; + version = "0.1.3.0"; + sha256 = "408f0a2c6ce4bc5c00746947262f43f421f0e8fb9cc29c0cd2563ee1e87502d0"; + libraryHaskellDepends = [ + base comonad hreader hset lens lens-action profunctors + ]; + doHaddock = false; + doCheck = false; + homepage = "http://github.com/dredozubov/hreader-lens"; + description = "Optics for hreader package"; + license = stdenv.lib.licenses.mit; + }) {}; + "hruby" = callPackage + ({ mkDerivation, aeson, attoparsec, base, bytestring, Cabal + , process, ruby, scientific, stdenv, stm, text + , unordered-containers, vector + }: + mkDerivation { + pname = "hruby"; + version = "0.3.5.4"; + sha256 = "739b014908dc4746880cb9e34eadbfdcfba8c5cde9abcdd06de16cf37a29d59e"; + setupHaskellDepends = [ base Cabal process ]; + libraryHaskellDepends = [ + aeson attoparsec base bytestring scientific stm text + unordered-containers vector + ]; + librarySystemDepends = [ ruby ]; + doHaddock = false; + doCheck = false; + description = "Embed a Ruby intepreter in your Haskell program !"; + license = stdenv.lib.licenses.bsd3; + }) {inherit (pkgs) ruby;}; + "hs-GeoIP" = callPackage + ({ mkDerivation, base, bytestring, deepseq, GeoIP, stdenv }: + mkDerivation { + pname = "hs-GeoIP"; + version = "0.3"; + sha256 = "8e5ff6a132d8944336f10dcaa69d8852cdd7953a5ff18248ae06cb2819a1ab8c"; + libraryHaskellDepends = [ base bytestring deepseq ]; + librarySystemDepends = [ GeoIP ]; + doHaddock = false; + doCheck = false; + homepage = "http://github.com/ozataman/hs-GeoIP"; + description = "Haskell bindings to the MaxMind GeoIPCity database via the C library"; + license = stdenv.lib.licenses.bsd3; + }) {inherit (pkgs) GeoIP;}; + "hs-bibutils" = callPackage + ({ mkDerivation, base, stdenv, syb }: + mkDerivation { + pname = "hs-bibutils"; + version = "6.6.0.0"; + sha256 = "14b80075b17b9bfa517e42156dafa2e2ca8951413126d27cbe5a5942bff85a58"; + libraryHaskellDepends = [ base syb ]; + doHaddock = false; + doCheck = false; + homepage = "https://github.com/wilx/hs-bibutils"; + description = "Haskell bindings to bibutils, the bibliography conversion utilities"; + license = "GPL"; + }) {}; + "hs-functors" = callPackage + ({ mkDerivation, base, stdenv, transformers }: + mkDerivation { + pname = "hs-functors"; + version = "0.1.2.0"; + sha256 = "a7f1f058915b3554cbb0d99b475c853023f33d5dcd5b3bc280b9420841a4104a"; + libraryHaskellDepends = [ base transformers ]; + doHaddock = false; + doCheck = false; + description = "Functors from products of Haskell and its dual to Haskell"; + license = stdenv.lib.licenses.bsd3; + }) {}; + "hsass" = callPackage + ({ mkDerivation, base, bytestring, data-default-class, filepath + , hlibsass, monad-loops, stdenv, transformers + }: + mkDerivation { + pname = "hsass"; + version = "0.7.0"; + sha256 = "73758e87ba43096c0b3eb9ed7029f30d3a4d602dbe68c97760f89e5165901a57"; + libraryHaskellDepends = [ + base bytestring data-default-class filepath hlibsass monad-loops + transformers + ]; + doHaddock = false; + doCheck = false; + homepage = "https://github.com/jakubfijalkowski/hsass"; + description = "Integrating Sass into Haskell applications"; + license = stdenv.lib.licenses.mit; + }) {}; + "hscolour" = callPackage + ({ mkDerivation, base, containers, stdenv }: + mkDerivation { + pname = "hscolour"; + version = "1.24.4"; + sha256 = "243332b082294117f37b2c2c68079fa61af68b36223b3fc07594f245e0e5321d"; + isLibrary = true; + isExecutable = true; + enableSeparateDataOutput = true; + libraryHaskellDepends = [ base containers ]; + executableHaskellDepends = [ base containers ]; + doHaddock = false; + doCheck = false; + homepage = "http://code.haskell.org/~malcolm/hscolour/"; + description = "Colourise Haskell code"; + license = "LGPL"; + }) {}; + "hsdns" = callPackage + ({ mkDerivation, adns, base, containers, network, stdenv }: + mkDerivation { + pname = "hsdns"; + version = "1.7.1"; + sha256 = "4fcd00e85cde989652ab5c6b179610c9514180a00cd7b161ea33ebfec3b8a044"; + isLibrary = true; + isExecutable = true; + libraryHaskellDepends = [ base containers network ]; + librarySystemDepends = [ adns ]; + doHaddock = false; + doCheck = false; + homepage = "http://github.com/peti/hsdns"; + description = "Asynchronous DNS Resolver"; + license = stdenv.lib.licenses.lgpl3; + }) {inherit (pkgs) adns;}; + "hsebaysdk" = callPackage + ({ mkDerivation, aeson, base, bytestring, http-client, http-types + , stdenv, text, time, transformers, unordered-containers + }: + mkDerivation { + pname = "hsebaysdk"; + version = "0.4.0.0"; + sha256 = "0738d0df113b15bb9148ecbe02f0a34562c557d8f64b65065122925e29df8901"; + libraryHaskellDepends = [ + aeson base bytestring http-client http-types text time transformers + unordered-containers + ]; + doHaddock = false; + doCheck = false; + homepage = "https://github.com/creichert/hsebaysdk"; + description = "Haskell eBay SDK"; + license = stdenv.lib.licenses.bsd3; + }) {}; + "hsemail" = callPackage + ({ mkDerivation, base, mtl, old-time, parsec, stdenv }: + mkDerivation { + pname = "hsemail"; + version = "2"; + sha256 = "f5f08a879444abd1f9a8a3e620d7fc83bc632ae3ba9b545bebdf58d5f4bfa8d9"; + libraryHaskellDepends = [ base mtl old-time parsec ]; + doHaddock = false; + doCheck = false; + homepage = "https://github.com/peti/hsemail#readme"; + description = "Parsec parsers for the RFC2822 Internet Message format"; + license = stdenv.lib.licenses.bsd3; + }) {}; + "hset" = callPackage + ({ mkDerivation, base, deepseq, stdenv, tagged, type-fun }: + mkDerivation { + pname = "hset"; + version = "2.2.0"; + sha256 = "b8747a0826aeaca2ca814e7a334f9de5a02f36ac83faea5e1c32c8f6040bf130"; + libraryHaskellDepends = [ base deepseq tagged type-fun ]; + doHaddock = false; + doCheck = false; + homepage = "https://bitbucket.org/s9gf4ult/hset"; + description = "Primitive list with elements of unique types"; + license = stdenv.lib.licenses.bsd3; + }) {}; + "hsexif" = callPackage + ({ mkDerivation, base, binary, bytestring, containers, iconv + , stdenv, text, time + }: + mkDerivation { + pname = "hsexif"; + version = "0.6.1.5"; + sha256 = "2f12ea1060adb46c9afb74d32b82989b3883968403e21ff125f5cf9da869b06e"; + revision = "1"; + editedCabalFile = "1q5ppjq8b08ljccg5680h1kklr288wfz52vnmgpcf9hqjm3icgvb"; + libraryHaskellDepends = [ + base binary bytestring containers iconv text time + ]; + doHaddock = false; + doCheck = false; + homepage = "https://github.com/emmanueltouzery/hsexif"; + description = "EXIF handling library in pure Haskell"; + license = stdenv.lib.licenses.bsd3; + }) {}; + "hsini" = callPackage + ({ mkDerivation, base, bytestring, containers, mtl, parsec, stdenv + }: + mkDerivation { + pname = "hsini"; + version = "0.5.1.2"; + sha256 = "eaa6ae68c6271d5c3187054e702719b3ee7916524ffda27bb328cc9aad9ed8e4"; + libraryHaskellDepends = [ base bytestring containers mtl parsec ]; + doHaddock = false; + doCheck = false; + description = "ini configuration files"; + license = stdenv.lib.licenses.bsd3; + }) {}; + "hsinstall" = callPackage + ({ mkDerivation, base, directory, filepath, stdenv }: + mkDerivation { + pname = "hsinstall"; + version = "1.6"; + sha256 = "061090c68bdcdad5efef879c4fc0e4c67c26d34221c333fe4c9880216635c811"; + isLibrary = true; + isExecutable = true; + enableSeparateDataOutput = true; + libraryHaskellDepends = [ base directory filepath ]; + executableHaskellDepends = [ base directory filepath ]; + doHaddock = false; + doCheck = false; + description = "Install Haskell software"; + license = stdenv.lib.licenses.isc; + }) {}; + "hslogger" = callPackage + ({ mkDerivation, base, containers, directory, mtl, network + , old-locale, process, stdenv, time, unix + }: + mkDerivation { + pname = "hslogger"; + version = "1.2.10"; + sha256 = "d7ca6e94a4aacb47a8dc30e3960ab8deff482d2ec9dca9a87b225e03e97e452b"; + revision = "1"; + editedCabalFile = "04vhwv9qidwan7fbkgvx8z5hnybjaf6wq2951fx4qw3nqsys9250"; + libraryHaskellDepends = [ + base containers directory mtl network old-locale process time unix + ]; + doHaddock = false; + doCheck = false; + homepage = "http://software.complete.org/hslogger"; + description = "Versatile logging framework"; + license = stdenv.lib.licenses.bsd3; + }) {}; + "hslua" = callPackage + ({ mkDerivation, base, bytestring, containers, exceptions, fail + , lua5_3, mtl, stdenv, text + }: + mkDerivation { + pname = "hslua"; + version = "0.9.5.2"; + sha256 = "0e4d26f8a76cbfb219851f33d31417c4a3c8f193123367a0749f047103d8bbe5"; + configureFlags = [ "-fsystem-lua" "-f-use-pkgconfig" ]; + libraryHaskellDepends = [ + base bytestring containers exceptions fail mtl text + ]; + librarySystemDepends = [ lua5_3 ]; + doHaddock = false; + doCheck = false; + description = "A Lua language interpreter embedding in Haskell"; + license = stdenv.lib.licenses.mit; + }) {inherit (pkgs) lua5_3;}; + "hslua-aeson" = callPackage + ({ mkDerivation, aeson, base, hashable, hslua, scientific, stdenv + , text, unordered-containers, vector + }: + mkDerivation { + pname = "hslua-aeson"; + version = "0.3.0.2"; + sha256 = "a22acf0984e7d78955ce76f75e7660f84d50b6b59fc70357d01ccbf2bbc0d861"; + libraryHaskellDepends = [ + aeson base hashable hslua scientific text unordered-containers + vector + ]; + doHaddock = false; + doCheck = false; + homepage = "https://github.com/tarleb/hslua-aeson#readme"; + description = "Allow aeson data types to be used with lua"; + license = stdenv.lib.licenses.mit; + }) {}; + "hslua-module-text" = callPackage + ({ mkDerivation, base, hslua, stdenv, text }: + mkDerivation { + pname = "hslua-module-text"; + version = "0.1.2.1"; + sha256 = "aeb384f9743b76360f3779e44065fe297fb60f27519933f203b75bd8c2ba8e2d"; + revision = "1"; + editedCabalFile = "0vajlsd7y6pwa08635q0cx8z5c1c55bk7fvavw7g2vmyvxqjzx6n"; + libraryHaskellDepends = [ base hslua text ]; + doHaddock = false; + doCheck = false; + homepage = "https://github.com/hslua/hslua-module-test"; + description = "Lua module for text"; + license = stdenv.lib.licenses.mit; + }) {}; + "hsp" = callPackage + ({ mkDerivation, base, mtl, stdenv, text }: + mkDerivation { + pname = "hsp"; + version = "0.10.0"; + sha256 = "4ed3905a9db91001bde09f060290833af462e87e35476ab0def1579a1ff7ceab"; + libraryHaskellDepends = [ base mtl text ]; + doHaddock = false; + doCheck = false; + homepage = "http://hub.darcs.net/nibro/hsp"; + description = "Haskell Server Pages is a library for writing dynamic server-side web pages"; + license = stdenv.lib.licenses.bsd3; + }) {}; + "hspec" = callPackage + ({ mkDerivation, base, call-stack, hspec-core, hspec-discover + , hspec-expectations, HUnit, QuickCheck, stdenv, transformers + }: + mkDerivation { + pname = "hspec"; + version = "2.5.4"; + sha256 = "a852de873e4a389b62e562506f2fc11f1e8bbb4fe05350eb9004bfac0dd050a7"; + libraryHaskellDepends = [ + base call-stack hspec-core hspec-discover hspec-expectations HUnit + QuickCheck transformers + ]; + doHaddock = false; + doCheck = false; + homepage = "http://hspec.github.io/"; + description = "A Testing Framework for Haskell"; + license = stdenv.lib.licenses.mit; + }) {}; + "hspec-attoparsec" = callPackage + ({ mkDerivation, attoparsec, base, bytestring, hspec-expectations + , stdenv, text + }: + mkDerivation { + pname = "hspec-attoparsec"; + version = "0.1.0.2"; + sha256 = "ea7a8b3f2989abde8c8537cec1a2ae312e88df80086b9b01ed12e5324137fb64"; + libraryHaskellDepends = [ + attoparsec base bytestring hspec-expectations text + ]; + doHaddock = false; + doCheck = false; + homepage = "http://github.com/alpmestan/hspec-attoparsec"; + description = "Utility functions for testing your attoparsec parsers with hspec"; + license = stdenv.lib.licenses.bsd3; + }) {}; + "hspec-checkers" = callPackage + ({ mkDerivation, base, checkers, hspec, stdenv }: + mkDerivation { + pname = "hspec-checkers"; + version = "0.1.0.2"; + sha256 = "e7db79dc527cf5b806723bbe3d511a074297976a0c7042968b9abc57f8337e99"; + libraryHaskellDepends = [ base checkers hspec ]; + doHaddock = false; + doCheck = false; + description = "Allows to use checkers properties from hspec"; + license = stdenv.lib.licenses.bsd3; + }) {}; + "hspec-contrib" = callPackage + ({ mkDerivation, base, hspec-core, HUnit, stdenv }: + mkDerivation { + pname = "hspec-contrib"; + version = "0.5.0"; + sha256 = "dba7348e75572f7cd79f3f0719ab39973431927f9bb5bec1445e2f8e5b4fa78c"; + libraryHaskellDepends = [ base hspec-core HUnit ]; + doHaddock = false; + doCheck = false; + homepage = "http://hspec.github.io/"; + description = "Contributed functionality for Hspec"; + license = stdenv.lib.licenses.mit; + }) {}; + "hspec-core" = callPackage + ({ mkDerivation, ansi-terminal, array, base, call-stack, clock + , deepseq, directory, filepath, hspec-expectations, HUnit + , QuickCheck, quickcheck-io, random, setenv, stdenv, stm, tf-random + , transformers + }: + mkDerivation { + pname = "hspec-core"; + version = "2.5.4"; + sha256 = "589c3a979a1d05db93024a012382de441cb3d2e5eeb8a026e96bd0866d2a30e5"; + revision = "1"; + editedCabalFile = "0wrdz73cfajss3lqgrh7a40kg8g2dgq0913yw15fnrvgcbzfmclp"; + libraryHaskellDepends = [ + ansi-terminal array base call-stack clock deepseq directory + filepath hspec-expectations HUnit QuickCheck quickcheck-io random + setenv stm tf-random transformers + ]; + doHaddock = false; + doCheck = false; + testTarget = "--test-option=--skip --test-option='Test.Hspec.Core.Runner.hspecResult runs specs in parallel'"; + homepage = "http://hspec.github.io/"; + description = "A Testing Framework for Haskell"; + license = stdenv.lib.licenses.mit; + }) {}; + "hspec-discover" = callPackage + ({ mkDerivation, base, directory, filepath, stdenv }: + mkDerivation { + pname = "hspec-discover"; + version = "2.5.4"; + sha256 = "d4fed4fa3d13a8afaa23ccc4d1b8cde615bd4bbe99e05708b0003b7cdc33eef3"; + isLibrary = true; + isExecutable = true; + libraryHaskellDepends = [ base directory filepath ]; + executableHaskellDepends = [ base directory filepath ]; + doHaddock = false; + doCheck = false; + homepage = "http://hspec.github.io/"; + description = "Automatically discover and run Hspec tests"; + license = stdenv.lib.licenses.mit; + }) {}; + "hspec-expectations" = callPackage + ({ mkDerivation, base, call-stack, HUnit, stdenv }: + mkDerivation { + pname = "hspec-expectations"; + version = "0.8.2"; + sha256 = "819607ea1faf35ce5be34be61c6f50f3389ea43892d56fb28c57a9f5d54fb4ef"; + libraryHaskellDepends = [ base call-stack HUnit ]; + doHaddock = false; + doCheck = false; + homepage = "https://github.com/hspec/hspec-expectations#readme"; + description = "Catchy combinators for HUnit"; + license = stdenv.lib.licenses.mit; + }) {}; + "hspec-expectations-lifted" = callPackage + ({ mkDerivation, base, hspec-expectations, stdenv, transformers }: + mkDerivation { + pname = "hspec-expectations-lifted"; + version = "0.10.0"; + sha256 = "22cdf1509b396fea2f53a0bb88dec3552f540d58cc60962a82970264c1e73828"; + libraryHaskellDepends = [ base hspec-expectations transformers ]; + doHaddock = false; + doCheck = false; + description = "A version of hspec-expectations generalized to MonadIO"; + license = stdenv.lib.licenses.mit; + }) {}; + "hspec-expectations-pretty-diff" = callPackage + ({ mkDerivation, ansi-terminal, base, Diff, hscolour, HUnit + , nicify-lib, stdenv, text + }: + mkDerivation { + pname = "hspec-expectations-pretty-diff"; + version = "0.7.2.4"; + sha256 = "1bbfd524330be3cb0b27945556d01f48e3005e042ee475cdf6e441ba21b51b0a"; + libraryHaskellDepends = [ + ansi-terminal base Diff hscolour HUnit nicify-lib text + ]; + doHaddock = false; + doCheck = false; + homepage = "https://github.com/myfreeweb/hspec-expectations-pretty-diff#readme"; + description = "Catchy combinators for HUnit"; + license = stdenv.lib.licenses.mit; + }) {}; + "hspec-golden-aeson" = callPackage + ({ mkDerivation, aeson, aeson-pretty, base, bytestring, directory + , filepath, hspec, QuickCheck, quickcheck-arbitrary-adt, random + , stdenv, transformers + }: + mkDerivation { + pname = "hspec-golden-aeson"; + version = "0.7.0.0"; + sha256 = "114ccdbe3b7425f6bacc7d0d78d160879528aa76d2a3e774d9c152d8444a4ca2"; + libraryHaskellDepends = [ + aeson aeson-pretty base bytestring directory filepath hspec + QuickCheck quickcheck-arbitrary-adt random transformers + ]; + doHaddock = false; + doCheck = false; + homepage = "https://github.com/plow-technologies/hspec-golden-aeson#readme"; + description = "Use tests to monitor changes in Aeson serialization"; + license = stdenv.lib.licenses.bsd3; + }) {}; + "hspec-megaparsec" = callPackage + ({ mkDerivation, base, containers, hspec-expectations, megaparsec + , stdenv + }: + mkDerivation { + pname = "hspec-megaparsec"; + version = "1.0.0"; + sha256 = "14961ae19fde7104f5099624195d0f21b4759e5e635e79d9e63f9f2affca4eb5"; + libraryHaskellDepends = [ + base containers hspec-expectations megaparsec + ]; + doHaddock = false; + doCheck = false; + homepage = "https://github.com/mrkkrp/hspec-megaparsec"; + description = "Utility functions for testing Megaparsec parsers with Hspec"; + license = stdenv.lib.licenses.bsd3; + }) {}; + "hspec-meta" = callPackage + ({ mkDerivation, ansi-terminal, array, async, base, call-stack + , deepseq, directory, filepath, hspec-expectations, HUnit + , QuickCheck, quickcheck-io, random, setenv, stdenv, time + , transformers + }: + mkDerivation { + pname = "hspec-meta"; + version = "2.4.6"; + sha256 = "2b31671bfbfe5df0604516278bb1051db42b1e55dfe474ecd446a6630398bb62"; + isLibrary = true; + isExecutable = true; + libraryHaskellDepends = [ + ansi-terminal array async base call-stack deepseq directory + filepath hspec-expectations HUnit QuickCheck quickcheck-io random + setenv time transformers + ]; + executableHaskellDepends = [ + ansi-terminal array async base call-stack deepseq directory + filepath hspec-expectations HUnit QuickCheck quickcheck-io random + setenv time transformers + ]; + doHaddock = false; + doCheck = false; + homepage = "http://hspec.github.io/"; + description = "A version of Hspec which is used to test Hspec itself"; + license = stdenv.lib.licenses.mit; + }) {}; + "hspec-pg-transact" = callPackage + ({ mkDerivation, base, bytestring, hspec, pg-transact + , postgresql-simple, resource-pool, stdenv, text, tmp-postgres + }: + mkDerivation { + pname = "hspec-pg-transact"; + version = "0.1.0.2"; + sha256 = "a5ec2a978a730500f03c15d16eff7e207a4135ebc63afe4cbca7392ad5f01c0c"; + libraryHaskellDepends = [ + base bytestring hspec pg-transact postgresql-simple resource-pool + text tmp-postgres + ]; + doHaddock = false; + doCheck = false; + homepage = "https://github.com/jfischoff/pg-transact-hspec#readme"; + description = "Helpers for creating database tests with hspec and pg-transact"; + license = stdenv.lib.licenses.bsd3; + }) {}; + "hspec-smallcheck" = callPackage + ({ mkDerivation, base, call-stack, hspec-core, HUnit, smallcheck + , stdenv + }: + mkDerivation { + pname = "hspec-smallcheck"; + version = "0.5.2"; + sha256 = "9a301a26a439a92b303217545b65792bd8500f25aeccbe48e46dfe914ef58119"; + libraryHaskellDepends = [ + base call-stack hspec-core HUnit smallcheck + ]; + doHaddock = false; + doCheck = false; + homepage = "http://hspec.github.io/"; + description = "SmallCheck support for the Hspec testing framework"; + license = stdenv.lib.licenses.mit; + }) {}; + "hspec-wai" = callPackage + ({ mkDerivation, base, base-compat, bytestring, case-insensitive + , hspec-core, hspec-expectations, http-types, QuickCheck, stdenv + , text, transformers, wai, wai-extra + }: + mkDerivation { + pname = "hspec-wai"; + version = "0.9.0"; + sha256 = "c8fe9ed0a1b77d6ad09b3d9c34e4dc65a2e5f1f0bbc6f7b8e2106d3d7556dfba"; + libraryHaskellDepends = [ + base base-compat bytestring case-insensitive hspec-core + hspec-expectations http-types QuickCheck text transformers wai + wai-extra + ]; + doHaddock = false; + doCheck = false; + homepage = "https://github.com/hspec/hspec-wai#readme"; + description = "Experimental Hspec support for testing WAI applications"; + license = stdenv.lib.licenses.mit; + }) {}; + "hspec-wai-json" = callPackage + ({ mkDerivation, aeson, aeson-qq, base, bytestring + , case-insensitive, hspec-wai, stdenv, template-haskell + }: + mkDerivation { + pname = "hspec-wai-json"; + version = "0.9.0"; + sha256 = "a1c5401fa7fc7ffc46950274702a0ef30045568c2d2f5bc528cd6bf26ae28085"; + libraryHaskellDepends = [ + aeson aeson-qq base bytestring case-insensitive hspec-wai + template-haskell + ]; + doHaddock = false; + doCheck = false; + homepage = "https://github.com/hspec/hspec-wai#readme"; + description = "Testing JSON APIs with hspec-wai"; + license = stdenv.lib.licenses.mit; + }) {}; + "hstatsd" = callPackage + ({ mkDerivation, base, bytestring, mtl, network, stdenv, text }: + mkDerivation { + pname = "hstatsd"; + version = "0.1"; + sha256 = "446779594257c0fa02d5271c997ee0c22f74f7636d89e34394ad87e5bd285824"; + libraryHaskellDepends = [ base bytestring mtl network text ]; + doHaddock = false; + doCheck = false; + homepage = "https://github.com/mokus0/hstatsd"; + description = "Quick and dirty statsd interface"; + license = stdenv.lib.licenses.publicDomain; + }) {}; + "hsx-jmacro" = callPackage + ({ mkDerivation, base, hsp, jmacro, mtl, stdenv, text + , wl-pprint-text + }: + mkDerivation { + pname = "hsx-jmacro"; + version = "7.3.8.1"; + sha256 = "f1903d80017381408ae3f7b9d7b2e4d8c193d72ede96a33ce68fe7e276f1af59"; + libraryHaskellDepends = [ + base hsp jmacro mtl text wl-pprint-text + ]; + doHaddock = false; + doCheck = false; + homepage = "http://www.happstack.com/"; + description = "hsp+jmacro support"; + license = stdenv.lib.licenses.bsd3; + }) {}; + "hsyslog" = callPackage + ({ mkDerivation, base, Cabal, cabal-doctest, stdenv }: + mkDerivation { + pname = "hsyslog"; + version = "5.0.1"; + sha256 = "86de0d8820a6cb7fe166e046ae00c1bbe37d27885cd3aa701deaca8fdf646016"; + isLibrary = true; + isExecutable = true; + setupHaskellDepends = [ base Cabal cabal-doctest ]; + libraryHaskellDepends = [ base ]; + doHaddock = false; + doCheck = false; + homepage = "http://github.com/peti/hsyslog"; + description = "FFI interface to syslog(3) from POSIX.1-2001"; + license = stdenv.lib.licenses.bsd3; + }) {}; + "hsyslog-udp" = callPackage + ({ mkDerivation, base, bytestring, hsyslog, network, stdenv, text + , time, unix + }: + mkDerivation { + pname = "hsyslog-udp"; + version = "0.2.3"; + sha256 = "f03fc4e26fd19f74834bff62891adeee49909326c2a7b9c93a70a9d370f4b6be"; + libraryHaskellDepends = [ + base bytestring hsyslog network text time unix + ]; + doHaddock = false; + doCheck = false; + homepage = "https://github.com/ThoughtLeadr/hsyslog-udp"; + description = "Log to syslog over a network via UDP"; + license = stdenv.lib.licenses.bsd3; + }) {}; + "htaglib" = callPackage + ({ mkDerivation, base, bytestring, stdenv, taglib, text + , transformers + }: + mkDerivation { + pname = "htaglib"; + version = "1.2.0"; + sha256 = "4a17c36ff45995c079d71368a3eeabe595ed7efe2b3e4a3dcbff4bed8324005e"; + enableSeparateDataOutput = true; + libraryHaskellDepends = [ base bytestring text transformers ]; + librarySystemDepends = [ taglib ]; + doHaddock = false; + doCheck = false; + homepage = "https://github.com/mrkkrp/htaglib"; + description = "Bindings to TagLib, audio meta-data library"; + license = stdenv.lib.licenses.bsd3; + }) {inherit (pkgs) taglib;}; + "html" = callPackage + ({ mkDerivation, base, stdenv }: + mkDerivation { + pname = "html"; + version = "1.0.1.2"; + sha256 = "0c35495ea33d65e69c69bc7441ec8e1af69fbb43433c2aa3406c0a13a3ab3061"; + libraryHaskellDepends = [ base ]; + doHaddock = false; + doCheck = false; + description = "HTML combinator library"; + license = stdenv.lib.licenses.bsd3; + }) {}; + "html-conduit" = callPackage + ({ mkDerivation, attoparsec, base, bytestring, conduit + , conduit-extra, containers, resourcet, stdenv, text, transformers + , xml-conduit, xml-types + }: + mkDerivation { + pname = "html-conduit"; + version = "1.3.1"; + sha256 = "71c13c149f471f4c7d9b6c2016eba59f3ccb80829c85ae8cc5234518e9d2e335"; + libraryHaskellDepends = [ + attoparsec base bytestring conduit conduit-extra containers + resourcet text transformers xml-conduit xml-types + ]; + doHaddock = false; + doCheck = false; + homepage = "https://github.com/snoyberg/xml"; + description = "Parse HTML documents using xml-conduit datatypes"; + license = stdenv.lib.licenses.mit; + }) {}; + "html-email-validate" = callPackage + ({ mkDerivation, attoparsec, base, stdenv, text }: + mkDerivation { + pname = "html-email-validate"; + version = "0.2.0.0"; + sha256 = "3d2a3ec75b638cec71df57512473052d485dc118aec4662d5a8dae5e95aa6daf"; + libraryHaskellDepends = [ attoparsec base text ]; + doHaddock = false; + doCheck = false; + description = "Validating an email address against HTML standard"; + license = stdenv.lib.licenses.bsd3; + }) {}; + "html-entities" = callPackage + ({ mkDerivation, attoparsec, base, base-prelude, stdenv, text + , unordered-containers + }: + mkDerivation { + pname = "html-entities"; + version = "1.1.4.2"; + sha256 = "161a0c9193b4c1279e41b2ce1203ee821e8d6ee2cf755b9f070d68602ed5cee7"; + libraryHaskellDepends = [ + attoparsec base base-prelude text unordered-containers + ]; + doHaddock = false; + doCheck = false; + homepage = "https://github.com/nikita-volkov/html-entities"; + description = "A codec library for HTML-escaped text and HTML-entities"; + license = stdenv.lib.licenses.mit; + }) {}; + "html-entity-map" = callPackage + ({ mkDerivation, base, stdenv, text, unordered-containers }: + mkDerivation { + pname = "html-entity-map"; + version = "0.1.0.0"; + sha256 = "983600c33e8515e6ca31742d25490fb5a7be02503331963621b0ba5cd70d344c"; + revision = "3"; + editedCabalFile = "0aj61kpf39rhn4d7nk3vwq933b826ywhwklw479y9nkczac5lpz8"; + libraryHaskellDepends = [ base text unordered-containers ]; + doHaddock = false; + doCheck = false; + homepage = "https://github.com/mrkkrp/html-entity-map"; + description = "Map from HTML5 entity names to the corresponding Unicode text"; + license = stdenv.lib.licenses.bsd3; + }) {}; + "htoml" = callPackage + ({ mkDerivation, aeson, base, containers, old-locale, parsec + , stdenv, text, time, unordered-containers, vector + }: + mkDerivation { + pname = "htoml"; + version = "1.0.0.3"; + sha256 = "08f8d88a326f80fb55c0abb9431941c3a2a30f2d58f49c94349961ceeb4c856f"; + libraryHaskellDepends = [ + aeson base containers old-locale parsec text time + unordered-containers vector + ]; + doHaddock = false; + doCheck = false; + homepage = "https://github.com/cies/htoml"; + description = "Parser for TOML files"; + license = stdenv.lib.licenses.bsd3; + }) {}; + "http-api-data" = callPackage + ({ mkDerivation, attoparsec, attoparsec-iso8601, base, bytestring + , Cabal, cabal-doctest, containers, hashable, http-types, stdenv + , text, time, time-locale-compat, unordered-containers + , uri-bytestring, uuid-types + }: + mkDerivation { + pname = "http-api-data"; + version = "0.3.8.1"; + sha256 = "6eeaba4b29a00407cb20b865825b17b8d884c26b09c5bbe7b6e673b4522106b3"; + revision = "1"; + editedCabalFile = "1843bapm2rdkl4941rycryircpqpp7mbal7vgmlikf11f8ws7y7x"; + setupHaskellDepends = [ base Cabal cabal-doctest ]; + libraryHaskellDepends = [ + attoparsec attoparsec-iso8601 base bytestring containers hashable + http-types text time time-locale-compat unordered-containers + uri-bytestring uuid-types + ]; + doHaddock = false; + doCheck = false; + homepage = "http://github.com/fizruk/http-api-data"; + description = "Converting to/from HTTP API data like URL pieces, headers and query parameters"; + license = stdenv.lib.licenses.bsd3; + }) {}; + "http-client" = callPackage + ({ mkDerivation, array, base, blaze-builder, bytestring + , case-insensitive, containers, cookie, deepseq, exceptions + , filepath, ghc-prim, http-types, memory, mime-types, network + , network-uri, random, stdenv, stm, streaming-commons, text, time + , transformers + }: + mkDerivation { + pname = "http-client"; + version = "0.5.13.1"; + sha256 = "e121b5c676aec29f2a3b92dcbbb8b3f6acfad4ac5985141f35e5b739f75bfc6b"; + libraryHaskellDepends = [ + array base blaze-builder bytestring case-insensitive containers + cookie deepseq exceptions filepath ghc-prim http-types memory + mime-types network network-uri random stm streaming-commons text + time transformers + ]; + doHaddock = false; + doCheck = false; + homepage = "https://github.com/snoyberg/http-client"; + description = "An HTTP client engine"; + license = stdenv.lib.licenses.mit; + }) {}; + "http-client-openssl" = callPackage + ({ mkDerivation, base, HsOpenSSL, http-client, network, stdenv }: + mkDerivation { + pname = "http-client-openssl"; + version = "0.2.2.0"; + sha256 = "96410d977b70f25208d74ffc31ee00ceab4aa970347ef4f8d5757246c61210aa"; + libraryHaskellDepends = [ base HsOpenSSL http-client network ]; + doHaddock = false; + doCheck = false; + homepage = "https://github.com/snoyberg/http-client"; + description = "http-client backend using the OpenSSL library"; + license = stdenv.lib.licenses.mit; + }) {}; + "http-client-tls" = callPackage + ({ mkDerivation, base, bytestring, case-insensitive, connection + , containers, cryptonite, data-default-class, exceptions + , http-client, http-types, memory, network, network-uri, stdenv + , text, tls, transformers + }: + mkDerivation { + pname = "http-client-tls"; + version = "0.3.5.3"; + sha256 = "471abf8f29a909f40b21eab26a410c0e120ae12ce337512a61dae9f52ebb4362"; + libraryHaskellDepends = [ + base bytestring case-insensitive connection containers cryptonite + data-default-class exceptions http-client http-types memory network + network-uri text tls transformers + ]; + doHaddock = false; + doCheck = false; + homepage = "https://github.com/snoyberg/http-client"; + description = "http-client backend using the connection package and tls library"; + license = stdenv.lib.licenses.mit; + }) {}; + "http-common" = callPackage + ({ mkDerivation, base, base64-bytestring, blaze-builder, bytestring + , case-insensitive, directory, mtl, network, stdenv, text + , transformers, unordered-containers + }: + mkDerivation { + pname = "http-common"; + version = "0.8.2.0"; + sha256 = "2915e77b0d000a617d4c1304fdc46f45b70acc0942670066a95b2c8d4e504593"; + libraryHaskellDepends = [ + base base64-bytestring blaze-builder bytestring case-insensitive + directory mtl network text transformers unordered-containers + ]; + doHaddock = false; + doCheck = false; + homepage = "http://research.operationaldynamics.com/projects/http-streams/"; + description = "Common types for HTTP clients and servers"; + license = stdenv.lib.licenses.bsd3; + }) {}; + "http-conduit" = callPackage + ({ mkDerivation, aeson, base, bytestring, conduit, conduit-extra + , http-client, http-client-tls, http-types, mtl, resourcet, stdenv + , transformers, unliftio-core + }: + mkDerivation { + pname = "http-conduit"; + version = "2.3.2"; + sha256 = "7596448325d8b3ad31b2100fe6ba4a3447a470a461cfb7fbcc0bc90a32245ec5"; + revision = "1"; + editedCabalFile = "0g6rg8r33q5rmrx5287vjfcqwjacchgzyfc8aqqrhrfz3fq5ll0g"; + libraryHaskellDepends = [ + aeson base bytestring conduit conduit-extra http-client + http-client-tls http-types mtl resourcet transformers unliftio-core + ]; + doHaddock = false; + doCheck = false; + homepage = "http://www.yesodweb.com/book/http-conduit"; + description = "HTTP client package with conduit interface and HTTPS support"; + license = stdenv.lib.licenses.bsd3; + }) {}; + "http-date" = callPackage + ({ mkDerivation, array, attoparsec, base, bytestring, stdenv, time + }: + mkDerivation { + pname = "http-date"; + version = "0.0.7"; + sha256 = "cef9dc7e0fb512bd0c665b208b0687c1d939dc0a3d1f8fc513f7636c88d1ffc2"; + libraryHaskellDepends = [ array attoparsec base bytestring time ]; + doHaddock = false; + doCheck = false; + description = "HTTP Date parser/formatter"; + license = stdenv.lib.licenses.bsd3; + }) {}; + "http-link-header" = callPackage + ({ mkDerivation, attoparsec, base, bytestring + , bytestring-conversion, errors, http-api-data, network-uri, stdenv + , text + }: + mkDerivation { + pname = "http-link-header"; + version = "1.0.3"; + sha256 = "59bd2db4e7d14b6f7ce86848af5e38b4bd2e9963e9ffe5068c7b1a710dbdd7fe"; + libraryHaskellDepends = [ + attoparsec base bytestring bytestring-conversion errors + http-api-data network-uri text + ]; + doHaddock = false; + doCheck = false; + homepage = "https://github.com/myfreeweb/http-link-header"; + description = "A parser and writer for the HTTP Link header as specified in RFC 5988 \"Web Linking\""; + license = stdenv.lib.licenses.publicDomain; + }) {}; + "http-media" = callPackage + ({ mkDerivation, base, bytestring, case-insensitive, containers + , stdenv, utf8-string + }: + mkDerivation { + pname = "http-media"; + version = "0.7.1.2"; + sha256 = "fe93d57a5bfcaf3acf6a0b6f643c179afb69a91f81057f149c5e89e54dcb7b07"; + revision = "2"; + editedCabalFile = "0in3xw1hqdz0s8pqvkfqw5qr186cd1yr4zxc5rnr0q95asi8s0rh"; + libraryHaskellDepends = [ + base bytestring case-insensitive containers utf8-string + ]; + doHaddock = false; + doCheck = false; + homepage = "https://github.com/zmthy/http-media"; + description = "Processing HTTP Content-Type and Accept headers"; + license = stdenv.lib.licenses.mit; + }) {}; + "http-reverse-proxy" = callPackage + ({ mkDerivation, base, blaze-builder, bytestring, case-insensitive + , conduit, conduit-extra, containers, http-client, http-types + , network, resourcet, stdenv, streaming-commons, text, transformers + , unliftio, wai, wai-logger, word8 + }: + mkDerivation { + pname = "http-reverse-proxy"; + version = "0.6.0"; + sha256 = "fb1c913111478384c4f23647810b8c3c01c79e9276a08a1ea46215e4a42dd1a8"; + libraryHaskellDepends = [ + base blaze-builder bytestring case-insensitive conduit + conduit-extra containers http-client http-types network resourcet + streaming-commons text transformers unliftio wai wai-logger word8 + ]; + doHaddock = false; + doCheck = false; + homepage = "https://github.com/fpco/http-reverse-proxy"; + description = "Reverse proxy HTTP requests, either over raw sockets or with WAI"; + license = stdenv.lib.licenses.bsd3; + }) {}; + "http-streams" = callPackage + ({ mkDerivation, aeson, attoparsec, base, base64-bytestring + , blaze-builder, bytestring, Cabal, case-insensitive, directory + , HsOpenSSL, http-common, io-streams, mtl, network, network-uri + , openssl-streams, stdenv, text, transformers, unordered-containers + }: + mkDerivation { + pname = "http-streams"; + version = "0.8.6.1"; + sha256 = "b8d71f2753ac7cda35b4f03ec64e4b3c7cc4ec5c2435b5e5237fe863cb687da3"; + setupHaskellDepends = [ base Cabal ]; + libraryHaskellDepends = [ + aeson attoparsec base base64-bytestring blaze-builder bytestring + case-insensitive directory HsOpenSSL http-common io-streams mtl + network network-uri openssl-streams text transformers + unordered-containers + ]; + doHaddock = false; + doCheck = false; + homepage = "https://github.com/afcowie/http-streams/"; + description = "An HTTP client using io-streams"; + license = stdenv.lib.licenses.bsd3; + }) {}; + "http-types" = callPackage + ({ mkDerivation, array, base, bytestring, case-insensitive, stdenv + , text + }: + mkDerivation { + pname = "http-types"; + version = "0.12.1"; + sha256 = "3fa7715428f375b6aa4998ef17822871d7bfe1b55ebd9329efbacd4dad9969f3"; + libraryHaskellDepends = [ + array base bytestring case-insensitive text + ]; + doHaddock = false; + doCheck = false; + homepage = "https://github.com/aristidb/http-types"; + description = "Generic HTTP types for Haskell (for both client and server code)"; + license = stdenv.lib.licenses.bsd3; + }) {}; + "http2" = callPackage + ({ mkDerivation, array, base, bytestring, bytestring-builder + , case-insensitive, containers, psqueues, stdenv, stm + }: + mkDerivation { + pname = "http2"; + version = "1.6.3"; + sha256 = "61620eca0f57875a6a9bd24f9cc04c301b5c3c668bf98f85e9989aad5d069c43"; + isLibrary = true; + isExecutable = true; + libraryHaskellDepends = [ + array base bytestring bytestring-builder case-insensitive + containers psqueues stm + ]; + doHaddock = false; + doCheck = false; + homepage = "https://github.com/kazu-yamamoto/http2"; + description = "HTTP/2 library including frames, priority queues and HPACK"; + license = stdenv.lib.licenses.bsd3; + }) {}; + "httpd-shed" = callPackage + ({ mkDerivation, base, network, network-uri, stdenv }: + mkDerivation { + pname = "httpd-shed"; + version = "0.4.0.3"; + sha256 = "b0ff87d81e61f788d3920d952e4469d984742ba49c006df086c159886bf09218"; + revision = "2"; + editedCabalFile = "12y9qf8s0aq4dc80wrvh14cjvvm4mcygrqq72w4z8w9n8mp8jg9p"; + isLibrary = true; + isExecutable = true; + libraryHaskellDepends = [ base network network-uri ]; + doHaddock = false; + doCheck = false; + description = "A simple web-server with an interact style API"; + license = stdenv.lib.licenses.bsd3; + }) {}; + "human-readable-duration" = callPackage + ({ mkDerivation, base, stdenv }: + mkDerivation { + pname = "human-readable-duration"; + version = "0.2.0.3"; + sha256 = "93f3a91a2994588728ae757dcca5104e18a570b3591773aa7f03c524c97599da"; + libraryHaskellDepends = [ base ]; + doHaddock = false; + doCheck = false; + homepage = "http://github.com/yogsototh/human-readable-duration#readme"; + description = "Provide duration helper"; + license = stdenv.lib.licenses.bsd3; + }) {}; + "hunit-dejafu" = callPackage + ({ mkDerivation, base, dejafu, exceptions, HUnit, stdenv }: + mkDerivation { + pname = "hunit-dejafu"; + version = "1.2.0.6"; + sha256 = "54aac2479fec2ecefeb7ff42e659d2d0d1fba125a339eb3df33ed2fb266ff683"; + libraryHaskellDepends = [ base dejafu exceptions HUnit ]; + doHaddock = false; + doCheck = false; + homepage = "https://github.com/barrucadu/dejafu"; + description = "Deja Fu support for the HUnit test framework"; + license = stdenv.lib.licenses.mit; + }) {}; + "hvect" = callPackage + ({ mkDerivation, base, stdenv }: + mkDerivation { + pname = "hvect"; + version = "0.4.0.0"; + sha256 = "cb50ef1a7f189f8c217a7d0d55b5568b2fa9bbe415b14ce114a93d2e1d5e30b6"; + libraryHaskellDepends = [ base ]; + doHaddock = false; + doCheck = false; + homepage = "https://github.com/agrafix/hvect"; + description = "Simple strict heterogeneous lists"; + license = stdenv.lib.licenses.mit; + }) {}; + "hw-balancedparens" = callPackage + ({ mkDerivation, base, hw-bits, hw-excess, hw-prim + , hw-rankselect-base, stdenv, storable-tuple, vector + }: + mkDerivation { + pname = "hw-balancedparens"; + version = "0.2.0.1"; + sha256 = "99d164e1f5b1fc50bfdcc887b1ef5f6cdfc42f702b847d06f31db5dd04b5e8cd"; + libraryHaskellDepends = [ + base hw-bits hw-excess hw-prim hw-rankselect-base storable-tuple + vector + ]; + doHaddock = false; + doCheck = false; + homepage = "http://github.com/haskell-works/hw-balancedparens#readme"; + description = "Balanced parentheses"; + license = stdenv.lib.licenses.bsd3; + }) {}; + "hw-bits" = callPackage + ({ mkDerivation, base, bytestring, hw-int, hw-prim, hw-string-parse + , safe, stdenv, vector + }: + mkDerivation { + pname = "hw-bits"; + version = "0.7.0.2"; + sha256 = "38621e0166bac49c1f68f85122c3fbfcadc6a3c447dd7f48ff1020151ad10ae8"; + revision = "1"; + editedCabalFile = "1gvv5ryx1lrgb3hk362fkqz98rggdxfmjp7fy0id7mqvdz6lk2av"; + libraryHaskellDepends = [ + base bytestring hw-int hw-prim hw-string-parse safe vector + ]; + doHaddock = false; + doCheck = false; + homepage = "http://github.com/haskell-works/hw-bits#readme"; + description = "Bit manipulation"; + license = stdenv.lib.licenses.bsd3; + }) {}; + "hw-conduit" = callPackage + ({ mkDerivation, array, base, bytestring, conduit + , conduit-combinators, stdenv, time, word8 + }: + mkDerivation { + pname = "hw-conduit"; + version = "0.2.0.3"; + sha256 = "6a20170fff38bb940121ecc922aa4cdb979b7869cfab6a0b18f00476eda3dca5"; + revision = "1"; + editedCabalFile = "0zr1r7px2qgpf5fgq18l6ziy2xaz773qbxc87cp84x0vpwas0yg7"; + libraryHaskellDepends = [ + array base bytestring conduit conduit-combinators time word8 + ]; + doHaddock = false; + doCheck = false; + homepage = "http://github.com/haskell-works/hw-conduit#readme"; + description = "Conduits for tokenizing streams"; + license = stdenv.lib.licenses.mit; + }) {}; + "hw-diagnostics" = callPackage + ({ mkDerivation, base, stdenv }: + mkDerivation { + pname = "hw-diagnostics"; + version = "0.0.0.5"; + sha256 = "5ceaec01c446c5a507e889f514201e4739ea6f1cc22a4c68894bb023257bd931"; + libraryHaskellDepends = [ base ]; + doHaddock = false; + doCheck = false; + homepage = "http://github.com/haskell-works/hw-diagnostics#readme"; + description = "Diagnostics library"; + license = stdenv.lib.licenses.bsd3; + }) {}; + "hw-excess" = callPackage + ({ mkDerivation, base, hw-bits, hw-prim, hw-rankselect-base, safe + , stdenv, vector + }: + mkDerivation { + pname = "hw-excess"; + version = "0.2.0.2"; + sha256 = "6735d0cd4ee86d5c13d5ea067251c6b1126f7569d78c6241f3147eb114b7a1f6"; + libraryHaskellDepends = [ + base hw-bits hw-prim hw-rankselect-base safe vector + ]; + doHaddock = false; + doCheck = false; + homepage = "http://github.com/haskell-works/hw-excess#readme"; + description = "Excess"; + license = stdenv.lib.licenses.bsd3; + }) {}; + "hw-fingertree-strict" = callPackage + ({ mkDerivation, base, deepseq, stdenv }: + mkDerivation { + pname = "hw-fingertree-strict"; + version = "0.1.1.1"; + sha256 = "1127b7cff38319a292ca6d57c8b7a1996bb80b90e86488a0f82a76eba9f91268"; + libraryHaskellDepends = [ base deepseq ]; + doHaddock = false; + doCheck = false; + homepage = "https://github.com/haskell-works/hw-fingertree-strict#readme"; + description = "Generic strict finger-tree structure"; + license = stdenv.lib.licenses.bsd3; + }) {}; + "hw-hedgehog" = callPackage + ({ mkDerivation, base, hedgehog, stdenv, vector }: + mkDerivation { + pname = "hw-hedgehog"; + version = "0.1.0.1"; + sha256 = "26177ea0748f5d85e70e1759ea6a88af15e5bfdbf0a174a80e7f28607addcf3a"; + revision = "1"; + editedCabalFile = "0a5qlh5dwsnv14ngimbsvpgxx4hf0c0wdi5yfv7afwj9h2afdpfz"; + libraryHaskellDepends = [ base hedgehog vector ]; + doHaddock = false; + doCheck = false; + homepage = "https://github.com/githubuser/hw-hedgehog#readme"; + description = "Extra hedgehog functionality"; + license = stdenv.lib.licenses.bsd3; + }) {}; + "hw-hspec-hedgehog" = callPackage + ({ mkDerivation, base, call-stack, hedgehog, hspec, HUnit, stdenv + , transformers + }: + mkDerivation { + pname = "hw-hspec-hedgehog"; + version = "0.1.0.5"; + sha256 = "d3d17aadf474e82bb2d90c2d48cadf18724cbeab08e010bdf250591ce9c5f64f"; + revision = "1"; + editedCabalFile = "05fg0d89652yhsji35ckh9qiiy4y7c04i6zya9hrkgwl2jaq55fv"; + libraryHaskellDepends = [ + base call-stack hedgehog hspec HUnit transformers + ]; + doHaddock = false; + doCheck = false; + homepage = "https://github.com/haskell-works/hw-hspec-hedgehog#readme"; + description = "Interoperability between hspec and hedgehog"; + license = stdenv.lib.licenses.bsd3; + }) {}; + "hw-int" = callPackage + ({ mkDerivation, base, stdenv }: + mkDerivation { + pname = "hw-int"; + version = "0.0.0.3"; + sha256 = "8336a5111638d3298266c9a1458233a09798bfa6d558219d4fe3bdd35d8d4a3f"; + libraryHaskellDepends = [ base ]; + doHaddock = false; + doCheck = false; + homepage = "http://github.com/haskell-works/hw-int#readme"; + description = "Integers"; + license = stdenv.lib.licenses.bsd3; + }) {}; + "hw-ip" = callPackage + ({ mkDerivation, base, stdenv }: + mkDerivation { + pname = "hw-ip"; + version = "0.1.0.0"; + sha256 = "3664d0fbbb1fd734b9b3a8d39b1115390ddc1a8a5e48b4ae5d5960d3ba7980bf"; + libraryHaskellDepends = [ base ]; + doHaddock = false; + doCheck = false; + homepage = "https://github.com/haskell-works/hw-ip#readme"; + description = "Library for manipulating IP addresses and CIDR blocks"; + license = stdenv.lib.licenses.bsd3; + }) {}; + "hw-json" = callPackage + ({ mkDerivation, ansi-wl-pprint, array, attoparsec, base + , bytestring, conduit, containers, criterion, dlist + , hw-balancedparens, hw-bits, hw-conduit, hw-diagnostics, hw-mquery + , hw-parser, hw-prim, hw-rankselect, hw-rankselect-base, mmap + , mono-traversable, resourcet, stdenv, text, vector, word8 + }: + mkDerivation { + pname = "hw-json"; + version = "0.6.0.0"; + sha256 = "bb8e20e8a035279ee398c6d9162cda3f965d4f96e39c1d363be2456b1feb41d9"; + revision = "2"; + editedCabalFile = "0ygq95nx4sb70l5kfxlsj6rf2b3ry84ixby567n0jk1g0zks3z7s"; + isLibrary = true; + isExecutable = true; + libraryHaskellDepends = [ + ansi-wl-pprint array attoparsec base bytestring conduit containers + dlist hw-balancedparens hw-bits hw-conduit hw-mquery hw-parser + hw-prim hw-rankselect hw-rankselect-base mmap mono-traversable + resourcet text vector word8 + ]; + executableHaskellDepends = [ + ansi-wl-pprint array attoparsec base bytestring conduit containers + criterion dlist hw-balancedparens hw-bits hw-conduit hw-diagnostics + hw-mquery hw-parser hw-prim hw-rankselect hw-rankselect-base mmap + mono-traversable resourcet text vector word8 + ]; + doHaddock = false; + doCheck = false; + homepage = "http://github.com/haskell-works/hw-json#readme"; + description = "Memory efficient JSON parser"; + license = stdenv.lib.licenses.bsd3; + }) {}; + "hw-mquery" = callPackage + ({ mkDerivation, ansi-wl-pprint, base, dlist, stdenv }: + mkDerivation { + pname = "hw-mquery"; + version = "0.1.0.1"; + sha256 = "724aa5b0490b57a89fb71b7042a3770f7978a4c975aa3d1b671576b0e83e113d"; + isLibrary = true; + isExecutable = true; + libraryHaskellDepends = [ ansi-wl-pprint base dlist ]; + executableHaskellDepends = [ base ]; + doHaddock = false; + doCheck = false; + homepage = "http://github.com/haskell-works/hw-mquery#readme"; + description = "Conduits for tokenizing streams"; + license = stdenv.lib.licenses.mit; + }) {}; + "hw-parser" = callPackage + ({ mkDerivation, attoparsec, base, bytestring, hw-prim + , mono-traversable, stdenv, text + }: + mkDerivation { + pname = "hw-parser"; + version = "0.0.0.3"; + sha256 = "dd8417c76ef5da89df2842b42767d825815ec3594c8e80e28e96570d8046c6f2"; + libraryHaskellDepends = [ + attoparsec base bytestring hw-prim mono-traversable text + ]; + doHaddock = false; + doCheck = false; + homepage = "http://github.com/haskell-works/hw-parser#readme"; + description = "Simple parser support"; + license = stdenv.lib.licenses.bsd3; + }) {}; + "hw-prim" = callPackage + ({ mkDerivation, base, bytestring, mmap, stdenv, vector }: + mkDerivation { + pname = "hw-prim"; + version = "0.6.2.0"; + sha256 = "dd22d1bb6e78dddf023538f8a9b327706dd570d1641642ad8d42886e8bc14e5d"; + revision = "1"; + editedCabalFile = "0ff5ms3h8gnjnpx5n9d0jy42lmdxv1sc85rgjikhkwpsi1i8j321"; + libraryHaskellDepends = [ base bytestring mmap vector ]; + doHaddock = false; + doCheck = false; + homepage = "http://github.com/haskell-works/hw-prim#readme"; + description = "Primitive functions and data types"; + license = stdenv.lib.licenses.bsd3; + }) {}; + "hw-rankselect" = callPackage + ({ mkDerivation, base, deepseq, directory, hw-balancedparens + , hw-bits, hw-prim, hw-rankselect-base, mmap, stdenv, vector + }: + mkDerivation { + pname = "hw-rankselect"; + version = "0.10.0.3"; + sha256 = "aa1d079f56064c649bc820219b55ae16d723faed663283ab73760db4f2f514cb"; + revision = "1"; + editedCabalFile = "1rkni89h3sq02y03phb2bgx4yrx4gly9mzan6r4ziph0qayf09wf"; + isLibrary = true; + isExecutable = true; + libraryHaskellDepends = [ + base deepseq hw-balancedparens hw-bits hw-prim hw-rankselect-base + vector + ]; + executableHaskellDepends = [ + base directory hw-bits hw-prim hw-rankselect-base mmap vector + ]; + doHaddock = false; + doCheck = false; + homepage = "http://github.com/haskell-works/hw-rankselect#readme"; + description = "Rank-select"; + license = stdenv.lib.licenses.bsd3; + }) {}; + "hw-rankselect-base" = callPackage + ({ mkDerivation, base, bits-extra, hw-bits, hw-int, hw-prim + , hw-string-parse, safe, stdenv, vector + }: + mkDerivation { + pname = "hw-rankselect-base"; + version = "0.3.2.0"; + sha256 = "7ad80a78f10fafb12851ba01825e9b1b4577be839cda54b840e43953368e654d"; + libraryHaskellDepends = [ + base bits-extra hw-bits hw-int hw-prim hw-string-parse safe vector + ]; + doHaddock = false; + doCheck = false; + homepage = "http://github.com/haskell-works/hw-rankselect-base#readme"; + description = "Rank-select base"; + license = stdenv.lib.licenses.bsd3; + }) {}; + "hw-string-parse" = callPackage + ({ mkDerivation, base, stdenv }: + mkDerivation { + pname = "hw-string-parse"; + version = "0.0.0.4"; + sha256 = "64a1ebf8d311e255f293c40febfb346da23a55a454b67f2d5e33de1cb7e9f2b7"; + libraryHaskellDepends = [ base ]; + doHaddock = false; + doCheck = false; + homepage = "http://github.com/haskell-works/hw-string-parse#readme"; + description = "String parser"; + license = stdenv.lib.licenses.bsd3; + }) {}; + "hw-succinct" = callPackage + ({ mkDerivation, attoparsec, base, bytestring, conduit, containers + , hw-balancedparens, hw-bits, hw-prim, hw-rankselect + , hw-rankselect-base, mmap, mono-traversable, stdenv, text, vector + , word8 + }: + mkDerivation { + pname = "hw-succinct"; + version = "0.1.0.1"; + sha256 = "002c578c1ff7a33cbef089b2a943218777c14125629f6bf63dea9e7c8e3749db"; + libraryHaskellDepends = [ + attoparsec base bytestring conduit containers hw-balancedparens + hw-bits hw-prim hw-rankselect hw-rankselect-base mmap + mono-traversable text vector word8 + ]; + doHaddock = false; + doCheck = false; + homepage = "http://github.com/haskell-works/hw-succinct#readme"; + description = "Succint datastructures"; + license = stdenv.lib.licenses.mit; + }) {}; + "hw-xml" = callPackage + ({ mkDerivation, ansi-wl-pprint, array, attoparsec, base + , bytestring, cereal, conduit, containers, deepseq, ghc-prim + , hw-balancedparens, hw-bits, hw-conduit, hw-parser, hw-prim + , hw-rankselect, hw-rankselect-base, lens, mtl, resourcet, stdenv + , transformers, vector, word8 + }: + mkDerivation { + pname = "hw-xml"; + version = "0.1.0.3"; + sha256 = "27a9a8212331c8c91d4a66baf8f0785c4ce90c087c02359bd16dfaeabc627e97"; + isLibrary = true; + isExecutable = true; + enableSeparateDataOutput = true; + libraryHaskellDepends = [ + ansi-wl-pprint array attoparsec base bytestring cereal conduit + containers deepseq ghc-prim hw-balancedparens hw-bits hw-conduit + hw-parser hw-prim hw-rankselect hw-rankselect-base lens mtl + resourcet transformers vector word8 + ]; + executableHaskellDepends = [ + base bytestring hw-balancedparens hw-bits hw-prim hw-rankselect + vector + ]; + doHaddock = false; + doCheck = false; + homepage = "http://github.com/haskell-works/hw-xml#readme"; + description = "Conduits for tokenizing streams"; + license = stdenv.lib.licenses.bsd3; + }) {}; + "hweblib" = callPackage + ({ mkDerivation, attoparsec, base, bytestring, containers, mtl + , stdenv, text, transformers + }: + mkDerivation { + pname = "hweblib"; + version = "0.6.3"; + sha256 = "1e8ee12baac496d56831935a60e78f54eb43d2b7268bf7d31acb6b9a63e9b50d"; + libraryHaskellDepends = [ + attoparsec base bytestring containers mtl text transformers + ]; + doHaddock = false; + doCheck = false; + homepage = "http://github.com/aycanirican/hweblib"; + description = "Haskell Web Library"; + license = stdenv.lib.licenses.bsd3; + }) {}; + "hworker" = callPackage + ({ mkDerivation, aeson, attoparsec, base, bytestring, hedis, stdenv + , text, time, uuid + }: + mkDerivation { + pname = "hworker"; + version = "0.1.0.1"; + sha256 = "34cbcc4db8f190ab0dc02a072adcf1fc75b7beab7e545982872bf265a1223f1d"; + revision = "1"; + editedCabalFile = "0w2bpvfr68n2qipvr8gc5096dain3g2536m4n9kqx1fahf12mwy5"; + libraryHaskellDepends = [ + aeson attoparsec base bytestring hedis text time uuid + ]; + doHaddock = false; + doCheck = false; + homepage = "http://github.com/dbp/hworker"; + description = "A reliable at-least-once job queue built on top of redis"; + license = stdenv.lib.licenses.isc; + }) {}; + "hxt" = callPackage + ({ mkDerivation, base, binary, bytestring, containers, deepseq + , directory, filepath, hxt-charproperties, hxt-regex-xmlschema + , hxt-unicode, mtl, network-uri, parsec, stdenv + }: + mkDerivation { + pname = "hxt"; + version = "9.3.1.16"; + sha256 = "0d55e35cc718891d0987b7c8e6c43499efa727c68bc92e88e8b99461dff403e3"; + libraryHaskellDepends = [ + base binary bytestring containers deepseq directory filepath + hxt-charproperties hxt-regex-xmlschema hxt-unicode mtl network-uri + parsec + ]; + doHaddock = false; + doCheck = false; + homepage = "https://github.com/UweSchmidt/hxt"; + description = "A collection of tools for processing XML with Haskell"; + license = stdenv.lib.licenses.mit; + }) {}; + "hxt-charproperties" = callPackage + ({ mkDerivation, base, stdenv }: + mkDerivation { + pname = "hxt-charproperties"; + version = "9.2.0.1"; + sha256 = "e46614d6bf0390b2a6a1aeeb0771e6d366944da40fb21c12c2f8a94d1f47b4d6"; + libraryHaskellDepends = [ base ]; + doHaddock = false; + doCheck = false; + homepage = "https://github.com/UweSchmidt/hxt"; + description = "Character properties and classes for XML and Unicode"; + license = stdenv.lib.licenses.mit; + }) {}; + "hxt-css" = callPackage + ({ mkDerivation, base, hxt, parsec, split, stdenv }: + mkDerivation { + pname = "hxt-css"; + version = "0.1.0.3"; + sha256 = "0244fc145d5923df0522ad80949e9b221b01a028c755ebfc4740339881ef65b7"; + isLibrary = true; + isExecutable = true; + libraryHaskellDepends = [ base hxt parsec split ]; + doHaddock = false; + doCheck = false; + homepage = "https://github.com/redneb/hxt-css"; + description = "CSS selectors for HXT"; + license = stdenv.lib.licenses.bsd3; + }) {}; + "hxt-curl" = callPackage + ({ mkDerivation, base, bytestring, curl, hxt, parsec, stdenv }: + mkDerivation { + pname = "hxt-curl"; + version = "9.1.1.1"; + sha256 = "cdc1cc8bf9b8699cabdee965c9737d497c199b5cf82eabc66a5fe3f2ffb3c5ea"; + libraryHaskellDepends = [ base bytestring curl hxt parsec ]; + doHaddock = false; + doCheck = false; + homepage = "https://github.com/UweSchmidt/hxt"; + description = "LibCurl interface for HXT"; + license = "unknown"; + }) {}; + "hxt-expat" = callPackage + ({ mkDerivation, base, bytestring, hexpat, hxt, stdenv }: + mkDerivation { + pname = "hxt-expat"; + version = "9.1.1"; + sha256 = "10d9c43c20c82e879fbc06944fcfed373f8b43bd3e0a44f9c712db30a27022d6"; + libraryHaskellDepends = [ base bytestring hexpat hxt ]; + doHaddock = false; + doCheck = false; + homepage = "http://www.fh-wedel.de/~si/HXmlToolbox/index.html"; + description = "Expat parser for HXT"; + license = "unknown"; + }) {}; + "hxt-http" = callPackage + ({ mkDerivation, base, bytestring, HTTP, hxt, network, network-uri + , parsec, stdenv + }: + mkDerivation { + pname = "hxt-http"; + version = "9.1.5.2"; + sha256 = "6fa19d03991d53c34f4525a4fdfaafde56dd48459093b4502832a1fdd9dfdd0b"; + libraryHaskellDepends = [ + base bytestring HTTP hxt network network-uri parsec + ]; + doHaddock = false; + doCheck = false; + homepage = "https://github.com/UweSchmidt/hxt"; + description = "Interface to native Haskell HTTP package HTTP"; + license = stdenv.lib.licenses.mit; + }) {}; + "hxt-pickle-utils" = callPackage + ({ mkDerivation, base, hxt, mtl, stdenv }: + mkDerivation { + pname = "hxt-pickle-utils"; + version = "0.1.0.3"; + sha256 = "9ddba19f27d9d8c155012da4dd9598fb318cab862da10f14ee4bc3eb5321a9c5"; + revision = "3"; + editedCabalFile = "0d5fg718y7xzw76ip33q0w1liqk70q9074qkd198mjnijxjcrkf3"; + libraryHaskellDepends = [ base hxt mtl ]; + doHaddock = false; + doCheck = false; + homepage = "https://github.com/silkapp/hxt-pickle-utils"; + description = "Utility functions for using HXT picklers"; + license = stdenv.lib.licenses.bsd3; + }) {}; + "hxt-regex-xmlschema" = callPackage + ({ mkDerivation, base, bytestring, hxt-charproperties, parsec + , stdenv, text + }: + mkDerivation { + pname = "hxt-regex-xmlschema"; + version = "9.2.0.3"; + sha256 = "f4743ba65498d6001cdfcf5cbc3317d4bc43941be5c7030b60beb83408c892b0"; + libraryHaskellDepends = [ + base bytestring hxt-charproperties parsec text + ]; + doHaddock = false; + doCheck = false; + homepage = "http://www.haskell.org/haskellwiki/Regular_expressions_for_XML_Schema"; + description = "A regular expression library for W3C XML Schema regular expressions"; + license = stdenv.lib.licenses.mit; + }) {}; + "hxt-tagsoup" = callPackage + ({ mkDerivation, base, hxt, hxt-charproperties, hxt-unicode, stdenv + , tagsoup + }: + mkDerivation { + pname = "hxt-tagsoup"; + version = "9.1.4"; + sha256 = "d77b290d63acf0ac8e5a07c5c69753f9984b97e0c9d2c0befadd7dd5b144b283"; + libraryHaskellDepends = [ + base hxt hxt-charproperties hxt-unicode tagsoup + ]; + doHaddock = false; + doCheck = false; + homepage = "https://github.com/UweSchmidt/hxt"; + description = "TagSoup parser for HXT"; + license = "unknown"; + }) {}; + "hxt-unicode" = callPackage + ({ mkDerivation, base, hxt-charproperties, stdenv }: + mkDerivation { + pname = "hxt-unicode"; + version = "9.0.2.4"; + sha256 = "7b5823f3bd94b57022d9d84ab3555303653c5121eaaef2ee1fd4918f3c434466"; + libraryHaskellDepends = [ base hxt-charproperties ]; + doHaddock = false; + doCheck = false; + homepage = "https://github.com/UweSchmidt/hxt"; + description = "Unicode en-/decoding functions for utf8, iso-latin-* and other encodings"; + license = stdenv.lib.licenses.mit; + }) {}; + "hybrid-vectors" = callPackage + ({ mkDerivation, base, deepseq, primitive, semigroups, stdenv + , vector + }: + mkDerivation { + pname = "hybrid-vectors"; + version = "0.2.2"; + sha256 = "41c6c371df64b9083354e66101ad8c92f87458474fed2a149e4632db644f86d7"; + libraryHaskellDepends = [ + base deepseq primitive semigroups vector + ]; + doHaddock = false; + doCheck = false; + homepage = "http://github.com/ekmett/hybrid-vectors"; + description = "Hybrid vectors e.g. Mixed Boxed/Unboxed vectors"; + license = stdenv.lib.licenses.bsd3; + }) {}; + "hyperloglog" = callPackage + ({ mkDerivation, approximate, base, binary, bits, bytes, Cabal + , cabal-doctest, cereal, cereal-vector, comonad, deepseq + , distributive, hashable, lens, reflection, safecopy, semigroupoids + , semigroups, siphash, stdenv, tagged, vector + }: + mkDerivation { + pname = "hyperloglog"; + version = "0.4.2"; + sha256 = "f5b83cfcc2c9d1e40e04bbc9724428b2655c3b54b26beef714c98dabee5f1048"; + setupHaskellDepends = [ base Cabal cabal-doctest ]; + libraryHaskellDepends = [ + approximate base binary bits bytes cereal cereal-vector comonad + deepseq distributive hashable lens reflection safecopy + semigroupoids semigroups siphash tagged vector + ]; + doHaddock = false; + doCheck = false; + homepage = "http://github.com/analytics/hyperloglog"; + description = "An approximate streaming (constant space) unique object counter"; + license = stdenv.lib.licenses.bsd3; + }) {}; + "hyphenation" = callPackage + ({ mkDerivation, base, bytestring, Cabal, cabal-doctest, containers + , stdenv, unordered-containers, zlib + }: + mkDerivation { + pname = "hyphenation"; + version = "0.7.1"; + sha256 = "a25c5073f42896ccf81ff5936f3a42f290730f61da7f225b126ad22ff601b1c0"; + revision = "4"; + editedCabalFile = "0pp7qm40alsfd9z5dvp6l2c7dp9zp0skl9g0iib3jahxs3n8qcrr"; + enableSeparateDataOutput = true; + setupHaskellDepends = [ base Cabal cabal-doctest ]; + libraryHaskellDepends = [ + base bytestring containers unordered-containers zlib + ]; + doHaddock = false; + doCheck = false; + homepage = "http://github.com/ekmett/hyphenation"; + description = "Configurable Knuth-Liang hyphenation"; + license = stdenv.lib.licenses.bsd2; + }) {}; + "iconv" = callPackage + ({ mkDerivation, base, bytestring, stdenv }: + mkDerivation { + pname = "iconv"; + version = "0.4.1.3"; + sha256 = "36425168e3314bc83ba5ee95152872d52e94ee0f9503f3591f84d458e005b554"; + libraryHaskellDepends = [ base bytestring ]; + doHaddock = false; + doCheck = false; + description = "String encoding conversion"; + license = stdenv.lib.licenses.bsd3; + }) {}; + "identicon" = callPackage + ({ mkDerivation, base, bytestring, JuicyPixels, stdenv }: + mkDerivation { + pname = "identicon"; + version = "0.2.2"; + sha256 = "3679b4fcc0a5bcc93b6ed2009f43e3ec87bf9549aee3eef182f7403d0c10f263"; + revision = "3"; + editedCabalFile = "0vya6zm3nnbdv3wmj3dwqwwjgsagql8q17078knhjddv2lm8m49q"; + enableSeparateDataOutput = true; + libraryHaskellDepends = [ base bytestring JuicyPixels ]; + doHaddock = false; + doCheck = false; + homepage = "https://github.com/mrkkrp/identicon"; + description = "Flexible generation of identicons"; + license = stdenv.lib.licenses.bsd3; + }) {}; + "ieee754" = callPackage + ({ mkDerivation, base, stdenv }: + mkDerivation { + pname = "ieee754"; + version = "0.8.0"; + sha256 = "0e2dff9c37f59acf5c64f978ec320005e9830f276f9f314e4bfed3f482289ad1"; + libraryHaskellDepends = [ base ]; + doHaddock = false; + doCheck = false; + homepage = "http://github.com/patperry/hs-ieee754"; + description = "Utilities for dealing with IEEE floating point numbers"; + license = stdenv.lib.licenses.bsd3; + }) {}; + "if" = callPackage + ({ mkDerivation, base, stdenv }: + mkDerivation { + pname = "if"; + version = "0.1.0.0"; + sha256 = "28f673e867dbe0f51324d97fcb7884673a34912593746520a470116b167a141d"; + libraryHaskellDepends = [ base ]; + doHaddock = false; + doCheck = false; + homepage = "https://github.com/winterland1989/if"; + description = "(?) and (?>) conditional operator"; + license = stdenv.lib.licenses.bsd3; + }) {}; + "iff" = callPackage + ({ mkDerivation, base, binary, bytestring, stdenv }: + mkDerivation { + pname = "iff"; + version = "0.0.6"; + sha256 = "6b8845808481307e2d374fd8d17e82a5de1284e612cf8ade27db8785e9e12837"; + libraryHaskellDepends = [ base binary bytestring ]; + doHaddock = false; + doCheck = false; + homepage = "http://code.haskell.org/~thielema/iff/"; + description = "Constructing and dissecting IFF files"; + license = "GPL"; + }) {}; + "ihaskell" = callPackage + ({ mkDerivation, aeson, base, base64-bytestring, bytestring, cereal + , cmdargs, containers, directory, filepath, ghc, ghc-boot + , ghc-parser, ghc-paths, haskeline, haskell-src-exts, hlint + , http-client, http-client-tls, ipython-kernel, mtl, parsec + , process, random, shelly, split, stdenv, stm, strict, system-argv0 + , text, transformers, unix, unordered-containers, utf8-string, uuid + , vector + }: + mkDerivation { + pname = "ihaskell"; + version = "0.9.0.3"; + sha256 = "9720c1037f0bf79f36b2aaa960e8afd30d9672b8b5d7b5b75e4f24cf0fa38b8d"; + isLibrary = true; + isExecutable = true; + enableSeparateDataOutput = true; + libraryHaskellDepends = [ + aeson base base64-bytestring bytestring cereal cmdargs containers + directory filepath ghc ghc-boot ghc-parser ghc-paths haskeline + haskell-src-exts hlint http-client http-client-tls ipython-kernel + mtl parsec process random shelly split stm strict system-argv0 text + transformers unix unordered-containers utf8-string uuid vector + ]; + executableHaskellDepends = [ + aeson base bytestring containers directory ghc ipython-kernel + process strict text transformers unix + ]; + doHaddock = false; + doCheck = false; + homepage = "http://github.com/gibiansky/IHaskell"; + description = "A Haskell backend kernel for the IPython project"; + license = stdenv.lib.licenses.mit; + }) {}; + "ihs" = callPackage + ({ mkDerivation, base, process, stdenv }: + mkDerivation { + pname = "ihs"; + version = "0.1.0.2"; + sha256 = "98477e742e5f131c8ceae4f2ca451bee3de7135340005252d107fc791edaf932"; + isLibrary = false; + isExecutable = true; + executableHaskellDepends = [ base process ]; + doHaddock = false; + doCheck = false; + homepage = "https://github.com/minad/ihs"; + description = "Interpolated Haskell"; + license = stdenv.lib.licenses.publicDomain; + }) {}; + "ilist" = callPackage + ({ mkDerivation, base, stdenv }: + mkDerivation { + pname = "ilist"; + version = "0.3.1.0"; + sha256 = "e898e1dd1077e5a268f66e2de15f15ef64eddac94133954c9e054d59092afe97"; + libraryHaskellDepends = [ base ]; + doHaddock = false; + doCheck = false; + homepage = "http://github.com/aelve/ilist"; + description = "Optimised list functions for doing index-related things"; + license = stdenv.lib.licenses.bsd3; + }) {}; + "imagesize-conduit" = callPackage + ({ mkDerivation, base, bytestring, conduit, conduit-extra + , exceptions, stdenv + }: + mkDerivation { + pname = "imagesize-conduit"; + version = "1.1"; + sha256 = "31c5784578b305921b89f7ab6fca35747e5a35f12884770b78c31e3a0a01ac19"; + revision = "3"; + editedCabalFile = "0p4zmizr01pg3d7gb0q88j1alvvlzbdvzyf1wbgajng68a4g0li9"; + libraryHaskellDepends = [ + base bytestring conduit conduit-extra exceptions + ]; + doHaddock = false; + doCheck = false; + homepage = "http://github.com/silkapp/imagesize-conduit"; + description = "Determine the size of some common image formats"; + license = stdenv.lib.licenses.bsd3; + }) {}; + "immortal" = callPackage + ({ mkDerivation, base, stdenv, stm, unliftio-core }: + mkDerivation { + pname = "immortal"; + version = "0.3"; + sha256 = "11c89db97f33c8bbfe6f72c728c68135a247608ceb2335dfb7ac6679acb41f88"; + libraryHaskellDepends = [ base stm unliftio-core ]; + doHaddock = false; + doCheck = false; + homepage = "https://github.com/feuerbach/immortal"; + description = "Spawn threads that never die (unless told to do so)"; + license = stdenv.lib.licenses.mit; + }) {}; + "include-file" = callPackage + ({ mkDerivation, base, bytestring, random, stdenv, template-haskell + }: + mkDerivation { + pname = "include-file"; + version = "0.1.0.3"; + sha256 = "208f1f3bdc717f5f953cb7c9935c84d6a6291b7cd5ed8a22fa8567184be33d29"; + libraryHaskellDepends = [ + base bytestring random template-haskell + ]; + doHaddock = false; + doCheck = false; + description = "Inclusion of files in executables at compile-time"; + license = stdenv.lib.licenses.bsd3; + }) {}; + "incremental-parser" = callPackage + ({ mkDerivation, base, monoid-subclasses, stdenv }: + mkDerivation { + pname = "incremental-parser"; + version = "0.3.1.1"; + sha256 = "7f87bf760af2d12967d8ffdabc8fa6f94a03a63c49e5520e2c046eb54e42f5dc"; + revision = "1"; + editedCabalFile = "0g6haprqb1w06bazjj107frraxc6bbj8i98im16k66wlx7c9f99i"; + libraryHaskellDepends = [ base monoid-subclasses ]; + doHaddock = false; + doCheck = false; + homepage = "https://github.com/blamario/incremental-parser"; + description = "Generic parser library capable of providing partial results from partial input"; + license = stdenv.lib.licenses.gpl3; + }) {}; + "indentation-core" = callPackage + ({ mkDerivation, base, mtl, stdenv }: + mkDerivation { + pname = "indentation-core"; + version = "0.0.0.1"; + sha256 = "21b78035e8933dddc15a8e90244c89daebea3043957b10a3f37a6775879dda8c"; + libraryHaskellDepends = [ base mtl ]; + doHaddock = false; + doCheck = false; + homepage = "https://bitbucket.org/adamsmd/indentation"; + description = "Indentation sensitive parsing combinators core library"; + license = stdenv.lib.licenses.bsd3; + }) {}; + "indentation-parsec" = callPackage + ({ mkDerivation, base, indentation-core, mtl, parsec, stdenv }: + mkDerivation { + pname = "indentation-parsec"; + version = "0.0.0.1"; + sha256 = "9716e5f757891a8ae07f9e67dd18952c151da66160a9ffed3c4fd013118b478b"; + libraryHaskellDepends = [ base indentation-core mtl parsec ]; + doHaddock = false; + doCheck = false; + homepage = "https://bitbucket.org/adamsmd/indentation"; + description = "Indentation sensitive parsing combinators for Parsec"; + license = stdenv.lib.licenses.bsd3; + }) {}; + "indents" = callPackage + ({ mkDerivation, base, mtl, parsec, stdenv }: + mkDerivation { + pname = "indents"; + version = "0.5.0.0"; + sha256 = "16bcc7ca0c1292e196a9c545df507e20e96f54a94392b775a686312503d9c3d3"; + libraryHaskellDepends = [ base mtl parsec ]; + doHaddock = false; + doCheck = false; + homepage = "http://github.com/jaspervdj/indents"; + description = "indentation sensitive parser-combinators for parsec"; + license = stdenv.lib.licenses.bsd3; + }) {}; + "indexed-list-literals" = callPackage + ({ mkDerivation, base, Only, stdenv }: + mkDerivation { + pname = "indexed-list-literals"; + version = "0.2.1.1"; + sha256 = "cf5d8cf1815c1798887658b616457e8ef39831323dd0ff0e19fbc46b52108fac"; + libraryHaskellDepends = [ base Only ]; + doHaddock = false; + doCheck = false; + homepage = "https://github.com/davidm-d/indexed-list-literals"; + description = "Type safe indexed list literals"; + license = stdenv.lib.licenses.bsd3; + }) {}; + "inflections" = callPackage + ({ mkDerivation, base, exceptions, megaparsec, stdenv, text + , unordered-containers + }: + mkDerivation { + pname = "inflections"; + version = "0.4.0.3"; + sha256 = "bda19185f3948a8988a53b1d6b7dc8f6676033c988c1d0d3c2e615fd6e920d09"; + libraryHaskellDepends = [ + base exceptions megaparsec text unordered-containers + ]; + doHaddock = false; + doCheck = false; + homepage = "https://github.com/stackbuilders/inflections-hs"; + description = "Inflections library for Haskell"; + license = stdenv.lib.licenses.mit; + }) {}; + "influxdb" = callPackage + ({ mkDerivation, aeson, attoparsec, base, bytestring, Cabal + , cabal-doctest, clock, containers, foldl, http-client, http-types + , lens, network, optional-args, scientific, stdenv, tagged, text + , time, unordered-containers, vector + }: + mkDerivation { + pname = "influxdb"; + version = "1.6.0.6"; + sha256 = "870e64877ede7c604571f5761ea46d2b9ce8c40961efbf86791f3103813ab9f1"; + isLibrary = true; + isExecutable = true; + setupHaskellDepends = [ base Cabal cabal-doctest ]; + libraryHaskellDepends = [ + aeson attoparsec base bytestring clock containers foldl http-client + http-types lens network optional-args scientific tagged text time + unordered-containers vector + ]; + doHaddock = false; + doCheck = false; + homepage = "https://github.com/maoe/influxdb-haskell"; + description = "Haskell client library for InfluxDB"; + license = stdenv.lib.licenses.bsd3; + }) {}; + "ini" = callPackage + ({ mkDerivation, attoparsec, base, stdenv, text + , unordered-containers + }: + mkDerivation { + pname = "ini"; + version = "0.3.6"; + sha256 = "fcbbe3745a125e80dd6d0b4fe9b3a590507cf73dfaa62e115b20a46f0fd53cd9"; + revision = "1"; + editedCabalFile = "0gfikdal67aws20i5r4wg4r0lgn844glykcn3nnmbmyvwsks049l"; + libraryHaskellDepends = [ + attoparsec base text unordered-containers + ]; + doHaddock = false; + doCheck = false; + homepage = "http://github.com/chrisdone/ini"; + description = "Quick and easy configuration files in the INI format"; + license = stdenv.lib.licenses.bsd3; + }) {}; + "inliterate" = callPackage + ({ mkDerivation, base, blaze-html, cheapskate, containers + , haskell-src-exts, lucid, lucid-extras, plotlyhs, stdenv, text + , time + }: + mkDerivation { + pname = "inliterate"; + version = "0.1.0"; + sha256 = "2d96cc64e3b923003668c88fd73c30d5da09a2c9e2fb6af62912f54478d1e39f"; + isLibrary = true; + isExecutable = true; + libraryHaskellDepends = [ + base blaze-html cheapskate containers haskell-src-exts lucid + lucid-extras plotlyhs text time + ]; + executableHaskellDepends = [ base text ]; + doHaddock = false; + doCheck = false; + homepage = "https://github.com/diffusionkinetics/open/inliterate"; + description = "Interactive literate programming"; + license = stdenv.lib.licenses.mit; + }) {}; + "insert-ordered-containers" = callPackage + ({ mkDerivation, aeson, base, base-compat, hashable, lens + , semigroupoids, semigroups, stdenv, text, transformers + , unordered-containers + }: + mkDerivation { + pname = "insert-ordered-containers"; + version = "0.2.1.0"; + sha256 = "d71d126bf455898492e1d2ba18b2ad04453f8b0e4daff3926a67f0560a712298"; + revision = "9"; + editedCabalFile = "02d4zqyb9dbahkpcbpgxylrc5xxc0zbw1awj5w0jyrql2g2b6a5f"; + libraryHaskellDepends = [ + aeson base base-compat hashable lens semigroupoids semigroups text + transformers unordered-containers + ]; + doHaddock = false; + doCheck = false; + homepage = "https://github.com/phadej/insert-ordered-containers#readme"; + description = "Associative containers retaining insertion order for traversals"; + license = stdenv.lib.licenses.bsd3; + }) {}; + "inspection-testing" = callPackage + ({ mkDerivation, base, containers, ghc, mtl, stdenv + , template-haskell, transformers + }: + mkDerivation { + pname = "inspection-testing"; + version = "0.2.0.1"; + sha256 = "1f699bf8e95ab90d36725a8a090ad052dbb051cce379fd45a664f561e66ea194"; + libraryHaskellDepends = [ + base containers ghc mtl template-haskell transformers + ]; + doHaddock = false; + doCheck = false; + homepage = "https://github.com/nomeata/inspection-testing"; + description = "GHC plugin to do inspection testing"; + license = stdenv.lib.licenses.mit; + }) {}; + "instance-control" = callPackage + ({ mkDerivation, base, mtl, stdenv, transformers }: + mkDerivation { + pname = "instance-control"; + version = "0.1.2.0"; + sha256 = "7d6dd381d8fb449584cdb016464cd02794e3ccc527c0589aab16d8a2221c6b73"; + libraryHaskellDepends = [ base mtl transformers ]; + doHaddock = false; + doCheck = false; + homepage = "https://github.com/lazac/instance-control"; + description = "Controls how the compiler searches for instances using type families"; + license = stdenv.lib.licenses.bsd3; + }) {}; + "integer-logarithms" = callPackage + ({ mkDerivation, array, base, ghc-prim, integer-gmp, stdenv }: + mkDerivation { + pname = "integer-logarithms"; + version = "1.0.2.1"; + sha256 = "32ad4a482a60ec957d1af1268952e2a6b382b67438c14f74f6c2aef2e49b48f2"; + libraryHaskellDepends = [ array base ghc-prim integer-gmp ]; + doHaddock = false; + doCheck = false; + homepage = "https://github.com/phadej/integer-logarithms"; + description = "Integer logarithms"; + license = stdenv.lib.licenses.mit; + }) {}; + "integration" = callPackage + ({ mkDerivation, base, parallel, stdenv }: + mkDerivation { + pname = "integration"; + version = "0.2.1"; + sha256 = "0c27385eadc10a580e78f7b7d4bc919c346b2c9b1e73aea7e7804d824d53582f"; + libraryHaskellDepends = [ base parallel ]; + doHaddock = false; + doCheck = false; + homepage = "https://github.com/ekmett/integration"; + description = "Fast robust numeric integration via tanh-sinh quadrature"; + license = stdenv.lib.licenses.bsd3; + }) {}; + "intern" = callPackage + ({ mkDerivation, array, base, bytestring, hashable, stdenv, text + , unordered-containers + }: + mkDerivation { + pname = "intern"; + version = "0.9.2"; + sha256 = "93a3b20e96dad8d83c9145dfc68bd9d2a6a72c9f64e4a7bc257d330070f42e20"; + libraryHaskellDepends = [ + array base bytestring hashable text unordered-containers + ]; + doHaddock = false; + doCheck = false; + homepage = "http://github.com/ekmett/intern/"; + description = "Efficient hash-consing for arbitrary data types"; + license = stdenv.lib.licenses.bsd3; + }) {}; + "interpolate" = callPackage + ({ mkDerivation, base, haskell-src-meta, stdenv, template-haskell + }: + mkDerivation { + pname = "interpolate"; + version = "0.2.0"; + sha256 = "6e112006073f2d91e7e93432ccb147b79a21fcc21a9dedd0d8c38cef51926abe"; + libraryHaskellDepends = [ base haskell-src-meta template-haskell ]; + doHaddock = false; + doCheck = false; + homepage = "https://github.com/sol/interpolate#readme"; + description = "String interpolation done right"; + license = stdenv.lib.licenses.mit; + }) {}; + "interpolatedstring-perl6" = callPackage + ({ mkDerivation, base, bytestring, haskell-src-meta, stdenv + , template-haskell, text + }: + mkDerivation { + pname = "interpolatedstring-perl6"; + version = "1.0.0"; + sha256 = "65e0b2ad2d7482755570637212417b84d1db3bcc3cd1aa348b6b37f57911a1d3"; + enableSeparateDataOutput = true; + libraryHaskellDepends = [ + base bytestring haskell-src-meta template-haskell text + ]; + doHaddock = false; + doCheck = false; + description = "QuasiQuoter for Perl6-style multi-line interpolated strings"; + license = stdenv.lib.licenses.publicDomain; + }) {}; + "interpolation" = callPackage + ({ mkDerivation, base, stdenv, utility-ht }: + mkDerivation { + pname = "interpolation"; + version = "0.1.0.2"; + sha256 = "18839b5b8a55bc7844c3d9839eaace933bad160a1879151b403df46eba0450e2"; + isLibrary = true; + isExecutable = true; + libraryHaskellDepends = [ base utility-ht ]; + doHaddock = false; + doCheck = false; + homepage = "http://hub.darcs.net/thielema/interpolation/"; + description = "piecewise linear and cubic Hermite interpolation"; + license = stdenv.lib.licenses.bsd3; + }) {}; + "intervals" = callPackage + ({ mkDerivation, array, base, Cabal, cabal-doctest, distributive + , ghc-prim, stdenv + }: + mkDerivation { + pname = "intervals"; + version = "0.8.1"; + sha256 = "9ce3bf9d31b9ab2296fccc25031fd52e1c3e4abeca5d3bb452a725b586eb7e03"; + revision = "4"; + editedCabalFile = "1qx3q0v13l1zaln9zdk8chxpxhshbz5x0vqm0qda7d1kpv7h6a7r"; + setupHaskellDepends = [ base Cabal cabal-doctest ]; + libraryHaskellDepends = [ array base distributive ghc-prim ]; + doHaddock = false; + doCheck = false; + homepage = "http://github.com/ekmett/intervals"; + description = "Interval Arithmetic"; + license = stdenv.lib.licenses.bsd3; + }) {}; + "intro" = callPackage + ({ mkDerivation, base, binary, bytestring, containers, deepseq + , dlist, extra, hashable, mtl, safe, stdenv, text, transformers + , unordered-containers, writer-cps-mtl + }: + mkDerivation { + pname = "intro"; + version = "0.3.1.0"; + sha256 = "da5e5e2c1a44d935271ad97b921e97be121f85a923152b5d0a756261ba357492"; + libraryHaskellDepends = [ + base binary bytestring containers deepseq dlist extra hashable mtl + safe text transformers unordered-containers writer-cps-mtl + ]; + doHaddock = false; + doCheck = false; + homepage = "https://github.com/minad/intro#readme"; + description = "\"Fixed Prelude\" - Mostly total and safe, provides Text and Monad transformers"; + license = stdenv.lib.licenses.mit; + }) {}; + "invariant" = callPackage + ({ mkDerivation, array, base, bifunctors, comonad, containers + , contravariant, ghc-prim, profunctors, semigroups, StateVar + , stdenv, stm, tagged, template-haskell, th-abstraction + , transformers, transformers-compat, unordered-containers + }: + mkDerivation { + pname = "invariant"; + version = "0.5.1"; + sha256 = "eb8c9c45ad24020af2978f22271458bf3787937d931c50c86b580c53ca3f122b"; + revision = "1"; + editedCabalFile = "100gsacbpal53khj94m5qs4aq70hbsp4dz4065czfm49ysd4yqq4"; + libraryHaskellDepends = [ + array base bifunctors comonad containers contravariant ghc-prim + profunctors semigroups StateVar stm tagged template-haskell + th-abstraction transformers transformers-compat + unordered-containers + ]; + doHaddock = false; + doCheck = false; + homepage = "https://github.com/nfrisby/invariant-functors"; + description = "Haskell98 invariant functors"; + license = stdenv.lib.licenses.bsd2; + }) {}; + "invertible" = callPackage + ({ mkDerivation, base, haskell-src-meta, invariant, lens + , partial-isomorphisms, semigroupoids, stdenv, template-haskell + , transformers + }: + mkDerivation { + pname = "invertible"; + version = "0.2.0.5"; + sha256 = "0a0adaa1f371f739fd2c506ff2ba3c4db278bbdfda0171bd8329d678c15b8dbb"; + libraryHaskellDepends = [ + base haskell-src-meta invariant lens partial-isomorphisms + semigroupoids template-haskell transformers + ]; + doHaddock = false; + doCheck = false; + description = "bidirectional arrows, bijective functions, and invariant functors"; + license = stdenv.lib.licenses.bsd3; + }) {}; + "invertible-grammar" = callPackage + ({ mkDerivation, base, bifunctors, containers, mtl, prettyprinter + , profunctors, semigroups, stdenv, tagged, template-haskell, text + , transformers + }: + mkDerivation { + pname = "invertible-grammar"; + version = "0.1.1"; + sha256 = "29900cf54783b8f67449a7fd45e986efaec6270cb31f3815650e9a0406061bef"; + libraryHaskellDepends = [ + base bifunctors containers mtl prettyprinter profunctors semigroups + tagged template-haskell text transformers + ]; + doHaddock = false; + doCheck = false; + homepage = "https://github.com/esmolanka/invertible-grammar"; + description = "Invertible parsing combinators framework"; + license = stdenv.lib.licenses.bsd3; + }) {}; + "io-choice" = callPackage + ({ mkDerivation, base, lifted-base, monad-control, stdenv + , template-haskell, transformers, transformers-base + }: + mkDerivation { + pname = "io-choice"; + version = "0.0.6"; + sha256 = "612b281110d18615000704f24fdb54a3b4401f7a39dcfe358433d7b4c22e1cef"; + libraryHaskellDepends = [ + base lifted-base monad-control template-haskell transformers + transformers-base + ]; + doHaddock = false; + doCheck = false; + description = "Choice for IO and lifted IO"; + license = stdenv.lib.licenses.bsd3; + }) {}; + "io-machine" = callPackage + ({ mkDerivation, base, stdenv, time }: + mkDerivation { + pname = "io-machine"; + version = "0.2.0.0"; + sha256 = "05dcc8d5fcbb6f0d7f3519488ebf743eaa776bc93c2f8b0d4bbd866ac1331ccb"; + libraryHaskellDepends = [ base time ]; + doHaddock = false; + doCheck = false; + homepage = "https://github.com/YoshikuniJujo/io-machine#readme"; + description = "Easy I/O model to learn IO monad"; + license = stdenv.lib.licenses.bsd3; + }) {}; + "io-manager" = callPackage + ({ mkDerivation, base, containers, stdenv }: + mkDerivation { + pname = "io-manager"; + version = "0.1.0.2"; + sha256 = "bf0aa7740a8aaf31fc4f2570a47957365ae7d9248edd309e694053f1cd804138"; + isLibrary = true; + isExecutable = true; + libraryHaskellDepends = [ base containers ]; + executableHaskellDepends = [ base containers ]; + doHaddock = false; + doCheck = false; + description = "Skeleton library around the IO monad"; + license = stdenv.lib.licenses.bsd3; + }) {}; + "io-memoize" = callPackage + ({ mkDerivation, async, base, stdenv }: + mkDerivation { + pname = "io-memoize"; + version = "1.1.1.0"; + sha256 = "c753a1b1a2fb286bf608d6467e6e7599cde8e641c619885197f298bf1b2f483d"; + libraryHaskellDepends = [ async base ]; + doHaddock = false; + doCheck = false; + homepage = "https://github.com/DanBurton/io-memoize"; + description = "Memoize IO actions"; + license = stdenv.lib.licenses.bsd3; + }) {}; + "io-region" = callPackage + ({ mkDerivation, base, stdenv, stm }: + mkDerivation { + pname = "io-region"; + version = "0.1.1"; + sha256 = "ee303f66c2b3d33fae877b0dbb7c64624109fc759dffa669ca182e387f1015f1"; + libraryHaskellDepends = [ base stm ]; + doHaddock = false; + doCheck = false; + homepage = "https://github.com/Yuras/io-region/wiki"; + description = "Exception safe resource management with dynamic regions"; + license = stdenv.lib.licenses.bsd3; + }) {}; + "io-storage" = callPackage + ({ mkDerivation, base, containers, stdenv }: + mkDerivation { + pname = "io-storage"; + version = "0.3"; + sha256 = "9a0df5cc7ff2eeef11e29e1362fea284f535bc2fe67469bba6dbc41c4f5b49bd"; + libraryHaskellDepends = [ base containers ]; + doHaddock = false; + doCheck = false; + homepage = "http://github.com/willdonnelly/io-storage"; + description = "A key-value store in the IO monad"; + license = stdenv.lib.licenses.bsd3; + }) {}; + "io-streams" = callPackage + ({ mkDerivation, attoparsec, base, bytestring, bytestring-builder + , network, primitive, process, stdenv, text, time, transformers + , vector, zlib-bindings + }: + mkDerivation { + pname = "io-streams"; + version = "1.5.0.1"; + sha256 = "5dcb3717933197a84f31be74abf545126b3d25eb0e0d64f722c480d3c46b2c8b"; + revision = "2"; + editedCabalFile = "1mcab95d6hm098myh9gp7sh10srigjphgvm8s9pfs7jg5hzghy14"; + configureFlags = [ "-fNoInteractiveTests" ]; + libraryHaskellDepends = [ + attoparsec base bytestring bytestring-builder network primitive + process text time transformers vector zlib-bindings + ]; + doHaddock = false; + doCheck = false; + description = "Simple, composable, and easy-to-use stream I/O"; + license = stdenv.lib.licenses.bsd3; + }) {}; + "io-streams-haproxy" = callPackage + ({ mkDerivation, attoparsec, base, bytestring, io-streams, network + , stdenv, transformers + }: + mkDerivation { + pname = "io-streams-haproxy"; + version = "1.0.0.2"; + sha256 = "77814f8258b5c32707a13e0d30ab2e144e7ad073aee821d6def65554024ed086"; + revision = "4"; + editedCabalFile = "06c51a057n5bc9xfbp2m4jz5ds4z1xvmsx5mppch6qfwbz7x5i9l"; + libraryHaskellDepends = [ + attoparsec base bytestring io-streams network transformers + ]; + doHaddock = false; + doCheck = false; + homepage = "http://snapframework.com/"; + description = "HAProxy protocol 1.5 support for io-streams"; + license = stdenv.lib.licenses.bsd3; + }) {}; + "ip" = callPackage + ({ mkDerivation, aeson, attoparsec, base, bytestring, hashable + , primitive, stdenv, text, vector + }: + mkDerivation { + pname = "ip"; + version = "1.3.0"; + sha256 = "9e4c869d00cc8348b4648983627fb05f4b4eb4cc6b51ec72523d0419c81aac81"; + libraryHaskellDepends = [ + aeson attoparsec base bytestring hashable primitive text vector + ]; + doHaddock = false; + doCheck = false; + homepage = "https://github.com/andrewthad/haskell-ip#readme"; + description = "Library for IP and MAC addresses"; + license = stdenv.lib.licenses.bsd3; + }) {}; + "ip6addr" = callPackage + ({ mkDerivation, base, cmdargs, IPv6Addr, stdenv, text }: + mkDerivation { + pname = "ip6addr"; + version = "1.0.0"; + sha256 = "e805be52d77edfb0e71740dbfa57403654cb34929083589d79d44757c01f80f1"; + isLibrary = false; + isExecutable = true; + executableHaskellDepends = [ base cmdargs IPv6Addr text ]; + doHaddock = false; + doCheck = false; + homepage = "https://github.com/MichelBoucey/ip6addr"; + description = "Commandline tool to generate IPv6 address text representations"; + license = stdenv.lib.licenses.bsd3; + }) {}; + "iproute" = callPackage + ({ mkDerivation, appar, base, byteorder, containers, network + , stdenv + }: + mkDerivation { + pname = "iproute"; + version = "1.7.5"; + sha256 = "ed638e0b0a098ee4a0f5c5fe48b2a803939c0be4a3612b2d86e16fa447b581ef"; + libraryHaskellDepends = [ + appar base byteorder containers network + ]; + doHaddock = false; + doCheck = false; + homepage = "http://www.mew.org/~kazu/proj/iproute/"; + description = "IP Routing Table"; + license = stdenv.lib.licenses.bsd3; + }) {}; + "ipython-kernel" = callPackage + ({ mkDerivation, aeson, base, bytestring, cereal, containers + , directory, filepath, mtl, process, SHA, stdenv, temporary, text + , transformers, unordered-containers, uuid, zeromq4-haskell + }: + mkDerivation { + pname = "ipython-kernel"; + version = "0.9.0.2"; + sha256 = "5923468f359c50c2e9313cf1aadc1d0ba09b571a621129ff672f8e337d158206"; + isLibrary = true; + isExecutable = true; + enableSeparateDataOutput = true; + libraryHaskellDepends = [ + aeson base bytestring cereal containers directory filepath mtl + process SHA temporary text transformers unordered-containers uuid + zeromq4-haskell + ]; + doHaddock = false; + doCheck = false; + homepage = "http://github.com/gibiansky/IHaskell"; + description = "A library for creating kernels for IPython frontends"; + license = stdenv.lib.licenses.mit; + }) {}; + "irc" = callPackage + ({ mkDerivation, attoparsec, base, bytestring, stdenv }: + mkDerivation { + pname = "irc"; + version = "0.6.1.0"; + sha256 = "3816ead4dfb32d61c03265e3a2a45053508cb27ca3132595773a27ef381637e1"; + libraryHaskellDepends = [ attoparsec base bytestring ]; + doHaddock = false; + doCheck = false; + description = "A small library for parsing IRC messages"; + license = stdenv.lib.licenses.bsd3; + }) {}; + "irc-client" = callPackage + ({ mkDerivation, base, bytestring, conduit, connection, containers + , contravariant, exceptions, irc-conduit, irc-ctcp, mtl + , network-conduit-tls, old-locale, profunctors, stdenv, stm + , stm-chans, text, time, tls, transformers, x509, x509-store + , x509-validation + }: + mkDerivation { + pname = "irc-client"; + version = "1.1.0.4"; + sha256 = "07c1ef48d6df16da9cb46a3d917810ccd5c40d7337aa0c7291638f3275cde1a9"; + libraryHaskellDepends = [ + base bytestring conduit connection containers contravariant + exceptions irc-conduit irc-ctcp mtl network-conduit-tls old-locale + profunctors stm stm-chans text time tls transformers x509 + x509-store x509-validation + ]; + doHaddock = false; + doCheck = false; + homepage = "https://github.com/barrucadu/irc-client"; + description = "An IRC client library"; + license = stdenv.lib.licenses.mit; + }) {}; + "irc-conduit" = callPackage + ({ mkDerivation, async, base, bytestring, conduit, conduit-extra + , connection, irc, irc-ctcp, network-conduit-tls, profunctors + , stdenv, text, time, tls, transformers, x509-validation + }: + mkDerivation { + pname = "irc-conduit"; + version = "0.3.0.1"; + sha256 = "b0a8f935eb3b4613e74efce7a913592f72835194b8977271f35eb09c578b3b52"; + libraryHaskellDepends = [ + async base bytestring conduit conduit-extra connection irc irc-ctcp + network-conduit-tls profunctors text time tls transformers + x509-validation + ]; + doHaddock = false; + doCheck = false; + homepage = "https://github.com/barrucadu/irc-conduit"; + description = "Streaming IRC message library using conduits"; + license = stdenv.lib.licenses.mit; + }) {}; + "irc-ctcp" = callPackage + ({ mkDerivation, base, bytestring, stdenv, text }: + mkDerivation { + pname = "irc-ctcp"; + version = "0.1.3.0"; + sha256 = "d67cd91a5521173565033777cea76636e4d2be6e6224f681392d9e726f4bb79a"; + libraryHaskellDepends = [ base bytestring text ]; + doHaddock = false; + doCheck = false; + homepage = "https://github.com/barrucadu/irc-ctcp"; + description = "A CTCP encoding and decoding library for IRC clients"; + license = stdenv.lib.licenses.mit; + }) {}; + "irc-dcc" = callPackage + ({ mkDerivation, attoparsec, base, binary, bytestring, io-streams + , iproute, irc-ctcp, mtl, network, path, safe-exceptions, stdenv + , transformers, utf8-string + }: + mkDerivation { + pname = "irc-dcc"; + version = "2.0.1"; + sha256 = "6408a28733743d3463664677c5e3ad72e46c168799dad458988067039f25d2df"; + revision = "8"; + editedCabalFile = "1ya1bl8pdzbs3gxkq7hsyvkaajf8prrdhr1lx5hm9pi1nqsi879z"; + libraryHaskellDepends = [ + attoparsec base binary bytestring io-streams iproute irc-ctcp mtl + network path safe-exceptions transformers utf8-string + ]; + doHaddock = false; + doCheck = false; + homepage = "https://github.com/JanGe/irc-dcc"; + description = "A DCC message parsing and helper library for IRC clients"; + license = stdenv.lib.licenses.mit; + }) {}; + "islink" = callPackage + ({ mkDerivation, base, stdenv, unordered-containers }: + mkDerivation { + pname = "islink"; + version = "0.1.0.0"; + sha256 = "cfbf9c1a6dc46327b7ed7bf9336e245a255626c9d04aeba3d887d90f26d2aed7"; + libraryHaskellDepends = [ base unordered-containers ]; + doHaddock = false; + doCheck = false; + homepage = "https://github.com/redneb/islink"; + description = "Check if an HTML element is a link"; + license = stdenv.lib.licenses.bsd3; + }) {}; + "iso3166-country-codes" = callPackage + ({ mkDerivation, base, stdenv }: + mkDerivation { + pname = "iso3166-country-codes"; + version = "0.20140203.8"; + sha256 = "b4d6e01cd61bcaef9a8e455c331a8e7a2298531cb587ef6f23675eae7a6b0a36"; + revision = "1"; + editedCabalFile = "0n01pmvkqi0w9l203i1v7kb6bb867plv4h5hmzlkpnhrf5abf0zf"; + libraryHaskellDepends = [ base ]; + doHaddock = false; + doCheck = false; + description = "A datatype for ISO 3166 country codes"; + license = "LGPL"; + }) {}; + "iso639" = callPackage + ({ mkDerivation, base, stdenv }: + mkDerivation { + pname = "iso639"; + version = "0.1.0.3"; + sha256 = "124b8322fabaedb4de3dbc39880b36d0eab0e28d5775954aadb6630bc0da25e8"; + libraryHaskellDepends = [ base ]; + doHaddock = false; + doCheck = false; + homepage = "https://github.com/HugoDaniel/iso639"; + description = "ISO-639-1 language codes"; + license = stdenv.lib.licenses.bsd3; + }) {}; + "iso8601-time" = callPackage + ({ mkDerivation, base, stdenv, time }: + mkDerivation { + pname = "iso8601-time"; + version = "0.1.5"; + sha256 = "f2cd444b2be68402c773a4b451912817f06d33093aea691b42ebeed3630ff0c8"; + libraryHaskellDepends = [ base time ]; + doHaddock = false; + doCheck = false; + homepage = "https://github.com/nh2/iso8601-time"; + description = "Convert to/from the ISO 8601 time format"; + license = stdenv.lib.licenses.mit; + }) {}; + "iterable" = callPackage + ({ mkDerivation, base, mtl, stdenv, tagged, template-haskell + , vector + }: + mkDerivation { + pname = "iterable"; + version = "3.0"; + sha256 = "6cd13d621144e937cc88acfed1663bd2e208dcbe54be4bad1f7b7279250a87a4"; + enableSeparateDataOutput = true; + libraryHaskellDepends = [ + base mtl tagged template-haskell vector + ]; + doHaddock = false; + doCheck = false; + homepage = "https://github.com/BioHaskell/iterable"; + description = "API for hierarchical multilevel collections"; + license = stdenv.lib.licenses.bsd3; + }) {}; + "ix-shapable" = callPackage + ({ mkDerivation, array, base, stdenv }: + mkDerivation { + pname = "ix-shapable"; + version = "0.1.0"; + sha256 = "5007ffb6a8a7bb490f962cedceed5ceb7c435126d09bc565441070cbfda79222"; + libraryHaskellDepends = [ array base ]; + doHaddock = false; + doCheck = false; + description = "Reshape multi-dimensional arrays"; + license = stdenv.lib.licenses.bsd3; + }) {}; + "ixset-typed" = callPackage + ({ mkDerivation, base, containers, deepseq, safecopy, stdenv, syb + , template-haskell + }: + mkDerivation { + pname = "ixset-typed"; + version = "0.4"; + sha256 = "4aa500595aabda4a9a9099f4b801549853d4ba1936b25e5a64e692ebe53e5276"; + revision = "1"; + editedCabalFile = "1ldf6bkm085idwp8a8ppxvyawii4gbhyw1pwrcyi3n8jpjh8hqcq"; + libraryHaskellDepends = [ + base containers deepseq safecopy syb template-haskell + ]; + doHaddock = false; + doCheck = false; + description = "Efficient relational queries on Haskell sets"; + license = stdenv.lib.licenses.bsd3; + }) {}; + "jack" = callPackage + ({ mkDerivation, array, base, bytestring, enumset, event-list + , explicit-exception, libjack2, midi, non-negative, semigroups + , stdenv, transformers + }: + mkDerivation { + pname = "jack"; + version = "0.7.1.3"; + sha256 = "8cbc488ebfdb359d55f89b2ace9ea233c3875b359bee300f6171233ca6b51fd8"; + isLibrary = true; + isExecutable = true; + libraryHaskellDepends = [ + array base bytestring enumset event-list explicit-exception midi + non-negative semigroups transformers + ]; + libraryPkgconfigDepends = [ libjack2 ]; + doHaddock = false; + doCheck = false; + homepage = "http://www.haskell.org/haskellwiki/JACK"; + description = "Bindings for the JACK Audio Connection Kit"; + license = "GPL"; + }) {inherit (pkgs) libjack2;}; + "jailbreak-cabal" = callPackage + ({ mkDerivation, base, Cabal, stdenv }: + mkDerivation { + pname = "jailbreak-cabal"; + version = "1.3.3"; + sha256 = "6bac08ad1a1ff7452a2963272f96f5de0a3df200fb3219dde6ee93e4963dd01c"; + revision = "3"; + editedCabalFile = "0f4gqssh2ayl089zzl8m5rwa66x430dg1q5hfwcfd56r6xr6wi1l"; + isLibrary = false; + isExecutable = true; + executableHaskellDepends = [ base Cabal ]; + doHaddock = false; + doCheck = false; + homepage = "https://github.com/peti/jailbreak-cabal#readme"; + description = "Strip version restrictions from Cabal files"; + license = stdenv.lib.licenses.bsd3; + }) {}; + "jmacro" = callPackage + ({ mkDerivation, aeson, base, bytestring, containers + , haskell-src-exts, haskell-src-meta, mtl, parseargs, parsec + , regex-posix, safe, stdenv, syb, template-haskell, text + , unordered-containers, vector, wl-pprint-text + }: + mkDerivation { + pname = "jmacro"; + version = "0.6.15"; + sha256 = "fae43fec6f4ba9ebc1fbd5605fc1b65b1c80bb0869bcfcd80d417e6d82cb6cac"; + revision = "1"; + editedCabalFile = "07jghfxn4m26q8rksxn4v6pcc8mwcjdlz1ypy7dqsvhzc3hs2s4i"; + isLibrary = true; + isExecutable = true; + libraryHaskellDepends = [ + aeson base bytestring containers haskell-src-exts haskell-src-meta + mtl parsec regex-posix safe syb template-haskell text + unordered-containers vector wl-pprint-text + ]; + executableHaskellDepends = [ + aeson base bytestring containers haskell-src-exts haskell-src-meta + mtl parseargs parsec regex-posix safe syb template-haskell text + unordered-containers vector wl-pprint-text + ]; + doHaddock = false; + doCheck = false; + description = "QuasiQuotation library for programmatic generation of Javascript code"; + license = stdenv.lib.licenses.bsd3; + }) {}; + "jmacro-rpc" = callPackage + ({ mkDerivation, aeson, attoparsec, base, blaze-html, bytestring + , containers, contravariant, jmacro, mtl, scientific, split, stdenv + , text, unordered-containers, vector + }: + mkDerivation { + pname = "jmacro-rpc"; + version = "0.3.3"; + sha256 = "ee912cdc6970ae6e71874e460eb40206f107371c2764f53777624a483cda1e3f"; + libraryHaskellDepends = [ + aeson attoparsec base blaze-html bytestring containers + contravariant jmacro mtl scientific split text unordered-containers + vector + ]; + doHaddock = false; + doCheck = false; + homepage = "http://hub.darcs.net/gershomb/jmacro"; + description = "JSON-RPC clients and servers using JMacro, and evented client-server Reactive Programming"; + license = stdenv.lib.licenses.bsd3; + }) {}; + "jmacro-rpc-snap" = callPackage + ({ mkDerivation, aeson, base, bytestring, containers, jmacro + , jmacro-rpc, mtl, snap-core, stdenv + }: + mkDerivation { + pname = "jmacro-rpc-snap"; + version = "0.3"; + sha256 = "48aea4a4ba90532ca105b6b274060a47a1c509b8346e0db1b61365c2a9e8dfeb"; + libraryHaskellDepends = [ + aeson base bytestring containers jmacro jmacro-rpc mtl snap-core + ]; + doHaddock = false; + doCheck = false; + homepage = "http://hub.darcs.net/gershomb/jmacro-rpc"; + description = "Snap backend for jmacro-rpc"; + license = stdenv.lib.licenses.bsd3; + }) {}; + "jose" = callPackage + ({ mkDerivation, aeson, attoparsec, base, base64-bytestring + , bytestring, concise, containers, cryptonite, lens, memory + , monad-time, mtl, network-uri, QuickCheck, quickcheck-instances + , safe, semigroups, stdenv, template-haskell, text, time + , unordered-containers, vector, x509 + }: + mkDerivation { + pname = "jose"; + version = "0.7.0.0"; + sha256 = "8cd90a1a205c2dd7d8ab5e37caf4889192820128f01f9164aaefc7a91d963914"; + isLibrary = true; + isExecutable = true; + libraryHaskellDepends = [ + aeson attoparsec base base64-bytestring bytestring concise + containers cryptonite lens memory monad-time mtl network-uri + QuickCheck quickcheck-instances safe semigroups template-haskell + text time unordered-containers vector x509 + ]; + executableHaskellDepends = [ aeson base bytestring lens mtl ]; + doHaddock = false; + doCheck = false; + homepage = "https://github.com/frasertweedale/hs-jose"; + description = "Javascript Object Signing and Encryption and JSON Web Token library"; + license = stdenv.lib.licenses.asl20; + }) {}; + "jose-jwt" = callPackage + ({ mkDerivation, aeson, attoparsec, base, bytestring, cereal + , containers, cryptonite, either, memory, mtl, stdenv, text, time + , transformers, transformers-compat, unordered-containers, vector + }: + mkDerivation { + pname = "jose-jwt"; + version = "0.7.8"; + sha256 = "d3e1693e28d2de4914011a4f573070b02a71c8e40c142c9ab8b00c8629c5f32b"; + libraryHaskellDepends = [ + aeson attoparsec base bytestring cereal containers cryptonite + either memory mtl text time transformers transformers-compat + unordered-containers vector + ]; + doHaddock = false; + doCheck = false; + homepage = "http://github.com/tekul/jose-jwt"; + description = "JSON Object Signing and Encryption Library"; + license = stdenv.lib.licenses.bsd3; + }) {}; + "js-flot" = callPackage + ({ mkDerivation, base, stdenv }: + mkDerivation { + pname = "js-flot"; + version = "0.8.3"; + sha256 = "1ba2f2a6b8d85da76c41f526c98903cbb107f8642e506c072c1e7e3c20fe5e7a"; + enableSeparateDataOutput = true; + libraryHaskellDepends = [ base ]; + doHaddock = false; + doCheck = false; + homepage = "https://github.com/ndmitchell/js-flot#readme"; + description = "Obtain minified flot code"; + license = stdenv.lib.licenses.mit; + }) {}; + "js-jquery" = callPackage + ({ mkDerivation, base, stdenv }: + mkDerivation { + pname = "js-jquery"; + version = "3.3.1"; + sha256 = "e0e0681f0da1130ede4e03a051630ea439c458cb97216cdb01771ebdbe44069b"; + enableSeparateDataOutput = true; + libraryHaskellDepends = [ base ]; + doHaddock = false; + doCheck = false; + homepage = "https://github.com/ndmitchell/js-jquery#readme"; + description = "Obtain minified jQuery code"; + license = stdenv.lib.licenses.mit; + }) {}; + "json" = callPackage + ({ mkDerivation, array, base, bytestring, containers, mtl, parsec + , pretty, stdenv, syb, text + }: + mkDerivation { + pname = "json"; + version = "0.9.2"; + sha256 = "e6bb16fa791cc3833ae7b459b7e7885c1c2b11b0d294b7e095287c54fa73738e"; + libraryHaskellDepends = [ + array base bytestring containers mtl parsec pretty syb text + ]; + doHaddock = false; + doCheck = false; + description = "Support for serialising Haskell to and from JSON"; + license = stdenv.lib.licenses.bsd3; + }) {}; + "json-autotype" = callPackage + ({ mkDerivation, aeson, base, bytestring, containers, filepath + , GenericPretty, hashable, lens, mtl, optparse-applicative, pretty + , process, scientific, stdenv, text, uniplate, unordered-containers + , vector, yaml + }: + mkDerivation { + pname = "json-autotype"; + version = "2.0.0"; + sha256 = "c8f4a45a495e534d51d7c3b045894d586ca6d9d2602ffe3fd6418c84c81c3756"; + revision = "1"; + editedCabalFile = "00wbcq9bx6sq6i5756ja6pf016xbpk2kflq20ncdv76zycxdkqnm"; + isLibrary = true; + isExecutable = true; + libraryHaskellDepends = [ + aeson base containers filepath GenericPretty hashable lens mtl + pretty process scientific text uniplate unordered-containers vector + ]; + executableHaskellDepends = [ + aeson base bytestring containers filepath GenericPretty hashable + lens mtl optparse-applicative pretty process scientific text + uniplate unordered-containers vector yaml + ]; + doHaddock = false; + doCheck = false; + homepage = "https://github.com/mgajda/json-autotype"; + description = "Automatic type declaration for JSON input data"; + license = stdenv.lib.licenses.bsd3; + }) {}; + "json-feed" = callPackage + ({ mkDerivation, aeson, base, bytestring, mime-types, network-uri + , stdenv, tagsoup, text, time + }: + mkDerivation { + pname = "json-feed"; + version = "1.0.3"; + sha256 = "a0c04b49c0f499070e2eb80784139f9a85729d4fdcfea15f71c099a634e1c623"; + libraryHaskellDepends = [ + aeson base bytestring mime-types network-uri tagsoup text time + ]; + doHaddock = false; + doCheck = false; + homepage = "https://github.com/tfausak/json-feed#readme"; + description = "JSON Feed"; + license = stdenv.lib.licenses.mit; + }) {}; + "json-rpc-client" = callPackage + ({ mkDerivation, aeson, base, bytestring, json-rpc-server, mtl + , stdenv, text, unordered-containers, vector, vector-algorithms + }: + mkDerivation { + pname = "json-rpc-client"; + version = "0.2.5.0"; + sha256 = "5349f5c0b0fa8f6c5433152d6effc10846cfb3480e78c5aa99adb7540bcff49c"; + revision = "9"; + editedCabalFile = "04b65m8lhk2g2d5x5i637ff3wkgvf4z6dhn5x1pizsj9y3aq35zm"; + isLibrary = true; + isExecutable = true; + libraryHaskellDepends = [ + aeson base bytestring json-rpc-server mtl text unordered-containers + vector vector-algorithms + ]; + doHaddock = false; + doCheck = false; + homepage = "https://github.com/grayjay/json-rpc-client"; + description = "JSON-RPC 2.0 on the client side."; + license = stdenv.lib.licenses.mit; + }) {}; + "json-rpc-generic" = callPackage + ({ mkDerivation, aeson, aeson-generic-compat, base, containers + , dlist, scientific, stdenv, text, transformers + , unordered-containers, vector + }: + mkDerivation { + pname = "json-rpc-generic"; + version = "0.2.1.4"; + sha256 = "741e68586714f163cc044634c718a3b940ffac3271c9e6beaaa96257585f2b7e"; + libraryHaskellDepends = [ + aeson aeson-generic-compat base containers dlist scientific text + transformers unordered-containers vector + ]; + doHaddock = false; + doCheck = false; + homepage = "http://github.com/khibino/haskell-json-rpc-generic"; + description = "Generic encoder and decode for JSON-RPC"; + license = stdenv.lib.licenses.bsd3; + }) {}; + "json-rpc-server" = callPackage + ({ mkDerivation, aeson, base, bytestring, deepseq, mtl, stdenv + , text, unordered-containers, vector + }: + mkDerivation { + pname = "json-rpc-server"; + version = "0.2.6.0"; + sha256 = "169e9997734bd1d7d07a13b5ae0223d5363c43de93b0d5fbb845a598f9eaccf5"; + revision = "6"; + editedCabalFile = "1rfabr679pk605v141gm0ynbp3l6x87s3ip3wa49lwnpab495mxs"; + isLibrary = true; + isExecutable = true; + libraryHaskellDepends = [ + aeson base bytestring deepseq mtl text unordered-containers vector + ]; + doHaddock = false; + doCheck = false; + homepage = "https://github.com/grayjay/json-rpc-server"; + description = "JSON-RPC 2.0 on the server side."; + license = stdenv.lib.licenses.mit; + }) {}; + "json-schema" = callPackage + ({ mkDerivation, aeson, base, base-compat-batteries, containers + , generic-aeson, generic-deriving, mtl, scientific, stdenv, text + , time, unordered-containers, vector + }: + mkDerivation { + pname = "json-schema"; + version = "0.7.4.2"; + sha256 = "e872038810b6befd18cc6a29d315ad2099f81a112b71fa5a2662070c00636f25"; + revision = "1"; + editedCabalFile = "0pwmh48z54n0mrwzmgff95mwy1jbmy1rwsk5kmddby86f0j5873g"; + libraryHaskellDepends = [ + aeson base base-compat-batteries containers generic-aeson + generic-deriving mtl scientific text time unordered-containers + vector + ]; + doHaddock = false; + doCheck = false; + description = "Types and type classes for defining JSON schemas"; + license = stdenv.lib.licenses.bsd3; + }) {}; + "justified-containers" = callPackage + ({ mkDerivation, base, containers, roles, stdenv }: + mkDerivation { + pname = "justified-containers"; + version = "0.3.0.0"; + sha256 = "d830c0ccd036e98ec6bab2bd336bb0bd580ce0495dedf3bf2176bd8084733e87"; + libraryHaskellDepends = [ base containers roles ]; + doHaddock = false; + doCheck = false; + homepage = "https://github.com/matt-noonan/justified-containers"; + description = "Keyed container types with type-checked proofs of key presence"; + license = stdenv.lib.licenses.bsd2; + }) {}; + "jwt" = callPackage + ({ mkDerivation, aeson, base, bytestring, containers, cryptonite + , data-default, http-types, memory, network-uri, scientific + , semigroups, stdenv, text, time, unordered-containers, vector + }: + mkDerivation { + pname = "jwt"; + version = "0.7.2"; + sha256 = "17967413d21399596a236bc8169d9e030bb85e2b1c349c6e470543767cc20a31"; + revision = "1"; + editedCabalFile = "1q8h94yslw6k6zcjbwx94pnji8dcr2w5n1wzgzfb8hb78w2qr1dm"; + libraryHaskellDepends = [ + aeson base bytestring containers cryptonite data-default http-types + memory network-uri scientific semigroups text time + unordered-containers vector + ]; + doHaddock = false; + doCheck = false; + homepage = "https://bitbucket.org/ssaasen/haskell-jwt"; + description = "JSON Web Token (JWT) decoding and encoding"; + license = stdenv.lib.licenses.mit; + }) {}; + "kan-extensions" = callPackage + ({ mkDerivation, adjunctions, array, base, comonad, containers + , contravariant, distributive, free, invariant, mtl, profunctors + , semigroupoids, stdenv, tagged, transformers, transformers-compat + }: + mkDerivation { + pname = "kan-extensions"; + version = "5.2"; + sha256 = "6b727e586f744b96529415eeabc745dfe05feea61f6b6bad90c224c879f4dbd3"; + libraryHaskellDepends = [ + adjunctions array base comonad containers contravariant + distributive free invariant mtl profunctors semigroupoids tagged + transformers transformers-compat + ]; + doHaddock = false; + doCheck = false; + homepage = "http://github.com/ekmett/kan-extensions/"; + description = "Kan extensions, Kan lifts, the Yoneda lemma, and (co)density (co)monads"; + license = stdenv.lib.licenses.bsd3; + }) {}; + "kanji" = callPackage + ({ mkDerivation, aeson, aeson-pretty, base, containers, deepseq + , hashable, microlens, microlens-aeson, optparse-applicative + , stdenv, text, transformers + }: + mkDerivation { + pname = "kanji"; + version = "3.4.0"; + sha256 = "d945ded925216b8f260c62c2fce593631d772bffa1f203550a6b9750ca3a81f1"; + revision = "2"; + editedCabalFile = "1bcc3kh6kndmkqi3vaxp27mg1qb7xbg1h8pgjc1kk1iawnhl930j"; + isLibrary = true; + isExecutable = true; + libraryHaskellDepends = [ + aeson base containers deepseq hashable text + ]; + executableHaskellDepends = [ + aeson aeson-pretty base containers microlens microlens-aeson + optparse-applicative text transformers + ]; + doHaddock = false; + doCheck = false; + homepage = "https://github.com/fosskers/kanji"; + description = "Perform 漢字検定 (Japan Kanji Aptitude Test) level analysis on Japanese Kanji"; + license = stdenv.lib.licenses.bsd3; + }) {}; + "kansas-comet" = callPackage + ({ mkDerivation, aeson, base, containers, data-default-class + , scotty, stdenv, stm, text, time, transformers + , unordered-containers + }: + mkDerivation { + pname = "kansas-comet"; + version = "0.4"; + sha256 = "1f1a4565f2e955b8947bafcb9611789b0ccdf9efdfed8aaa2a2aa162a07339e1"; + revision = "16"; + editedCabalFile = "1fnncjd9wjwrnl0247gizlvwklihjbfk21pad6a4mqnaa3li5672"; + enableSeparateDataOutput = true; + libraryHaskellDepends = [ + aeson base containers data-default-class scotty stm text time + transformers unordered-containers + ]; + doHaddock = false; + doCheck = false; + homepage = "https://github.com/ku-fpg/kansas-comet/"; + description = "A JavaScript push mechanism based on the comet idiom"; + license = stdenv.lib.licenses.bsd3; + }) {}; + "kawhi" = callPackage + ({ mkDerivation, aeson, base, bytestring, exceptions, http-client + , http-conduit, http-types, mtl, safe, scientific, stdenv, text + }: + mkDerivation { + pname = "kawhi"; + version = "0.3.0"; + sha256 = "2321387a3ddaa17c09db3a8e7a41a39f8e211467bd80bccd73791de8fca2a44f"; + libraryHaskellDepends = [ + aeson base bytestring exceptions http-client http-conduit + http-types mtl safe scientific text + ]; + doHaddock = false; + doCheck = false; + homepage = "https://github.com/thunky-monk/kawhi"; + description = "stats.NBA.com library"; + license = stdenv.lib.licenses.mit; + }) {}; + "kdt" = callPackage + ({ mkDerivation, base, deepseq, deepseq-generics, heap, stdenv }: + mkDerivation { + pname = "kdt"; + version = "0.2.4"; + sha256 = "bc0f8f9ac0cb01466273171f47b627abe170d1130bd59657fb9198b4f9479f9a"; + libraryHaskellDepends = [ base deepseq deepseq-generics heap ]; + doHaddock = false; + doCheck = false; + homepage = "https://github.com/giogadi/kdt"; + description = "Fast and flexible k-d trees for various types of point queries"; + license = stdenv.lib.licenses.mit; + }) {}; + "keycode" = callPackage + ({ mkDerivation, base, containers, ghc-prim, stdenv + , template-haskell + }: + mkDerivation { + pname = "keycode"; + version = "0.2.2"; + sha256 = "56f9407cf182b01e5f0fda80f569ff629f37d894f75ef28b6b8af3024343d310"; + revision = "3"; + editedCabalFile = "18dgbpf3xwdm3x9j63vsr5q7l028qvifgc6jmjf1ar4p2wv1fzz0"; + libraryHaskellDepends = [ + base containers ghc-prim template-haskell + ]; + doHaddock = false; + doCheck = false; + homepage = "https://github.com/RyanGlScott/keycode"; + description = "Maps web browser keycodes to their corresponding keyboard keys"; + license = stdenv.lib.licenses.bsd3; + }) {}; + "keys" = callPackage + ({ mkDerivation, array, base, comonad, containers, free, hashable + , semigroupoids, semigroups, stdenv, tagged, transformers + , transformers-compat, unordered-containers + }: + mkDerivation { + pname = "keys"; + version = "3.12.1"; + sha256 = "7fcea48187df82c02c159dea07a581cddf371023e6a3c34de7fa69a8ef2315fb"; + libraryHaskellDepends = [ + array base comonad containers free hashable semigroupoids + semigroups tagged transformers transformers-compat + unordered-containers + ]; + doHaddock = false; + doCheck = false; + homepage = "http://github.com/ekmett/keys/"; + description = "Keyed functors and containers"; + license = stdenv.lib.licenses.bsd3; + }) {}; + "kleene" = callPackage + ({ mkDerivation, base, base-compat-batteries, containers, lattices + , MemoTrie, QuickCheck, range-set-list, regex-applicative, stdenv + , step-function, text, transformers + }: + mkDerivation { + pname = "kleene"; + version = "0"; + sha256 = "c652aecfb2a42fec6b7cc0135fe95764a27fe099c6934071ef5fa55075cd0b02"; + revision = "1"; + editedCabalFile = "1izdmr7a2d7qssnj732m2qc02inm3hrc882x9nyvz68648pvwwsx"; + libraryHaskellDepends = [ + base base-compat-batteries containers lattices MemoTrie QuickCheck + range-set-list regex-applicative step-function text transformers + ]; + doHaddock = false; + doCheck = false; + homepage = "https://github.com/phadej/kleene"; + description = "Kleene algebra"; + license = stdenv.lib.licenses.bsd3; + }) {}; + "kmeans" = callPackage + ({ mkDerivation, base, stdenv }: + mkDerivation { + pname = "kmeans"; + version = "0.1.3"; + sha256 = "3d9e24a12ce01354c2a731ee079144c3bea2c9f011ffd51db82e5c26da1a2c0b"; + libraryHaskellDepends = [ base ]; + doHaddock = false; + doCheck = false; + description = "K-means clustering algorithm"; + license = stdenv.lib.licenses.bsd3; + }) {}; + "koofr-client" = callPackage + ({ mkDerivation, aeson, base, bytestring, filepath, http-client + , http-client-tls, http-types, mtl, stdenv + }: + mkDerivation { + pname = "koofr-client"; + version = "1.0.0.3"; + sha256 = "2ab6f0af8be4f1912ad06ad860db993f9c33c8f0206f87ff0b566b7dda54e7af"; + revision = "1"; + editedCabalFile = "0qaipcg9n93z0za2a8jy3mv73a3q2b1dv98v2g5wwcv1qx7rvvhv"; + libraryHaskellDepends = [ + aeson base bytestring filepath http-client http-client-tls + http-types mtl + ]; + doHaddock = false; + doCheck = false; + homepage = "https://github.com/edofic/koofr-api-hs"; + description = "Client to Koofr API"; + license = stdenv.lib.licenses.mit; + }) {}; + "kraken" = callPackage + ({ mkDerivation, aeson, base, bytestring, http-client + , http-client-tls, mtl, stdenv + }: + mkDerivation { + pname = "kraken"; + version = "0.1.0"; + sha256 = "335ce7cb85f7d3ed71eb067ad9642d13d2ca1d62ce8670596c8b69aacc27828a"; + revision = "2"; + editedCabalFile = "141qx2fb3dimv20qsl2q1bagwcn9i0r72z2ha1w7191m557in319"; + libraryHaskellDepends = [ + aeson base bytestring http-client http-client-tls mtl + ]; + doHaddock = false; + doCheck = false; + description = "Kraken.io API client"; + license = stdenv.lib.licenses.mit; + }) {}; + "l10n" = callPackage + ({ mkDerivation, base, stdenv, text, time }: + mkDerivation { + pname = "l10n"; + version = "0.1.0.1"; + sha256 = "0a7032476d257981eb7c274600bef809b4a515ab162a1772a7887f0113455ca0"; + libraryHaskellDepends = [ base text time ]; + doHaddock = false; + doCheck = false; + homepage = "https://github.com/louispan/l10n#readme"; + description = "Enables providing localization as typeclass instances in separate files"; + license = stdenv.lib.licenses.bsd3; + }) {}; + "labels" = callPackage + ({ mkDerivation, base, stdenv, template-haskell }: + mkDerivation { + pname = "labels"; + version = "0.3.3"; + sha256 = "e6b4c02b5340c68b911fd2df157766260e06939ad2919f555339356613433013"; + libraryHaskellDepends = [ base template-haskell ]; + doHaddock = false; + doCheck = false; + homepage = "https://github.com/chrisdone/labels#readme"; + description = "Anonymous records via named tuples"; + license = stdenv.lib.licenses.bsd3; + }) {}; + "lackey" = callPackage + ({ mkDerivation, base, servant, servant-foreign, stdenv, text }: + mkDerivation { + pname = "lackey"; + version = "1.0.5"; + sha256 = "c3e53667fcdc74b0d6cec072de9fc9440a045927d99a282e5cb3e923efc5b147"; + libraryHaskellDepends = [ base servant servant-foreign text ]; + doHaddock = false; + doCheck = false; + homepage = "https://github.com/tfausak/lackey#readme"; + description = "Generate Ruby clients from Servant APIs"; + license = stdenv.lib.licenses.mit; + }) {}; + "lambdabot-core" = callPackage + ({ mkDerivation, base, binary, bytestring, containers + , dependent-map, dependent-sum, dependent-sum-template, directory + , edit-distance, filepath, haskeline, hslogger, HTTP, lifted-base + , monad-control, mtl, network, parsec, prim-uniq, random, random-fu + , random-source, regex-tdfa, SafeSemaphore, split, stdenv, syb + , template-haskell, time, transformers, transformers-base, unix + , utf8-string, zlib + }: + mkDerivation { + pname = "lambdabot-core"; + version = "5.1.0.2"; + sha256 = "c104f2294b1a4436c96c17616056335ef91137ff45de837732813515d7c40cd8"; + libraryHaskellDepends = [ + base binary bytestring containers dependent-map dependent-sum + dependent-sum-template directory edit-distance filepath haskeline + hslogger HTTP lifted-base monad-control mtl network parsec + prim-uniq random random-fu random-source regex-tdfa SafeSemaphore + split syb template-haskell time transformers transformers-base unix + utf8-string zlib + ]; + doHaddock = false; + doCheck = false; + homepage = "https://wiki.haskell.org/Lambdabot"; + description = "Lambdabot core functionality"; + license = "GPL"; + }) {}; + "lambdabot-irc-plugins" = callPackage + ({ mkDerivation, base, bytestring, containers, directory, filepath + , lambdabot-core, lifted-base, mtl, network, SafeSemaphore, split + , stdenv, time + }: + mkDerivation { + pname = "lambdabot-irc-plugins"; + version = "5.1.0.1"; + sha256 = "4e50f2430da752ac36e23cf87ce5b2db9e42cf2e76b48447d2fbc882cdeab1ab"; + libraryHaskellDepends = [ + base bytestring containers directory filepath lambdabot-core + lifted-base mtl network SafeSemaphore split time + ]; + doHaddock = false; + doCheck = false; + homepage = "https://wiki.haskell.org/Lambdabot"; + description = "IRC plugins for lambdabot"; + license = "GPL"; + }) {}; + "lame" = callPackage + ({ mkDerivation, base, bytestring, data-default-class, directory + , exceptions, filepath, mp3lame, stdenv, text, transformers, wave + }: + mkDerivation { + pname = "lame"; + version = "0.1.1"; + sha256 = "b36009a35c02f7f18b4ba91d9ead7e5b47aef4eb5c0d014d4d60dd0bddfd6548"; + revision = "4"; + editedCabalFile = "0r364limqm570a8xd82wwpcvmcx2j7nfndg5kad022vz2v5n0smz"; + enableSeparateDataOutput = true; + libraryHaskellDepends = [ + base bytestring data-default-class directory exceptions filepath + text transformers wave + ]; + librarySystemDepends = [ mp3lame ]; + doHaddock = false; + doCheck = false; + homepage = "https://github.com/mrkkrp/lame"; + description = "Fairly complete high-level binding to LAME encoder"; + license = stdenv.lib.licenses.bsd3; + }) {inherit (pkgs) mp3lame;}; + "language-c" = callPackage + ({ mkDerivation, alex, array, base, bytestring, containers, deepseq + , directory, filepath, happy, pretty, process, stdenv, syb + }: + mkDerivation { + pname = "language-c"; + version = "0.8.1"; + sha256 = "6dd42c9518d22f239bc1add06c145a59e72da75c929ada984be6220c8194b369"; + revision = "2"; + editedCabalFile = "08h8a747k68nbv2mmbjlq2y2pqs738v8z54glrrh94963b2bh4h1"; + libraryHaskellDepends = [ + array base bytestring containers deepseq directory filepath pretty + process syb + ]; + libraryToolDepends = [ alex happy ]; + doHaddock = false; + doCheck = false; + homepage = "http://visq.github.io/language-c/"; + description = "Analysis and generation of C code"; + license = stdenv.lib.licenses.bsd3; + }) {}; + "language-c-quote" = callPackage + ({ mkDerivation, alex, array, base, bytestring, containers + , exception-mtl, exception-transformers, filepath, happy + , haskell-src-meta, mainland-pretty, mtl, srcloc, stdenv, syb + , symbol, template-haskell + }: + mkDerivation { + pname = "language-c-quote"; + version = "0.12.2"; + sha256 = "eb319b4d1154f88f4d0f8817c85efad34c14d774c47d4c9193c89c9064cb8695"; + revision = "1"; + editedCabalFile = "099w1lln1vm000sf06wrmq6gya5sx2w4flrlwqz2c8wwvv8c9j9h"; + libraryHaskellDepends = [ + array base bytestring containers exception-mtl + exception-transformers filepath haskell-src-meta mainland-pretty + mtl srcloc syb symbol template-haskell + ]; + libraryToolDepends = [ alex happy ]; + doHaddock = false; + doCheck = false; + homepage = "https://github.com/mainland/language-c-quote"; + description = "C/CUDA/OpenCL/Objective-C quasiquoting library"; + license = stdenv.lib.licenses.bsd3; + }) {}; + "language-docker" = callPackage + ({ mkDerivation, base, bytestring, containers, free, megaparsec + , mtl, prettyprinter, split, stdenv, template-haskell, text + , th-lift, time + }: + mkDerivation { + pname = "language-docker"; + version = "6.0.4"; + sha256 = "8111f95648723df0a31fbf0424536e24dbe3a95996c013aed8f1c0a03ac534af"; + revision = "1"; + editedCabalFile = "0la3l8m32zmgb4nk4fwchy1abip0k1b0x1i9205dih136g1iaq62"; + libraryHaskellDepends = [ + base bytestring containers free megaparsec mtl prettyprinter split + template-haskell text th-lift time + ]; + doHaddock = false; + doCheck = false; + homepage = "https://github.com/hadolint/language-docker#readme"; + description = "Dockerfile parser, pretty-printer and embedded DSL"; + license = stdenv.lib.licenses.gpl3; + }) {}; + "language-ecmascript" = callPackage + ({ mkDerivation, ansi-wl-pprint, base, charset, containers + , data-default-class, Diff, mtl, parsec, QuickCheck, stdenv + , template-haskell, uniplate + }: + mkDerivation { + pname = "language-ecmascript"; + version = "0.19"; + sha256 = "570a4b7bdebf4532e9c059f2afa7575247be2b7f539361995297308c387c658f"; + libraryHaskellDepends = [ + ansi-wl-pprint base charset containers data-default-class Diff mtl + parsec QuickCheck template-haskell uniplate + ]; + doHaddock = false; + doCheck = false; + homepage = "http://github.com/jswebtools/language-ecmascript"; + description = "JavaScript parser and pretty-printer library"; + license = stdenv.lib.licenses.bsd3; + }) {}; + "language-haskell-extract" = callPackage + ({ mkDerivation, base, regex-posix, stdenv, template-haskell }: + mkDerivation { + pname = "language-haskell-extract"; + version = "0.2.4"; + sha256 = "14da16e56665bf971723e0c5fd06dbb7cc30b4918cf8fb5748570785ded1acdb"; + libraryHaskellDepends = [ base regex-posix template-haskell ]; + doHaddock = false; + doCheck = false; + homepage = "http://github.com/finnsson/template-helper"; + description = "Module to automatically extract functions from the local code"; + license = stdenv.lib.licenses.bsd3; + }) {}; + "language-java" = callPackage + ({ mkDerivation, alex, array, base, parsec, pretty, stdenv }: + mkDerivation { + pname = "language-java"; + version = "0.2.9"; + sha256 = "1d15c8ad2a1eff6b195ec1ed799b8523aeda1c183392b9b713bc4aff2092190e"; + revision = "1"; + editedCabalFile = "0fnbg9b8isyk8dpmggh736mms7a2m65956y1z15wds63imzhs2ik"; + libraryHaskellDepends = [ array base parsec pretty ]; + libraryToolDepends = [ alex ]; + doHaddock = false; + doCheck = false; + homepage = "http://github.com/vincenthz/language-java"; + description = "Java source manipulation"; + license = stdenv.lib.licenses.bsd3; + }) {}; + "language-javascript" = callPackage + ({ mkDerivation, alex, array, base, blaze-builder, bytestring + , containers, happy, mtl, stdenv, text, utf8-string + }: + mkDerivation { + pname = "language-javascript"; + version = "0.6.0.11"; + sha256 = "d4756e9bc9a180cb93701e964a3157a03d4db4c7cb5a7b6b196067e587cc6143"; + libraryHaskellDepends = [ + array base blaze-builder bytestring containers mtl text utf8-string + ]; + libraryToolDepends = [ alex happy ]; + doHaddock = false; + doCheck = false; + homepage = "https://github.com/erikd/language-javascript"; + description = "Parser for JavaScript"; + license = stdenv.lib.licenses.bsd3; + }) {}; + "language-nix" = callPackage + ({ mkDerivation, base, base-compat, Cabal, deepseq, lens, pretty + , QuickCheck, stdenv + }: + mkDerivation { + pname = "language-nix"; + version = "2.1.0.1"; + sha256 = "f0147300724ac39ce388cd6cd717ac3ccc6ed1884ffaafebb18d0f3021e01acf"; + revision = "1"; + editedCabalFile = "1zv12p4ralrks0517zs52rzmzmsxxkcxkqz7zijfgcsvh6bsmafi"; + libraryHaskellDepends = [ + base base-compat Cabal deepseq lens pretty QuickCheck + ]; + doHaddock = false; + doCheck = false; + homepage = "https://github.com/peti/language-nix#readme"; + description = "Data types and useful functions to represent and manipulate the Nix language"; + license = stdenv.lib.licenses.bsd3; + }) {}; + "language-puppet" = callPackage + ({ mkDerivation, aeson, ansi-wl-pprint, attoparsec, base + , base16-bytestring, bytestring, case-insensitive, containers + , cryptonite, directory, exceptions, filecache, filepath + , formatting, Glob, hashable, hruby, hslogger, hspec, http-api-data + , http-client, lens, lens-aeson, megaparsec, memory, mtl + , operational, optparse-applicative, parallel-io, parsec + , pcre-utils, process, protolude, random, regex-pcre-builtin + , scientific, servant, servant-client, split, stdenv, stm + , strict-base-types, text, time, transformers, unix + , unordered-containers, vector, yaml + }: + mkDerivation { + pname = "language-puppet"; + version = "1.3.19.1"; + sha256 = "f076c2a8f4b32c7eda47b2bec4e3d963c99a03ec1c998bf4f5d26b3fb04e2f38"; + isLibrary = true; + isExecutable = true; + enableSeparateDataOutput = true; + libraryHaskellDepends = [ + aeson ansi-wl-pprint attoparsec base base16-bytestring bytestring + case-insensitive containers cryptonite directory exceptions + filecache filepath formatting hashable hruby hslogger hspec + http-api-data http-client lens lens-aeson megaparsec memory mtl + operational parsec pcre-utils process protolude random + regex-pcre-builtin scientific servant servant-client split stm + strict-base-types text time transformers unix unordered-containers + vector yaml + ]; + executableHaskellDepends = [ + aeson ansi-wl-pprint base bytestring containers Glob hslogger + http-client lens megaparsec mtl optparse-applicative parallel-io + regex-pcre-builtin strict-base-types text transformers + unordered-containers vector yaml + ]; + doHaddock = false; + doCheck = false; + homepage = "http://lpuppet.banquise.net/"; + description = "Tools to parse and evaluate the Puppet DSL"; + license = stdenv.lib.licenses.bsd3; + }) {}; + "lapack-carray" = callPackage + ({ mkDerivation, base, carray, lapack-ffi, netlib-carray + , netlib-ffi, stdenv, storable-complex, transformers + }: + mkDerivation { + pname = "lapack-carray"; + version = "0.0.2"; + sha256 = "ca3a3d99016b7428b3781142ca2ab96eb2ad3318257a3dedaa41f8c2e0aa24b7"; + libraryHaskellDepends = [ + base carray lapack-ffi netlib-carray netlib-ffi storable-complex + transformers + ]; + doHaddock = false; + doCheck = false; + homepage = "http://hub.darcs.net/thielema/lapack-carray/"; + description = "Auto-generated interface to Fortran LAPACK via CArrays"; + license = stdenv.lib.licenses.bsd3; + }) {}; + "lapack-ffi" = callPackage + ({ mkDerivation, base, liblapack, netlib-ffi, stdenv }: + mkDerivation { + pname = "lapack-ffi"; + version = "0.0.2"; + sha256 = "d4b73268bb25244f0234ef4a8b4407818e244d297612a189c7f34fe0b64ae584"; + libraryHaskellDepends = [ base netlib-ffi ]; + libraryPkgconfigDepends = [ liblapack ]; + doHaddock = false; + doCheck = false; + homepage = "http://hub.darcs.net/thielema/lapack-ffi/"; + description = "Auto-generated interface to Fortran LAPACK"; + license = stdenv.lib.licenses.bsd3; + }) {inherit (pkgs) liblapack;}; + "lapack-ffi-tools" = callPackage + ({ mkDerivation, base, bytestring, cassava, containers + , explicit-exception, filepath, non-empty, optparse-applicative + , parsec, pathtype, stdenv, transformers, unordered-containers + , utility-ht, vector + }: + mkDerivation { + pname = "lapack-ffi-tools"; + version = "0.1.0.1"; + sha256 = "7c9c500a04bd4c56b6d86f59498867a012b7c647c39538e4945a9c0a0d83ad31"; + isLibrary = false; + isExecutable = true; + enableSeparateDataOutput = true; + executableHaskellDepends = [ + base bytestring cassava containers explicit-exception filepath + non-empty optparse-applicative parsec pathtype transformers + unordered-containers utility-ht vector + ]; + doHaddock = false; + doCheck = false; + homepage = "http://hub.darcs.net/thielema/lapack-ffi-tools/"; + description = "Generator for Haskell interface to Fortran LAPACK"; + license = stdenv.lib.licenses.bsd3; + }) {}; + "large-hashable" = callPackage + ({ mkDerivation, aeson, base, base16-bytestring, bytes, bytestring + , containers, scientific, stdenv, strict, template-haskell, text + , time, transformers, unordered-containers, utf8-light, vector + , void + }: + mkDerivation { + pname = "large-hashable"; + version = "0.1.0.4"; + sha256 = "e9c3345d9fa0161f1b809f2c57e00b4c687ebd48ea42623fe480cc85339a628e"; + libraryHaskellDepends = [ + aeson base base16-bytestring bytes bytestring containers scientific + strict template-haskell text time transformers unordered-containers + utf8-light vector void + ]; + doHaddock = false; + doCheck = false; + homepage = "https://github.com/factisresearch/large-hashable"; + description = "Efficiently hash (large) Haskell values"; + license = stdenv.lib.licenses.bsd3; + }) {}; + "largeword" = callPackage + ({ mkDerivation, base, binary, stdenv }: + mkDerivation { + pname = "largeword"; + version = "1.2.5"; + sha256 = "00b3b06d846649bf404f52a725c88349a38bc8c810e16c99f3100c4e1e9d7d46"; + libraryHaskellDepends = [ base binary ]; + doHaddock = false; + doCheck = false; + homepage = "https://github.com/idontgetoutmuch/largeword"; + description = "Provides Word128, Word192 and Word256 and a way of producing other large words if required"; + license = stdenv.lib.licenses.bsd3; + }) {}; + "latex" = callPackage + ({ mkDerivation, base, containers, stdenv, utility-ht }: + mkDerivation { + pname = "latex"; + version = "0.1.0.3"; + sha256 = "b742ff5c83f6019469e55d2f3559d8efbc7ce62607e5de76485a7cb314e636d2"; + libraryHaskellDepends = [ base containers utility-ht ]; + doHaddock = false; + doCheck = false; + homepage = "http://www.haskell.org/haskellwiki/LaTeX"; + description = "Parse, format and process LaTeX files"; + license = stdenv.lib.licenses.bsd3; + }) {}; + "lattices" = callPackage + ({ mkDerivation, base, base-compat, containers, deepseq, hashable + , semigroupoids, stdenv, tagged, universe-base + , universe-reverse-instances, unordered-containers + }: + mkDerivation { + pname = "lattices"; + version = "1.7.1.1"; + sha256 = "797c89a34c6d631f76ff3bf342275f090ebceb705d6ad69c1a4108582b14ddaf"; + revision = "1"; + editedCabalFile = "18182vlzaz5kzcn2j0k1jmdl8kgqmnpjc3ynsi7v6jdl3vig89dr"; + libraryHaskellDepends = [ + base base-compat containers deepseq hashable semigroupoids tagged + universe-base universe-reverse-instances unordered-containers + ]; + doHaddock = false; + doCheck = false; + homepage = "http://github.com/phadej/lattices/"; + description = "Fine-grained library for constructing and manipulating lattices"; + license = stdenv.lib.licenses.bsd3; + }) {}; + "lawful" = callPackage + ({ mkDerivation, base, stdenv }: + mkDerivation { + pname = "lawful"; + version = "0.1.0.0"; + sha256 = "0056794106bbf7fa4d8d4d943fdc75a39b8a5ac1e18ceac2909183a1a7cc8d04"; + libraryHaskellDepends = [ base ]; + doHaddock = false; + doCheck = false; + homepage = "https://github.com/matt-noonan/lawful#readme"; + description = "Assert the lawfulness of your typeclass instances"; + license = stdenv.lib.licenses.bsd3; + }) {}; + "lazyio" = callPackage + ({ mkDerivation, base, stdenv, transformers, unsafe }: + mkDerivation { + pname = "lazyio"; + version = "0.1.0.4"; + sha256 = "8b54f0bccdc1c836393ce667ea0f1ad069d52c04762e61fad633d4d44916cf6c"; + isLibrary = true; + isExecutable = true; + libraryHaskellDepends = [ base transformers unsafe ]; + doHaddock = false; + doCheck = false; + homepage = "http://www.haskell.org/haskellwiki/Lazy_IO"; + description = "Run IO actions lazily while respecting their order"; + license = stdenv.lib.licenses.bsd3; + }) {}; + "lca" = callPackage + ({ mkDerivation, base, Cabal, cabal-doctest, stdenv }: + mkDerivation { + pname = "lca"; + version = "0.3.1"; + sha256 = "8a8d045ae00d82ddb491e873cc36f1ca89e91556a183c343b99f4df6abfe434e"; + setupHaskellDepends = [ base Cabal cabal-doctest ]; + libraryHaskellDepends = [ base ]; + doHaddock = false; + doCheck = false; + homepage = "http://github.com/ekmett/lca/"; + description = "O(log n) persistent online lowest common ancestor search without preprocessing"; + license = stdenv.lib.licenses.bsd3; + }) {}; + "leancheck" = callPackage + ({ mkDerivation, base, stdenv, template-haskell }: + mkDerivation { + pname = "leancheck"; + version = "0.7.0"; + sha256 = "6e5c30ca628077921adb7195a68b01e7d9b00901b046124a7793af3c2077e6d7"; + libraryHaskellDepends = [ base template-haskell ]; + doHaddock = false; + doCheck = false; + homepage = "https://github.com/rudymatela/leancheck#readme"; + description = "Cholesterol-free property-based testing"; + license = stdenv.lib.licenses.bsd3; + }) {}; + "leapseconds-announced" = callPackage + ({ mkDerivation, base, stdenv, time }: + mkDerivation { + pname = "leapseconds-announced"; + version = "2017.1.0.1"; + sha256 = "cd3bb27caf704a975ef5718a9a8e641cd9cf9a9f2df27153f7cf80405292a8d6"; + libraryHaskellDepends = [ base time ]; + doHaddock = false; + doCheck = false; + homepage = "https://github.com/bjornbm/leapseconds-announced"; + description = "Leap seconds announced at library release time"; + license = stdenv.lib.licenses.bsd3; + }) {}; + "learn-physics" = callPackage + ({ mkDerivation, base, gloss, gnuplot, hmatrix, stdenv + , vector-space + }: + mkDerivation { + pname = "learn-physics"; + version = "0.6.2"; + sha256 = "d28460d3ed415eb5060a8bdcaeb53339bdc05c130358efe78f52daefe5c1c948"; + isLibrary = true; + isExecutable = true; + libraryHaskellDepends = [ + base gloss gnuplot hmatrix vector-space + ]; + executableHaskellDepends = [ base gloss gnuplot ]; + doHaddock = false; + doCheck = false; + description = "Haskell code for learning physics"; + license = stdenv.lib.licenses.bsd3; + }) {}; + "lens" = callPackage + ({ mkDerivation, array, base, base-orphans, bifunctors, bytestring + , Cabal, cabal-doctest, call-stack, comonad, containers + , contravariant, distributive, exceptions, filepath, free, ghc-prim + , hashable, kan-extensions, mtl, parallel, profunctors, reflection + , semigroupoids, semigroups, stdenv, tagged, template-haskell, text + , th-abstraction, transformers, transformers-compat + , unordered-containers, vector, void + }: + mkDerivation { + pname = "lens"; + version = "4.16.1"; + sha256 = "f5bec97b1d5cf3d6487afebc79b927bd5a18f1fd594b104de36a35bf606ea4c6"; + revision = "2"; + editedCabalFile = "11h83lj5mba4grhz1qx3irz10ysm9c3k7k6i6xv2cr60q8xin3ri"; + setupHaskellDepends = [ base Cabal cabal-doctest filepath ]; + libraryHaskellDepends = [ + array base base-orphans bifunctors bytestring call-stack comonad + containers contravariant distributive exceptions filepath free + ghc-prim hashable kan-extensions mtl parallel profunctors + reflection semigroupoids semigroups tagged template-haskell text + th-abstraction transformers transformers-compat + unordered-containers vector void + ]; + doHaddock = false; + doCheck = false; + homepage = "http://github.com/ekmett/lens/"; + description = "Lenses, Folds and Traversals"; + license = stdenv.lib.licenses.bsd2; + }) {}; + "lens-action" = callPackage + ({ mkDerivation, base, Cabal, cabal-doctest, comonad, contravariant + , lens, mtl, profunctors, semigroupoids, semigroups, stdenv + , transformers + }: + mkDerivation { + pname = "lens-action"; + version = "0.2.3"; + sha256 = "06848a6c7f217c3dd3228633bedc9a73b2cce139c1a6dff61af0994d410a98e0"; + setupHaskellDepends = [ base Cabal cabal-doctest ]; + libraryHaskellDepends = [ + base comonad contravariant lens mtl profunctors semigroupoids + semigroups transformers + ]; + doHaddock = false; + doCheck = false; + homepage = "http://github.com/ekmett/lens-action/"; + description = "Monadic Getters and Folds"; + license = stdenv.lib.licenses.bsd3; + }) {}; + "lens-aeson" = callPackage + ({ mkDerivation, aeson, attoparsec, base, bytestring, Cabal + , cabal-doctest, lens, scientific, stdenv, text + , unordered-containers, vector + }: + mkDerivation { + pname = "lens-aeson"; + version = "1.0.2"; + sha256 = "4311f035caa39db3a70915a165bcbfb55ad22376085d95a9b4f57c58994702cc"; + revision = "6"; + editedCabalFile = "1pg5v8fnlqw1krgi3d2a03a0zkjjdv5yp5f5z6q4mlb5jldz99a8"; + setupHaskellDepends = [ base Cabal cabal-doctest ]; + libraryHaskellDepends = [ + aeson attoparsec base bytestring lens scientific text + unordered-containers vector + ]; + doHaddock = false; + doCheck = false; + homepage = "http://github.com/lens/lens-aeson/"; + description = "Law-abiding lenses for aeson"; + license = stdenv.lib.licenses.mit; + }) {}; + "lens-datetime" = callPackage + ({ mkDerivation, base, lens, stdenv, time }: + mkDerivation { + pname = "lens-datetime"; + version = "0.3"; + sha256 = "bb1f8d7bf71c9ef8901bc39e2a2d629b1101307115c0c4d844fcbd8e86b6ccd4"; + libraryHaskellDepends = [ base lens time ]; + doHaddock = false; + doCheck = false; + homepage = "https://github.com/nilcons/lens-datetime"; + description = "Lenses for Data.Time.* types"; + license = stdenv.lib.licenses.bsd3; + }) {}; + "lens-family" = callPackage + ({ mkDerivation, base, containers, lens-family-core, mtl, stdenv + , transformers + }: + mkDerivation { + pname = "lens-family"; + version = "1.2.2"; + sha256 = "dda24de579550daa56c49d2d4fbe59deac18e5fbcbbe6a9b0196ba0a1b27433b"; + libraryHaskellDepends = [ + base containers lens-family-core mtl transformers + ]; + doHaddock = false; + doCheck = false; + description = "Lens Families"; + license = stdenv.lib.licenses.bsd3; + }) {}; + "lens-family-core" = callPackage + ({ mkDerivation, base, containers, stdenv, transformers }: + mkDerivation { + pname = "lens-family-core"; + version = "1.2.2"; + sha256 = "95fe891b61f2d2a7c9ff86f56e40866534a947f87ccf2fcaa5e727ccdfca4628"; + libraryHaskellDepends = [ base containers transformers ]; + doHaddock = false; + doCheck = false; + description = "Haskell 98 Lens Families"; + license = stdenv.lib.licenses.bsd3; + }) {}; + "lens-family-th" = callPackage + ({ mkDerivation, base, stdenv, template-haskell }: + mkDerivation { + pname = "lens-family-th"; + version = "0.5.0.2"; + sha256 = "9c275afad37a5064b9a13c6207ee2307f6ccccc3a5517c0fae84524bad65b0e6"; + libraryHaskellDepends = [ base template-haskell ]; + doHaddock = false; + doCheck = false; + homepage = "http://github.com/DanBurton/lens-family-th#readme"; + description = "Generate lens-family style lenses"; + license = stdenv.lib.licenses.bsd3; + }) {}; + "lens-labels" = callPackage + ({ mkDerivation, base, ghc-prim, profunctors, stdenv, tagged }: + mkDerivation { + pname = "lens-labels"; + version = "0.2.0.1"; + sha256 = "929fea0fe771702780d309e4b2915327cde062a51219df5561bc18dac1c5c0da"; + revision = "1"; + editedCabalFile = "0iyh7msip83dzj9gj5f18zchvjinhx40dmdb52vza0x1763qkilv"; + libraryHaskellDepends = [ base ghc-prim profunctors tagged ]; + doHaddock = false; + doCheck = false; + homepage = "https://github.com/google/proto-lens#readme"; + description = "Integration of lenses with OverloadedLabels"; + license = stdenv.lib.licenses.bsd3; + }) {}; + "lens-misc" = callPackage + ({ mkDerivation, base, lens, stdenv, tagged, template-haskell }: + mkDerivation { + pname = "lens-misc"; + version = "0.0.2.0"; + sha256 = "59925fe9125e297df0f1afcc8ac0f25de14fd017f7848ac2687ed63850ecd8cb"; + libraryHaskellDepends = [ base lens tagged template-haskell ]; + doHaddock = false; + doCheck = false; + homepage = "https://github.com/louispan/lens-misc#readme"; + description = "Miscellaneous lens utilities"; + license = stdenv.lib.licenses.bsd3; + }) {}; + "lens-properties" = callPackage + ({ mkDerivation, base, lens, QuickCheck, stdenv, transformers }: + mkDerivation { + pname = "lens-properties"; + version = "4.11.1"; + sha256 = "4f7c5b75a7204c151dbe62160a6917a22ab9e2a1b2e3848b7043d972ac8f4cb1"; + revision = "2"; + editedCabalFile = "1b14fcncz2yby0d4jhx2h0ma6nx0fd1z7hrg1va4h7zn06m99482"; + libraryHaskellDepends = [ base lens QuickCheck transformers ]; + doHaddock = false; + doCheck = false; + homepage = "http://github.com/ekmett/lens/"; + description = "QuickCheck properties for lens"; + license = stdenv.lib.licenses.bsd3; + }) {}; + "lens-regex" = callPackage + ({ mkDerivation, array, base, lens, regex-base, stdenv + , template-haskell + }: + mkDerivation { + pname = "lens-regex"; + version = "0.1.0"; + sha256 = "4954b3ae395661e916c536bfe837c42a1cd8223ea81ffd86b1fdd9b6abfc5142"; + isLibrary = true; + isExecutable = true; + libraryHaskellDepends = [ + array base lens regex-base template-haskell + ]; + doHaddock = false; + doCheck = false; + homepage = "https://github.com/himura/lens-regex"; + description = "Lens powered regular expression"; + license = stdenv.lib.licenses.bsd3; + }) {}; + "lens-simple" = callPackage + ({ mkDerivation, base, lens-family, lens-family-core + , lens-family-th, mtl, stdenv, transformers + }: + mkDerivation { + pname = "lens-simple"; + version = "0.1.0.9"; + sha256 = "613d99b8074197f8a026a641a9940dd188e0d81e808169f420981a9ca15b832a"; + libraryHaskellDepends = [ + base lens-family lens-family-core lens-family-th mtl transformers + ]; + doHaddock = false; + doCheck = false; + homepage = "https://github.com/michaelt/lens-simple"; + description = "simplified import of elementary lens-family combinators"; + license = stdenv.lib.licenses.bsd3; + }) {}; + "lenz" = callPackage + ({ mkDerivation, base, base-unicode-symbols, hs-functors, stdenv + , transformers + }: + mkDerivation { + pname = "lenz"; + version = "0.3.0.0"; + sha256 = "632232db41f7c49359f37ed541bbbbe99f74d45c1cf583d1081b83af426a439d"; + libraryHaskellDepends = [ + base base-unicode-symbols hs-functors transformers + ]; + doHaddock = false; + doCheck = false; + description = "Van Laarhoven lenses"; + license = stdenv.lib.licenses.bsd3; + }) {}; + "leveldb-haskell" = callPackage + ({ mkDerivation, base, bytestring, data-default, exceptions + , filepath, leveldb, resourcet, stdenv, transformers + }: + mkDerivation { + pname = "leveldb-haskell"; + version = "0.6.5"; + sha256 = "a417b088068deba73a77936c1345302bac7ce06019fb10254857cafad1d76c28"; + isLibrary = true; + isExecutable = true; + libraryHaskellDepends = [ + base bytestring data-default exceptions filepath resourcet + transformers + ]; + librarySystemDepends = [ leveldb ]; + doHaddock = false; + doCheck = false; + homepage = "http://github.com/kim/leveldb-haskell"; + description = "Haskell bindings to LevelDB"; + license = stdenv.lib.licenses.bsd3; + }) {inherit (pkgs) leveldb;}; + "libffi" = callPackage + ({ mkDerivation, base, bytestring, ffi, libffi, stdenv }: + mkDerivation { + pname = "libffi"; + version = "0.1"; + sha256 = "48387067c0f33bcfadf7a3bebbf48a55294202500f2b754229ffc8f12cb4f23c"; + libraryHaskellDepends = [ base bytestring ]; + librarySystemDepends = [ ffi ]; + libraryPkgconfigDepends = [ libffi ]; + doHaddock = false; + doCheck = false; + description = "A binding to libffi"; + license = stdenv.lib.licenses.bsd3; + }) {inherit (pkgs) ffi; inherit (pkgs) libffi;}; + "libgit" = callPackage + ({ mkDerivation, base, mtl, process, stdenv }: + mkDerivation { + pname = "libgit"; + version = "0.3.1"; + sha256 = "1d4c60dd987c363d77c4be947678d01a51ab4b568964c30a33827ccc854f7522"; + libraryHaskellDepends = [ base mtl process ]; + doHaddock = false; + doCheck = false; + homepage = "https://github.com/vincenthz/hs-libgit"; + description = "Simple Git Wrapper"; + license = stdenv.lib.licenses.bsd3; + }) {}; + "libgraph" = callPackage + ({ mkDerivation, array, base, containers, monads-tf, process + , stdenv, union-find + }: + mkDerivation { + pname = "libgraph"; + version = "1.14"; + sha256 = "b7978be50d6182101ca79fb3ea83d0621f5394d483d1fa1eb7d590e45f8d3f3f"; + libraryHaskellDepends = [ + array base containers monads-tf process union-find + ]; + doHaddock = false; + doCheck = false; + homepage = "http://maartenfaddegon.nl"; + description = "Store and manipulate data in a graph"; + license = stdenv.lib.licenses.bsd3; + }) {}; + "libmpd" = callPackage + ({ mkDerivation, attoparsec, base, bytestring, containers + , data-default-class, filepath, mtl, network, old-locale, stdenv + , text, time, utf8-string + }: + mkDerivation { + pname = "libmpd"; + version = "0.9.0.8"; + sha256 = "582b0a405e39148d3a5046e8ad00c9e217688e60c70393eb36cd651e1991ed4e"; + libraryHaskellDepends = [ + attoparsec base bytestring containers data-default-class filepath + mtl network old-locale text time utf8-string + ]; + doHaddock = false; + doCheck = false; + homepage = "http://github.com/vimus/libmpd-haskell#readme"; + description = "An MPD client library"; + license = stdenv.lib.licenses.mit; + }) {}; + "libxml-sax" = callPackage + ({ mkDerivation, base, bytestring, libxml2, stdenv, text, xml-types + }: + mkDerivation { + pname = "libxml-sax"; + version = "0.7.5"; + sha256 = "99141784cc0d6c5749f0df618b2d46922391eede09f4f9ccfc36fb58a9c16d51"; + libraryHaskellDepends = [ base bytestring text xml-types ]; + librarySystemDepends = [ libxml2 ]; + libraryPkgconfigDepends = [ libxml2 ]; + doHaddock = false; + doCheck = false; + homepage = "https://john-millikin.com/software/haskell-libxml/"; + description = "Bindings for the libXML2 SAX interface"; + license = stdenv.lib.licenses.mit; + }) {inherit (pkgs) libxml2;}; + "lift-generics" = callPackage + ({ mkDerivation, base, generic-deriving, ghc-prim, stdenv + , template-haskell + }: + mkDerivation { + pname = "lift-generics"; + version = "0.1.2"; + sha256 = "0e9fbd17cd3e1af6ef1e994e7c14cfd42896e56499864e707f72246b6e2b604e"; + revision = "2"; + editedCabalFile = "171f8cpn0kw9psikx3n7cdwyqfwg8rr8gf1hja6g7pnm0683l5l8"; + libraryHaskellDepends = [ + base generic-deriving ghc-prim template-haskell + ]; + doHaddock = false; + doCheck = false; + homepage = "https://github.com/RyanGlScott/lift-generics"; + description = "GHC.Generics-based Language.Haskell.TH.Syntax.lift implementation"; + license = stdenv.lib.licenses.bsd3; + }) {}; + "lifted-async" = callPackage + ({ mkDerivation, async, base, constraints, lifted-base + , monad-control, stdenv, transformers-base + }: + mkDerivation { + pname = "lifted-async"; + version = "0.10.0.2"; + sha256 = "8ed740437f5ca16aa4d7508626cfa3da14f3305f292b0976a8a2072642c9e380"; + libraryHaskellDepends = [ + async base constraints lifted-base monad-control transformers-base + ]; + doHaddock = false; + doCheck = false; + homepage = "https://github.com/maoe/lifted-async"; + description = "Run lifted IO operations asynchronously and wait for their results"; + license = stdenv.lib.licenses.bsd3; + }) {}; + "lifted-base" = callPackage + ({ mkDerivation, base, monad-control, stdenv, transformers-base }: + mkDerivation { + pname = "lifted-base"; + version = "0.2.3.12"; + sha256 = "c134a95f56750aae806e38957bb03c59627cda16034af9e00a02b699474317c5"; + libraryHaskellDepends = [ base monad-control transformers-base ]; + doHaddock = false; + doCheck = false; + homepage = "https://github.com/basvandijk/lifted-base"; + description = "lifted IO operations from the base library"; + license = stdenv.lib.licenses.bsd3; + }) {}; + "line" = callPackage + ({ mkDerivation, aeson, base, base64-bytestring, bytestring + , cryptohash-sha256, http-conduit, http-types, scotty, stdenv, text + , time, transformers, wai + }: + mkDerivation { + pname = "line"; + version = "4.0.1"; + sha256 = "a1dfab5dcd078747920fc61a024eb096a554f465d57c8bc642c155150f41667c"; + libraryHaskellDepends = [ + aeson base base64-bytestring bytestring cryptohash-sha256 + http-conduit http-types scotty text time transformers wai + ]; + doHaddock = false; + doCheck = false; + homepage = "https://github.com/utatti/line"; + description = "Haskell SDK for the LINE API"; + license = stdenv.lib.licenses.bsd3; + }) {}; + "linear" = callPackage + ({ mkDerivation, adjunctions, base, base-orphans, binary, bytes + , Cabal, cabal-doctest, cereal, containers, deepseq, distributive + , ghc-prim, hashable, lens, reflection, semigroupoids, semigroups + , stdenv, tagged, template-haskell, transformers + , transformers-compat, unordered-containers, vector, void + }: + mkDerivation { + pname = "linear"; + version = "1.20.8"; + sha256 = "5ebd1b99837f2e3c7386bcd2ca425d9c66b09a61409792b141428345fb9edb10"; + setupHaskellDepends = [ base Cabal cabal-doctest ]; + libraryHaskellDepends = [ + adjunctions base base-orphans binary bytes cereal containers + deepseq distributive ghc-prim hashable lens reflection + semigroupoids semigroups tagged template-haskell transformers + transformers-compat unordered-containers vector void + ]; + doHaddock = false; + doCheck = false; + homepage = "http://github.com/ekmett/linear/"; + description = "Linear Algebra"; + license = stdenv.lib.licenses.bsd3; + }) {}; + "linked-list-with-iterator" = callPackage + ({ mkDerivation, base, containers, stdenv }: + mkDerivation { + pname = "linked-list-with-iterator"; + version = "0.1.1.0"; + sha256 = "c6ae37cc9d123afcb92f28fef9c5dae6d3713489bdf7f73ac9af420bb3f11b89"; + libraryHaskellDepends = [ base containers ]; + doHaddock = false; + doCheck = false; + homepage = "https://github.com/CindyLinz/Haskell-linked-list-with-iterator#readme"; + description = "A pure linked list which is mutable through iterators"; + license = stdenv.lib.licenses.bsd3; + }) {}; + "linux-file-extents" = callPackage + ({ mkDerivation, base, stdenv, unix }: + mkDerivation { + pname = "linux-file-extents"; + version = "0.2.0.0"; + sha256 = "6c7cd9e700f666f774736d31a0e6aa7bfe9bd1e075c11eed701ba95095fd9bd0"; + isLibrary = true; + isExecutable = true; + libraryHaskellDepends = [ base unix ]; + doHaddock = false; + doCheck = false; + homepage = "https://github.com/redneb/linux-file-extents"; + description = "Retrieve file fragmentation information under Linux"; + license = stdenv.lib.licenses.bsd3; + }) {}; + "linux-namespaces" = callPackage + ({ mkDerivation, base, bytestring, stdenv, unix }: + mkDerivation { + pname = "linux-namespaces"; + version = "0.1.3.0"; + sha256 = "1412db341c574b6a18e2fa23ee5e3ca6f32719409ea602a6215f1fd0aafb73e7"; + libraryHaskellDepends = [ base bytestring unix ]; + doHaddock = false; + doCheck = false; + homepage = "https://github.com/redneb/hs-linux-namespaces"; + description = "Work with linux namespaces: create new or enter existing ones"; + license = stdenv.lib.licenses.bsd3; + }) {}; + "list-t" = callPackage + ({ mkDerivation, base, mmorph, monad-control, mtl, stdenv + , transformers, transformers-base + }: + mkDerivation { + pname = "list-t"; + version = "1.0.1"; + sha256 = "c3438dde9d22e882ccdad091eb9c6f95706e9d564a57d5f845e991e706436773"; + revision = "1"; + editedCabalFile = "0jv0wxxr6rpw9mi3n6jbjqlk403wzycyafrc26vcwkdjaw63ckxb"; + libraryHaskellDepends = [ + base mmorph monad-control mtl transformers transformers-base + ]; + doHaddock = false; + doCheck = false; + homepage = "https://github.com/nikita-volkov/list-t"; + description = "ListT done right"; + license = stdenv.lib.licenses.mit; + }) {}; + "listsafe" = callPackage + ({ mkDerivation, base, exceptions, stdenv }: + mkDerivation { + pname = "listsafe"; + version = "0.1.0.1"; + sha256 = "1a073247edfbea7dd7b7f9629fc64ddd3bce67fa61695da23ff43fb31d398d69"; + libraryHaskellDepends = [ base exceptions ]; + doHaddock = false; + doCheck = false; + homepage = "https://github.com/ombocomp/listsafe"; + description = "Safe wrappers for partial list functions, supporting MonadThrow"; + license = stdenv.lib.licenses.asl20; + }) {}; + "llvm-hs" = callPackage + ({ mkDerivation, array, attoparsec, base, bytestring, Cabal + , containers, exceptions, llvm-config, llvm-hs-pure, mtl, stdenv + , template-haskell, transformers, utf8-string + }: + mkDerivation { + pname = "llvm-hs"; + version = "6.3.0"; + sha256 = "4d9e74b6ab369d4d3abe8395bda47a395d0c44c9bcbc0be9f94a6a76811b6183"; + revision = "2"; + editedCabalFile = "08rm1y7icxp2bdmv65n5nxg5mkppqpqd3m62n50gk6991kki9qdf"; + setupHaskellDepends = [ base Cabal containers ]; + libraryHaskellDepends = [ + array attoparsec base bytestring containers exceptions llvm-hs-pure + mtl template-haskell transformers utf8-string + ]; + libraryToolDepends = [ llvm-config ]; + doHaddock = false; + doCheck = false; + homepage = "http://github.com/llvm-hs/llvm-hs/"; + description = "General purpose LLVM bindings"; + license = stdenv.lib.licenses.bsd3; + }) {}; + "llvm-hs-pretty" = callPackage + ({ mkDerivation, array, base, bytestring, llvm-hs-pure + , prettyprinter, stdenv, text + }: + mkDerivation { + pname = "llvm-hs-pretty"; + version = "0.5.0.0"; + sha256 = "0dca50bf44df9128fe6f4ad0ed09281c1fc4e615ceac390b2197d2f7f8e9259c"; + libraryHaskellDepends = [ + array base bytestring llvm-hs-pure prettyprinter text + ]; + doHaddock = false; + doCheck = false; + homepage = "https://github.com/llvm-hs/llvm-hs-pretty"; + description = "A pretty printer for LLVM IR"; + license = stdenv.lib.licenses.mit; + }) {}; + "llvm-hs-pure" = callPackage + ({ mkDerivation, attoparsec, base, bytestring, containers, fail + , mtl, stdenv, template-haskell, transformers, unordered-containers + }: + mkDerivation { + pname = "llvm-hs-pure"; + version = "6.2.1"; + sha256 = "7908a944616107142a804b5e4a9772c12358b3bd78de3ddb91a63d82cdfb3da9"; + libraryHaskellDepends = [ + attoparsec base bytestring containers fail mtl template-haskell + transformers unordered-containers + ]; + doHaddock = false; + doCheck = false; + homepage = "http://github.com/llvm-hs/llvm-hs/"; + description = "Pure Haskell LLVM functionality (no FFI)"; + license = stdenv.lib.licenses.bsd3; + }) {}; + "lmdb" = callPackage + ({ mkDerivation, array, base, lmdb, stdenv }: + mkDerivation { + pname = "lmdb"; + version = "0.2.5"; + sha256 = "80552856211cdce06b808685d621bdd9c33a5ac5540a4dafe120c6b20c901c7d"; + libraryHaskellDepends = [ array base ]; + librarySystemDepends = [ lmdb ]; + doHaddock = false; + doCheck = false; + homepage = "http://github.com/dmbarbour/haskell-lmdb"; + description = "Lightning MDB bindings"; + license = stdenv.lib.licenses.bsd2; + }) {inherit (pkgs) lmdb;}; + "load-env" = callPackage + ({ mkDerivation, base, directory, filepath, parsec, stdenv }: + mkDerivation { + pname = "load-env"; + version = "0.2.0.1"; + sha256 = "cbe747e854d7ef3626487114d5cc4a93cbb303ed1df353ab5d8eaceba83873f6"; + libraryHaskellDepends = [ base directory filepath parsec ]; + doHaddock = false; + doCheck = false; + homepage = "https://github.com/pbrisbin/load-env#readme"; + description = "Load environment variables from a file"; + license = stdenv.lib.licenses.bsd3; + }) {}; + "locators" = callPackage + ({ mkDerivation, base, bytestring, containers, cryptohash, stdenv + }: + mkDerivation { + pname = "locators"; + version = "0.2.4.4"; + sha256 = "2d6d0940206e285a086ea66c7b5f8b3a082fa629a8d335323dbbf78547e09aa5"; + libraryHaskellDepends = [ base bytestring containers cryptohash ]; + doHaddock = false; + doCheck = false; + description = "Human exchangable identifiers and locators"; + license = stdenv.lib.licenses.bsd3; + }) {}; + "loch-th" = callPackage + ({ mkDerivation, base, pretty, stdenv, template-haskell }: + mkDerivation { + pname = "loch-th"; + version = "0.2.2"; + sha256 = "cc059372b12a79375a0f268db7dc5a2973307a200440d4112e665b9a3d9b6dc3"; + libraryHaskellDepends = [ base pretty template-haskell ]; + doHaddock = false; + doCheck = false; + homepage = "https://github.com/liskin/loch-th"; + description = "Support for precise error locations in source files (Template Haskell version)"; + license = stdenv.lib.licenses.bsd3; + }) {}; + "lockfree-queue" = callPackage + ({ mkDerivation, abstract-deque, atomic-primops, base, bytestring + , ghc-prim, stdenv + }: + mkDerivation { + pname = "lockfree-queue"; + version = "0.2.3.1"; + sha256 = "2a576a54bae8eabde01ebe901c9fd26a11bebb30516841de4525b5b60c0f3a8c"; + libraryHaskellDepends = [ + abstract-deque atomic-primops base bytestring ghc-prim + ]; + doHaddock = false; + doCheck = false; + homepage = "https://github.com/rrnewton/haskell-lockfree/wiki"; + description = "Michael and Scott lock-free queues"; + license = stdenv.lib.licenses.bsd3; + }) {}; + "log-base" = callPackage + ({ mkDerivation, aeson, aeson-pretty, base, bytestring, deepseq + , exceptions, mmorph, monad-control, monad-time, mtl, semigroups + , stdenv, stm, text, time, transformers-base, unordered-containers + }: + mkDerivation { + pname = "log-base"; + version = "0.7.4.0"; + sha256 = "4067eba80db49eb4509c10770959d0350f9eb9df5e0bde2fbf9024f106dc3f1b"; + libraryHaskellDepends = [ + aeson aeson-pretty base bytestring deepseq exceptions mmorph + monad-control monad-time mtl semigroups stm text time + transformers-base unordered-containers + ]; + doHaddock = false; + doCheck = false; + homepage = "https://github.com/scrive/log"; + description = "Structured logging solution (base package)"; + license = stdenv.lib.licenses.bsd3; + }) {}; + "log-domain" = callPackage + ({ mkDerivation, base, binary, bytes, Cabal, cabal-doctest, cereal + , comonad, deepseq, distributive, hashable, semigroupoids + , semigroups, stdenv, vector + }: + mkDerivation { + pname = "log-domain"; + version = "0.12"; + sha256 = "7191cba40b9b348c54171f2b86caabb75a30e52b6d7e4c57321bf5dcdf1f367e"; + revision = "3"; + editedCabalFile = "19xc24jwfhzy3v26689sc4ma50w4ylqd378dpxphl0nrxili645z"; + setupHaskellDepends = [ base Cabal cabal-doctest ]; + libraryHaskellDepends = [ + base binary bytes cereal comonad deepseq distributive hashable + semigroupoids semigroups vector + ]; + doHaddock = false; + doCheck = false; + homepage = "http://github.com/ekmett/log-domain/"; + description = "Log-domain arithmetic"; + license = stdenv.lib.licenses.bsd3; + }) {}; + "log-postgres" = callPackage + ({ mkDerivation, aeson, aeson-pretty, base, base64-bytestring + , bytestring, deepseq, hpqtypes, http-client, lifted-base, log-base + , mtl, semigroups, split, stdenv, text, text-show, time + , unordered-containers, vector + }: + mkDerivation { + pname = "log-postgres"; + version = "0.7.0.2"; + sha256 = "51c60374838cbd89d027cde9cdf2d8982b4f4152befe76899085520922e5639b"; + revision = "1"; + editedCabalFile = "1f18nzrh3bxnb58cmd3zyqpwaw2jyfl92dg6qd30zhlvlnkz1q7q"; + libraryHaskellDepends = [ + aeson aeson-pretty base base64-bytestring bytestring deepseq + hpqtypes http-client lifted-base log-base mtl semigroups split text + text-show time unordered-containers vector + ]; + doHaddock = false; + doCheck = false; + homepage = "https://github.com/scrive/log"; + description = "Structured logging solution (PostgreSQL back end)"; + license = stdenv.lib.licenses.bsd3; + }) {}; + "logfloat" = callPackage + ({ mkDerivation, array, base, stdenv }: + mkDerivation { + pname = "logfloat"; + version = "0.13.3.3"; + sha256 = "f774bd71d82ae053046ab602aa451ce4f65440d5c634dc8d950ae87f53527f82"; + libraryHaskellDepends = [ array base ]; + doHaddock = false; + doCheck = false; + homepage = "http://code.haskell.org/~wren/"; + description = "Log-domain floating point numbers"; + license = stdenv.lib.licenses.bsd3; + }) {}; + "logger-thread" = callPackage + ({ mkDerivation, base, fast-logger, protolude, safe-exceptions + , stdenv, stm, text, time + }: + mkDerivation { + pname = "logger-thread"; + version = "0.1.0.2"; + sha256 = "ac0a54001a69cff6f975209c4d9d399fb58ef59bb0ad6ac742c5ffedeac04a2a"; + isLibrary = true; + isExecutable = true; + libraryHaskellDepends = [ + base fast-logger protolude safe-exceptions stm text time + ]; + executableHaskellDepends = [ base protolude stm ]; + doHaddock = false; + doCheck = false; + homepage = "https://github.com/joe9/logger-thread#readme"; + description = "Run FastLogger in a thread and direct all queued messages to it"; + license = stdenv.lib.licenses.bsd3; + }) {}; + "logging-effect" = callPackage + ({ mkDerivation, async, base, exceptions, free, monad-control, mtl + , prettyprinter, semigroups, stdenv, stm, stm-delay, text, time + , transformers, transformers-base, unliftio-core + }: + mkDerivation { + pname = "logging-effect"; + version = "1.3.2"; + sha256 = "6dbdcbf3043186dabf7446206558ed1993a72d909da3462c9eac97f4a18615e1"; + libraryHaskellDepends = [ + async base exceptions free monad-control mtl prettyprinter + semigroups stm stm-delay text time transformers transformers-base + unliftio-core + ]; + doHaddock = false; + doCheck = false; + homepage = "https://github.com/ocharles/logging-effect"; + description = "A mtl-style monad transformer for general purpose & compositional logging"; + license = stdenv.lib.licenses.bsd3; + }) {}; + "logging-facade" = callPackage + ({ mkDerivation, base, call-stack, stdenv, transformers }: + mkDerivation { + pname = "logging-facade"; + version = "0.3.0"; + sha256 = "8e7115258b76e0bf5d21b532dd916c63e79b32d1776cc355d2d184f67ae71434"; + libraryHaskellDepends = [ base call-stack transformers ]; + doHaddock = false; + doCheck = false; + homepage = "https://github.com/sol/logging-facade#readme"; + description = "Simple logging abstraction that allows multiple back-ends"; + license = stdenv.lib.licenses.mit; + }) {}; + "logging-facade-syslog" = callPackage + ({ mkDerivation, base, hsyslog, logging-facade, stdenv }: + mkDerivation { + pname = "logging-facade-syslog"; + version = "1"; + sha256 = "eb8b23c3f77a788891eac00e2d84bf489b683d761028a7938cf93e36729d8ea9"; + libraryHaskellDepends = [ base hsyslog logging-facade ]; + doHaddock = false; + doCheck = false; + homepage = "https://github.com/peti/logging-facade-syslog#readme"; + description = "A logging back-end to syslog(3) for the logging-facade library"; + license = stdenv.lib.licenses.bsd3; + }) {}; + "logict" = callPackage + ({ mkDerivation, base, mtl, stdenv }: + mkDerivation { + pname = "logict"; + version = "0.6.0.2"; + sha256 = "1182b68e8d00279460c7fb9b8284bf129805c07754c678b2a8de5a6d768e161e"; + libraryHaskellDepends = [ base mtl ]; + doHaddock = false; + doCheck = false; + homepage = "http://code.haskell.org/~dolio/"; + description = "A backtracking logic-programming monad"; + license = stdenv.lib.licenses.bsd3; + }) {}; + "loop" = callPackage + ({ mkDerivation, base, stdenv }: + mkDerivation { + pname = "loop"; + version = "0.3.0"; + sha256 = "92962010bdab28cc0092dd3fe42819d6f215c717dd10d9349626d92a0d0b3ecf"; + libraryHaskellDepends = [ base ]; + doHaddock = false; + doCheck = false; + homepage = "https://github.com/nh2/loop"; + description = "Fast loops (for when GHC can't optimize forM_)"; + license = stdenv.lib.licenses.mit; + }) {}; + "lrucache" = callPackage + ({ mkDerivation, base, containers, contravariant, stdenv }: + mkDerivation { + pname = "lrucache"; + version = "1.2.0.0"; + sha256 = "5f17a9e026e198152d13830a0eae0df21be437c238a3f157f7c188fe27a37616"; + libraryHaskellDepends = [ base containers contravariant ]; + doHaddock = false; + doCheck = false; + homepage = "http://github.com/chowells79/lrucache"; + description = "a simple, pure LRU cache"; + license = stdenv.lib.licenses.bsd3; + }) {}; + "lrucaching" = callPackage + ({ mkDerivation, base, base-compat, deepseq, hashable, psqueues + , stdenv, vector + }: + mkDerivation { + pname = "lrucaching"; + version = "0.3.3"; + sha256 = "aa7e5fd27963c70fc1108a7c0526ca0e05f76ccd885844bc50bdae70d5174aa4"; + revision = "5"; + editedCabalFile = "0dfrgg60nd7l7pfjar1s1g380r4591y6ccv9fyh0n34ymhizk84y"; + libraryHaskellDepends = [ + base base-compat deepseq hashable psqueues vector + ]; + doHaddock = false; + doCheck = false; + homepage = "https://github.com/cocreature/lrucaching#readme"; + description = "LRU cache"; + license = stdenv.lib.licenses.bsd3; + }) {}; + "lucid" = callPackage + ({ mkDerivation, base, blaze-builder, bytestring, containers + , hashable, mmorph, mtl, stdenv, text, transformers + , unordered-containers + }: + mkDerivation { + pname = "lucid"; + version = "2.9.10"; + sha256 = "c0e7dfae8337694082e3f34573c144d2672dc8c8e16175614079cd9d2d434390"; + revision = "1"; + editedCabalFile = "0n94x2havrvks85z8azsa4pvz33amhb444cias3kfxmkyvypn5ah"; + libraryHaskellDepends = [ + base blaze-builder bytestring containers hashable mmorph mtl text + transformers unordered-containers + ]; + doHaddock = false; + doCheck = false; + homepage = "https://github.com/chrisdone/lucid"; + description = "Clear to write, read and edit DSL for HTML"; + license = stdenv.lib.licenses.bsd3; + }) {}; + "lucid-extras" = callPackage + ({ mkDerivation, aeson, base, blaze-builder, bytestring, lucid + , stdenv, text + }: + mkDerivation { + pname = "lucid-extras"; + version = "0.1.0.1"; + sha256 = "5cc5e269c313cba6871b70d48825e6b63ae49db91d507b7f9dccc10bf12dcb73"; + revision = "1"; + editedCabalFile = "030mj3yddbia6dkbl8d6mssi42l3z8gs79z50r78gwiif6mh5dny"; + libraryHaskellDepends = [ + aeson base blaze-builder bytestring lucid text + ]; + doHaddock = false; + doCheck = false; + homepage = "https://github.com/diffusionkinetics/open/lucid-extras"; + description = "Generate more HTML with Lucid"; + license = stdenv.lib.licenses.mit; + }) {}; + "lxd-client-config" = callPackage + ({ mkDerivation, aeson, base, containers, directory, filepath + , stdenv, text, yaml + }: + mkDerivation { + pname = "lxd-client-config"; + version = "0.1.0.1"; + sha256 = "903852c99bebc0af3cc3a26734056003f9097ada08eb1f361abce097a120afcf"; + libraryHaskellDepends = [ + aeson base containers directory filepath text yaml + ]; + doHaddock = false; + doCheck = false; + homepage = "https://github.com/hverr/haskell-lxd-client-config#readme"; + description = "Read the configuration file of the standard LXD client"; + license = stdenv.lib.licenses.gpl3; + }) {}; + "lz4" = callPackage + ({ mkDerivation, base, bytestring, cereal, stdenv }: + mkDerivation { + pname = "lz4"; + version = "0.2.3.1"; + sha256 = "98cc62bea1a359201f9e39a7db2457272f996ede25d97a2dbee3a07aa80693f1"; + libraryHaskellDepends = [ base bytestring cereal ]; + doHaddock = false; + doCheck = false; + homepage = "http://github.com/mwotton/lz4hs"; + description = "LZ4 compression for ByteStrings"; + license = stdenv.lib.licenses.bsd3; + }) {}; + "lzma" = callPackage + ({ mkDerivation, base, bytestring, lzma, stdenv }: + mkDerivation { + pname = "lzma"; + version = "0.0.0.3"; + sha256 = "af8321c3511bde3e2745093fa3bd74c642e386db7d2e7c43b3a54814f1338144"; + revision = "3"; + editedCabalFile = "1sify6gnsalyp6dakfzi0mdy5jcz2kcp9jsdsgkmxd40nfzgd44m"; + libraryHaskellDepends = [ base bytestring ]; + librarySystemDepends = [ lzma ]; + doHaddock = false; + doCheck = false; + homepage = "https://github.com/hvr/lzma"; + description = "LZMA/XZ compression and decompression"; + license = stdenv.lib.licenses.bsd3; + }) {inherit (pkgs) lzma;}; + "lzma-conduit" = callPackage + ({ mkDerivation, base, bytestring, conduit, lzma, resourcet, stdenv + , transformers + }: + mkDerivation { + pname = "lzma-conduit"; + version = "1.2.1"; + sha256 = "e955da2b8b108b3bf07073e12e5b01c46d42c8f3e40828fb1f34cd7e5413a742"; + libraryHaskellDepends = [ + base bytestring conduit lzma resourcet transformers + ]; + doHaddock = false; + doCheck = false; + homepage = "http://github.com/alphaHeavy/lzma-conduit"; + description = "Conduit interface for lzma/xz compression"; + license = stdenv.lib.licenses.bsd3; + }) {}; + "machines" = callPackage + ({ mkDerivation, adjunctions, base, Cabal, cabal-doctest, comonad + , containers, distributive, mtl, pointed, profunctors + , semigroupoids, semigroups, stdenv, transformers + , transformers-compat, void + }: + mkDerivation { + pname = "machines"; + version = "0.6.4"; + sha256 = "72de2b2e27cb36832ec4a66de36f1ba6c53d2abd197b7f0351865b4567db7768"; + setupHaskellDepends = [ base Cabal cabal-doctest ]; + libraryHaskellDepends = [ + adjunctions base comonad containers distributive mtl pointed + profunctors semigroupoids semigroups transformers + transformers-compat void + ]; + doHaddock = false; + doCheck = false; + homepage = "http://github.com/ekmett/machines/"; + description = "Networked stream transducers"; + license = stdenv.lib.licenses.bsd3; + }) {}; + "machines-binary" = callPackage + ({ mkDerivation, base, binary, bytestring, machines, stdenv }: + mkDerivation { + pname = "machines-binary"; + version = "0.3.0.3"; + sha256 = "60ff456d658ea1a427f32ee5ae1c726e2e7703942bd33edf28b457d753c20652"; + libraryHaskellDepends = [ base binary bytestring machines ]; + doHaddock = false; + doCheck = false; + homepage = "http://github.com/aloiscochard/machines-binary"; + description = "Binary utilities for the machines library"; + license = stdenv.lib.licenses.asl20; + }) {}; + "machines-directory" = callPackage + ({ mkDerivation, base, directory, filepath, machines, machines-io + , stdenv, transformers + }: + mkDerivation { + pname = "machines-directory"; + version = "0.2.1.0"; + sha256 = "849c07db6ff6cfd88348d228a7a3f8ccb16e99568230ee0d20faa5670474deb4"; + libraryHaskellDepends = [ + base directory filepath machines machines-io transformers + ]; + doHaddock = false; + doCheck = false; + homepage = "http://github.com/aloiscochard/machines-directory"; + description = "Directory (system) utilities for the machines library"; + license = stdenv.lib.licenses.asl20; + }) {}; + "machines-io" = callPackage + ({ mkDerivation, base, bytestring, chunked-data, machines, stdenv + , transformers + }: + mkDerivation { + pname = "machines-io"; + version = "0.2.0.13"; + sha256 = "4d579d5e9e94fafcfca91322734263498999d2e2af45c40ff0d1db78f4a8f5d4"; + libraryHaskellDepends = [ + base bytestring chunked-data machines transformers + ]; + doHaddock = false; + doCheck = false; + homepage = "http://github.com/aloiscochard/machines-io"; + description = "IO utilities for the machines library"; + license = stdenv.lib.licenses.asl20; + }) {}; + "magicbane" = callPackage + ({ mkDerivation, aeson, aeson-qq, attoparsec, base, bytestring + , conduit, conduit-combinators, data-default, data-has, ekg-core + , ekg-wai, envy, errors, exceptions, fast-logger, http-api-data + , http-client, http-client-tls, http-conduit, http-link-header + , http-types, lifted-base, monad-control, monad-logger + , monad-metrics, mono-traversable, mtl, network-uri, raw-strings-qq + , refined, rio, rio-orphans, servant-server, split, stdenv + , string-conversions, text, transformers, transformers-base + , unliftio, unliftio-core, unordered-containers, wai, wai-cli + , wai-middleware-metrics + }: + mkDerivation { + pname = "magicbane"; + version = "0.3.0"; + sha256 = "20d334206f75bc4d569ec6c55991ccda8bdd00b1a27f0e2bb8ed190222ace6c9"; + libraryHaskellDepends = [ + aeson aeson-qq attoparsec base bytestring conduit + conduit-combinators data-default data-has ekg-core ekg-wai envy + errors exceptions fast-logger http-api-data http-client + http-client-tls http-conduit http-link-header http-types + lifted-base monad-control monad-logger monad-metrics + mono-traversable mtl network-uri raw-strings-qq refined rio + rio-orphans servant-server split string-conversions text + transformers transformers-base unliftio unliftio-core + unordered-containers wai wai-cli wai-middleware-metrics + ]; + doHaddock = false; + doCheck = false; + homepage = "https://github.com/myfreeweb/magicbane#readme"; + description = "A web framework that integrates Servant, RIO, EKG, fast-logger, wai-cli…"; + license = stdenv.lib.licenses.publicDomain; + }) {}; + "main-tester" = callPackage + ({ mkDerivation, base, bytestring, directory, stdenv }: + mkDerivation { + pname = "main-tester"; + version = "0.1.0.0"; + sha256 = "ac09d9c0ac602252d7baef90ef87933b66469f18522e014c475bbe365daa4f69"; + libraryHaskellDepends = [ base bytestring directory ]; + doHaddock = false; + doCheck = false; + homepage = "https://gitlab.com/igrep/main-tester#readme"; + description = "Capture stdout/stderr/exit code, and replace stdin of your main function"; + license = stdenv.lib.licenses.asl20; + }) {}; + "mainland-pretty" = callPackage + ({ mkDerivation, base, containers, srcloc, stdenv, text + , transformers + }: + mkDerivation { + pname = "mainland-pretty"; + version = "0.7"; + sha256 = "11777bd365251813c512a3e17e0303b30f2a86411a12118751858cbb20dbeaf7"; + revision = "1"; + editedCabalFile = "1apyqnbcsbjfkqc1d6mk74pxl12130r6ijwhj555gddls9g0qdf3"; + libraryHaskellDepends = [ + base containers srcloc text transformers + ]; + doHaddock = false; + doCheck = false; + homepage = "https://github.com/mainland/mainland-pretty"; + description = "Pretty printing designed for printing source code"; + license = stdenv.lib.licenses.bsd3; + }) {}; + "makefile" = callPackage + ({ mkDerivation, attoparsec, base, stdenv, text }: + mkDerivation { + pname = "makefile"; + version = "1.1.0.0"; + sha256 = "ed7a12094fe93ef0c6350ed6607ad488703f54bc2ad5d8cb2f9d89eb10b75c07"; + libraryHaskellDepends = [ attoparsec base text ]; + doHaddock = false; + doCheck = false; + homepage = "http://github.com/nmattia/mask"; + description = "Simple Makefile parser and generator"; + license = stdenv.lib.licenses.mit; + }) {}; + "managed" = callPackage + ({ mkDerivation, base, stdenv, transformers }: + mkDerivation { + pname = "managed"; + version = "1.0.6"; + sha256 = "f1a70a23c0866b75d609b2c818b426712d7a2b4256f43a3d5da517e853e279cd"; + libraryHaskellDepends = [ base transformers ]; + doHaddock = false; + doCheck = false; + description = "A monad for managed values"; + license = stdenv.lib.licenses.bsd3; + }) {}; + "mapquest-api" = callPackage + ({ mkDerivation, aeson, base, bytestring, exceptions, goggles, mtl + , req, stdenv, text + }: + mkDerivation { + pname = "mapquest-api"; + version = "0.3.1"; + sha256 = "43339221b91816e8f793a98a4d281285e8e9de8788f13bb30ec345ef855a7b85"; + libraryHaskellDepends = [ + aeson base bytestring exceptions goggles mtl req text + ]; + doHaddock = false; + doCheck = false; + homepage = "https://github.com/ocramz/mapquest-api"; + description = "Bindings to the MapQuest API"; + license = stdenv.lib.licenses.bsd3; + }) {}; + "markdown" = callPackage + ({ mkDerivation, attoparsec, base, blaze-html, blaze-markup + , conduit, conduit-extra, containers, data-default, stdenv, text + , transformers, xml-conduit, xml-types, xss-sanitize + }: + mkDerivation { + pname = "markdown"; + version = "0.1.17.1"; + sha256 = "e1f72d8829bdc86f52aba9f31f107847dc29b240cca9de7dd5efc2ba01673b58"; + libraryHaskellDepends = [ + attoparsec base blaze-html blaze-markup conduit conduit-extra + containers data-default text transformers xml-conduit xml-types + xss-sanitize + ]; + doHaddock = false; + doCheck = false; + homepage = "https://github.com/snoyberg/markdown"; + description = "Convert Markdown to HTML, with XSS protection"; + license = stdenv.lib.licenses.bsd3; + }) {}; + "markdown-unlit" = callPackage + ({ mkDerivation, base, base-compat, stdenv }: + mkDerivation { + pname = "markdown-unlit"; + version = "0.5.0"; + sha256 = "e72d0d7b82525e2a2c664012ce9dc35835b3fff91040d9f20897ed82f24ec7bf"; + isLibrary = true; + isExecutable = true; + libraryHaskellDepends = [ base base-compat ]; + executableHaskellDepends = [ base base-compat ]; + doHaddock = false; + doCheck = false; + homepage = "https://github.com/sol/markdown-unlit#readme"; + description = "Literate Haskell support for Markdown"; + license = stdenv.lib.licenses.mit; + }) {}; + "markov-chain" = callPackage + ({ mkDerivation, base, containers, random, stdenv, transformers }: + mkDerivation { + pname = "markov-chain"; + version = "0.0.3.4"; + sha256 = "6e51b800101a28593be28ce7ef1b21b7cc7a177a821fb99ecd8a28c69b7b92cd"; + libraryHaskellDepends = [ base containers random transformers ]; + doHaddock = false; + doCheck = false; + homepage = "http://code.haskell.org/~thielema/markov-chain/"; + description = "Markov Chains for generating random sequences with a user definable behaviour"; + license = "GPL"; + }) {}; + "marvin-interpolate" = callPackage + ({ mkDerivation, base, haskell-src-meta, mtl, parsec, stdenv + , template-haskell, text + }: + mkDerivation { + pname = "marvin-interpolate"; + version = "1.1.2"; + sha256 = "d640c3bc2f70e17d1fb23c914a3d19b11f72568fda5d5c52e52c1de2e940eccf"; + libraryHaskellDepends = [ + base haskell-src-meta mtl parsec template-haskell text + ]; + doHaddock = false; + doCheck = false; + homepage = "http://marvin.readthedocs.io/en/latest/interpolation.html"; + description = "Compile time string interpolation a la Scala and CoffeeScript"; + license = stdenv.lib.licenses.bsd3; + }) {}; + "massiv" = callPackage + ({ mkDerivation, base, data-default-class, deepseq, ghc-prim + , primitive, stdenv, vector + }: + mkDerivation { + pname = "massiv"; + version = "0.2.0.0"; + sha256 = "32690aeda5953db2231f0eb4b513a5426416e5e6d565b8f64a423502ff8dd94b"; + libraryHaskellDepends = [ + base data-default-class deepseq ghc-prim primitive vector + ]; + doHaddock = false; + doCheck = false; + homepage = "https://github.com/lehins/massiv"; + description = "Massiv (Массив) is an Array Library"; + license = stdenv.lib.licenses.bsd3; + }) {}; + "massiv-io" = callPackage + ({ mkDerivation, base, bytestring, data-default, deepseq, directory + , filepath, JuicyPixels, massiv, netpbm, process, stdenv, vector + }: + mkDerivation { + pname = "massiv-io"; + version = "0.1.4.0"; + sha256 = "8c118ca171008d92cf4f68a3504e328d6b557afeeb4d4cff9fa9a4cace0b5079"; + libraryHaskellDepends = [ + base bytestring data-default deepseq directory filepath JuicyPixels + massiv netpbm process vector + ]; + doHaddock = false; + doCheck = false; + homepage = "https://github.com/lehins/massiv"; + description = "Import/export of Image files into massiv Arrays"; + license = stdenv.lib.licenses.bsd3; + }) {}; + "math-functions" = callPackage + ({ mkDerivation, base, deepseq, primitive, stdenv, vector + , vector-th-unbox + }: + mkDerivation { + pname = "math-functions"; + version = "0.2.1.0"; + sha256 = "f71b5598de453546396a3f5f7f6ce877fffcc996639b7569d8628cae97da65eb"; + libraryHaskellDepends = [ + base deepseq primitive vector vector-th-unbox + ]; + doHaddock = false; + doCheck = false; + homepage = "https://github.com/bos/math-functions"; + description = "Special functions and Chebyshev polynomials"; + license = stdenv.lib.licenses.bsd3; + }) {}; + "mathexpr" = callPackage + ({ mkDerivation, base, data-default-class, stdenv }: + mkDerivation { + pname = "mathexpr"; + version = "0.3.0.0"; + sha256 = "23c30ae0c962a7858d57bed320be6421baeb82fa795260e1eea0bc8fcc4871ad"; + libraryHaskellDepends = [ base data-default-class ]; + doHaddock = false; + doCheck = false; + homepage = "https://github.com/mdibaiee/mathexpr"; + description = "Parse and evaluate math expressions with variables and functions"; + license = stdenv.lib.licenses.gpl3; + }) {}; + "matrices" = callPackage + ({ mkDerivation, base, deepseq, primitive, stdenv, vector }: + mkDerivation { + pname = "matrices"; + version = "0.4.5"; + sha256 = "2d396f130d675eabaa435caba122fe2b2c1d2dfc5343471131b7392e479b7397"; + libraryHaskellDepends = [ base deepseq primitive vector ]; + doHaddock = false; + doCheck = false; + description = "native matrix based on vector"; + license = stdenv.lib.licenses.bsd3; + }) {}; + "matrix" = callPackage + ({ mkDerivation, base, deepseq, loop, primitive, semigroups, stdenv + , vector + }: + mkDerivation { + pname = "matrix"; + version = "0.3.6.1"; + sha256 = "fa976ca3bc98149ce59b7ae37869eda615562711e1fef90889f6e0c4f2093b2c"; + revision = "1"; + editedCabalFile = "0iy0gdgg68ldhgm4lzvzl5pmzflx0r4brdbdkq75rkarm7cigawn"; + libraryHaskellDepends = [ + base deepseq loop primitive semigroups vector + ]; + doHaddock = false; + doCheck = false; + description = "A native implementation of matrix operations"; + license = stdenv.lib.licenses.bsd3; + }) {}; + "matrix-market-attoparsec" = callPackage + ({ mkDerivation, attoparsec, base, bytestring, exceptions + , scientific, stdenv + }: + mkDerivation { + pname = "matrix-market-attoparsec"; + version = "0.1.0.8"; + sha256 = "5e41aa81abdfd6062dc4607ea7c684b9ac09a286d2ebf76829504acf09260a77"; + enableSeparateDataOutput = true; + libraryHaskellDepends = [ + attoparsec base bytestring exceptions scientific + ]; + doHaddock = false; + doCheck = false; + homepage = "https://github.com/ocramz/matrix-market-attoparsec"; + description = "Parsing and serialization functions for the NIST Matrix Market format"; + license = stdenv.lib.licenses.bsd2; + }) {}; + "maximal-cliques" = callPackage + ({ mkDerivation, base, containers, stdenv, vector }: + mkDerivation { + pname = "maximal-cliques"; + version = "0.1.1"; + sha256 = "709d05c753c7d2d7466ade515da0255fc79241432d0118b3182dd3b2def475e9"; + libraryHaskellDepends = [ base containers vector ]; + doHaddock = false; + doCheck = false; + description = "Enumerate all maximal cliques of a graph"; + license = stdenv.lib.licenses.bsd3; + }) {}; + "mbox" = callPackage + ({ mkDerivation, base, safe, stdenv, text, time, time-locale-compat + }: + mkDerivation { + pname = "mbox"; + version = "0.3.4"; + sha256 = "dce4b538bbe03928a1d1438bf80b4d341ffb1a9d23ead1c2b16a04b0fa5371de"; + revision = "1"; + editedCabalFile = "11jikczq21fnhsvr6n33qbb5q6ixbhab4s0js8n39zwgmglighz5"; + libraryHaskellDepends = [ base safe text time time-locale-compat ]; + doHaddock = false; + doCheck = false; + description = "Read and write standard mailbox files"; + license = stdenv.lib.licenses.bsd3; + }) {}; + "mbox-utility" = callPackage + ({ mkDerivation, base, bytestring, hsemail, non-empty, old-time + , parsec, spreadsheet, stdenv, utility-ht + }: + mkDerivation { + pname = "mbox-utility"; + version = "0.0.1"; + sha256 = "e5e009f83c95b20d85c4b39d233b2f32ee15eae08d54edbaa7928848ae15e9f8"; + isLibrary = false; + isExecutable = true; + executableHaskellDepends = [ + base bytestring hsemail non-empty old-time parsec spreadsheet + utility-ht + ]; + doHaddock = false; + doCheck = false; + description = "List contents of an mbox file containing e-mails"; + license = stdenv.lib.licenses.bsd3; + }) {}; + "mbtiles" = callPackage + ({ mkDerivation, base, bytestring, directory, monad-control, mtl + , resource-pool, sqlite-simple, stdenv, text, transformers + , unordered-containers + }: + mkDerivation { + pname = "mbtiles"; + version = "0.6.0.0"; + sha256 = "b8a82f0a1c551a59961449587f031f679dd2f5f082ce45b6f7d88d81f99ad62f"; + libraryHaskellDepends = [ + base bytestring directory monad-control mtl resource-pool + sqlite-simple text transformers unordered-containers + ]; + doHaddock = false; + doCheck = false; + homepage = "https://github.com/caneroj1/mbtiles#readme"; + description = "Haskell MBTiles client"; + license = stdenv.lib.licenses.bsd3; + }) {}; + "mbug" = callPackage + ({ mkDerivation, base, bytestring, directory, extra, formatting + , http-client, http-client-tls, mtl, optparse-applicative, process + , scalpel-core, stdenv, tagsoup, text, time, xdg-basedir + }: + mkDerivation { + pname = "mbug"; + version = "1.3"; + sha256 = "21450dc132fa7a30805ba5a72012c9fc4a0560233dc2930e092b63d1bcaf43dd"; + isLibrary = true; + isExecutable = true; + libraryHaskellDepends = [ + base bytestring directory extra formatting http-client + http-client-tls mtl optparse-applicative process scalpel-core + tagsoup text time xdg-basedir + ]; + executableHaskellDepends = [ + base bytestring directory extra formatting http-client + http-client-tls mtl optparse-applicative process scalpel-core + tagsoup text time xdg-basedir + ]; + doHaddock = false; + doCheck = false; + homepage = "https://gitlab.com/iu-guest/mbug"; + description = "download bugs mailboxes"; + license = stdenv.lib.licenses.gpl3; + }) {}; + "mcmc-types" = callPackage + ({ mkDerivation, base, containers, mwc-probability, stdenv + , transformers + }: + mkDerivation { + pname = "mcmc-types"; + version = "1.0.3"; + sha256 = "3c4b25030b05567694ddc313ca808a32133ad5433b4d89837e1ed00bbfcefc6e"; + libraryHaskellDepends = [ + base containers mwc-probability transformers + ]; + doHaddock = false; + doCheck = false; + homepage = "http://github.com/jtobin/mcmc-types"; + description = "Common types for sampling"; + license = stdenv.lib.licenses.mit; + }) {}; + "med-module" = callPackage + ({ mkDerivation, base, bytestring, stdenv, storable-endian + , transformers, utility-ht + }: + mkDerivation { + pname = "med-module"; + version = "0.1.1"; + sha256 = "f78974fba8f8d17267297b268b84cf7434f51f5d2ad106a461f225f1d873eee3"; + isLibrary = true; + isExecutable = true; + libraryHaskellDepends = [ + base bytestring storable-endian transformers utility-ht + ]; + doHaddock = false; + doCheck = false; + description = "Parse song module files from Amiga MED and OctaMED"; + license = stdenv.lib.licenses.gpl3; + }) {}; + "median-stream" = callPackage + ({ mkDerivation, base, heap, stdenv }: + mkDerivation { + pname = "median-stream"; + version = "0.7.0.0"; + sha256 = "e92fc44be8189dafe9190aad225462780f26d0b1fe1823376342329db6c71f3d"; + libraryHaskellDepends = [ base heap ]; + doHaddock = false; + doCheck = false; + homepage = "https://github.com/caneroj1/median-stream#readme"; + description = "Constant-time queries for the median of a stream of numeric data"; + license = stdenv.lib.licenses.bsd3; + }) {}; + "mega-sdist" = callPackage + ({ mkDerivation, base, bytestring, conduit, conduit-extra + , http-conduit, optparse-simple, rio, rio-orphans, stdenv + , tar-conduit, yaml + }: + mkDerivation { + pname = "mega-sdist"; + version = "0.3.3.1"; + sha256 = "9c27f3f84bfdb48ee6c85e17201893a8767f3f5b28d8f282b60ca018522d965c"; + isLibrary = false; + isExecutable = true; + executableHaskellDepends = [ + base bytestring conduit conduit-extra http-conduit optparse-simple + rio rio-orphans tar-conduit yaml + ]; + doHaddock = false; + doCheck = false; + homepage = "https://github.com/snoyberg/mega-sdist#readme"; + description = "Handles uploading to Hackage from mega repos"; + license = stdenv.lib.licenses.mit; + }) {}; + "megaparsec" = callPackage + ({ mkDerivation, base, bytestring, case-insensitive, containers + , deepseq, mtl, parser-combinators, scientific, stdenv, text + , transformers + }: + mkDerivation { + pname = "megaparsec"; + version = "6.5.0"; + sha256 = "bebdef43c6b857b8c494de79bcd2399ef712c403ee1353e5481db98b8f7f2f8a"; + revision = "4"; + editedCabalFile = "0ij3asi5vwlhbgwsy6nhli9a0qb7926mg809fsgyl1rnhs9fvpx1"; + libraryHaskellDepends = [ + base bytestring case-insensitive containers deepseq mtl + parser-combinators scientific text transformers + ]; + doHaddock = false; + doCheck = false; + homepage = "https://github.com/mrkkrp/megaparsec"; + description = "Monadic parser combinators"; + license = stdenv.lib.licenses.bsd2; + }) {}; + "memory" = callPackage + ({ mkDerivation, base, basement, bytestring, deepseq, foundation + , ghc-prim, stdenv + }: + mkDerivation { + pname = "memory"; + version = "0.14.16"; + sha256 = "7bb0834ab28ce1248f3be09df211d49d20d703cdcda3ed16cde99356e2d72b0f"; + revision = "1"; + editedCabalFile = "10j8737fm287ii0nm4hqnhf87apls3xjczkzdw9qqkb4a2dybsbx"; + libraryHaskellDepends = [ + base basement bytestring deepseq foundation ghc-prim + ]; + doHaddock = false; + doCheck = false; + homepage = "https://github.com/vincenthz/hs-memory"; + description = "memory and related abstraction stuff"; + license = stdenv.lib.licenses.bsd3; + }) {}; + "mercury-api" = callPackage + ({ mkDerivation, ansi-terminal, base, bytestring, clock, hashable + , optparse-applicative, stdenv, text, unordered-containers + }: + mkDerivation { + pname = "mercury-api"; + version = "0.1.0.1"; + sha256 = "f9e398ec0256b065de94f9412de6d164bd6fc425ad64d407d513db232602bb40"; + revision = "2"; + editedCabalFile = "093c8afmcrnbfliz1ykpyc4w40dli2wig0qi0xcwg8445idwp2kg"; + isLibrary = true; + isExecutable = true; + libraryHaskellDepends = [ + ansi-terminal base bytestring clock hashable text + unordered-containers + ]; + executableHaskellDepends = [ + ansi-terminal base bytestring optparse-applicative text + ]; + doHaddock = false; + doCheck = false; + homepage = "https://github.com/ppelleti/hs-mercury-api"; + description = "Haskell binding to Mercury API for ThingMagic RFID readers"; + license = stdenv.lib.licenses.mit; + }) {}; + "mersenne-random-pure64" = callPackage + ({ mkDerivation, base, random, stdenv, time }: + mkDerivation { + pname = "mersenne-random-pure64"; + version = "0.2.2.0"; + sha256 = "ef1400ddc1ddafb0b98d4331a58bdbe3b5209a81579e17f85f180731a96d75d1"; + revision = "1"; + editedCabalFile = "0pxq0xz42x60993rl4pr4pia80jv1xcqh6njvjzfvn75018j4gw5"; + libraryHaskellDepends = [ base random time ]; + doHaddock = false; + doCheck = false; + homepage = "http://code.haskell.org/~dons/code/mersenne-random-pure64/"; + description = "Generate high quality pseudorandom numbers purely using a Mersenne Twister"; + license = stdenv.lib.licenses.bsd3; + }) {}; + "messagepack" = callPackage + ({ mkDerivation, base, bytestring, cereal, containers, deepseq + , stdenv + }: + mkDerivation { + pname = "messagepack"; + version = "0.5.4"; + sha256 = "939590c05d5b0831b3b4796f2e1a070e290982c92b2009f2aa1ef5f4b05b5d7c"; + revision = "1"; + editedCabalFile = "0p13in70gvxl8d8hjl1dcxczfpcfyffy2lxbdy1d21h742ks1zjb"; + libraryHaskellDepends = [ + base bytestring cereal containers deepseq + ]; + doHaddock = false; + doCheck = false; + homepage = "https://github.com/rodrigosetti/messagepack"; + description = "Serialize instance for Message Pack Object"; + license = stdenv.lib.licenses.mit; + }) {}; + "messagepack-rpc" = callPackage + ({ mkDerivation, base, bytestring, cereal, containers, messagepack + , network-simple, stdenv + }: + mkDerivation { + pname = "messagepack-rpc"; + version = "0.5.1"; + sha256 = "aa7960644668284e6add36e5c305af2c6d3ebf0a9a2c3fcd62529554a049a0bc"; + revision = "1"; + editedCabalFile = "05p6naaxswmsc3w7k67ydzzwyn60ymp0jbrc0f66p2sajvlnviax"; + libraryHaskellDepends = [ + base bytestring cereal containers messagepack network-simple + ]; + doHaddock = false; + doCheck = false; + homepage = "http://github.com/rodrigosetti/messagepack-rpc"; + description = "Message Pack RPC over TCP"; + license = stdenv.lib.licenses.mit; + }) {}; + "metrics" = callPackage + ({ mkDerivation, ansi-terminal, base, bytestring, containers, lens + , mwc-random, primitive, stdenv, text, time, transformers + , transformers-base, unix-compat, unordered-containers, vector + , vector-algorithms + }: + mkDerivation { + pname = "metrics"; + version = "0.4.1.1"; + sha256 = "d55f6e704ec6f0c6bab0da46417049b7de3e76ca69a0be4c49a790db28c75bb8"; + libraryHaskellDepends = [ + ansi-terminal base bytestring containers lens mwc-random primitive + text time transformers transformers-base unix-compat + unordered-containers vector vector-algorithms + ]; + doHaddock = false; + doCheck = false; + description = "High-performance application metric tracking"; + license = stdenv.lib.licenses.mit; + }) {}; + "mfsolve" = callPackage + ({ mkDerivation, base, hashable, mtl, mtl-compat, stdenv + , unordered-containers + }: + mkDerivation { + pname = "mfsolve"; + version = "0.3.2.0"; + sha256 = "232167442f9c0f326b7514b362d4521b3937b716fd4155c65060d34430aa42f1"; + libraryHaskellDepends = [ + base hashable mtl mtl-compat unordered-containers + ]; + doHaddock = false; + doCheck = false; + description = "Equation solver and calculator à la metafont"; + license = stdenv.lib.licenses.bsd3; + }) {}; + "microformats2-parser" = callPackage + ({ mkDerivation, aeson, aeson-pretty, aeson-qq, attoparsec, base + , base-compat, blaze-html, blaze-markup, bytestring, containers + , data-default, either, errors, html-conduit, lens-aeson, network + , network-uri, options, pcre-heavy, safe, scotty, stdenv, tagsoup + , text, time, transformers, unordered-containers, vector, wai-cli + , wai-extra, xml-lens, xss-sanitize + }: + mkDerivation { + pname = "microformats2-parser"; + version = "1.0.1.9"; + sha256 = "50c71d9cd57991011855ad16759a6d43f56abc0e7424475db5263c5f04e2abd3"; + isLibrary = true; + isExecutable = true; + libraryHaskellDepends = [ + aeson aeson-qq attoparsec base base-compat blaze-markup bytestring + containers data-default either errors html-conduit lens-aeson + network-uri pcre-heavy safe tagsoup text time transformers + unordered-containers vector xml-lens xss-sanitize + ]; + executableHaskellDepends = [ + aeson aeson-pretty base base-compat blaze-html blaze-markup + data-default network network-uri options scotty text wai-cli + wai-extra + ]; + doHaddock = false; + doCheck = false; + homepage = "https://github.com/myfreeweb/microformats2-parser"; + description = "A Microformats 2 parser"; + license = stdenv.lib.licenses.publicDomain; + }) {}; + "microlens" = callPackage + ({ mkDerivation, base, stdenv }: + mkDerivation { + pname = "microlens"; + version = "0.4.9.1"; + sha256 = "a1401c6f92c142bafea4cf58a1d99cc34af285df808b97f5b64af4bb81fb5648"; + libraryHaskellDepends = [ base ]; + doHaddock = false; + doCheck = false; + homepage = "http://github.com/aelve/microlens"; + description = "A tiny lens library with no dependencies. If you're writing an app, you probably want microlens-platform, not this."; + license = stdenv.lib.licenses.bsd3; + }) {}; + "microlens-aeson" = callPackage + ({ mkDerivation, aeson, attoparsec, base, bytestring, deepseq + , hashable, microlens, scientific, stdenv, text + , unordered-containers, vector + }: + mkDerivation { + pname = "microlens-aeson"; + version = "2.3.0"; + sha256 = "f2f28288bfc190127423a452514d35f7b66f9d5625cf6653bb34cb020aa450c5"; + revision = "2"; + editedCabalFile = "1ri98vr3bbx0l9b4vpmcwhf8fm5lgj92kw4g0v3jx6xajwwc5dc8"; + libraryHaskellDepends = [ + aeson attoparsec base bytestring deepseq hashable microlens + scientific text unordered-containers vector + ]; + doHaddock = false; + doCheck = false; + homepage = "http://github.com/fosskers/microlens-aeson/"; + description = "Law-abiding lenses for Aeson, using microlens"; + license = stdenv.lib.licenses.mit; + }) {}; + "microlens-contra" = callPackage + ({ mkDerivation, base, contravariant, microlens, stdenv }: + mkDerivation { + pname = "microlens-contra"; + version = "0.1.0.1"; + sha256 = "4983f19d37168a7cb862f76a22e8a43156df89c3c58b8206e2c84b2262c7f595"; + libraryHaskellDepends = [ base contravariant microlens ]; + doHaddock = false; + doCheck = false; + homepage = "http://github.com/aelve/microlens"; + description = "True folds and getters for microlens"; + license = stdenv.lib.licenses.bsd3; + }) {}; + "microlens-ghc" = callPackage + ({ mkDerivation, array, base, bytestring, containers, microlens + , stdenv, transformers + }: + mkDerivation { + pname = "microlens-ghc"; + version = "0.4.9"; + sha256 = "aa3af55477443a05516d70676926e5b83403c319ed387d22e094bea393cabc71"; + libraryHaskellDepends = [ + array base bytestring containers microlens transformers + ]; + doHaddock = false; + doCheck = false; + homepage = "http://github.com/aelve/microlens"; + description = "microlens + array, bytestring, containers, transformers"; + license = stdenv.lib.licenses.bsd3; + }) {}; + "microlens-mtl" = callPackage + ({ mkDerivation, base, microlens, mtl, stdenv, transformers + , transformers-compat + }: + mkDerivation { + pname = "microlens-mtl"; + version = "0.1.11.1"; + sha256 = "d3e74f46a72aad12b71d8549a98fbc023fb364766f17d75742fb32fee70bdf50"; + libraryHaskellDepends = [ + base microlens mtl transformers transformers-compat + ]; + doHaddock = false; + doCheck = false; + homepage = "http://github.com/aelve/microlens"; + description = "microlens support for Reader/Writer/State from mtl"; + license = stdenv.lib.licenses.bsd3; + }) {}; + "microlens-platform" = callPackage + ({ mkDerivation, base, hashable, microlens, microlens-ghc + , microlens-mtl, microlens-th, stdenv, text, unordered-containers + , vector + }: + mkDerivation { + pname = "microlens-platform"; + version = "0.3.10"; + sha256 = "9b7fe59900ee35af9b070d154e9505b9f5c1953a95437c588f00cbe45e8596b4"; + libraryHaskellDepends = [ + base hashable microlens microlens-ghc microlens-mtl microlens-th + text unordered-containers vector + ]; + doHaddock = false; + doCheck = false; + homepage = "http://github.com/aelve/microlens"; + description = "Feature-complete microlens"; + license = stdenv.lib.licenses.bsd3; + }) {}; + "microlens-th" = callPackage + ({ mkDerivation, base, containers, microlens, stdenv + , template-haskell, th-abstraction, transformers + }: + mkDerivation { + pname = "microlens-th"; + version = "0.4.2.1"; + sha256 = "ec57108e9ab54c085dd316b60ac156e6624078a46682a60ed2462005cae4fc42"; + libraryHaskellDepends = [ + base containers microlens template-haskell th-abstraction + transformers + ]; + doHaddock = false; + doCheck = false; + homepage = "http://github.com/aelve/microlens"; + description = "Automatic generation of record lenses for microlens"; + license = stdenv.lib.licenses.bsd3; + }) {}; + "microspec" = callPackage + ({ mkDerivation, base, QuickCheck, stdenv }: + mkDerivation { + pname = "microspec"; + version = "0.1.0.0"; + sha256 = "e1e4156574d81786e1c8d04ba22e7283001ef3eada3104a99e9c31a45656d343"; + revision = "1"; + editedCabalFile = "0cnfj3v6fzck57bgrsnmgz8a9azvz04pm3hv17fg12xzchmp07cq"; + libraryHaskellDepends = [ base QuickCheck ]; + doHaddock = false; + doCheck = false; + description = "Tiny QuickCheck test library with minimal dependencies"; + license = stdenv.lib.licenses.bsd3; + }) {}; + "microstache" = callPackage + ({ mkDerivation, aeson, base, bytestring, containers, deepseq + , directory, filepath, parsec, stdenv, text, transformers + , unordered-containers, vector + }: + mkDerivation { + pname = "microstache"; + version = "1.0.1.1"; + sha256 = "5de98542313eb75f84961366ff8a70ed632387ba6518215035b2dd1b32d6a120"; + revision = "3"; + editedCabalFile = "1pq0h64vxc7zlncn2ld6k02wi6rfa5ccqc4z0hfkvaldj41y2sb1"; + libraryHaskellDepends = [ + aeson base bytestring containers deepseq directory filepath parsec + text transformers unordered-containers vector + ]; + doHaddock = false; + doCheck = false; + homepage = "https://github.com/phadej/microstache"; + description = "Mustache templates for Haskell"; + license = stdenv.lib.licenses.bsd3; + }) {}; + "midi" = callPackage + ({ mkDerivation, base, binary, bytestring, event-list + , explicit-exception, monoid-transformer, non-negative, QuickCheck + , random, semigroups, stdenv, transformers, utility-ht + }: + mkDerivation { + pname = "midi"; + version = "0.2.2.2"; + sha256 = "de7cb58971a43f23e2a1ec0c4c01f690c1dd11ba55bc71264e1b9731014a693b"; + libraryHaskellDepends = [ + base binary bytestring event-list explicit-exception + monoid-transformer non-negative QuickCheck random semigroups + transformers utility-ht + ]; + doHaddock = false; + doCheck = false; + homepage = "http://www.haskell.org/haskellwiki/MIDI"; + description = "Handling of MIDI messages and files"; + license = "GPL"; + }) {}; + "mighty-metropolis" = callPackage + ({ mkDerivation, base, kan-extensions, mcmc-types, mwc-probability + , pipes, primitive, stdenv, transformers + }: + mkDerivation { + pname = "mighty-metropolis"; + version = "1.2.0"; + sha256 = "8d3c0b4b65024846291c4f547c45e5c04f587aefd0e8d041d54679bb519871c0"; + libraryHaskellDepends = [ + base kan-extensions mcmc-types mwc-probability pipes primitive + transformers + ]; + doHaddock = false; + doCheck = false; + homepage = "http://github.com/jtobin/mighty-metropolis"; + description = "The Metropolis algorithm"; + license = stdenv.lib.licenses.mit; + }) {}; + "milena" = callPackage + ({ mkDerivation, base, bytestring, cereal, containers, digest, lens + , lifted-base, monad-control, mtl, murmur-hash, network, random + , resource-pool, semigroups, stdenv, transformers, zlib + }: + mkDerivation { + pname = "milena"; + version = "0.5.2.2"; + sha256 = "21da8cd70415a1ea46a463f715c228cd222785829caed39a3f065f9e4e164f35"; + libraryHaskellDepends = [ + base bytestring cereal containers digest lens lifted-base + monad-control mtl murmur-hash network random resource-pool + semigroups transformers zlib + ]; + doHaddock = false; + doCheck = false; + homepage = "https://github.com/adamflott/milena.git#readme"; + description = "A Kafka client for Haskell"; + license = stdenv.lib.licenses.bsd3; + }) {}; + "mime-mail" = callPackage + ({ mkDerivation, base, base64-bytestring, blaze-builder, bytestring + , filepath, process, random, stdenv, text + }: + mkDerivation { + pname = "mime-mail"; + version = "0.4.14"; + sha256 = "9632c3d54c9741fece0a3ea705d965485a1299ebe5798d2aa7cca2c8e4baaa3e"; + libraryHaskellDepends = [ + base base64-bytestring blaze-builder bytestring filepath process + random text + ]; + doHaddock = false; + doCheck = false; + homepage = "http://github.com/snoyberg/mime-mail"; + description = "Compose MIME email messages"; + license = stdenv.lib.licenses.mit; + }) {}; + "mime-mail-ses" = callPackage + ({ mkDerivation, base, base64-bytestring, byteable, bytestring + , conduit, cryptohash, http-client, http-client-tls, http-conduit + , http-types, mime-mail, old-locale, stdenv, text, time + , transformers, xml-conduit, xml-types + }: + mkDerivation { + pname = "mime-mail-ses"; + version = "0.4.1"; + sha256 = "a76f29d1e52d8fbfc7ea8119f6ede5ed87f9e5b9d5587f1e6c69295f2a23d3f0"; + libraryHaskellDepends = [ + base base64-bytestring byteable bytestring conduit cryptohash + http-client http-client-tls http-conduit http-types mime-mail + old-locale text time transformers xml-conduit xml-types + ]; + doHaddock = false; + doCheck = false; + homepage = "http://github.com/snoyberg/mime-mail"; + description = "Send mime-mail messages via Amazon SES"; + license = stdenv.lib.licenses.mit; + }) {}; + "mime-types" = callPackage + ({ mkDerivation, base, bytestring, containers, stdenv, text }: + mkDerivation { + pname = "mime-types"; + version = "0.1.0.8"; + sha256 = "a88b14a27cb03a0193b1d7afdbfcded82f3aff3eec2e20fd3f41794190a08c91"; + libraryHaskellDepends = [ base bytestring containers text ]; + doHaddock = false; + doCheck = false; + homepage = "https://github.com/yesodweb/wai"; + description = "Basic mime-type handling types and functions"; + license = stdenv.lib.licenses.mit; + }) {}; + "minimorph" = callPackage + ({ mkDerivation, base, stdenv, text }: + mkDerivation { + pname = "minimorph"; + version = "0.1.6.1"; + sha256 = "94677b454b86a47d1b04ef1462873708976546bbb7a3bcc4f3ffe222d98bb844"; + libraryHaskellDepends = [ base text ]; + doHaddock = false; + doCheck = false; + homepage = "https://github.com/Mikolaj/minimorph"; + description = "English spelling functions with an emphasis on simplicity"; + license = stdenv.lib.licenses.bsd3; + }) {}; + "minio-hs" = callPackage + ({ mkDerivation, aeson, base, base64-bytestring, bytestring + , case-insensitive, conduit, conduit-extra, containers, cryptonite + , cryptonite-conduit, directory, filepath, http-client + , http-conduit, http-types, ini, memory, protolude, resourcet + , stdenv, text, time, transformers, unliftio, unliftio-core + , xml-conduit + }: + mkDerivation { + pname = "minio-hs"; + version = "1.2.0"; + sha256 = "311494977fdab5f112807b13d485542c5b57147039063ad57c09bc1367541093"; + libraryHaskellDepends = [ + aeson base base64-bytestring bytestring case-insensitive conduit + conduit-extra containers cryptonite cryptonite-conduit directory + filepath http-client http-conduit http-types ini memory protolude + resourcet text time transformers unliftio unliftio-core xml-conduit + ]; + doHaddock = false; + doCheck = false; + homepage = "https://github.com/minio/minio-hs#readme"; + description = "A Minio Haskell Library for Amazon S3 compatible cloud storage"; + license = stdenv.lib.licenses.asl20; + }) {}; + "minisat-solver" = callPackage + ({ mkDerivation, base, containers, stdenv, transformers }: + mkDerivation { + pname = "minisat-solver"; + version = "0.1"; + sha256 = "c12098dee034afb98b31ce7ac346398b93a3537c11e30e7573d25160120fd37d"; + libraryHaskellDepends = [ base containers transformers ]; + doHaddock = false; + doCheck = false; + homepage = "http://www.mathstat.dal.ca/~selinger/minisat-solver/"; + description = "High-level Haskell bindings for the MiniSat SAT solver"; + license = stdenv.lib.licenses.mit; + }) {}; + "miniutter" = callPackage + ({ mkDerivation, base, binary, containers, ghc-prim, minimorph + , stdenv, text + }: + mkDerivation { + pname = "miniutter"; + version = "0.4.7.0"; + sha256 = "adc9ac6a2160e87a8a4c4b88087d478ee74dded59d0cf6205a105dc0f778dc82"; + libraryHaskellDepends = [ + base binary containers ghc-prim minimorph text + ]; + doHaddock = false; + doCheck = false; + homepage = "https://github.com/Mikolaj/miniutter"; + description = "Simple English clause creation from arbitrary words"; + license = stdenv.lib.licenses.bsd3; + }) {}; + "mintty" = callPackage + ({ mkDerivation, base, stdenv }: + mkDerivation { + pname = "mintty"; + version = "0.1.2"; + sha256 = "7c8af77bcde4e9b54692e3761f41adf35a50664974ba77f2ba65ea2af9f950da"; + libraryHaskellDepends = [ base ]; + doHaddock = false; + doCheck = false; + homepage = "https://github.com/RyanGlScott/mintty"; + description = "A reliable way to detect the presence of a MinTTY console on Windows"; + license = stdenv.lib.licenses.bsd3; + }) {}; + "miso" = callPackage + ({ mkDerivation, aeson, base, bytestring, containers, http-api-data + , http-types, lucid, network-uri, servant, servant-lucid, stdenv + , text, transformers, vector + }: + mkDerivation { + pname = "miso"; + version = "0.21.1.0"; + sha256 = "14017e15fa6cebe493705f0a0b30bb0121928b42b9e03549dd12835a6d02e9fb"; + isLibrary = true; + isExecutable = true; + libraryHaskellDepends = [ + aeson base bytestring containers http-api-data http-types lucid + network-uri servant servant-lucid text transformers vector + ]; + doHaddock = false; + doCheck = false; + homepage = "http://github.com/dmjio/miso"; + description = "A tasty Haskell front-end framework"; + license = stdenv.lib.licenses.bsd3; + }) {}; + "missing-foreign" = callPackage + ({ mkDerivation, base, stdenv }: + mkDerivation { + pname = "missing-foreign"; + version = "0.1.1"; + sha256 = "9e1b36cdb8626d848386c1c4d54f3b9f80b3458398aa6a4d499266b5ecbcc885"; + libraryHaskellDepends = [ base ]; + doHaddock = false; + doCheck = false; + description = "Convenience functions for FFI work"; + license = stdenv.lib.licenses.bsd3; + }) {}; + "mixed-types-num" = callPackage + ({ mkDerivation, base, convertible, hspec, hspec-smallcheck + , QuickCheck, smallcheck, stdenv, template-haskell + }: + mkDerivation { + pname = "mixed-types-num"; + version = "0.3.1.4"; + sha256 = "c4ffffea5a5eae0a1fafde3187be1bdf9cd0d166bee0bd502b1aa6cd898dc100"; + libraryHaskellDepends = [ + base convertible hspec hspec-smallcheck QuickCheck smallcheck + template-haskell + ]; + doHaddock = false; + doCheck = false; + homepage = "https://github.com/michalkonecny/mixed-types-num"; + description = "Alternative Prelude with numeric and logic expressions typed bottom-up"; + license = stdenv.lib.licenses.bsd3; + }) {}; + "mltool" = callPackage + ({ mkDerivation, ascii-progress, base, deepseq, hmatrix + , hmatrix-gsl, hmatrix-morpheus, MonadRandom, random, stdenv + , vector + }: + mkDerivation { + pname = "mltool"; + version = "0.2.0.1"; + sha256 = "716ec75fc8eb573c9c6ab327a9658685f5131eacff69fbbc72289cdd0133e0ff"; + libraryHaskellDepends = [ + ascii-progress base deepseq hmatrix hmatrix-gsl hmatrix-morpheus + MonadRandom random vector + ]; + doHaddock = false; + doCheck = false; + homepage = "https://github.com/aligusnet/mltool"; + description = "Machine Learning Toolbox"; + license = stdenv.lib.licenses.bsd3; + }) {}; + "mmap" = callPackage + ({ mkDerivation, base, bytestring, stdenv }: + mkDerivation { + pname = "mmap"; + version = "0.5.9"; + sha256 = "58fcbb04e1cb8e7c36c05823b02dce2faaa989c53d745a7f36192de2fc98b5f8"; + isLibrary = true; + isExecutable = true; + libraryHaskellDepends = [ base bytestring ]; + doHaddock = false; + doCheck = false; + description = "Memory mapped files for POSIX and Windows"; + license = stdenv.lib.licenses.bsd3; + }) {}; + "mmark" = callPackage + ({ mkDerivation, aeson, base, case-insensitive, containers + , data-default-class, deepseq, dlist, email-validate, foldl + , hashable, html-entity-map, lucid, megaparsec, microlens + , microlens-th, modern-uri, mtl, parser-combinators, stdenv, text + , text-metrics, unordered-containers, yaml + }: + mkDerivation { + pname = "mmark"; + version = "0.0.5.6"; + sha256 = "fc036385fd4cea07a490df00d8fe443cc6656a6d090d537d4d5e860564ef1234"; + revision = "6"; + editedCabalFile = "13cn8nkqj0zl26rgs01rspb2mz6gq1a6ax3g5bygdphvwzraswc5"; + enableSeparateDataOutput = true; + libraryHaskellDepends = [ + aeson base case-insensitive containers data-default-class deepseq + dlist email-validate foldl hashable html-entity-map lucid + megaparsec microlens microlens-th modern-uri mtl parser-combinators + text text-metrics unordered-containers yaml + ]; + doHaddock = false; + doCheck = false; + homepage = "https://github.com/mmark-md/mmark"; + description = "Strict markdown processor for writers"; + license = stdenv.lib.licenses.bsd3; + }) {}; + "mmark-cli" = callPackage + ({ mkDerivation, aeson, base, bytestring, directory, gitrev, lucid + , megaparsec, mmark, mmark-ext, optparse-applicative, stache + , stdenv, text, unordered-containers + }: + mkDerivation { + pname = "mmark-cli"; + version = "0.0.3.0"; + sha256 = "37d3e98d15ccc036db5e2ec1b8b1e84a20c303ba1821a44ec441e835c43c6159"; + revision = "2"; + editedCabalFile = "0i3gvfgm4bfbdyflhhaf4gdr7cbkw51i330f25rgha9k3s4v59w3"; + isLibrary = false; + isExecutable = true; + executableHaskellDepends = [ + aeson base bytestring directory gitrev lucid megaparsec mmark + mmark-ext optparse-applicative stache text unordered-containers + ]; + doHaddock = false; + doCheck = false; + homepage = "https://github.com/mmark-md/mmark-cli"; + description = "Command line interface to MMark markdown processor"; + license = stdenv.lib.licenses.bsd3; + }) {}; + "mmark-ext" = callPackage + ({ mkDerivation, base, foldl, ghc-syntax-highlighter, lucid + , microlens, mmark, modern-uri, skylighting, stdenv, text + }: + mkDerivation { + pname = "mmark-ext"; + version = "0.2.1.0"; + sha256 = "1a02396a80708c60b3aecb668c16a3d0cb890bbfcc4fbf722c9742b75ce23fcd"; + revision = "2"; + editedCabalFile = "0xcjkzaah0npyw87mdsymq4bjwdf988fqmylzgr4kihks1a8d4xs"; + enableSeparateDataOutput = true; + libraryHaskellDepends = [ + base foldl ghc-syntax-highlighter lucid microlens mmark modern-uri + skylighting text + ]; + doHaddock = false; + doCheck = false; + homepage = "https://github.com/mmark-md/mmark-ext"; + description = "Commonly useful extensions for the MMark markdown processor"; + license = stdenv.lib.licenses.bsd3; + }) {}; + "mmorph" = callPackage + ({ mkDerivation, base, mtl, stdenv, transformers + , transformers-compat + }: + mkDerivation { + pname = "mmorph"; + version = "1.1.2"; + sha256 = "c90afd7996c94be2b9a5796a7b94918d198c53b0c1d7a3eaf2982293560c5fbe"; + libraryHaskellDepends = [ + base mtl transformers transformers-compat + ]; + doHaddock = false; + doCheck = false; + description = "Monad morphisms"; + license = stdenv.lib.licenses.bsd3; + }) {}; + "mnist-idx" = callPackage + ({ mkDerivation, base, binary, bytestring, stdenv, vector }: + mkDerivation { + pname = "mnist-idx"; + version = "0.1.2.8"; + sha256 = "42ff167e84414821ed47d783042cad20a0bd198f935648aa6cdf97bdc291b2fe"; + libraryHaskellDepends = [ base binary bytestring vector ]; + doHaddock = false; + doCheck = false; + homepage = "https://github.com/kryoxide/mnist-idx/"; + description = "Read and write IDX data that is used in e.g. the MNIST database."; + license = stdenv.lib.licenses.lgpl3; + }) {}; + "mockery" = callPackage + ({ mkDerivation, base, base-compat, bytestring, directory, filepath + , logging-facade, stdenv, temporary + }: + mkDerivation { + pname = "mockery"; + version = "0.3.5"; + sha256 = "b7a1edacd3d32dc7f0e28c67877209d3ca3551d1da186f6445f825f3477dd727"; + libraryHaskellDepends = [ + base base-compat bytestring directory filepath logging-facade + temporary + ]; + doHaddock = false; + doCheck = false; + description = "Support functions for automated testing"; + license = stdenv.lib.licenses.mit; + }) {}; + "modern-uri" = callPackage + ({ mkDerivation, base, bytestring, containers, contravariant + , deepseq, exceptions, megaparsec, mtl, profunctors, QuickCheck + , reflection, stdenv, tagged, template-haskell, text + }: + mkDerivation { + pname = "modern-uri"; + version = "0.2.1.0"; + sha256 = "e65aca7e994b3a470584da17571878084e90120507b8deab9a9b021d529f981a"; + revision = "5"; + editedCabalFile = "089smjciwx6iav6wqpxhwdzlm0d1jdmgcgjv0r2c4vqrwdd1wb4h"; + libraryHaskellDepends = [ + base bytestring containers contravariant deepseq exceptions + megaparsec mtl profunctors QuickCheck reflection tagged + template-haskell text + ]; + doHaddock = false; + doCheck = false; + homepage = "https://github.com/mrkkrp/modern-uri"; + description = "Modern library for working with URIs"; + license = stdenv.lib.licenses.bsd3; + }) {}; + "moesocks" = callPackage + ({ mkDerivation, aeson, async, attoparsec, base, binary, bytestring + , containers, cryptohash, hslogger, HsOpenSSL, iproute, lens + , lens-aeson, mtl, network, optparse-applicative, random, stdenv + , stm, strict, text, time, transformers, unordered-containers + }: + mkDerivation { + pname = "moesocks"; + version = "1.0.0.44"; + sha256 = "bf35a237dffeaebc82237439fe457d0c423d235a48a69f02c9e616297540e1c8"; + isLibrary = false; + isExecutable = true; + executableHaskellDepends = [ + aeson async attoparsec base binary bytestring containers cryptohash + hslogger HsOpenSSL iproute lens lens-aeson mtl network + optparse-applicative random stm strict text time transformers + unordered-containers + ]; + doHaddock = false; + doCheck = false; + homepage = "https://github.com/nfjinjing/moesocks"; + description = "A functional firewall killer"; + license = stdenv.lib.licenses.asl20; + }) {}; + "monad-control" = callPackage + ({ mkDerivation, base, stdenv, stm, transformers, transformers-base + , transformers-compat + }: + mkDerivation { + pname = "monad-control"; + version = "1.0.2.3"; + sha256 = "6c1034189d237ae45368c70f0e68f714dd3beda715dd265b6c8a99fcc64022b1"; + libraryHaskellDepends = [ + base stm transformers transformers-base transformers-compat + ]; + doHaddock = false; + doCheck = false; + homepage = "https://github.com/basvandijk/monad-control"; + description = "Lift control operations, like exception catching, through monad transformers"; + license = stdenv.lib.licenses.bsd3; + }) {}; + "monad-control-aligned" = callPackage + ({ mkDerivation, base, stdenv, stm, transformers, transformers-base + , transformers-compat + }: + mkDerivation { + pname = "monad-control-aligned"; + version = "0.0.1.1"; + sha256 = "44e78fd32d6644e974ab0644dc79331643c8ada4837c8f3c94f4a30b5ee011f6"; + libraryHaskellDepends = [ + base stm transformers transformers-base transformers-compat + ]; + doHaddock = false; + doCheck = false; + homepage = "https://github.com/athanclark/monad-control#readme"; + description = "Just like monad-control, except less efficient, and the monadic state terms are all * -> *"; + license = stdenv.lib.licenses.bsd3; + }) {}; + "monad-coroutine" = callPackage + ({ mkDerivation, base, monad-parallel, stdenv, transformers + , transformers-compat + }: + mkDerivation { + pname = "monad-coroutine"; + version = "0.9.0.4"; + sha256 = "13e0ff12046296390ea69dda5001aa02b1b57e968447d27712a24c8c7cfe5de7"; + libraryHaskellDepends = [ + base monad-parallel transformers transformers-compat + ]; + doHaddock = false; + doCheck = false; + homepage = "http://trac.haskell.org/SCC/wiki/monad-coroutine"; + description = "Coroutine monad transformer for suspending and resuming monadic computations"; + license = "GPL"; + }) {}; + "monad-extras" = callPackage + ({ mkDerivation, base, mmorph, monad-control, stdenv, stm + , transformers, transformers-base + }: + mkDerivation { + pname = "monad-extras"; + version = "0.6.0"; + sha256 = "df33d7c51a97d16226b8160d9bc09686cb6f7b7bf5c54557381c6fe4a3c84f2c"; + libraryHaskellDepends = [ + base mmorph monad-control stm transformers transformers-base + ]; + doHaddock = false; + doCheck = false; + homepage = "http://github.com/jwiegley/monad-extras"; + description = "Extra utility functions for working with monads"; + license = stdenv.lib.licenses.bsd3; + }) {}; + "monad-journal" = callPackage + ({ mkDerivation, base, monad-control, mtl, stdenv, transformers + , transformers-base + }: + mkDerivation { + pname = "monad-journal"; + version = "0.8.1"; + sha256 = "e20ac220086081b5cf1964e9486e04113ec03b15f247512a2193898100a105ac"; + libraryHaskellDepends = [ + base monad-control mtl transformers transformers-base + ]; + doHaddock = false; + doCheck = false; + homepage = "http://github.com/phaazon/monad-journal"; + description = "Pure logger typeclass and monad transformer"; + license = stdenv.lib.licenses.bsd3; + }) {}; + "monad-logger" = callPackage + ({ mkDerivation, base, bytestring, conduit, conduit-extra + , exceptions, fast-logger, lifted-base, monad-control, monad-loops + , mtl, resourcet, stdenv, stm, stm-chans, template-haskell, text + , transformers, transformers-base, transformers-compat + , unliftio-core + }: + mkDerivation { + pname = "monad-logger"; + version = "0.3.28.5"; + sha256 = "225ed7cd2d0d375c0207d5d3b9faa12b339ca7dd51ca92f96d3eaf2d360027f1"; + libraryHaskellDepends = [ + base bytestring conduit conduit-extra exceptions fast-logger + lifted-base monad-control monad-loops mtl resourcet stm stm-chans + template-haskell text transformers transformers-base + transformers-compat unliftio-core + ]; + doHaddock = false; + doCheck = false; + homepage = "https://github.com/snoyberg/monad-logger#readme"; + description = "A class of monads which can log messages"; + license = stdenv.lib.licenses.mit; + }) {}; + "monad-logger-json" = callPackage + ({ mkDerivation, aeson, base, monad-logger, stdenv + , template-haskell, text + }: + mkDerivation { + pname = "monad-logger-json"; + version = "0.1.0.0"; + sha256 = "10871c4aef838c01c8fdd7586161367b4d66907a53cbd9737efb717a1041e9aa"; + libraryHaskellDepends = [ + aeson base monad-logger template-haskell text + ]; + doHaddock = false; + doCheck = false; + homepage = "http://github.com/fpco/monad-logger-json"; + description = "JSON-friendly Logging APIs"; + license = stdenv.lib.licenses.mit; + }) {}; + "monad-logger-prefix" = callPackage + ({ mkDerivation, base, exceptions, monad-control, monad-logger, mtl + , resourcet, stdenv, text, transformers, transformers-base + }: + mkDerivation { + pname = "monad-logger-prefix"; + version = "0.1.10"; + sha256 = "a3ac2d043a13d9e9296692dc729a299361b04757690894cac1b6904510a0d975"; + libraryHaskellDepends = [ + base exceptions monad-control monad-logger mtl resourcet text + transformers transformers-base + ]; + doHaddock = false; + doCheck = false; + homepage = "https://github.com/parsonsmatt/monad-logger-prefix#readme"; + description = "Add prefixes to your monad-logger output"; + license = stdenv.lib.licenses.asl20; + }) {}; + "monad-logger-syslog" = callPackage + ({ mkDerivation, base, bytestring, fast-logger, hsyslog + , monad-logger, stdenv, text, transformers + }: + mkDerivation { + pname = "monad-logger-syslog"; + version = "0.1.4.0"; + sha256 = "052c3e13e235e7fb31caecc117e3ab4629e85bbfd3b35ec03f74d732acbc9ccb"; + libraryHaskellDepends = [ + base bytestring fast-logger hsyslog monad-logger text transformers + ]; + doHaddock = false; + doCheck = false; + homepage = "https://github.com/fpco/monad-logger-syslog"; + description = "syslog output for monad-logger"; + license = stdenv.lib.licenses.mit; + }) {}; + "monad-loops" = callPackage + ({ mkDerivation, base, stdenv }: + mkDerivation { + pname = "monad-loops"; + version = "0.4.3"; + sha256 = "7eaaaf6bc43661e9e86e310ff8c56fbea16eb6bf13c31a2e28103138ac164c18"; + libraryHaskellDepends = [ base ]; + doHaddock = false; + doCheck = false; + homepage = "https://github.com/mokus0/monad-loops"; + description = "Monadic loops"; + license = stdenv.lib.licenses.publicDomain; + }) {}; + "monad-memo" = callPackage + ({ mkDerivation, array, base, containers, mtl, primitive, stdenv + , transformers, vector + }: + mkDerivation { + pname = "monad-memo"; + version = "0.4.1"; + sha256 = "4c00c4aff00c85bfcce0a9a7d96a2a7d08f1efe64b3326e67e47499d5168f11d"; + libraryHaskellDepends = [ + array base containers mtl primitive transformers vector + ]; + doHaddock = false; + doCheck = false; + homepage = "https://github.com/EduardSergeev/monad-memo"; + description = "Memoization monad transformer"; + license = stdenv.lib.licenses.bsd3; + }) {}; + "monad-metrics" = callPackage + ({ mkDerivation, base, clock, ekg-core, exceptions, hashable + , microlens, mtl, stdenv, text, transformers, unordered-containers + }: + mkDerivation { + pname = "monad-metrics"; + version = "0.2.1.2"; + sha256 = "38130b74de16bde2862a96245b25135b719488c4fcb803b78db6e95b4e6fbb7f"; + libraryHaskellDepends = [ + base clock ekg-core exceptions hashable microlens mtl text + transformers unordered-containers + ]; + doHaddock = false; + doCheck = false; + homepage = "https://github.com/parsonsmatt/monad-metrics#readme"; + description = "A convenient wrapper around EKG metrics"; + license = stdenv.lib.licenses.mit; + }) {}; + "monad-par" = callPackage + ({ mkDerivation, abstract-deque, abstract-par, array, base + , containers, deepseq, monad-par-extras, mtl, mwc-random, parallel + , stdenv + }: + mkDerivation { + pname = "monad-par"; + version = "0.3.4.8"; + sha256 = "f84cdf51908a1c41c3f672be9520a8fdc028ea39d90a25ecfe5a3b223cfeb951"; + libraryHaskellDepends = [ + abstract-deque abstract-par array base containers deepseq + monad-par-extras mtl mwc-random parallel + ]; + doHaddock = false; + doCheck = false; + homepage = "https://github.com/simonmar/monad-par"; + description = "A library for parallel programming based on a monad"; + license = stdenv.lib.licenses.bsd3; + }) {}; + "monad-par-extras" = callPackage + ({ mkDerivation, abstract-par, base, cereal, deepseq, mtl, random + , stdenv, transformers + }: + mkDerivation { + pname = "monad-par-extras"; + version = "0.3.3"; + sha256 = "e21e33190bc248afa4ae467287ac37d24037ef3de6050c44fd85b52f4d5b842e"; + libraryHaskellDepends = [ + abstract-par base cereal deepseq mtl random transformers + ]; + doHaddock = false; + doCheck = false; + homepage = "https://github.com/simonmar/monad-par"; + description = "Combinators and extra features for Par monads"; + license = stdenv.lib.licenses.bsd3; + }) {}; + "monad-parallel" = callPackage + ({ mkDerivation, base, parallel, stdenv, transformers + , transformers-compat + }: + mkDerivation { + pname = "monad-parallel"; + version = "0.7.2.3"; + sha256 = "128fb8c36be717f82aa3146d855303f48d04c56ba025078e6cd35d6050b45089"; + libraryHaskellDepends = [ + base parallel transformers transformers-compat + ]; + doHaddock = false; + doCheck = false; + homepage = "http://trac.haskell.org/SCC/wiki/monad-parallel"; + description = "Parallel execution of monadic computations"; + license = stdenv.lib.licenses.bsd3; + }) {}; + "monad-peel" = callPackage + ({ mkDerivation, base, extensible-exceptions, stdenv, transformers + }: + mkDerivation { + pname = "monad-peel"; + version = "0.2.1.2"; + sha256 = "2dd5e9090f3951dbc298e35c3cea7099818aba0485a55059475c4f346fc933f4"; + libraryHaskellDepends = [ + base extensible-exceptions transformers + ]; + doHaddock = false; + doCheck = false; + homepage = "http://andersk.mit.edu/haskell/monad-peel/"; + description = "Lift control operations like exception catching through monad transformers"; + license = stdenv.lib.licenses.bsd3; + }) {}; + "monad-products" = callPackage + ({ mkDerivation, base, semigroupoids, stdenv }: + mkDerivation { + pname = "monad-products"; + version = "4.0.1"; + sha256 = "02bfe1db2ae1a5cff19f73736a219605b1f0649f6af44ca848d09160a7946cea"; + libraryHaskellDepends = [ base semigroupoids ]; + doHaddock = false; + doCheck = false; + homepage = "http://github.com/ekmett/monad-products"; + description = "Monad products"; + license = stdenv.lib.licenses.bsd3; + }) {}; + "monad-recorder" = callPackage + ({ mkDerivation, base, exceptions, monad-control, mtl, stdenv + , transformers, transformers-base + }: + mkDerivation { + pname = "monad-recorder"; + version = "0.1.1"; + sha256 = "0863eb37dae0a9dc996a73dd7743d0c9fc22b9713d4be4d7c7e49e4e073ca215"; + libraryHaskellDepends = [ + base exceptions monad-control mtl transformers transformers-base + ]; + doHaddock = false; + doCheck = false; + homepage = "http://github.com/harendra-kumar/monad-recorder"; + description = "Record and replay the results of monadic actions"; + license = stdenv.lib.licenses.mit; + }) {}; + "monad-skeleton" = callPackage + ({ mkDerivation, base, stdenv }: + mkDerivation { + pname = "monad-skeleton"; + version = "0.1.5"; + sha256 = "a96840713ffdbb97d58e8dc7a47d2b725993868f005903fa9aa26bcf6f32559e"; + libraryHaskellDepends = [ base ]; + doHaddock = false; + doCheck = false; + homepage = "https://github.com/fumieval/monad-skeleton"; + description = "Monads of program skeleta"; + license = stdenv.lib.licenses.bsd3; + }) {}; + "monad-st" = callPackage + ({ mkDerivation, base, stdenv, transformers }: + mkDerivation { + pname = "monad-st"; + version = "0.2.4.1"; + sha256 = "8e1818576bc486e884b953680fe41c524ff23eef2ec382b5f28f47fa7b8abf08"; + libraryHaskellDepends = [ base transformers ]; + doHaddock = false; + doCheck = false; + homepage = "http://github.com/ekmett/monad-st"; + description = "Provides a MonadST class"; + license = stdenv.lib.licenses.bsd3; + }) {}; + "monad-time" = callPackage + ({ mkDerivation, base, mtl, stdenv, time }: + mkDerivation { + pname = "monad-time"; + version = "0.3.1.0"; + sha256 = "0af450bfc710a9653e008de3df4cff094423e434d54ac5b7419fe2552660607c"; + libraryHaskellDepends = [ base mtl time ]; + doHaddock = false; + doCheck = false; + homepage = "https://github.com/scrive/monad-time"; + description = "Type class for monads which carry the notion of the current time"; + license = stdenv.lib.licenses.bsd3; + }) {}; + "monad-unlift" = callPackage + ({ mkDerivation, base, constraints, monad-control, stdenv + , transformers, transformers-base + }: + mkDerivation { + pname = "monad-unlift"; + version = "0.2.0"; + sha256 = "4b5e638619e4821918b4ec67aeffb581ab9df23d168fbb72164137009a15ee0f"; + libraryHaskellDepends = [ + base constraints monad-control transformers transformers-base + ]; + doHaddock = false; + doCheck = false; + homepage = "https://github.com/fpco/monad-unlift"; + description = "Typeclasses for representing monad transformer unlifting"; + license = stdenv.lib.licenses.mit; + }) {}; + "monad-unlift-ref" = callPackage + ({ mkDerivation, base, constraints, exceptions, monad-control + , monad-unlift, mtl, mutable-containers, resourcet, stdenv, stm + , transformers, transformers-base + }: + mkDerivation { + pname = "monad-unlift-ref"; + version = "0.2.1"; + sha256 = "0f059539297478ad8b7e861682207b37b91eaf7e36bd8fdcc3f865a3c6971d1d"; + libraryHaskellDepends = [ + base constraints exceptions monad-control monad-unlift mtl + mutable-containers resourcet stm transformers transformers-base + ]; + doHaddock = false; + doCheck = false; + homepage = "https://github.com/fpco/monad-unlift"; + description = "Typeclasses for representing monad transformer unlifting"; + license = stdenv.lib.licenses.mit; + }) {}; + "monadic-arrays" = callPackage + ({ mkDerivation, array, base, stdenv, stm, transformers + , transformers-compat + }: + mkDerivation { + pname = "monadic-arrays"; + version = "0.2.2"; + sha256 = "667714c6100272b48c4377cf2e2984b67a4445521a2a2e9c37539128c7e276a0"; + libraryHaskellDepends = [ + array base stm transformers transformers-compat + ]; + doHaddock = false; + doCheck = false; + homepage = "http://github.com/ekmett/monadic-arrays/"; + description = "Boxed and unboxed arrays for monad transformers"; + license = stdenv.lib.licenses.bsd3; + }) {}; + "monads-tf" = callPackage + ({ mkDerivation, base, stdenv, transformers }: + mkDerivation { + pname = "monads-tf"; + version = "0.1.0.3"; + sha256 = "249dd2aa55c4dd6530f1e49f6b052ec91bc590ecfef2bd24c58837a3f8d4b0f1"; + libraryHaskellDepends = [ base transformers ]; + doHaddock = false; + doCheck = false; + description = "Monad classes, using type families"; + license = stdenv.lib.licenses.bsd3; + }) {}; + "mongoDB" = callPackage + ({ mkDerivation, array, base, base16-bytestring, base64-bytestring + , binary, bson, bytestring, conduit, conduit-extra, containers + , cryptohash, data-default-class, hashtables, lifted-base + , monad-control, mtl, network, nonce, parsec, pureMD5, random + , random-shuffle, resourcet, stdenv, stm, tagged, text, time, tls + , transformers, transformers-base + }: + mkDerivation { + pname = "mongoDB"; + version = "2.4.0.0"; + sha256 = "fdb80241825c70d795a1e552b25afc916e58d7755ec31feaf7ab7afdd5aee719"; + libraryHaskellDepends = [ + array base base16-bytestring base64-bytestring binary bson + bytestring conduit conduit-extra containers cryptohash + data-default-class hashtables lifted-base monad-control mtl network + nonce parsec pureMD5 random random-shuffle resourcet stm tagged + text time tls transformers transformers-base + ]; + doHaddock = false; + doCheck = false; + homepage = "https://github.com/mongodb-haskell/mongodb"; + description = "Driver (client) for MongoDB, a free, scalable, fast, document DBMS"; + license = stdenv.lib.licenses.asl20; + }) {}; + "mono-traversable" = callPackage + ({ mkDerivation, base, bytestring, containers, hashable, split + , stdenv, text, transformers, unordered-containers, vector + , vector-algorithms + }: + mkDerivation { + pname = "mono-traversable"; + version = "1.0.8.1"; + sha256 = "991290797bd77ce2f2e23dd5dea32fb159c6cb9310615f64a0703ea4c6373935"; + libraryHaskellDepends = [ + base bytestring containers hashable split text transformers + unordered-containers vector vector-algorithms + ]; + doHaddock = false; + doCheck = false; + homepage = "https://github.com/snoyberg/mono-traversable#readme"; + description = "Type classes for mapping, folding, and traversing monomorphic containers"; + license = stdenv.lib.licenses.mit; + }) {}; + "mono-traversable-instances" = callPackage + ({ mkDerivation, base, comonad, containers, dlist, dlist-instances + , mono-traversable, semigroupoids, semigroups, stdenv, transformers + , vector-instances + }: + mkDerivation { + pname = "mono-traversable-instances"; + version = "0.1.0.0"; + sha256 = "b5ff2b8bcebe31ffcc652a8dd3adde6aa7cd7f27a1cf6d058d4c658b370c087e"; + libraryHaskellDepends = [ + base comonad containers dlist dlist-instances mono-traversable + semigroupoids semigroups transformers vector-instances + ]; + doHaddock = false; + doCheck = false; + homepage = "https://github.com/snoyberg/mono-traversable#readme"; + description = "Extra typeclass instances for mono-traversable"; + license = stdenv.lib.licenses.mit; + }) {}; + "monoid-extras" = callPackage + ({ mkDerivation, base, groups, semigroupoids, semigroups, stdenv }: + mkDerivation { + pname = "monoid-extras"; + version = "0.5"; + sha256 = "c6571ab25a24e4300d507beeb8e534c20b3e530c6bd19c82694f1d6d5d0d4d9c"; + revision = "2"; + editedCabalFile = "1q73ghd12fd451zm4m045h8v3y61jmfhj6k890gnv6z7lyb7xwg2"; + libraryHaskellDepends = [ base groups semigroupoids semigroups ]; + doHaddock = false; + doCheck = false; + description = "Various extra monoid-related definitions and utilities"; + license = stdenv.lib.licenses.bsd3; + }) {}; + "monoid-subclasses" = callPackage + ({ mkDerivation, base, bytestring, containers, primes, stdenv, text + , vector + }: + mkDerivation { + pname = "monoid-subclasses"; + version = "0.4.6"; + sha256 = "15c1aade7351bea9db03e047b063d3f68507e31bebff8e49fc9797a5d4be51e7"; + libraryHaskellDepends = [ + base bytestring containers primes text vector + ]; + doHaddock = false; + doCheck = false; + homepage = "https://github.com/blamario/monoid-subclasses/"; + description = "Subclasses of Monoid"; + license = stdenv.lib.licenses.bsd3; + }) {}; + "monoid-transformer" = callPackage + ({ mkDerivation, base, semigroups, stdenv }: + mkDerivation { + pname = "monoid-transformer"; + version = "0.0.4"; + sha256 = "43abf147e4d1b57c5d306d9533e42fb52828d64e761e0e3d8797fb52cfc98388"; + libraryHaskellDepends = [ base semigroups ]; + doHaddock = false; + doCheck = false; + description = "Monoid counterparts to some ubiquitous monad transformers"; + license = stdenv.lib.licenses.bsd3; + }) {}; + "monoidal-containers" = callPackage + ({ mkDerivation, base, containers, deepseq, hashable, lens, newtype + , semigroups, stdenv, unordered-containers + }: + mkDerivation { + pname = "monoidal-containers"; + version = "0.3.1.0"; + sha256 = "44c325aa5a46a624688eefca1a0a3cc818e932a3805ed7749d0693c2c8c5f785"; + libraryHaskellDepends = [ + base containers deepseq hashable lens newtype semigroups + unordered-containers + ]; + doHaddock = false; + doCheck = false; + homepage = "http://github.com/bgamari/monoidal-containers"; + description = "Containers with monoidal accumulation"; + license = stdenv.lib.licenses.bsd3; + }) {}; + "morte" = callPackage + ({ mkDerivation, alex, array, base, binary, code-page, containers + , deepseq, Earley, formatting, http-client, http-client-tls + , microlens, microlens-mtl, optparse-applicative, pipes, stdenv + , system-fileio, system-filepath, text, transformers + }: + mkDerivation { + pname = "morte"; + version = "1.6.20"; + sha256 = "7449e92308373c7459f97da2389a26ee1cead0532a7931868b49e9338240a306"; + isLibrary = true; + isExecutable = true; + enableSeparateDataOutput = true; + libraryHaskellDepends = [ + array base binary containers deepseq Earley formatting http-client + http-client-tls microlens microlens-mtl pipes system-fileio + system-filepath text transformers + ]; + libraryToolDepends = [ alex ]; + executableHaskellDepends = [ + base code-page formatting optparse-applicative text + ]; + doHaddock = false; + doCheck = false; + description = "A bare-bones calculus of constructions"; + license = stdenv.lib.licenses.bsd3; + }) {}; + "mountpoints" = callPackage + ({ mkDerivation, base, stdenv }: + mkDerivation { + pname = "mountpoints"; + version = "1.0.2"; + sha256 = "67fcdf64fdb8111f58939c64b168a9dfa519d7068e0f439887d739866f18d5c2"; + libraryHaskellDepends = [ base ]; + doHaddock = false; + doCheck = false; + description = "list mount points"; + license = "LGPL"; + }) {}; + "mstate" = callPackage + ({ mkDerivation, base, monad-peel, mtl, stdenv, stm }: + mkDerivation { + pname = "mstate"; + version = "0.2.7"; + sha256 = "4508e3e7cc2dec5a0e75ba7dd085c73fdd4f886ac6d1a74cf071816795bb2c17"; + libraryHaskellDepends = [ base monad-peel mtl stm ]; + doHaddock = false; + doCheck = false; + description = "MState: A consistent State monad for concurrent applications"; + license = stdenv.lib.licenses.bsd3; + }) {}; + "mtl" = callPackage + ({ mkDerivation, base, stdenv, transformers }: + mkDerivation { + pname = "mtl"; + version = "2.2.2"; + sha256 = "8803f48a8ed33296c3a3272f448198737a287ec31baa901af09e2118c829bef6"; + libraryHaskellDepends = [ base transformers ]; + doHaddock = false; + doCheck = false; + homepage = "http://github.com/haskell/mtl"; + description = "Monad classes, using functional dependencies"; + license = stdenv.lib.licenses.bsd3; + }) {}; + "mtl-compat" = callPackage + ({ mkDerivation, base, mtl, stdenv }: + mkDerivation { + pname = "mtl-compat"; + version = "0.2.1.3"; + sha256 = "6458ca53593a31ebce1d94ef8dd4f6a06d050dd7ed32335f6cc6b6e5d3456894"; + revision = "4"; + editedCabalFile = "1mfrx8cpx0502sjv0bmlfkl0h46c4krldg8m89k4fj6iawwg2ab5"; + libraryHaskellDepends = [ base mtl ]; + doHaddock = false; + doCheck = false; + homepage = "https://github.com/haskell-compat/mtl-compat"; + description = "Backported Control.Monad.Except module from mtl"; + license = stdenv.lib.licenses.bsd3; + }) {}; + "mtl-prelude" = callPackage + ({ mkDerivation, base, mtl, stdenv, transformers }: + mkDerivation { + pname = "mtl-prelude"; + version = "2.0.3.1"; + sha256 = "c4a6dda093d63bd2161f55030c5825903dfa9b7d5e766c487fd848cb2aa01233"; + libraryHaskellDepends = [ base mtl transformers ]; + doHaddock = false; + doCheck = false; + homepage = "https://github.com/nikita-volkov/mtl-prelude"; + description = "Reexports of most definitions from \"mtl\" and \"transformers\""; + license = stdenv.lib.licenses.mit; + }) {}; + "multiarg" = callPackage + ({ mkDerivation, base, stdenv }: + mkDerivation { + pname = "multiarg"; + version = "0.30.0.10"; + sha256 = "c9fa623a8e06d62addc2b7ad5102ceac3a6f0db6a67afbc8e693d0d0aec417a1"; + isLibrary = true; + isExecutable = true; + libraryHaskellDepends = [ base ]; + doHaddock = false; + doCheck = false; + homepage = "https://github.com/massysett/multiarg"; + description = "Command lines for options that take multiple arguments"; + license = stdenv.lib.licenses.bsd3; + }) {}; + "multimap" = callPackage + ({ mkDerivation, base, containers, stdenv }: + mkDerivation { + pname = "multimap"; + version = "1.2.1"; + sha256 = "6332c529475177b9e08d762d5701804dc2edc0ff26dd98a2a1dcd7ed092e7434"; + libraryHaskellDepends = [ base containers ]; + doHaddock = false; + doCheck = false; + homepage = "http://hub.darcs.net/scravy/multimap"; + description = "A multimap"; + license = stdenv.lib.licenses.mit; + }) {}; + "multipart" = callPackage + ({ mkDerivation, base, bytestring, parsec, stdenv }: + mkDerivation { + pname = "multipart"; + version = "0.1.2"; + sha256 = "e543fb307beb14fc366171d7767a6a18244bacf78db295d8d161c5c03d94043c"; + libraryHaskellDepends = [ base bytestring parsec ]; + doHaddock = false; + doCheck = false; + homepage = "http://www.github.com/silkapp/multipart"; + description = "HTTP multipart split out of the cgi package"; + license = stdenv.lib.licenses.bsd3; + }) {}; + "multistate" = callPackage + ({ mkDerivation, base, monad-control, mtl, stdenv, tagged + , transformers, transformers-base + }: + mkDerivation { + pname = "multistate"; + version = "0.8.0.0"; + sha256 = "013fb518a342cca9650859f21016077693f7b594d70df569548b7de9074a5d69"; + revision = "3"; + editedCabalFile = "0gi4l3765jgsvhr6jj2q1l7v6188kg2xw4zwcaarq3hcg1ncaakw"; + isLibrary = true; + isExecutable = true; + libraryHaskellDepends = [ + base monad-control mtl tagged transformers transformers-base + ]; + doHaddock = false; + doCheck = false; + homepage = "https://github.com/lspitzner/multistate"; + description = "like mtl's ReaderT / WriterT / StateT, but more than one contained value/type"; + license = stdenv.lib.licenses.bsd3; + }) {}; + "murmur-hash" = callPackage + ({ mkDerivation, base, bytestring, stdenv }: + mkDerivation { + pname = "murmur-hash"; + version = "0.1.0.9"; + sha256 = "89b9db94ead4cc0784dbcfb47c51b5664c1718860db00cd8ada3ef6fdd4465ad"; + libraryHaskellDepends = [ base bytestring ]; + doHaddock = false; + doCheck = false; + homepage = "http://github.com/nominolo/murmur-hash"; + description = "MurmurHash2 implementation for Haskell"; + license = stdenv.lib.licenses.bsd3; + }) {}; + "mustache" = callPackage + ({ mkDerivation, aeson, base, bytestring, cmdargs, containers + , directory, either, filepath, mtl, parsec, scientific, stdenv + , template-haskell, text, th-lift, unordered-containers, vector + , yaml + }: + mkDerivation { + pname = "mustache"; + version = "2.3.0"; + sha256 = "018863e578e971e393edc65dd7e0ed92a0e37fc152a47bb379fd8abd59537be0"; + isLibrary = true; + isExecutable = true; + libraryHaskellDepends = [ + aeson base bytestring containers directory either filepath mtl + parsec scientific template-haskell text th-lift + unordered-containers vector + ]; + executableHaskellDepends = [ + aeson base bytestring cmdargs filepath text yaml + ]; + doHaddock = false; + doCheck = false; + homepage = "https://github.com/JustusAdam/mustache"; + description = "A mustache template parser library"; + license = stdenv.lib.licenses.bsd3; + }) {}; + "mutable-containers" = callPackage + ({ mkDerivation, base, containers, ghc-prim, mono-traversable + , primitive, stdenv, vector + }: + mkDerivation { + pname = "mutable-containers"; + version = "0.3.4"; + sha256 = "641966e0adee48badb8bf07037af6c879480e4e97f673d9e2b84fbf43685137e"; + libraryHaskellDepends = [ + base containers ghc-prim mono-traversable primitive vector + ]; + doHaddock = false; + doCheck = false; + homepage = "https://github.com/snoyberg/mono-traversable#readme"; + description = "Abstactions and concrete implementations of mutable containers"; + license = stdenv.lib.licenses.mit; + }) {}; + "mwc-probability" = callPackage + ({ mkDerivation, base, mwc-random, primitive, stdenv, transformers + }: + mkDerivation { + pname = "mwc-probability"; + version = "2.0.4"; + sha256 = "9fe9ed0e264bf85420a3086a1af9d6e749ff33c9c59428891dfaaa72b1385157"; + revision = "1"; + editedCabalFile = "1b4wbxkxx0szjgzgn5jc1qap80zx6ispxrd51yxs4z7llv15w5k6"; + libraryHaskellDepends = [ base mwc-random primitive transformers ]; + doHaddock = false; + doCheck = false; + homepage = "http://github.com/jtobin/mwc-probability"; + description = "Sampling function-based probability distributions"; + license = stdenv.lib.licenses.mit; + }) {}; + "mwc-probability-transition" = callPackage + ({ mkDerivation, base, exceptions, ghc-prim, hspec, logging-effect + , mtl, mwc-probability, primitive, QuickCheck, stdenv, transformers + }: + mkDerivation { + pname = "mwc-probability-transition"; + version = "0.4"; + sha256 = "3e44b6f3f3b2a739776484e7d4ab98ab1d5c7e50bcba53a40d2f0ac96003e768"; + libraryHaskellDepends = [ + base exceptions ghc-prim hspec logging-effect mtl mwc-probability + primitive QuickCheck transformers + ]; + doHaddock = false; + doCheck = false; + homepage = "https://github.com/ocramz/mwc-probability-transition"; + description = "A Markov stochastic transition operator with logging"; + license = stdenv.lib.licenses.bsd3; + }) {}; + "mwc-random" = callPackage + ({ mkDerivation, base, math-functions, primitive, stdenv, time + , vector + }: + mkDerivation { + pname = "mwc-random"; + version = "0.13.6.0"; + sha256 = "065f334fc13c057eb03ef0b6aa3665ff193609d9bfcad8068bdd260801f44716"; + libraryHaskellDepends = [ + base math-functions primitive time vector + ]; + doHaddock = false; + doCheck = false; + homepage = "https://github.com/bos/mwc-random"; + description = "Fast, high quality pseudo random number generation"; + license = stdenv.lib.licenses.bsd3; + }) {}; + "mysql" = callPackage + ({ mkDerivation, base, bytestring, Cabal, containers, mysql, stdenv + }: + mkDerivation { + pname = "mysql"; + version = "0.1.5"; + sha256 = "49b367d07f6d93fd4cbd08390f83bbf8e40c66156a1d2b0f570b68921e6f3075"; + setupHaskellDepends = [ base Cabal ]; + libraryHaskellDepends = [ base bytestring containers ]; + librarySystemDepends = [ mysql ]; + doHaddock = false; + doCheck = false; + homepage = "https://github.com/paul-rouse/mysql"; + description = "A low-level MySQL client library"; + license = stdenv.lib.licenses.bsd3; + }) {inherit (pkgs) mysql;}; + "mysql-haskell" = callPackage + ({ mkDerivation, base, binary, binary-ieee754, binary-parsers + , blaze-textual, bytestring, bytestring-lexing, cryptonite + , io-streams, memory, monad-loops, network, scientific, stdenv + , tcp-streams, text, time, tls, vector, wire-streams, word24 + }: + mkDerivation { + pname = "mysql-haskell"; + version = "0.8.3.0"; + sha256 = "e9aef28ccccc0801a1db1c936945a226961334ec11d85905ae58a09a42507aac"; + revision = "1"; + editedCabalFile = "1kpfmrwwdaxjqwbsc6m9imlcfi2vvkz62pin5nrvm1fk17isy69v"; + libraryHaskellDepends = [ + base binary binary-ieee754 binary-parsers blaze-textual bytestring + bytestring-lexing cryptonite io-streams memory monad-loops network + scientific tcp-streams text time tls vector wire-streams word24 + ]; + doHaddock = false; + doCheck = false; + homepage = "https://github.com/winterland1989/mysql-haskell"; + description = "pure haskell MySQL driver"; + license = stdenv.lib.licenses.bsd3; + }) {}; + "mysql-haskell-nem" = callPackage + ({ mkDerivation, base, bytestring, io-streams, mysql-haskell + , scientific, stdenv, text, time + }: + mkDerivation { + pname = "mysql-haskell-nem"; + version = "0.1.0.0"; + sha256 = "7a0868b76edc96a7aff7860f96436b9040f6cb9319dd67f68bfd700948721f0d"; + libraryHaskellDepends = [ + base bytestring io-streams mysql-haskell scientific text time + ]; + doHaddock = false; + doCheck = false; + homepage = "https://github.com/lorenzo/mysql-haskell-nem#readme"; + description = "Adds a interface like mysql-simple to mysql-haskell"; + license = stdenv.lib.licenses.bsd3; + }) {}; + "mysql-haskell-openssl" = callPackage + ({ mkDerivation, base, binary, HsOpenSSL, mysql-haskell, stdenv + , tcp-streams, tcp-streams-openssl, wire-streams + }: + mkDerivation { + pname = "mysql-haskell-openssl"; + version = "0.8.3.0"; + sha256 = "44345ef9b5d98b1fca5089533990b8f4ba67afde7995282c323dacfb44dba55e"; + libraryHaskellDepends = [ + base binary HsOpenSSL mysql-haskell tcp-streams tcp-streams-openssl + wire-streams + ]; + doHaddock = false; + doCheck = false; + homepage = "https://github.com/winterland1989/mysql-haskell"; + description = "TLS support for mysql-haskell package using openssl"; + license = stdenv.lib.licenses.bsd3; + }) {}; + "mysql-simple" = callPackage + ({ mkDerivation, attoparsec, base, base16-bytestring, blaze-builder + , blaze-textual, bytestring, containers, mysql, old-locale + , pcre-light, stdenv, text, time + }: + mkDerivation { + pname = "mysql-simple"; + version = "0.4.5"; + sha256 = "b03c422ed8a62fa7f98b62634a06da8454980c6a733e275020ca7cedbb6e7cb1"; + libraryHaskellDepends = [ + attoparsec base base16-bytestring blaze-builder blaze-textual + bytestring containers mysql old-locale pcre-light text time + ]; + doHaddock = false; + doCheck = false; + homepage = "https://github.com/paul-rouse/mysql-simple"; + description = "A mid-level MySQL client library"; + license = stdenv.lib.licenses.bsd3; + }) {}; + "nagios-check" = callPackage + ({ mkDerivation, base, bifunctors, exceptions, mtl, stdenv, text }: + mkDerivation { + pname = "nagios-check"; + version = "0.3.2"; + sha256 = "1bc9b85cb10c396943d53c44e2701c5bc2a02ecdf3e8f46da238981f8b7860b7"; + libraryHaskellDepends = [ base bifunctors exceptions mtl text ]; + doHaddock = false; + doCheck = false; + homepage = "https://github.com/olorin/haskell-nagios-check"; + description = "Package for writing monitoring plugins"; + license = stdenv.lib.licenses.mit; + }) {}; + "named" = callPackage + ({ mkDerivation, base, stdenv }: + mkDerivation { + pname = "named"; + version = "0.1.0.0"; + sha256 = "e7fa5c63906a3e8db05ead8c64a962045016ef8d450ab0f8579861080b024658"; + libraryHaskellDepends = [ base ]; + doHaddock = false; + doCheck = false; + description = "Named parameters (keyword arguments) for Haskell"; + license = stdenv.lib.licenses.bsd3; + }) {}; + "names-th" = callPackage + ({ mkDerivation, base, containers, stdenv, template-haskell }: + mkDerivation { + pname = "names-th"; + version = "0.3.0.0"; + sha256 = "0be38f6a22afb69ddda5a3cae095b51835bdae853256403e97078679a9fba526"; + libraryHaskellDepends = [ base containers template-haskell ]; + doHaddock = false; + doCheck = false; + homepage = "http://khibino.github.io/haskell-relational-record/"; + description = "Manipulate name strings for TH"; + license = stdenv.lib.licenses.bsd3; + }) {}; + "nano-erl" = callPackage + ({ mkDerivation, base, stdenv, stm }: + mkDerivation { + pname = "nano-erl"; + version = "0.1.0.1"; + sha256 = "370a60682b38ca77b793ee7326c54d5e74dd688f316f31fdd5cf999ad498ee12"; + libraryHaskellDepends = [ base stm ]; + doHaddock = false; + doCheck = false; + description = "Small library for Erlang-style actor semantics"; + license = stdenv.lib.licenses.mit; + }) {}; + "nanospec" = callPackage + ({ mkDerivation, base, stdenv }: + mkDerivation { + pname = "nanospec"; + version = "0.2.2"; + sha256 = "cf14ccc2b296c910000cdc3eb51b37389b3eb94139384b9555db79b8128595e5"; + libraryHaskellDepends = [ base ]; + doHaddock = false; + doCheck = false; + homepage = "https://github.com/hspec/nanospec#readme"; + description = "A lightweight implementation of a subset of Hspec's API"; + license = stdenv.lib.licenses.mit; + }) {}; + "nats" = callPackage + ({ mkDerivation, stdenv }: + mkDerivation { + pname = "nats"; + version = "1.1.2"; + sha256 = "b9d2d85d8612f9b06f8c9bfd1acecd848e03ab82cfb53afe1d93f5086b6e80ec"; + revision = "1"; + editedCabalFile = "1jzyysf758lfindlclqpzqcd0lrgrdv0rnz2lg8g1rvv07x2n7zh"; + doHaddock = false; + doCheck = false; + homepage = "http://github.com/ekmett/nats/"; + description = "Natural numbers"; + license = stdenv.lib.licenses.bsd3; + }) {}; + "natural-induction" = callPackage + ({ mkDerivation, base, peano, stdenv }: + mkDerivation { + pname = "natural-induction"; + version = "0.2.0.0"; + sha256 = "99aa944a9bf54f549a867b73de56e56adf95d67408822054ee1abfcbe7ae33af"; + libraryHaskellDepends = [ base peano ]; + doHaddock = false; + doCheck = false; + description = "Induction over natural numbers"; + license = stdenv.lib.licenses.bsd3; + }) {}; + "natural-sort" = callPackage + ({ mkDerivation, base, bytestring, parsec, stdenv, text }: + mkDerivation { + pname = "natural-sort"; + version = "0.1.2"; + sha256 = "7b72b734680827ab07df38a004d4f523540055389d62fcd587edd2fcf19a6b50"; + libraryHaskellDepends = [ base bytestring parsec text ]; + doHaddock = false; + doCheck = false; + homepage = "https://john-millikin.com/software/natural-sort/"; + description = "User-friendly text collation"; + license = stdenv.lib.licenses.bsd3; + }) {}; + "natural-transformation" = callPackage + ({ mkDerivation, base, stdenv }: + mkDerivation { + pname = "natural-transformation"; + version = "0.4"; + sha256 = "aac28e2c1147ed77c1ec0f0eb607a577fa26d0fd67474293ba860ec124efc8af"; + revision = "6"; + editedCabalFile = "0qdjf1756gmq6vjd1p7i4b398s7j1gqfiaz3yf894h5p6x1ym0zl"; + libraryHaskellDepends = [ base ]; + doHaddock = false; + doCheck = false; + homepage = "https://github.com/ku-fpg/natural-transformation"; + description = "A natural transformation package"; + license = stdenv.lib.licenses.bsd3; + }) {}; + "ndjson-conduit" = callPackage + ({ mkDerivation, aeson, attoparsec, base, bytestring, conduit + , stdenv + }: + mkDerivation { + pname = "ndjson-conduit"; + version = "0.1.0.5"; + sha256 = "c037b8f7c47b146f1384585541ae8a4f9218bc4456f428935f973ae07da49db1"; + libraryHaskellDepends = [ + aeson attoparsec base bytestring conduit + ]; + doHaddock = false; + doCheck = false; + homepage = "https://github.com/srijs/haskell-ndjson-conduit"; + description = "Conduit-based parsing and serialization for newline delimited JSON"; + license = stdenv.lib.licenses.mit; + }) {}; + "neat-interpolation" = callPackage + ({ mkDerivation, base, base-prelude, megaparsec, stdenv + , template-haskell, text + }: + mkDerivation { + pname = "neat-interpolation"; + version = "0.3.2.2"; + sha256 = "b6c8c5eca58ee99f9528ff21386ffa8e7dbc2e02186824cbaf74d795b0c9cc39"; + libraryHaskellDepends = [ + base base-prelude megaparsec template-haskell text + ]; + doHaddock = false; + doCheck = false; + homepage = "https://github.com/nikita-volkov/neat-interpolation"; + description = "A quasiquoter for neat and simple multiline text interpolation"; + license = stdenv.lib.licenses.mit; + }) {}; + "netlib-carray" = callPackage + ({ mkDerivation, base, carray, netlib-ffi, stdenv, transformers }: + mkDerivation { + pname = "netlib-carray"; + version = "0.0.1.1"; + sha256 = "9bc702f6d09240400b99d0769aaa0fe6bf32f83b312d33a6e2dd7b75a173beef"; + libraryHaskellDepends = [ base carray netlib-ffi transformers ]; + doHaddock = false; + doCheck = false; + homepage = "http://hub.darcs.net/thielema/netlib-carray/"; + description = "Helper modules for CArray wrappers to BLAS and LAPACK"; + license = stdenv.lib.licenses.bsd3; + }) {}; + "netlib-ffi" = callPackage + ({ mkDerivation, base, stdenv, storable-complex, transformers }: + mkDerivation { + pname = "netlib-ffi"; + version = "0.1"; + sha256 = "505ca55093efdbd71b8b8cbeaa52ce2cbdd5477dc6c35b163e52748772517c32"; + libraryHaskellDepends = [ base storable-complex transformers ]; + doHaddock = false; + doCheck = false; + homepage = "http://hub.darcs.net/thielema/netlib-ffi/"; + description = "Helper modules for FFI to BLAS and LAPACK"; + license = stdenv.lib.licenses.bsd3; + }) {}; + "netpbm" = callPackage + ({ mkDerivation, attoparsec, attoparsec-binary, base, bytestring + , stdenv, storable-record, unordered-containers, vector + , vector-th-unbox + }: + mkDerivation { + pname = "netpbm"; + version = "1.0.2"; + sha256 = "846a04bca94be31c779888febc390c64cfba93e40f3a7a2f80ff6a6e44fcc2d7"; + revision = "1"; + editedCabalFile = "1vhwjv5c5gxn9l9982da54nzczbmj8rl09xn8ac7rix0zmmyvl50"; + libraryHaskellDepends = [ + attoparsec attoparsec-binary base bytestring storable-record + unordered-containers vector vector-th-unbox + ]; + doHaddock = false; + doCheck = false; + homepage = "https://github.com/nh2/haskell-netpbm"; + description = "Loading PBM, PGM, PPM image files"; + license = stdenv.lib.licenses.mit; + }) {}; + "nettle" = callPackage + ({ mkDerivation, base, byteable, bytestring, crypto-cipher-types + , nettle, securemem, stdenv, tagged + }: + mkDerivation { + pname = "nettle"; + version = "0.3.0"; + sha256 = "cf3f08980e8e52190301d33db3b1fe7f02bcf5d276a74a8b8283b79e72bf7d5d"; + libraryHaskellDepends = [ + base byteable bytestring crypto-cipher-types securemem tagged + ]; + libraryPkgconfigDepends = [ nettle ]; + doHaddock = false; + doCheck = false; + homepage = "https://github.com/stbuehler/haskell-nettle"; + description = "safe nettle binding"; + license = stdenv.lib.licenses.mit; + }) {inherit (pkgs) nettle;}; + "netwire" = callPackage + ({ mkDerivation, base, containers, deepseq, parallel, profunctors + , random, semigroups, stdenv, time, transformers + }: + mkDerivation { + pname = "netwire"; + version = "5.0.3"; + sha256 = "f1dde7293efe9cdb3080f53a1be702f473ef0bcc0d3e4ea2d23b847fa3ef222e"; + libraryHaskellDepends = [ + base containers deepseq parallel profunctors random semigroups time + transformers + ]; + doHaddock = false; + doCheck = false; + homepage = "https://github.com/esoeylemez/netwire"; + description = "Functional reactive programming library"; + license = stdenv.lib.licenses.bsd3; + }) {}; + "netwire-input" = callPackage + ({ mkDerivation, base, deepseq, netwire, stdenv }: + mkDerivation { + pname = "netwire-input"; + version = "0.0.7"; + sha256 = "29c6b087c2092ca409442b28aca500642b870461ad820d8bc579097f19ed3db9"; + libraryHaskellDepends = [ base deepseq netwire ]; + doHaddock = false; + doCheck = false; + homepage = "https://www.github.com/Mokosha/netwire-input"; + description = "Input handling abstractions for netwire"; + license = stdenv.lib.licenses.mit; + }) {}; + "netwire-input-glfw" = callPackage + ({ mkDerivation, base, containers, deepseq, GLFW-b, mtl + , netwire-input, stdenv, stm + }: + mkDerivation { + pname = "netwire-input-glfw"; + version = "0.0.10"; + sha256 = "1ea458273055fa2f82451b889b9a2c54e0b5bbdf55a16c35d0ccd392793728e4"; + isLibrary = true; + isExecutable = true; + libraryHaskellDepends = [ + base containers deepseq GLFW-b mtl netwire-input stm + ]; + doHaddock = false; + doCheck = false; + homepage = "https://www.github.com/Mokosha/netwire-input-glfw"; + description = "GLFW instance of netwire-input"; + license = stdenv.lib.licenses.mit; + }) {}; + "network" = callPackage + ({ mkDerivation, base, bytestring, stdenv, unix }: + mkDerivation { + pname = "network"; + version = "2.6.3.6"; + sha256 = "9bde0609ab39441daa7da376c09f501e2913305ef64be5d245c45ba84e5515a5"; + libraryHaskellDepends = [ base bytestring unix ]; + doHaddock = false; + doCheck = false; + homepage = "https://github.com/haskell/network"; + description = "Low-level networking interface"; + license = stdenv.lib.licenses.bsd3; + }) {}; + "network-anonymous-i2p" = callPackage + ({ mkDerivation, attoparsec, base, bytestring, exceptions, mtl + , network, network-attoparsec, network-simple, stdenv, text + , transformers, uuid + }: + mkDerivation { + pname = "network-anonymous-i2p"; + version = "0.10.0"; + sha256 = "cff5796c36c1ebbb969e5433538eb3f3979acef9825a7bfb683ed002023fff2c"; + enableSeparateDataOutput = true; + libraryHaskellDepends = [ + attoparsec base bytestring exceptions mtl network + network-attoparsec network-simple text transformers uuid + ]; + doHaddock = false; + doCheck = false; + homepage = "http://github.com/solatis/haskell-network-anonymous-i2p"; + description = "Haskell API for I2P anonymous networking"; + license = stdenv.lib.licenses.mit; + }) {}; + "network-anonymous-tor" = callPackage + ({ mkDerivation, attoparsec, base, base32string, bytestring + , exceptions, hexstring, network, network-attoparsec + , network-simple, socks, splice, stdenv, text, transformers + }: + mkDerivation { + pname = "network-anonymous-tor"; + version = "0.11.0"; + sha256 = "41aee5b34aaaec6fa47a56cca61fafec22097bda25d13d5baef6b7924e127549"; + isLibrary = true; + isExecutable = true; + enableSeparateDataOutput = true; + libraryHaskellDepends = [ + attoparsec base base32string bytestring exceptions hexstring + network network-attoparsec network-simple socks text transformers + ]; + executableHaskellDepends = [ + base exceptions network network-simple splice + ]; + doHaddock = false; + doCheck = false; + homepage = "http://www.leonmergen.com/opensource.html"; + description = "Haskell API for Tor anonymous networking"; + license = stdenv.lib.licenses.mit; + }) {}; + "network-attoparsec" = callPackage + ({ mkDerivation, attoparsec, base, bytestring, enclosed-exceptions + , exceptions, lifted-base, monad-control, mtl, network, stdenv + , transformers + }: + mkDerivation { + pname = "network-attoparsec"; + version = "0.12.2"; + sha256 = "9790a9bad286ab1474dadbece3e4b2e1dd068d4ede3847cb73bcd66386bf08f0"; + enableSeparateDataOutput = true; + libraryHaskellDepends = [ + attoparsec base bytestring enclosed-exceptions exceptions + lifted-base monad-control mtl network transformers + ]; + doHaddock = false; + doCheck = false; + homepage = "http://github.com/solatis/haskell-network-attoparsec"; + description = "Utility functions for running a parser against a socket"; + license = stdenv.lib.licenses.mit; + }) {}; + "network-conduit-tls" = callPackage + ({ mkDerivation, base, bytestring, conduit, conduit-extra + , connection, data-default-class, network, stdenv + , streaming-commons, tls, transformers, unliftio-core + }: + mkDerivation { + pname = "network-conduit-tls"; + version = "1.3.2"; + sha256 = "ecfd60e162de3993a71906293dcf2ec8bd4c794471eb8dca13746c1d8fd3ad7f"; + libraryHaskellDepends = [ + base bytestring conduit conduit-extra connection data-default-class + network streaming-commons tls transformers unliftio-core + ]; + doHaddock = false; + doCheck = false; + homepage = "https://github.com/snoyberg/conduit"; + description = "Create TLS-aware network code with conduits"; + license = stdenv.lib.licenses.mit; + }) {}; + "network-house" = callPackage + ({ mkDerivation, array, base, containers, mtl, stdenv }: + mkDerivation { + pname = "network-house"; + version = "0.1.0.2"; + sha256 = "071fbc22fc516175e78235d9e29ccefd8eec7c3caa2e6de74dddf62cdbffab43"; + libraryHaskellDepends = [ array base containers mtl ]; + doHaddock = false; + doCheck = false; + homepage = "https://github.com/nh2/network-house"; + description = "data and parsers for Ethernet, TCP, UDP, IPv4, IPv6, ICMP, DHCP, TFTP"; + license = stdenv.lib.licenses.gpl2; + }) {}; + "network-info" = callPackage + ({ mkDerivation, base, stdenv }: + mkDerivation { + pname = "network-info"; + version = "0.2.0.10"; + sha256 = "5680f6975d34cf4f81fa7ca0c8efd682261d6a1119e06dece0f67c7bd97fd52a"; + libraryHaskellDepends = [ base ]; + doHaddock = false; + doCheck = false; + homepage = "http://github.com/jystic/network-info"; + description = "Access the local computer's basic network configuration"; + license = stdenv.lib.licenses.bsd3; + }) {}; + "network-ip" = callPackage + ({ mkDerivation, base, data-default-class, data-dword, data-endian + , data-serializer, data-textual, hashable, parsers, stdenv + , text-printer, type-hint + }: + mkDerivation { + pname = "network-ip"; + version = "0.3.0.2"; + sha256 = "ee259d236312aafc4bd08dfeff2ebe4b4f930b2f5879764e1a6d5675c5105efe"; + libraryHaskellDepends = [ + base data-default-class data-dword data-endian data-serializer + data-textual hashable parsers text-printer type-hint + ]; + doHaddock = false; + doCheck = false; + homepage = "https://github.com/mvv/network-ip"; + description = "Internet Protocol data structures"; + license = stdenv.lib.licenses.bsd3; + }) {}; + "network-multicast" = callPackage + ({ mkDerivation, base, network, stdenv }: + mkDerivation { + pname = "network-multicast"; + version = "0.2.0"; + sha256 = "0f3b50abc3a401c20cc6a0ec51a49d2a48e5b467d9fbd63b7cf803165fe975f2"; + libraryHaskellDepends = [ base network ]; + doHaddock = false; + doCheck = false; + description = "Simple multicast library"; + license = stdenv.lib.licenses.publicDomain; + }) {}; + "network-simple" = callPackage + ({ mkDerivation, base, bytestring, exceptions, network, stdenv + , transformers + }: + mkDerivation { + pname = "network-simple"; + version = "0.4.1"; + sha256 = "72be3a16779fffeb71436f421c7de4b83a78523362c4787a807c3174d7db9b1d"; + libraryHaskellDepends = [ + base bytestring exceptions network transformers + ]; + doHaddock = false; + doCheck = false; + homepage = "https://github.com/k0001/network-simple"; + description = "Simple network sockets usage patterns"; + license = stdenv.lib.licenses.bsd3; + }) {}; + "network-simple-tls" = callPackage + ({ mkDerivation, base, bytestring, data-default, exceptions + , network, network-simple, stdenv, tls, transformers, x509 + , x509-store, x509-system, x509-validation + }: + mkDerivation { + pname = "network-simple-tls"; + version = "0.3"; + sha256 = "bc2dffc45af7771721f13c4ffe739fbef3b2050f9d3ebb6abd47ad15f7c94587"; + libraryHaskellDepends = [ + base bytestring data-default exceptions network network-simple tls + transformers x509 x509-store x509-system x509-validation + ]; + doHaddock = false; + doCheck = false; + homepage = "https://github.com/k0001/network-simple-tls"; + description = "Simple interface to TLS secured network sockets"; + license = stdenv.lib.licenses.bsd3; + }) {}; + "network-transport" = callPackage + ({ mkDerivation, base, binary, bytestring, deepseq, hashable + , stdenv, transformers + }: + mkDerivation { + pname = "network-transport"; + version = "0.5.2"; + sha256 = "e795672b43d67ac7bfade72173548ae6bf8208c1890e22aba7809098558f9054"; + libraryHaskellDepends = [ + base binary bytestring deepseq hashable transformers + ]; + doHaddock = false; + doCheck = false; + homepage = "http://haskell-distributed.github.com"; + description = "Network abstraction layer"; + license = stdenv.lib.licenses.bsd3; + }) {}; + "network-transport-composed" = callPackage + ({ mkDerivation, base, bytestring, network-transport, stdenv }: + mkDerivation { + pname = "network-transport-composed"; + version = "0.2.1"; + sha256 = "a35bbfbe35a7a6c6e20e9d839f9f5b30f82f3680863968f73ce82e0e03e55944"; + libraryHaskellDepends = [ base bytestring network-transport ]; + doHaddock = false; + doCheck = false; + homepage = "http://haskell-distributed.github.com"; + description = "Compose network transports"; + license = stdenv.lib.licenses.bsd3; + }) {}; + "network-transport-inmemory" = callPackage + ({ mkDerivation, base, bytestring, containers, data-accessor + , network-transport, stdenv, stm + }: + mkDerivation { + pname = "network-transport-inmemory"; + version = "0.5.2"; + sha256 = "8245d795330157d90ad9de599854d119c6d8938a45ab8c4ec89f3160b2e9ef4e"; + revision = "1"; + editedCabalFile = "1cls49jpl0hs6pviyn1ga8nhsdgsvqg163sprif0pb21xz848d9k"; + libraryHaskellDepends = [ + base bytestring containers data-accessor network-transport stm + ]; + doHaddock = false; + doCheck = false; + homepage = "http://haskell-distributed.github.com"; + description = "In-memory instantiation of Network.Transport"; + license = stdenv.lib.licenses.bsd3; + }) {}; + "network-transport-tests" = callPackage + ({ mkDerivation, ansi-terminal, base, bytestring, containers, mtl + , network-transport, random, stdenv + }: + mkDerivation { + pname = "network-transport-tests"; + version = "0.2.4.2"; + sha256 = "cb24c4bf7eed5a381eb21a3efadf8752050845e5d4426a1d2e00f128ea27cbc7"; + libraryHaskellDepends = [ + ansi-terminal base bytestring containers mtl network-transport + random + ]; + doHaddock = false; + doCheck = false; + homepage = "http://haskell-distributed.github.com"; + description = "Unit tests for Network.Transport implementations"; + license = stdenv.lib.licenses.bsd3; + }) {}; + "network-uri" = callPackage + ({ mkDerivation, base, deepseq, parsec, stdenv }: + mkDerivation { + pname = "network-uri"; + version = "2.6.1.0"; + sha256 = "423e0a2351236f3fcfd24e39cdbc38050ec2910f82245e69ca72a661f7fc47f0"; + revision = "1"; + editedCabalFile = "141nj7q0p9wkn5gr41ayc63cgaanr9m59yym47wpxqr3c334bk32"; + libraryHaskellDepends = [ base deepseq parsec ]; + doHaddock = false; + doCheck = false; + homepage = "https://github.com/haskell/network-uri"; + description = "URI manipulation"; + license = stdenv.lib.licenses.bsd3; + }) {}; + "newtype" = callPackage + ({ mkDerivation, base, stdenv }: + mkDerivation { + pname = "newtype"; + version = "0.2"; + sha256 = "b714033abd9a8b0903bcef0d36d0913de2a5003c852f43f97fa688717289e459"; + libraryHaskellDepends = [ base ]; + doHaddock = false; + doCheck = false; + description = "A typeclass and set of functions for working with newtypes"; + license = stdenv.lib.licenses.bsd3; + }) {}; + "newtype-generics" = callPackage + ({ mkDerivation, base, stdenv, transformers }: + mkDerivation { + pname = "newtype-generics"; + version = "0.5.3"; + sha256 = "f295f001a86bdbcf759d6b91b9e7ae27cd431ccf41d9b9d34ee1c926b88efe45"; + revision = "1"; + editedCabalFile = "1glnwq1lw7780qgahqvh1qfx6k2ciwmbhc2wcc78v3aa3s954c8v"; + libraryHaskellDepends = [ base transformers ]; + doHaddock = false; + doCheck = false; + homepage = "http://github.com/sjakobi/newtype-generics"; + description = "A typeclass and set of functions for working with newtypes"; + license = stdenv.lib.licenses.bsd3; + }) {}; + "next-ref" = callPackage + ({ mkDerivation, base, stdenv, stm }: + mkDerivation { + pname = "next-ref"; + version = "0.1.0.2"; + sha256 = "a586f15c17d5d53dd647411d02660dcbfd293f38a75f030d6892a76a2c24789f"; + libraryHaskellDepends = [ base stm ]; + doHaddock = false; + doCheck = false; + description = "A concurrency primitive for a slow consumer"; + license = stdenv.lib.licenses.bsd3; + }) {}; + "nicify-lib" = callPackage + ({ mkDerivation, base, parsec, stdenv, transformers }: + mkDerivation { + pname = "nicify-lib"; + version = "1.0.1"; + sha256 = "7d26f86d792dda166805e9dda17cfbc7a2101f3654fe798f4231385d8136e732"; + libraryHaskellDepends = [ base parsec transformers ]; + doHaddock = false; + doCheck = false; + description = "Pretty print the standard output of default `Show` instances"; + license = stdenv.lib.licenses.mit; + }) {}; + "nix-paths" = callPackage + ({ mkDerivation, base, nix, process, stdenv }: + mkDerivation { + pname = "nix-paths"; + version = "1.0.1"; + sha256 = "ab37163bc2970ea16c2eb6e091d1e99ab50b8e2ba93c23d24dac761803e509f8"; + libraryHaskellDepends = [ base process ]; + libraryToolDepends = [ nix ]; + doHaddock = false; + doCheck = false; + homepage = "https://github.com/peti/nix-paths"; + description = "Knowledge of Nix's installation directories"; + license = stdenv.lib.licenses.bsd3; + }) {}; + "non-empty" = callPackage + ({ mkDerivation, base, containers, deepseq, QuickCheck, stdenv + , utility-ht + }: + mkDerivation { + pname = "non-empty"; + version = "0.3"; + sha256 = "77906c1d4c94738e8b34d9aa28c6a3981edb82df7ee82f2f43aeb57b20bd5be0"; + revision = "1"; + editedCabalFile = "0ivvxcfm3qhv7ynb3ql89wrybbda1s2p5nr0viw7nqrybjz5hfzh"; + libraryHaskellDepends = [ + base containers deepseq QuickCheck utility-ht + ]; + doHaddock = false; + doCheck = false; + homepage = "http://hub.darcs.net/thielema/non-empty/"; + description = "List-like structures with static restrictions on the number of elements"; + license = stdenv.lib.licenses.bsd3; + }) {}; + "non-empty-sequence" = callPackage + ({ mkDerivation, base, containers, semigroups, stdenv }: + mkDerivation { + pname = "non-empty-sequence"; + version = "0.2.0.2"; + sha256 = "d9a3604c0c140197731895af56413edbf1cf6866f9c0636ece9d8314366dd1e1"; + libraryHaskellDepends = [ base containers semigroups ]; + doHaddock = false; + doCheck = false; + homepage = "http://www.github.com/massysett/non-empty-sequence"; + description = "Non-empty sequence"; + license = stdenv.lib.licenses.bsd3; + }) {}; + "non-negative" = callPackage + ({ mkDerivation, base, QuickCheck, semigroups, stdenv, utility-ht + }: + mkDerivation { + pname = "non-negative"; + version = "0.1.2"; + sha256 = "5614acf55f3c16a21fea263e375e8993f9b859e21997b0410c74fe6642c20138"; + libraryHaskellDepends = [ base QuickCheck semigroups utility-ht ]; + doHaddock = false; + doCheck = false; + homepage = "http://code.haskell.org/~thielema/non-negative/"; + description = "Non-negative numbers"; + license = "GPL"; + }) {}; + "nonce" = callPackage + ({ mkDerivation, base, base64-bytestring, bytestring, entropy + , stdenv, text, transformers, unliftio, unliftio-core + }: + mkDerivation { + pname = "nonce"; + version = "1.0.7"; + sha256 = "4b4f6232b2cb07a6de47a838b4dc35c346a745683866dbfc6ebb8682158037e1"; + libraryHaskellDepends = [ + base base64-bytestring bytestring entropy text transformers + unliftio unliftio-core + ]; + doHaddock = false; + doCheck = false; + homepage = "https://github.com/prowdsponsor/nonce"; + description = "Generate cryptographic nonces"; + license = stdenv.lib.licenses.bsd3; + }) {}; + "nondeterminism" = callPackage + ({ mkDerivation, base, containers, mtl, stdenv }: + mkDerivation { + pname = "nondeterminism"; + version = "1.4"; + sha256 = "3037c93b0277037ab51ad8640f72a7975dcf48ba81570640be12d390d7b47dc5"; + libraryHaskellDepends = [ base containers mtl ]; + doHaddock = false; + doCheck = false; + description = "A monad and monad transformer for nondeterministic computations"; + license = "LGPL"; + }) {}; + "nsis" = callPackage + ({ mkDerivation, base, stdenv, transformers, uniplate }: + mkDerivation { + pname = "nsis"; + version = "0.3.2"; + sha256 = "b9985b8d62569c192d89b20965eed2b98186a67148b667202823c6389b8f15ca"; + libraryHaskellDepends = [ base transformers uniplate ]; + doHaddock = false; + doCheck = false; + homepage = "https://github.com/ndmitchell/nsis#readme"; + description = "DSL for producing Windows Installer using NSIS"; + license = stdenv.lib.licenses.bsd3; + }) {}; + "numbers" = callPackage + ({ mkDerivation, base, stdenv }: + mkDerivation { + pname = "numbers"; + version = "3000.2.0.2"; + sha256 = "f0cee40b90c3746bd0bc0559d3827d3cf1b1e2c43270b7ec9bf4fa458fcb5a77"; + libraryHaskellDepends = [ base ]; + doHaddock = false; + doCheck = false; + homepage = "https://github.com/jwiegley/numbers#readme"; + description = "Various number types"; + license = stdenv.lib.licenses.bsd3; + }) {}; + "numeric-extras" = callPackage + ({ mkDerivation, base, stdenv }: + mkDerivation { + pname = "numeric-extras"; + version = "0.1"; + sha256 = "c700711021d96334be43a21fbd80a5f7146fdd6706ef8656f1d287ff000b61d6"; + libraryHaskellDepends = [ base ]; + doHaddock = false; + doCheck = false; + homepage = "http://github.com/ekmett/numeric-extras"; + description = "Useful tools from the C standard library"; + license = stdenv.lib.licenses.bsd3; + }) {}; + "numeric-prelude" = callPackage + ({ mkDerivation, array, base, containers, deepseq, non-negative + , parsec, QuickCheck, random, semigroups, stdenv, storable-record + , utility-ht + }: + mkDerivation { + pname = "numeric-prelude"; + version = "0.4.3"; + sha256 = "b8f8f9a660e598055898c1d6c981885c629882ae028fec90f91955bade19892d"; + isLibrary = true; + isExecutable = true; + libraryHaskellDepends = [ + array base containers deepseq non-negative parsec QuickCheck random + semigroups storable-record utility-ht + ]; + doHaddock = false; + doCheck = false; + homepage = "http://www.haskell.org/haskellwiki/Numeric_Prelude"; + description = "An experimental alternative hierarchy of numeric type classes"; + license = stdenv.lib.licenses.bsd3; + }) {}; + "numhask" = callPackage + ({ mkDerivation, base, stdenv }: + mkDerivation { + pname = "numhask"; + version = "0.2.3.1"; + sha256 = "33084f2bd2dd37cdc1923745896e39d3a34f8d7b5181dff6577c4605dd7fc111"; + libraryHaskellDepends = [ base ]; + doHaddock = false; + doCheck = false; + homepage = "https://github.com/tonyday567/numhask#readme"; + description = "numeric classes"; + license = stdenv.lib.licenses.bsd3; + }) {}; + "numhask-prelude" = callPackage + ({ mkDerivation, base, numhask, protolude, stdenv }: + mkDerivation { + pname = "numhask-prelude"; + version = "0.1.0.1"; + sha256 = "b1f15bcf21f33b25f841d1b6f0c5cbfc2a2837b3bb8962a0082950fa9b8ca25f"; + libraryHaskellDepends = [ base numhask protolude ]; + doHaddock = false; + doCheck = false; + homepage = "https://github.com/tonyday567/numhask#readme"; + description = "A numeric prelude"; + license = stdenv.lib.licenses.bsd3; + }) {}; + "numhask-range" = callPackage + ({ mkDerivation, adjunctions, base, distributive, numhask-prelude + , protolude, QuickCheck, semigroupoids, stdenv + }: + mkDerivation { + pname = "numhask-range"; + version = "0.2.3.1"; + sha256 = "6c62a172d2d35da7e5cb4ade742e802a4e1b9a21746149cd367d71f95822dcfd"; + libraryHaskellDepends = [ + adjunctions base distributive numhask-prelude protolude QuickCheck + semigroupoids + ]; + doHaddock = false; + doCheck = false; + homepage = "https://github.com/tonyday567/numhask-range#readme"; + description = "Numbers that are range representations"; + license = stdenv.lib.licenses.bsd3; + }) {}; + "numhask-test" = callPackage + ({ mkDerivation, base, numhask-prelude, QuickCheck, stdenv, tasty + , tasty-quickcheck + }: + mkDerivation { + pname = "numhask-test"; + version = "0.1.0.0"; + sha256 = "de74c9e8cc66ead2eeffc9062d6f7b57728c9aef834751132e03d5deb17decb3"; + libraryHaskellDepends = [ + base numhask-prelude QuickCheck tasty tasty-quickcheck + ]; + doHaddock = false; + doCheck = false; + homepage = "https://github.com/tonyday567/numhask#readme"; + description = "Laws and tests for numhask"; + license = stdenv.lib.licenses.bsd3; + }) {}; + "numtype-dk" = callPackage + ({ mkDerivation, base, stdenv }: + mkDerivation { + pname = "numtype-dk"; + version = "0.5.0.1"; + sha256 = "29dbb9bf7693989f94605804de31b1a4dacf53ab566ce0346445288eae95d017"; + revision = "1"; + editedCabalFile = "0n37j80fljalw7n528gwfmcqs53p9sss156i2rsvjx3ax1igaf55"; + libraryHaskellDepends = [ base ]; + doHaddock = false; + doCheck = false; + homepage = "https://github.com/bjornbm/numtype-dk"; + description = "Type-level integers, using TypeNats, Data Kinds, and Closed Type Families"; + license = stdenv.lib.licenses.bsd3; + }) {}; + "nvim-hs" = callPackage + ({ mkDerivation, base, bytestring, cereal, cereal-conduit, conduit + , containers, data-default, deepseq, directory, dyre, filepath + , foreign-store, hslogger, megaparsec, messagepack, mtl, network + , optparse-applicative, prettyprinter, prettyprinter-ansi-terminal + , process, resourcet, setenv, stdenv, stm, streaming-commons + , template-haskell, text, time, time-locale-compat, transformers + , transformers-base, unliftio, unliftio-core, utf8-string, void + }: + mkDerivation { + pname = "nvim-hs"; + version = "1.0.0.2"; + sha256 = "40647aeebc690b678b301007a4d0e2551796faf69101a5e5445dfdafbe554803"; + isLibrary = true; + isExecutable = true; + libraryHaskellDepends = [ + base bytestring cereal cereal-conduit conduit containers + data-default deepseq directory dyre filepath foreign-store hslogger + megaparsec messagepack mtl network optparse-applicative + prettyprinter prettyprinter-ansi-terminal process resourcet setenv + stm streaming-commons template-haskell text time time-locale-compat + transformers transformers-base unliftio unliftio-core utf8-string + void + ]; + executableHaskellDepends = [ base data-default ]; + doHaddock = false; + doCheck = false; + homepage = "https://github.com/neovimhaskell/nvim-hs"; + description = "Haskell plugin backend for neovim"; + license = stdenv.lib.licenses.asl20; + }) {}; + "nvim-hs-contrib" = callPackage + ({ mkDerivation, base, bytestring, data-default, directory + , filepath, messagepack, mtl, nvim-hs, prettyprinter + , prettyprinter-ansi-terminal, stdenv, text, time, utf8-string + , yaml + }: + mkDerivation { + pname = "nvim-hs-contrib"; + version = "1.0.0.0"; + sha256 = "bd342ebd086b2825e74908ebe93621d7d06cd6b06f0bb2fdf98c44351f7a1394"; + libraryHaskellDepends = [ + base bytestring data-default directory filepath messagepack mtl + nvim-hs prettyprinter prettyprinter-ansi-terminal text time + utf8-string yaml + ]; + doHaddock = false; + doCheck = false; + homepage = "https://github.com/neovimhaskell/nvim-hs-contrib"; + description = "Haskell plugin backend for neovim"; + license = stdenv.lib.licenses.asl20; + }) {}; + "o-clock" = callPackage + ({ mkDerivation, base, ghc-prim, stdenv }: + mkDerivation { + pname = "o-clock"; + version = "1.0.0"; + sha256 = "7294710f111b9a0b803e0780b8a8d173db700936164daf656d2414eb40f295a3"; + revision = "1"; + editedCabalFile = "0df6b78y05q8pmlxyfpln01vkm0r38cay1ffsbz1biyfs6s115j5"; + isLibrary = true; + isExecutable = true; + libraryHaskellDepends = [ base ghc-prim ]; + executableHaskellDepends = [ base ]; + doHaddock = false; + doCheck = false; + homepage = "https://github.com/serokell/o-clock"; + description = "Type-safe time library"; + license = stdenv.lib.licenses.mit; + }) {}; + "oauthenticated" = callPackage + ({ mkDerivation, aeson, base, base64-bytestring, blaze-builder + , bytestring, case-insensitive, cryptonite, exceptions, http-client + , http-types, memory, mtl, network, network-uri, stdenv, text, time + , transformers + }: + mkDerivation { + pname = "oauthenticated"; + version = "0.2.1.0"; + sha256 = "d44cd060a4bfb26b0b958a8a203fb25dc171c146093eab82827542264f57d222"; + libraryHaskellDepends = [ + aeson base base64-bytestring blaze-builder bytestring + case-insensitive cryptonite exceptions http-client http-types + memory mtl network network-uri text time transformers + ]; + doHaddock = false; + doCheck = false; + homepage = "https://github.com/tel/oauthenticated.git#readme"; + description = "Simple OAuth for http-client"; + license = stdenv.lib.licenses.mit; + }) {}; + "objective" = callPackage + ({ mkDerivation, base, containers, exceptions, free, hashable + , monad-skeleton, mtl, profunctors, stdenv, template-haskell + , transformers, transformers-compat, unordered-containers, void + , witherable + }: + mkDerivation { + pname = "objective"; + version = "1.1.2"; + sha256 = "2fcf283ede3f447f2e65ed9c434bb8facef873ba534aa0de29eb5ffefcc86644"; + revision = "1"; + editedCabalFile = "039j3xac9ish0yk4w04bmip6g9p6ndfd9ngh46ya125ms4nhmyj4"; + libraryHaskellDepends = [ + base containers exceptions free hashable monad-skeleton mtl + profunctors template-haskell transformers transformers-compat + unordered-containers void witherable + ]; + doHaddock = false; + doCheck = false; + homepage = "https://github.com/fumieval/objective"; + description = "Composable objects"; + license = stdenv.lib.licenses.bsd3; + }) {}; + "odbc" = callPackage + ({ mkDerivation, async, base, bytestring, containers, deepseq + , formatting, optparse-applicative, parsec, semigroups, stdenv + , template-haskell, text, time, transformers, unixODBC + , unliftio-core + }: + mkDerivation { + pname = "odbc"; + version = "0.2.0"; + sha256 = "276edb22591f21c7d47f4765594c44c1e8dafca761a6f4a1d72d156f988067b7"; + isLibrary = true; + isExecutable = true; + libraryHaskellDepends = [ + async base bytestring containers deepseq formatting parsec + semigroups template-haskell text time transformers unliftio-core + ]; + librarySystemDepends = [ unixODBC ]; + executableHaskellDepends = [ + base bytestring optparse-applicative text + ]; + doHaddock = false; + doCheck = false; + homepage = "https://github.com/fpco/odbc"; + description = "Haskell binding to the ODBC API, aimed at SQL Server driver"; + license = stdenv.lib.licenses.bsd3; + }) {inherit (pkgs) unixODBC;}; + "oeis" = callPackage + ({ mkDerivation, base, HTTP, network, network-uri, stdenv }: + mkDerivation { + pname = "oeis"; + version = "0.3.9"; + sha256 = "8a692c0b898f5d89e607f9593697a24827981a1cfee53045c192084015061b8e"; + revision = "1"; + editedCabalFile = "0rb6l3qblay8aiwaznp35gj7vwmhm87y57wvf3babwrh91s88jaj"; + libraryHaskellDepends = [ base HTTP network network-uri ]; + doHaddock = false; + doCheck = false; + description = "Interface to the Online Encyclopedia of Integer Sequences (OEIS)"; + license = stdenv.lib.licenses.bsd3; + }) {}; + "ofx" = callPackage + ({ mkDerivation, base, parsec, pretty, stdenv, time }: + mkDerivation { + pname = "ofx"; + version = "0.4.2.0"; + sha256 = "0e22e2269f099603832f666814235051fadf92cbdec3dfacf7d1e8231ccd95f1"; + isLibrary = true; + isExecutable = true; + libraryHaskellDepends = [ base parsec pretty time ]; + executableHaskellDepends = [ base parsec pretty time ]; + doHaddock = false; + doCheck = false; + homepage = "http://www.github.com/massysett/ofx"; + description = "Parser for OFX data"; + license = stdenv.lib.licenses.bsd3; + }) {}; + "old-locale" = callPackage + ({ mkDerivation, base, stdenv }: + mkDerivation { + pname = "old-locale"; + version = "1.0.0.7"; + sha256 = "dbaf8bf6b888fb98845705079296a23c3f40ee2f449df7312f7f7f1de18d7b50"; + revision = "2"; + editedCabalFile = "04b9vn007hlvsrx4ksd3r8r3kbyaj2kvwxchdrmd4370qzi8p6gs"; + libraryHaskellDepends = [ base ]; + doHaddock = false; + doCheck = false; + description = "locale library"; + license = stdenv.lib.licenses.bsd3; + }) {}; + "old-time" = callPackage + ({ mkDerivation, base, old-locale, stdenv }: + mkDerivation { + pname = "old-time"; + version = "1.1.0.3"; + sha256 = "1ccb158b0f7851715d36b757c523b026ca1541e2030d02239802ba39b4112bc1"; + revision = "2"; + editedCabalFile = "1j6ln1dkvhdvnwl33bp0xf9lhc4sybqk0aw42p8cq81xwwzbn7y9"; + libraryHaskellDepends = [ base old-locale ]; + doHaddock = false; + doCheck = false; + description = "Time library"; + license = stdenv.lib.licenses.bsd3; + }) {}; + "om-elm" = callPackage + ({ mkDerivation, base, bytestring, Cabal, containers, directory + , http-types, safe, safe-exceptions, stdenv, template-haskell, text + , unix, wai + }: + mkDerivation { + pname = "om-elm"; + version = "1.0.0.3"; + sha256 = "af10f05a0eed4e17829211f06e79b7c4884dbd5c2736674e9e7680bbe426c744"; + libraryHaskellDepends = [ + base bytestring Cabal containers directory http-types safe + safe-exceptions template-haskell text unix wai + ]; + doHaddock = false; + doCheck = false; + homepage = "https://github.com/owensmurray/om-elm"; + description = "Haskell utilities for building embedded Elm programs"; + license = stdenv.lib.licenses.mit; + }) {}; + "once" = callPackage + ({ mkDerivation, base, containers, hashable, stdenv + , template-haskell, unordered-containers + }: + mkDerivation { + pname = "once"; + version = "0.2"; + sha256 = "753ec628a1fac1f308a4b0e75adee768f962815485e1832a8052ee9af61848a8"; + libraryHaskellDepends = [ + base containers hashable template-haskell unordered-containers + ]; + doHaddock = false; + doCheck = false; + homepage = "https://anonscm.debian.org/cgit/users/kaction-guest/haskell-once.git"; + description = "memoization for IO actions and functions"; + license = stdenv.lib.licenses.gpl3; + }) {}; + "one-liner" = callPackage + ({ mkDerivation, base, bifunctors, contravariant, ghc-prim + , profunctors, stdenv, tagged, transformers + }: + mkDerivation { + pname = "one-liner"; + version = "1.0"; + sha256 = "c7f4fbea856adcaa145eb4ff9c81bb730f0a1796b24f4075c0a8028ae87a31b6"; + revision = "1"; + editedCabalFile = "1ijc5mj93zyfj7hh12aw3xh30kc1xsp7wf6rbbfal36yllnl2xhs"; + libraryHaskellDepends = [ + base bifunctors contravariant ghc-prim profunctors tagged + transformers + ]; + doHaddock = false; + doCheck = false; + homepage = "https://github.com/sjoerdvisscher/one-liner"; + description = "Constraint-based generics"; + license = stdenv.lib.licenses.bsd3; + }) {}; + "one-liner-instances" = callPackage + ({ mkDerivation, base, one-liner, random, stdenv }: + mkDerivation { + pname = "one-liner-instances"; + version = "0.1.2.1"; + sha256 = "9384f47a3bdd5be17fa8ac3deca8e406794a1e9e140ec3b173ccd8d22c00c9bf"; + libraryHaskellDepends = [ base one-liner random ]; + doHaddock = false; + doCheck = false; + homepage = "https://github.com/mstksg/one-liner-instances#readme"; + description = "Generics-based implementations for common typeclasses"; + license = stdenv.lib.licenses.bsd3; + }) {}; + "online" = callPackage + ({ mkDerivation, base, foldl, numhask-prelude, protolude, stdenv + , tdigest, vector, vector-algorithms + }: + mkDerivation { + pname = "online"; + version = "0.3.0.0"; + sha256 = "baadb1cccc0b59547bf9e0829fba1c8079e38a68a925971c07f2b99f674bca14"; + libraryHaskellDepends = [ + base foldl numhask-prelude protolude tdigest vector + vector-algorithms + ]; + doHaddock = false; + doCheck = false; + homepage = "https://github.com/tonyday567/online#readme"; + description = "online statistics"; + license = stdenv.lib.licenses.bsd3; + }) {}; + "oo-prototypes" = callPackage + ({ mkDerivation, base, stdenv }: + mkDerivation { + pname = "oo-prototypes"; + version = "0.1.0.0"; + sha256 = "9eaee40e3221f817b957e472917977bdb06ac0e163a0c6ef87941de29a12f576"; + libraryHaskellDepends = [ base ]; + doHaddock = false; + doCheck = false; + homepage = "https://github.com/yi-editor/oo-prototypes"; + description = "Support for OO-like prototypes"; + license = stdenv.lib.licenses.gpl2; + }) {}; + "open-browser" = callPackage + ({ mkDerivation, base, process, stdenv }: + mkDerivation { + pname = "open-browser"; + version = "0.2.1.0"; + sha256 = "0bed2e63800f738e78a4803ed22902accb50ac02068b96c17ce83a267244ca66"; + isLibrary = true; + isExecutable = true; + libraryHaskellDepends = [ base process ]; + executableHaskellDepends = [ base ]; + doHaddock = false; + doCheck = false; + homepage = "https://github.com/rightfold/open-browser"; + description = "Open a web browser from Haskell"; + license = stdenv.lib.licenses.bsd3; + }) {}; + "open-witness" = callPackage + ({ mkDerivation, base, constraints, hashable, random, stdenv + , template-haskell, transformers, witness + }: + mkDerivation { + pname = "open-witness"; + version = "0.4.0.1"; + sha256 = "0770500d6eeb301fc92d30bec2ccef55b05beb0200125fcbddb6b50836034111"; + libraryHaskellDepends = [ + base constraints hashable random template-haskell transformers + witness + ]; + doHaddock = false; + doCheck = false; + homepage = "https://github.com/AshleyYakeley/open-witness"; + description = "open witnesses"; + license = stdenv.lib.licenses.bsd3; + }) {}; + "openexr-write" = callPackage + ({ mkDerivation, base, binary, bytestring, data-binary-ieee754 + , deepseq, split, stdenv, vector, vector-split, zlib + }: + mkDerivation { + pname = "openexr-write"; + version = "0.1.0.1"; + sha256 = "6de3f2d859f72ad3654dbe24ef89aa98967a55a3fd98e0c090b93a04e4938538"; + libraryHaskellDepends = [ + base binary bytestring data-binary-ieee754 deepseq split vector + vector-split zlib + ]; + doHaddock = false; + doCheck = false; + homepage = "https://github.com/pavolzetor/openexr-write#readme"; + description = "Library for writing images in OpenEXR HDR file format"; + license = stdenv.lib.licenses.gpl3; + }) {}; + "openpgp-asciiarmor" = callPackage + ({ mkDerivation, attoparsec, base, base64-bytestring, binary + , bytestring, stdenv + }: + mkDerivation { + pname = "openpgp-asciiarmor"; + version = "0.1.1"; + sha256 = "b92f3f5316f18c9e30a95cd59888658384ddd20b628e4cd5fbb647177f52f607"; + libraryHaskellDepends = [ + attoparsec base base64-bytestring binary bytestring + ]; + doHaddock = false; + doCheck = false; + homepage = "http://floss.scru.org/openpgp-asciiarmor"; + description = "OpenPGP (RFC4880) ASCII Armor codec"; + license = stdenv.lib.licenses.isc; + }) {}; + "opensource" = callPackage + ({ mkDerivation, aeson, base, http-client, http-client-tls, stdenv + , text, transformers + }: + mkDerivation { + pname = "opensource"; + version = "0.1.0.0"; + sha256 = "3459b6ce70fb8fc8bdf9d9f6ed0476724cb8a11b673fc60422edac2376620127"; + revision = "1"; + editedCabalFile = "02zb9m7d6fsjbqgwbjnkrpgqc93zm34bvzgasw903hhdkskshrp6"; + libraryHaskellDepends = [ + aeson base http-client http-client-tls text transformers + ]; + doHaddock = false; + doCheck = false; + homepage = "https://api.opensource.org/"; + description = "Haskell API Wrapper for the Open Source License API"; + license = stdenv.lib.licenses.mit; + }) {}; + "openssl-streams" = callPackage + ({ mkDerivation, base, bytestring, HsOpenSSL, io-streams, network + , stdenv + }: + mkDerivation { + pname = "openssl-streams"; + version = "1.2.1.3"; + sha256 = "dc7170e835cf71a132903e2a6ccc976bd2984f9241ea2e4e99a9ece74f868f5f"; + revision = "2"; + editedCabalFile = "1004kgdryflpkp19dv4ikilhcn0xbfc5dsp6v3ib34580pcfj7wy"; + libraryHaskellDepends = [ + base bytestring HsOpenSSL io-streams network + ]; + doHaddock = false; + doCheck = false; + description = "OpenSSL network support for io-streams"; + license = stdenv.lib.licenses.bsd3; + }) {}; + "operational" = callPackage + ({ mkDerivation, base, mtl, random, stdenv }: + mkDerivation { + pname = "operational"; + version = "0.2.3.5"; + sha256 = "91d479063ae7ed3d0a6ae911bdee550fbf31cf341910f9778046b484c55b4af4"; + isLibrary = true; + isExecutable = true; + libraryHaskellDepends = [ base mtl ]; + executableHaskellDepends = [ base mtl random ]; + doHaddock = false; + doCheck = false; + homepage = "http://wiki.haskell.org/Operational"; + description = "Implementation of difficult monads made easy with operational semantics"; + license = stdenv.lib.licenses.bsd3; + }) {}; + "operational-class" = callPackage + ({ mkDerivation, base, operational, stdenv, transformers }: + mkDerivation { + pname = "operational-class"; + version = "0.3.0.0"; + sha256 = "8b28b9cb86a2dd520196f6a563538dc2c9e8730f0a0f5e5f3bca19559631e70b"; + libraryHaskellDepends = [ base operational transformers ]; + doHaddock = false; + doCheck = false; + homepage = "https://github.com/srijs/haskell-operational-class"; + description = "MonadProgram typeclass for the operational package"; + license = stdenv.lib.licenses.mit; + }) {}; + "opml-conduit" = callPackage + ({ mkDerivation, base, case-insensitive, conduit + , conduit-combinators, containers, lens-simple, mono-traversable + , monoid-subclasses, safe-exceptions, semigroups, stdenv, text + , time, timerep, uri-bytestring, xml-conduit, xml-types + }: + mkDerivation { + pname = "opml-conduit"; + version = "0.6.0.4"; + sha256 = "480b557690aab79e3761ad7f1ba1d44873c3d395d2b27f2d133372a01c535d1d"; + revision = "1"; + editedCabalFile = "160sazqsrmm2755642c5y5i38miiglqb66cy5k0hy4k2jkdmjfbi"; + enableSeparateDataOutput = true; + libraryHaskellDepends = [ + base case-insensitive conduit conduit-combinators containers + lens-simple mono-traversable monoid-subclasses safe-exceptions + semigroups text time timerep uri-bytestring xml-conduit xml-types + ]; + doHaddock = false; + doCheck = false; + homepage = "https://github.com/k0ral/opml-conduit"; + description = "Streaming parser/renderer for the OPML 2.0 format."; + license = stdenv.lib.licenses.publicDomain; + }) {}; + "optional-args" = callPackage + ({ mkDerivation, base, stdenv }: + mkDerivation { + pname = "optional-args"; + version = "1.0.2"; + sha256 = "2e3454ad77cba80b15c02dbe1915889fafa81a22deb7fe5e7e01b0dd8d85b0e4"; + libraryHaskellDepends = [ base ]; + doHaddock = false; + doCheck = false; + description = "Optional function arguments"; + license = stdenv.lib.licenses.bsd3; + }) {}; + "options" = callPackage + ({ mkDerivation, base, containers, monads-tf, stdenv, transformers + }: + mkDerivation { + pname = "options"; + version = "1.2.1.1"; + sha256 = "283eea9ae2c539830c6c65f5c03fb00626cfd1274da0526c285c146fc3065a62"; + libraryHaskellDepends = [ base containers monads-tf transformers ]; + doHaddock = false; + doCheck = false; + homepage = "https://john-millikin.com/software/haskell-options/"; + description = "A powerful and easy-to-use command-line option parser"; + license = stdenv.lib.licenses.mit; + }) {}; + "optparse-applicative" = callPackage + ({ mkDerivation, ansi-wl-pprint, base, process, stdenv + , transformers, transformers-compat + }: + mkDerivation { + pname = "optparse-applicative"; + version = "0.14.2.0"; + sha256 = "e1341e9831c7b10332d1b29cfa966a80d46b476bb52d99d50bdb53eb770d7f30"; + libraryHaskellDepends = [ + ansi-wl-pprint base process transformers transformers-compat + ]; + doHaddock = false; + doCheck = false; + homepage = "https://github.com/pcapriotti/optparse-applicative"; + description = "Utilities and combinators for parsing command line options"; + license = stdenv.lib.licenses.bsd3; + }) {}; + "optparse-generic" = callPackage + ({ mkDerivation, base, bytestring, Only, optparse-applicative + , semigroups, stdenv, system-filepath, text, time, transformers + , void + }: + mkDerivation { + pname = "optparse-generic"; + version = "1.3.0"; + sha256 = "80929958606e4a73672b570ba1a23493fbf46268666d14ab5af53623301c398f"; + libraryHaskellDepends = [ + base bytestring Only optparse-applicative semigroups + system-filepath text time transformers void + ]; + doHaddock = false; + doCheck = false; + description = "Auto-generate a command-line parser for your datatype"; + license = stdenv.lib.licenses.bsd3; + }) {}; + "optparse-simple" = callPackage + ({ mkDerivation, base, gitrev, optparse-applicative, stdenv + , template-haskell, transformers + }: + mkDerivation { + pname = "optparse-simple"; + version = "0.1.0"; + sha256 = "838d795faa3de3b426b83df11834bead33d02d7fe89df30300ca05c72e714cbc"; + libraryHaskellDepends = [ + base gitrev optparse-applicative template-haskell transformers + ]; + doHaddock = false; + doCheck = false; + homepage = "https://github.com/fpco/optparse-simple#readme"; + description = "Simple interface to optparse-applicative"; + license = stdenv.lib.licenses.bsd3; + }) {}; + "optparse-text" = callPackage + ({ mkDerivation, base, optparse-applicative, stdenv, text }: + mkDerivation { + pname = "optparse-text"; + version = "0.1.1.0"; + sha256 = "f6c081ecec880ae4124f25c1d91ba3a1a3caed9d2fde9e977bceab7d300884ef"; + libraryHaskellDepends = [ base optparse-applicative text ]; + doHaddock = false; + doCheck = false; + homepage = "https://github.com/passy/optparse-text#readme"; + description = "Data.Text helpers for optparse-applicative"; + license = stdenv.lib.licenses.bsd3; + }) {}; + "overhang" = callPackage + ({ mkDerivation, base, stdenv }: + mkDerivation { + pname = "overhang"; + version = "1.0.0"; + sha256 = "1d68f59354930cdb4372adb86386ca9cbd699d90d2d8c8a1042314f296772a1e"; + libraryHaskellDepends = [ base ]; + doHaddock = false; + doCheck = false; + homepage = "https://github.com/jship/overhang#readme"; + description = "Hang loose with your lambdas!"; + license = stdenv.lib.licenses.mit; + }) {}; + "packcheck" = callPackage + ({ mkDerivation, base, stdenv }: + mkDerivation { + pname = "packcheck"; + version = "0.3.1"; + sha256 = "1b76a08553d65e62235a9ca8ba001a2620fbee5a2169e4d40e06e28bdf0a27e8"; + libraryHaskellDepends = [ base ]; + doHaddock = false; + doCheck = false; + homepage = "https://github.com/harendra-kumar/packcheck"; + description = "Universal build and CI testing for Haskell packages"; + license = stdenv.lib.licenses.bsd3; + }) {}; + "packdeps" = callPackage + ({ mkDerivation, base, bytestring, Cabal, containers, directory + , filepath, optparse-applicative, process, semigroups, split + , stdenv, tar, text, time + }: + mkDerivation { + pname = "packdeps"; + version = "0.4.5"; + sha256 = "17de7170a104434ba1c686a0a279cc43a3841fae89f75636e0e7f8a27bb7da1e"; + isLibrary = true; + isExecutable = true; + libraryHaskellDepends = [ + base bytestring Cabal containers directory filepath split tar text + time + ]; + executableHaskellDepends = [ + base Cabal containers optparse-applicative process semigroups + ]; + doHaddock = false; + doCheck = false; + homepage = "http://packdeps.haskellers.com/"; + description = "Check your cabal packages for lagging dependencies"; + license = stdenv.lib.licenses.bsd3; + }) {}; + "pager" = callPackage + ({ mkDerivation, base, bytestring, conduit, conduit-extra + , directory, process, resourcet, safe, stdenv, terminfo, text + , transformers, unix + }: + mkDerivation { + pname = "pager"; + version = "0.1.1.0"; + sha256 = "3e1e4f2ca17be6dd68d2d480f29e7a770c0f7ca3109aa1980da677d96cd4eef3"; + isLibrary = true; + isExecutable = true; + enableSeparateDataOutput = true; + libraryHaskellDepends = [ + base bytestring conduit conduit-extra directory process resourcet + safe terminfo text transformers unix + ]; + executableHaskellDepends = [ base bytestring conduit-extra text ]; + doHaddock = false; + doCheck = false; + homepage = "https://github.com/pharpend/pager"; + description = "Open up a pager, like 'less' or 'more'"; + license = stdenv.lib.licenses.bsd2; + }) {}; + "pagination" = callPackage + ({ mkDerivation, base, deepseq, exceptions, stdenv }: + mkDerivation { + pname = "pagination"; + version = "0.2.1"; + sha256 = "88dcbae69e830adac0943f24f8ae6915f9e4ba684531a76bce936767cbeb203d"; + revision = "2"; + editedCabalFile = "0wvwi3hymp2vhhpzpycdc65zbsqmi2h0c6r0nf8p5nkgsk4pm1k2"; + libraryHaskellDepends = [ base deepseq exceptions ]; + doHaddock = false; + doCheck = false; + homepage = "https://github.com/mrkkrp/pagination"; + description = "Framework-agnostic pagination boilerplate"; + license = stdenv.lib.licenses.bsd3; + }) {}; + "palette" = callPackage + ({ mkDerivation, array, base, colour, containers, MonadRandom + , stdenv + }: + mkDerivation { + pname = "palette"; + version = "0.3.0.1"; + sha256 = "f1153525439d18423b73599a545f4f4bfa49fc481d5608c0770e56a0ce7a9c7a"; + libraryHaskellDepends = [ + array base colour containers MonadRandom + ]; + doHaddock = false; + doCheck = false; + homepage = "http://projects.haskell.org/diagrams"; + description = "Utilities for choosing and creating color schemes"; + license = stdenv.lib.licenses.bsd3; + }) {}; + "pandoc" = callPackage + ({ mkDerivation, aeson, aeson-pretty, base, base64-bytestring + , binary, blaze-html, blaze-markup, bytestring, Cabal + , case-insensitive, cmark-gfm, containers, data-default, deepseq + , directory, doctemplates, exceptions, filepath, Glob + , haddock-library, hslua, hslua-module-text, HTTP, http-client + , http-client-tls, http-types, JuicyPixels, mtl, network + , network-uri, pandoc-types, parsec, process, random, safe + , scientific, SHA, skylighting, split, stdenv, syb, tagsoup + , temporary, texmath, text, time, unix, unordered-containers + , vector, xml, yaml, zip-archive, zlib + }: + mkDerivation { + pname = "pandoc"; + version = "2.2.1"; + sha256 = "fe037f5fbb62fb27e7b1dbddfbd0aa45ea6e9fcdaff1f2203f7484c245b211b7"; + revision = "1"; + editedCabalFile = "16f2c7awxbs17xycl3z1x11h7gc7rfzvw7i3pslsn9nms7rz3s3v"; + configureFlags = [ "-fhttps" "-f-trypandoc" ]; + isLibrary = true; + isExecutable = true; + enableSeparateDataOutput = true; + setupHaskellDepends = [ base Cabal ]; + libraryHaskellDepends = [ + aeson aeson-pretty base base64-bytestring binary blaze-html + blaze-markup bytestring case-insensitive cmark-gfm containers + data-default deepseq directory doctemplates exceptions filepath + Glob haddock-library hslua hslua-module-text HTTP http-client + http-client-tls http-types JuicyPixels mtl network network-uri + pandoc-types parsec process random safe scientific SHA skylighting + split syb tagsoup temporary texmath text time unix + unordered-containers vector xml yaml zip-archive zlib + ]; + executableHaskellDepends = [ base ]; + doHaddock = false; + doCheck = false; + homepage = "https://pandoc.org"; + description = "Conversion between markup formats"; + license = stdenv.lib.licenses.gpl2; + }) {}; + "pandoc-citeproc" = callPackage + ({ mkDerivation, aeson, aeson-pretty, attoparsec, base, bytestring + , Cabal, containers, data-default, directory, filepath, hs-bibutils + , mtl, old-locale, pandoc, pandoc-types, parsec, rfc5051, setenv + , split, stdenv, syb, tagsoup, text, time, unordered-containers + , vector, xml-conduit, yaml + }: + mkDerivation { + pname = "pandoc-citeproc"; + version = "0.14.3.1"; + sha256 = "42c0b2c8365441bf884daa6202e6ed01b42181cf255406c88b3b31cd27cb467a"; + revision = "1"; + editedCabalFile = "1lqz432ij7yp6l412vcfk400nmxzbix6qckgmir46k1jm4glyqwk"; + isLibrary = true; + isExecutable = true; + enableSeparateDataOutput = true; + setupHaskellDepends = [ base Cabal ]; + libraryHaskellDepends = [ + aeson base bytestring containers data-default directory filepath + hs-bibutils mtl old-locale pandoc pandoc-types parsec rfc5051 + setenv split syb tagsoup text time unordered-containers vector + xml-conduit yaml + ]; + executableHaskellDepends = [ + aeson aeson-pretty attoparsec base bytestring filepath pandoc + pandoc-types syb text yaml + ]; + doHaddock = false; + doCheck = false; + homepage = "https://github.com/jgm/pandoc-citeproc"; + description = "Supports using pandoc with citeproc"; + license = stdenv.lib.licenses.bsd3; + }) {}; + "pandoc-types" = callPackage + ({ mkDerivation, aeson, base, bytestring, containers, deepseq + , ghc-prim, QuickCheck, stdenv, syb, transformers + }: + mkDerivation { + pname = "pandoc-types"; + version = "1.17.5.1"; + sha256 = "271cebd0300e236000c2352d597afe2e72a65bc7b01e32b623e2c868fd12dbe0"; + libraryHaskellDepends = [ + aeson base bytestring containers deepseq ghc-prim QuickCheck syb + transformers + ]; + doHaddock = false; + doCheck = false; + homepage = "http://johnmacfarlane.net/pandoc"; + description = "Types for representing a structured document"; + license = stdenv.lib.licenses.bsd3; + }) {}; + "pango" = callPackage + ({ mkDerivation, array, base, Cabal, cairo, containers, directory + , filepath, glib, gtk2hs-buildtools, mtl, pango, pretty, process + , stdenv, text + }: + mkDerivation { + pname = "pango"; + version = "0.13.5.0"; + sha256 = "bf59b9273134e5d1c9c648a253e5a766cd1ef51afc2216175bce21a15b6d49e8"; + enableSeparateDataOutput = true; + setupHaskellDepends = [ base Cabal filepath gtk2hs-buildtools ]; + libraryHaskellDepends = [ + array base cairo containers directory glib mtl pretty process text + ]; + libraryPkgconfigDepends = [ pango ]; + doHaddock = false; + doCheck = false; + homepage = "http://projects.haskell.org/gtk2hs/"; + description = "Binding to the Pango text rendering engine"; + license = stdenv.lib.licenses.lgpl21; + }) {inherit (pkgs) pango;}; + "papillon" = callPackage + ({ mkDerivation, base, bytestring, directory, filepath, monads-tf + , stdenv, template-haskell, transformers + }: + mkDerivation { + pname = "papillon"; + version = "0.1.0.6"; + sha256 = "2b5a614c8792ab3e36fae53f5303a9e62b78b896da1752d65b8ebf7b98ea1ac8"; + isLibrary = true; + isExecutable = true; + libraryHaskellDepends = [ + base bytestring monads-tf template-haskell transformers + ]; + executableHaskellDepends = [ + base directory filepath monads-tf template-haskell transformers + ]; + doHaddock = false; + doCheck = false; + homepage = "https://skami.iocikun.jp/haskell/packages/papillon"; + description = "packrat parser"; + license = stdenv.lib.licenses.bsd3; + }) {}; + "parallel" = callPackage + ({ mkDerivation, array, base, containers, deepseq, ghc-prim, stdenv + }: + mkDerivation { + pname = "parallel"; + version = "3.2.2.0"; + sha256 = "170453a71a2a8b31cca63125533f7771d7debeb639700bdabdd779c34d8a6ef6"; + libraryHaskellDepends = [ array base containers deepseq ghc-prim ]; + doHaddock = false; + doCheck = false; + description = "Parallel programming library"; + license = stdenv.lib.licenses.bsd3; + }) {}; + "parallel-io" = callPackage + ({ mkDerivation, base, containers, extensible-exceptions, random + , stdenv + }: + mkDerivation { + pname = "parallel-io"; + version = "0.3.3"; + sha256 = "3a14c02b9b8b7c72577eb90a8dd72de75d99192def87d7aa79545ee4d6e80645"; + revision = "2"; + editedCabalFile = "0mggzni708nzxlsjbibdzf03s3b5lnqj2zi1hnbh1rd4j4jr07ym"; + isLibrary = true; + isExecutable = true; + libraryHaskellDepends = [ + base containers extensible-exceptions random + ]; + doHaddock = false; + doCheck = false; + homepage = "http://batterseapower.github.com/parallel-io"; + description = "Combinators for executing IO actions in parallel on a thread pool"; + license = stdenv.lib.licenses.bsd3; + }) {}; + "parseargs" = callPackage + ({ mkDerivation, base, containers, stdenv }: + mkDerivation { + pname = "parseargs"; + version = "0.2.0.8"; + sha256 = "7b789204c15d0c478db3d133f349a6970b5509fc6af655faedc03c7426dcf7d6"; + isLibrary = true; + isExecutable = true; + libraryHaskellDepends = [ base containers ]; + executableHaskellDepends = [ base containers ]; + doHaddock = false; + doCheck = false; + homepage = "http://github.com/BartMassey/parseargs"; + description = "Full-featured command-line argument parsing library"; + license = stdenv.lib.licenses.bsd3; + }) {}; + "parsec" = callPackage + ({ mkDerivation, base, bytestring, mtl, stdenv, text }: + mkDerivation { + pname = "parsec"; + version = "3.1.13.0"; + sha256 = "7861ae437a6177ee7c08899432fd8c062e7c110361da48a9f9e88263fd4d80f1"; + revision = "2"; + editedCabalFile = "032sizm03m2vdqshkv4sdviyka05gqf8gs6r4hqf9did177i0qnm"; + libraryHaskellDepends = [ base bytestring mtl text ]; + doHaddock = false; + doCheck = false; + homepage = "https://github.com/hvr/parsec"; + description = "Monadic parser combinators"; + license = stdenv.lib.licenses.bsd3; + }) {}; + "parsec-numeric" = callPackage + ({ mkDerivation, base, parsec, stdenv }: + mkDerivation { + pname = "parsec-numeric"; + version = "0.1.0.0"; + sha256 = "7bdd9ae4aa63695e3072c73d99b85ef1572ffe9f5a07621edaa9515393a6e52f"; + libraryHaskellDepends = [ base parsec ]; + doHaddock = false; + doCheck = false; + homepage = "https://github.com/AndrewRademacher/parsec-numeric"; + description = "Parsec combinators for parsing Haskell numeric types"; + license = "unknown"; + }) {}; + "parser-combinators" = callPackage + ({ mkDerivation, base, stdenv }: + mkDerivation { + pname = "parser-combinators"; + version = "1.0.0"; + sha256 = "e54c8d6071bc67866dffb661e5f56de6d632f40abdfe76b9f56a734ca76e8edf"; + libraryHaskellDepends = [ base ]; + doHaddock = false; + doCheck = false; + homepage = "https://github.com/mrkkrp/parser-combinators"; + description = "Lightweight package providing commonly useful parser combinators"; + license = stdenv.lib.licenses.bsd3; + }) {}; + "parsers" = callPackage + ({ mkDerivation, attoparsec, base, base-orphans, binary, charset + , containers, mtl, parsec, scientific, semigroups, stdenv, text + , transformers, unordered-containers + }: + mkDerivation { + pname = "parsers"; + version = "0.12.9"; + sha256 = "81e52fc9d71b587a8034015344e9162c59975750094f930a47933e5603d305e4"; + libraryHaskellDepends = [ + attoparsec base base-orphans binary charset containers mtl parsec + scientific semigroups text transformers unordered-containers + ]; + doHaddock = false; + doCheck = false; + homepage = "http://github.com/ekmett/parsers/"; + description = "Parsing combinators"; + license = stdenv.lib.licenses.bsd3; + }) {}; + "partial-handler" = callPackage + ({ mkDerivation, base, stdenv }: + mkDerivation { + pname = "partial-handler"; + version = "1.0.3"; + sha256 = "94c72af024417ec04e3d94b5b57c7bfeb8b48acb8444e7c0fe0764ff1139c131"; + libraryHaskellDepends = [ base ]; + doHaddock = false; + doCheck = false; + homepage = "https://github.com/nikita-volkov/partial-handler"; + description = "A composable exception handler"; + license = stdenv.lib.licenses.mit; + }) {}; + "partial-isomorphisms" = callPackage + ({ mkDerivation, base, stdenv, template-haskell }: + mkDerivation { + pname = "partial-isomorphisms"; + version = "0.2.2.1"; + sha256 = "4c551fa69119e87de1ba0ec7b854f6ed13fb2fe2768db4afff2f8468f0f4a164"; + libraryHaskellDepends = [ base template-haskell ]; + doHaddock = false; + doCheck = false; + homepage = "http://www.informatik.uni-marburg.de/~rendel/unparse"; + description = "Partial isomorphisms"; + license = stdenv.lib.licenses.bsd3; + }) {}; + "partial-order" = callPackage + ({ mkDerivation, base, containers, stdenv }: + mkDerivation { + pname = "partial-order"; + version = "0.1.2.1"; + sha256 = "e37dc77f4b8852b1c96fe9b8b06db41aa00d06c5ce7f0c1c5bea15ea462ac397"; + libraryHaskellDepends = [ base containers ]; + doHaddock = false; + doCheck = false; + homepage = "https://github.com/mtesseract/haskell-partial-order"; + description = "Provides typeclass suitable for types admitting a partial order"; + license = stdenv.lib.licenses.bsd3; + }) {}; + "path" = callPackage + ({ mkDerivation, aeson, base, deepseq, exceptions, filepath + , hashable, stdenv, template-haskell + }: + mkDerivation { + pname = "path"; + version = "0.6.1"; + sha256 = "4b8bd85a13395b4240c639b9cf804371854d5dac69158f661068bd3089a25e59"; + revision = "1"; + editedCabalFile = "05b1zwx2a893h4h5wvgpc5g5pyx71hfmx409rqisd8s1bq1hn463"; + libraryHaskellDepends = [ + aeson base deepseq exceptions filepath hashable template-haskell + ]; + doHaddock = false; + doCheck = false; + description = "Support for well-typed paths"; + license = stdenv.lib.licenses.bsd3; + }) {}; + "path-extra" = callPackage + ({ mkDerivation, attoparsec, base, path, stdenv, text }: + mkDerivation { + pname = "path-extra"; + version = "0.2.0"; + sha256 = "eb08be914e718762cad0e1fc7588201258bd8637c486990791e5b816f7a8043a"; + libraryHaskellDepends = [ attoparsec base path text ]; + doHaddock = false; + doCheck = false; + homepage = "https://github.com/athanclark/path-extra#readme"; + description = "URLs without host information"; + license = stdenv.lib.licenses.bsd3; + }) {}; + "path-io" = callPackage + ({ mkDerivation, base, containers, directory, dlist, exceptions + , filepath, path, stdenv, temporary, time, transformers + , unix-compat + }: + mkDerivation { + pname = "path-io"; + version = "1.3.3"; + sha256 = "2aec05914a7569f221cf73e25070fea5fad8125a9a93845e8d614a1c291e35bd"; + revision = "3"; + editedCabalFile = "1h9hsibbflkxpjl2fqamqiv3x3gasf51apnmklrs9l9x8r32hzcc"; + libraryHaskellDepends = [ + base containers directory dlist exceptions filepath path temporary + time transformers unix-compat + ]; + doHaddock = false; + doCheck = false; + homepage = "https://github.com/mrkkrp/path-io"; + description = "Interface to ‘directory’ package for users of ‘path’"; + license = stdenv.lib.licenses.bsd3; + }) {}; + "path-pieces" = callPackage + ({ mkDerivation, base, stdenv, text, time }: + mkDerivation { + pname = "path-pieces"; + version = "0.2.1"; + sha256 = "080bd49f53e20597ca3e5962e0c279a3422345f5b088840a30a751cd76d4a36f"; + revision = "1"; + editedCabalFile = "0p7wsphh513s8l5d62lzgbhk2l1h6kj5y7bc27qqjsry9g8ah4y7"; + libraryHaskellDepends = [ base text time ]; + doHaddock = false; + doCheck = false; + description = "Components of paths"; + license = stdenv.lib.licenses.bsd3; + }) {}; + "pathtype" = callPackage + ({ mkDerivation, base, deepseq, directory, old-time, QuickCheck + , semigroups, stdenv, tagged, time, transformers, utility-ht + }: + mkDerivation { + pname = "pathtype"; + version = "0.8.1"; + sha256 = "d5e6dc557dcf53e97cc2f7f6d6ee30992920e3ea074042b6ac11f74f2792340f"; + isLibrary = true; + isExecutable = true; + libraryHaskellDepends = [ + base deepseq directory old-time QuickCheck semigroups tagged time + transformers utility-ht + ]; + doHaddock = false; + doCheck = false; + homepage = "http://hub.darcs.net/thielema/pathtype/"; + description = "Type-safe replacement for System.FilePath etc"; + license = stdenv.lib.licenses.bsd3; + }) {}; + "pathwalk" = callPackage + ({ mkDerivation, base, directory, filepath, stdenv, transformers }: + mkDerivation { + pname = "pathwalk"; + version = "0.3.1.2"; + sha256 = "76e0d0646a3133a062dbae4e9d37d59e71d6328706bb178552a93800e4550e91"; + libraryHaskellDepends = [ base directory filepath transformers ]; + doHaddock = false; + doCheck = false; + homepage = "https://github.com/Xe/pathwalk"; + description = "Path walking utilities for Haskell programs"; + license = stdenv.lib.licenses.mit; + }) {}; + "pattern-arrows" = callPackage + ({ mkDerivation, base, mtl, stdenv }: + mkDerivation { + pname = "pattern-arrows"; + version = "0.0.2"; + sha256 = "6fc2d972e72785d727d2b68e1f82ef94a2c93cedbc00e6a4cdc03498825c078f"; + libraryHaskellDepends = [ base mtl ]; + doHaddock = false; + doCheck = false; + homepage = "http://blog.functorial.com/posts/2013-10-27-Pretty-Printing-Arrows.html"; + description = "Arrows for Pretty Printing"; + license = stdenv.lib.licenses.mit; + }) {}; + "pcf-font" = callPackage + ({ mkDerivation, base, binary, bytestring, containers, stdenv + , vector, zlib + }: + mkDerivation { + pname = "pcf-font"; + version = "0.2.2.0"; + sha256 = "8a67d04240a7668e669414d1b4f531d290c79a63198e0ecf02cb0339bff098ef"; + libraryHaskellDepends = [ + base binary bytestring containers vector zlib + ]; + doHaddock = false; + doCheck = false; + homepage = "https://github.com/michael-swan/pcf-font"; + description = "PCF font parsing and rendering library"; + license = stdenv.lib.licenses.bsd3; + }) {}; + "pcf-font-embed" = callPackage + ({ mkDerivation, base, bytestring, pcf-font, stdenv + , template-haskell, vector + }: + mkDerivation { + pname = "pcf-font-embed"; + version = "0.1.2.0"; + sha256 = "c55d51ee6f959c9c05bb9d9adac3aad1cd87b2bba3cca7d3667d67f1a230fd51"; + libraryHaskellDepends = [ + base bytestring pcf-font template-haskell vector + ]; + doHaddock = false; + doCheck = false; + homepage = "https://github.com/michael-swan/pcf-font-embed"; + description = "Template Haskell for embedding text rendered using PCF fonts"; + license = stdenv.lib.licenses.bsd3; + }) {}; + "pcg-random" = callPackage + ({ mkDerivation, base, bytestring, entropy, primitive, random + , stdenv + }: + mkDerivation { + pname = "pcg-random"; + version = "0.1.3.5"; + sha256 = "de43ff8805f9e0ffd4cd6b4f2fed8c9cfa9ab45c0fd42374636ac7a5567840a4"; + libraryHaskellDepends = [ + base bytestring entropy primitive random + ]; + doHaddock = false; + doCheck = false; + homepage = "http://github.com/cchalmers/pcg-random"; + description = "Haskell bindings to the PCG random number generator"; + license = stdenv.lib.licenses.bsd3; + }) {}; + "pcre-heavy" = callPackage + ({ mkDerivation, base, base-compat, bytestring, pcre-light + , semigroups, stdenv, string-conversions, template-haskell + }: + mkDerivation { + pname = "pcre-heavy"; + version = "1.0.0.2"; + sha256 = "8a5cf697b7683127812450cef57d0d74ac5c1117ec80618d10509642f793cbd1"; + revision = "1"; + editedCabalFile = "14pprgwxkiaji3rqhsm0fv454wic6qxm7vy4a475yigadb1vz1ls"; + libraryHaskellDepends = [ + base base-compat bytestring pcre-light semigroups + string-conversions template-haskell + ]; + doHaddock = false; + doCheck = false; + homepage = "https://github.com/myfreeweb/pcre-heavy"; + description = "A regexp (regex) library on top of pcre-light you can actually use"; + license = stdenv.lib.licenses.publicDomain; + }) {}; + "pcre-light" = callPackage + ({ mkDerivation, base, bytestring, pcre, stdenv }: + mkDerivation { + pname = "pcre-light"; + version = "0.4.0.4"; + sha256 = "02c97e39263d18fd26aa63d52c88c4bfbb5c3f66ab40564552e7f11d5d889e75"; + libraryHaskellDepends = [ base bytestring ]; + libraryPkgconfigDepends = [ pcre ]; + doHaddock = false; + doCheck = false; + homepage = "https://github.com/Daniel-Diaz/pcre-light"; + description = "Portable regex library for Perl 5 compatible regular expressions"; + license = stdenv.lib.licenses.bsd3; + }) {inherit (pkgs) pcre;}; + "pcre-utils" = callPackage + ({ mkDerivation, array, attoparsec, base, bytestring, mtl + , regex-pcre-builtin, stdenv, vector + }: + mkDerivation { + pname = "pcre-utils"; + version = "0.1.8.1.1"; + sha256 = "1f2a80ca63308e182542534866a844efaf880deac4145213bf1c83a560586df4"; + libraryHaskellDepends = [ + array attoparsec base bytestring mtl regex-pcre-builtin vector + ]; + doHaddock = false; + doCheck = false; + homepage = "https://github.com/bartavelle/pcre-utils"; + description = "Perl-like substitute and split for PCRE regexps"; + license = stdenv.lib.licenses.bsd3; + }) {}; + "pdfinfo" = callPackage + ({ mkDerivation, base, mtl, old-locale, process-extras, stdenv + , text, time, time-locale-compat + }: + mkDerivation { + pname = "pdfinfo"; + version = "1.5.4"; + sha256 = "9a6a1f7d8ab0a5e8f7f8276da070ccddec140d6b2549b084042159b639230911"; + libraryHaskellDepends = [ + base mtl old-locale process-extras text time time-locale-compat + ]; + doHaddock = false; + doCheck = false; + homepage = "https://github.com/chrisdone/pdfinfo"; + description = "Wrapper around the pdfinfo command"; + license = stdenv.lib.licenses.bsd3; + }) {}; + "peano" = callPackage + ({ mkDerivation, base, stdenv }: + mkDerivation { + pname = "peano"; + version = "0.1.0.1"; + sha256 = "31fdd23993a76155738224a7b230a1a6fcfde091b2fbc945df4cb54068eeec7b"; + revision = "2"; + editedCabalFile = "10b0vjc7lnfkscg2c8hhqbvf1xdvgbr3njrs9b4ick91n44vjbhk"; + libraryHaskellDepends = [ base ]; + doHaddock = false; + doCheck = false; + description = "Peano numbers"; + license = "unknown"; + }) {}; + "pem" = callPackage + ({ mkDerivation, base, basement, bytestring, memory, stdenv }: + mkDerivation { + pname = "pem"; + version = "0.2.4"; + sha256 = "770c4c1b9cd24b3db7f511f8a48404a0d098999e28573c3743a8a296bb96f8d4"; + libraryHaskellDepends = [ base basement bytestring memory ]; + doHaddock = false; + doCheck = false; + homepage = "http://github.com/vincenthz/hs-pem"; + description = "Privacy Enhanced Mail (PEM) format reader and writer"; + license = stdenv.lib.licenses.bsd3; + }) {}; + "perf" = callPackage + ({ mkDerivation, base, containers, deepseq, foldl, rdtsc, stdenv + , text, time, transformers + }: + mkDerivation { + pname = "perf"; + version = "0.4.1.0"; + sha256 = "881d50dc3603ba7008807ab03247a321bb1f9377da192135922a536c1d1201fc"; + libraryHaskellDepends = [ + base containers deepseq foldl rdtsc text time transformers + ]; + doHaddock = false; + doCheck = false; + homepage = "https://github.com/tonyday567/perf#readme"; + description = "Low-level run time measurement"; + license = stdenv.lib.licenses.bsd3; + }) {}; + "perfect-hash-generator" = callPackage + ({ mkDerivation, base, binary, bytestring, containers, data-ordlist + , directory, filepath, hashable, optparse-applicative, random + , stdenv, text, unordered-containers, vector + }: + mkDerivation { + pname = "perfect-hash-generator"; + version = "0.2.0.6"; + sha256 = "df727611ca45994fc40e3e37ebae783a892f3b46db95897ba2df876e65f7b110"; + isLibrary = true; + isExecutable = true; + libraryHaskellDepends = [ + base binary bytestring containers data-ordlist directory filepath + hashable text unordered-containers vector + ]; + executableHaskellDepends = [ + base binary bytestring containers hashable optparse-applicative + random text unordered-containers vector + ]; + doHaddock = false; + doCheck = false; + homepage = "https://github.com/kostmo/perfect-hash-generator#readme"; + description = "Perfect minimal hashing implementation in native Haskell"; + license = stdenv.lib.licenses.asl20; + }) {}; + "persistable-record" = callPackage + ({ mkDerivation, array, base, containers, dlist, names-th + , product-isomorphic, stdenv, template-haskell, th-data-compat + , transformers + }: + mkDerivation { + pname = "persistable-record"; + version = "0.6.0.4"; + sha256 = "6d3abe73d61cf691bb1b5a412fa8a6d8fcc5cb3070176041ad8953b63ca5f8f9"; + libraryHaskellDepends = [ + array base containers dlist names-th product-isomorphic + template-haskell th-data-compat transformers + ]; + doHaddock = false; + doCheck = false; + homepage = "http://khibino.github.io/haskell-relational-record/"; + description = "Binding between SQL database values and haskell records"; + license = stdenv.lib.licenses.bsd3; + }) {}; + "persistable-types-HDBC-pg" = callPackage + ({ mkDerivation, base, bytestring, convertible, dlist, HDBC + , persistable-record, relational-query, relational-query-HDBC + , stdenv, text-postgresql + }: + mkDerivation { + pname = "persistable-types-HDBC-pg"; + version = "0.0.3.5"; + sha256 = "955c73edd056e1ecb6a3543d726070c3f219a67017ef18ac9ae75711f63cec2f"; + libraryHaskellDepends = [ + base bytestring convertible dlist HDBC persistable-record + relational-query relational-query-HDBC text-postgresql + ]; + doHaddock = false; + doCheck = false; + homepage = "http://khibino.github.io/haskell-relational-record/"; + description = "HDBC and Relational-Record instances of PostgreSQL extended types"; + license = stdenv.lib.licenses.bsd3; + }) {}; + "persistent" = callPackage + ({ mkDerivation, aeson, attoparsec, base, base64-bytestring + , blaze-html, blaze-markup, bytestring, conduit, containers + , fast-logger, haskell-src-meta, http-api-data, monad-logger, mtl + , old-locale, path-pieces, resource-pool, resourcet, scientific + , silently, stdenv, tagged, template-haskell, text, time + , transformers, unliftio-core, unordered-containers, vector, void + }: + mkDerivation { + pname = "persistent"; + version = "2.8.2"; + sha256 = "696bb279259e307778dc7fbd49565c48a66429f14e793a41a13cfae0968c1ec0"; + revision = "1"; + editedCabalFile = "18a6dfpjakcmyl9qnflgi63rss09zj3xg0py6bliary4y2cqw4fz"; + libraryHaskellDepends = [ + aeson attoparsec base base64-bytestring blaze-html blaze-markup + bytestring conduit containers fast-logger haskell-src-meta + http-api-data monad-logger mtl old-locale path-pieces resource-pool + resourcet scientific silently tagged template-haskell text time + transformers unliftio-core unordered-containers vector void + ]; + doHaddock = false; + doCheck = false; + homepage = "http://www.yesodweb.com/book/persistent"; + description = "Type-safe, multi-backend data serialization"; + license = stdenv.lib.licenses.mit; + }) {}; + "persistent-iproute" = callPackage + ({ mkDerivation, aeson, aeson-iproute, base, bytestring + , http-api-data, iproute, path-pieces, persistent, stdenv, text + }: + mkDerivation { + pname = "persistent-iproute"; + version = "0.2.3"; + sha256 = "f595a11ceaa1c19e11d6f4fc58ec2834eb100791ae82626912115f1d79edbfaa"; + libraryHaskellDepends = [ + aeson aeson-iproute base bytestring http-api-data iproute + path-pieces persistent text + ]; + doHaddock = false; + doCheck = false; + homepage = "https://github.com/greydot/persistent-iproute"; + description = "Persistent instances for types in iproute"; + license = stdenv.lib.licenses.bsd3; + }) {}; + "persistent-mysql" = callPackage + ({ mkDerivation, aeson, base, blaze-builder, bytestring, conduit + , containers, monad-logger, mysql, mysql-simple, persistent + , resource-pool, resourcet, stdenv, text, transformers + , unliftio-core + }: + mkDerivation { + pname = "persistent-mysql"; + version = "2.8.1"; + sha256 = "80cc29f8fa90503a13c348e14f10dd0883f17837ca72a5cd5b2884fdb286e654"; + libraryHaskellDepends = [ + aeson base blaze-builder bytestring conduit containers monad-logger + mysql mysql-simple persistent resource-pool resourcet text + transformers unliftio-core + ]; + doHaddock = false; + doCheck = false; + homepage = "http://www.yesodweb.com/book/persistent"; + description = "Backend for the persistent library using MySQL database server"; + license = stdenv.lib.licenses.mit; + }) {}; + "persistent-mysql-haskell" = callPackage + ({ mkDerivation, aeson, base, bytestring, conduit, containers + , io-streams, monad-logger, mysql-haskell, network, persistent + , persistent-template, resource-pool, resourcet, stdenv, text, time + , tls, transformers, unliftio-core + }: + mkDerivation { + pname = "persistent-mysql-haskell"; + version = "0.4.1"; + sha256 = "2109f8e08fbc499ad3059e72a2ea2335ef6bcf8cbf52c8280771001a84dae8f2"; + isLibrary = true; + isExecutable = true; + libraryHaskellDepends = [ + aeson base bytestring conduit containers io-streams monad-logger + mysql-haskell network persistent resource-pool resourcet text time + tls transformers unliftio-core + ]; + executableHaskellDepends = [ + base monad-logger persistent persistent-template transformers + ]; + doHaddock = false; + doCheck = false; + homepage = "http://www.yesodweb.com/book/persistent"; + description = "A pure haskell backend for the persistent library using MySQL database server"; + license = stdenv.lib.licenses.mit; + }) {}; + "persistent-postgresql" = callPackage + ({ mkDerivation, aeson, base, blaze-builder, bytestring, conduit + , containers, monad-logger, persistent, postgresql-libpq + , postgresql-simple, resource-pool, resourcet, stdenv, text, time + , transformers, unliftio-core + }: + mkDerivation { + pname = "persistent-postgresql"; + version = "2.8.2.0"; + sha256 = "f2f3c80b9f1d5ae494492204f3170e33ff3a5792b9675748839de6309d082f49"; + libraryHaskellDepends = [ + aeson base blaze-builder bytestring conduit containers monad-logger + persistent postgresql-libpq postgresql-simple resource-pool + resourcet text time transformers unliftio-core + ]; + doHaddock = false; + doCheck = false; + homepage = "http://www.yesodweb.com/book/persistent"; + description = "Backend for the persistent library using postgresql"; + license = stdenv.lib.licenses.mit; + }) {}; + "persistent-refs" = callPackage + ({ mkDerivation, base, containers, mtl, ref-fd, stdenv + , transformers + }: + mkDerivation { + pname = "persistent-refs"; + version = "0.4"; + sha256 = "46b310e034e23993e7da740d388e06e410483ada05cbcc8c0a4953ee19f8d0d3"; + libraryHaskellDepends = [ + base containers mtl ref-fd transformers + ]; + doHaddock = false; + doCheck = false; + homepage = "https://github.com/acfoltzer/persistent-refs"; + description = "Haskell references backed by an IntMap for persistence and reversibility"; + license = stdenv.lib.licenses.bsd3; + }) {}; + "persistent-sqlite" = callPackage + ({ mkDerivation, aeson, base, bytestring, conduit, containers + , microlens-th, monad-logger, old-locale, persistent, resource-pool + , resourcet, sqlite, stdenv, text, time, transformers + , unliftio-core, unordered-containers + }: + mkDerivation { + pname = "persistent-sqlite"; + version = "2.8.1.2"; + sha256 = "2f7157f3830370f60c7c36490ea49b7c52caf0f2a7349f86cf47970189f9ad0c"; + configureFlags = [ "-fsystemlib" ]; + isLibrary = true; + isExecutable = true; + libraryHaskellDepends = [ + aeson base bytestring conduit containers microlens-th monad-logger + old-locale persistent resource-pool resourcet text time + transformers unliftio-core unordered-containers + ]; + librarySystemDepends = [ sqlite ]; + doHaddock = false; + doCheck = false; + homepage = "http://www.yesodweb.com/book/persistent"; + description = "Backend for the persistent library using sqlite3"; + license = stdenv.lib.licenses.mit; + }) {inherit (pkgs) sqlite;}; + "persistent-template" = callPackage + ({ mkDerivation, aeson, aeson-compat, base, bytestring, containers + , ghc-prim, http-api-data, monad-control, monad-logger, path-pieces + , persistent, stdenv, tagged, template-haskell, text, transformers + , unordered-containers + }: + mkDerivation { + pname = "persistent-template"; + version = "2.5.4"; + sha256 = "4cae740ce92f98cb3ae9e092e740753394d5687b887399ee5f87af7f3c730a01"; + revision = "3"; + editedCabalFile = "12f4pqxwfv2li78sd9s56p66xd0w465cmjycpkqvg8n1rjxkc8vs"; + libraryHaskellDepends = [ + aeson aeson-compat base bytestring containers ghc-prim + http-api-data monad-control monad-logger path-pieces persistent + tagged template-haskell text transformers unordered-containers + ]; + doHaddock = false; + doCheck = false; + homepage = "http://www.yesodweb.com/book/persistent"; + description = "Type-safe, non-relational, multi-backend persistence"; + license = stdenv.lib.licenses.mit; + }) {}; + "pg-transact" = callPackage + ({ mkDerivation, base, bytestring, exceptions, monad-control + , postgresql-simple, stdenv, transformers + }: + mkDerivation { + pname = "pg-transact"; + version = "0.1.0.1"; + sha256 = "598236369ee1228a3a76b4f0d5830d652a90ddbc0f98fdde064ad979a1abc97d"; + libraryHaskellDepends = [ + base bytestring exceptions monad-control postgresql-simple + transformers + ]; + doHaddock = false; + doCheck = false; + homepage = "https://github.com/jfischoff/pg-transact#readme"; + description = "Another postgresql-simple transaction monad"; + license = stdenv.lib.licenses.bsd3; + }) {}; + "pgp-wordlist" = callPackage + ({ mkDerivation, base, bytestring, containers, stdenv, text, vector + }: + mkDerivation { + pname = "pgp-wordlist"; + version = "0.1.0.2"; + sha256 = "e28b6fe85222adf1247d5870ab47c68c3d25df3f9ceda104bfb64e1414a92466"; + libraryHaskellDepends = [ base bytestring containers text vector ]; + doHaddock = false; + doCheck = false; + homepage = "https://github.com/quchen/pgp-wordlist"; + description = "Translate between binary data and a human-readable collection of words"; + license = stdenv.lib.licenses.bsd3; + }) {}; + "phantom-state" = callPackage + ({ mkDerivation, base, stdenv, transformers }: + mkDerivation { + pname = "phantom-state"; + version = "0.2.1.2"; + sha256 = "f978ef98e810e9a9e53f1479340ba7a28f80a64aba431322959cbf8c620c3811"; + libraryHaskellDepends = [ base transformers ]; + doHaddock = false; + doCheck = false; + description = "Phantom State Transformer. Like State Monad, but without values."; + license = stdenv.lib.licenses.bsd3; + }) {}; + "picosat" = callPackage + ({ mkDerivation, base, containers, stdenv, transformers }: + mkDerivation { + pname = "picosat"; + version = "0.1.4"; + sha256 = "5a6d9fae04a77a95a8c92ec6dd76302010b726d8c934dc8d8bbabc82851e9039"; + libraryHaskellDepends = [ base containers transformers ]; + doHaddock = false; + doCheck = false; + homepage = "https://github.com/sdiehl/haskell-picosat"; + description = "Bindings to the PicoSAT solver"; + license = stdenv.lib.licenses.mit; + }) {}; + "pid1" = callPackage + ({ mkDerivation, base, directory, process, stdenv, unix }: + mkDerivation { + pname = "pid1"; + version = "0.1.2.0"; + sha256 = "9e97bf9b4b6ffd6a9b706cc6d5fadd8089cd37d2b8763111bd743104db267f76"; + revision = "1"; + editedCabalFile = "11yg5pjci1d6p5ml0ic4vqn70vjx8vvhqs20rahgfqhh8palkyw9"; + isLibrary = true; + isExecutable = true; + libraryHaskellDepends = [ base directory process unix ]; + executableHaskellDepends = [ base ]; + doHaddock = false; + doCheck = false; + homepage = "https://github.com/fpco/pid1#readme"; + description = "Do signal handling and orphan reaping for Unix PID1 init processes"; + license = stdenv.lib.licenses.mit; + }) {}; + "pinboard" = callPackage + ({ mkDerivation, aeson, base, bytestring, containers, http-client + , http-client-tls, http-types, monad-logger, mtl, network + , profunctors, random, safe-exceptions, stdenv, text, time + , transformers, unordered-containers, vector + }: + mkDerivation { + pname = "pinboard"; + version = "0.9.12.10"; + sha256 = "bac98d28d29f47d39ca15f0b406f438fb2797841a21edfd1cdf8d54bdb64b049"; + libraryHaskellDepends = [ + aeson base bytestring containers http-client http-client-tls + http-types monad-logger mtl network profunctors random + safe-exceptions text time transformers unordered-containers vector + ]; + doHaddock = false; + doCheck = false; + homepage = "https://github.com/jonschoning/pinboard"; + description = "Access to the Pinboard API"; + license = stdenv.lib.licenses.mit; + }) {}; + "pipes" = callPackage + ({ mkDerivation, base, exceptions, mmorph, mtl, semigroups, stdenv + , transformers, void + }: + mkDerivation { + pname = "pipes"; + version = "4.3.9"; + sha256 = "5c4cda351f9cf59376832baaeb857db25bd4990fd78c4b061aca0bde47271acb"; + revision = "1"; + editedCabalFile = "0mkwbbn8vlrsvm3pl2cyaw1qr9hbjqfm831naj7cbrmiksf2l5aa"; + libraryHaskellDepends = [ + base exceptions mmorph mtl semigroups transformers void + ]; + doHaddock = false; + doCheck = false; + description = "Compositional pipelines"; + license = stdenv.lib.licenses.bsd3; + }) {}; + "pipes-aeson" = callPackage + ({ mkDerivation, aeson, attoparsec, base, bytestring, pipes + , pipes-attoparsec, pipes-bytestring, pipes-parse, stdenv + , transformers + }: + mkDerivation { + pname = "pipes-aeson"; + version = "0.4.1.8"; + sha256 = "350411f492fefa8d5a2554e7521d22b7ee88bacbea9d27c0d22468f6355ebe75"; + libraryHaskellDepends = [ + aeson attoparsec base bytestring pipes pipes-attoparsec + pipes-bytestring pipes-parse transformers + ]; + doHaddock = false; + doCheck = false; + homepage = "https://github.com/k0001/pipes-aeson"; + description = "Encode and decode JSON streams using Aeson and Pipes"; + license = stdenv.lib.licenses.bsd3; + }) {}; + "pipes-attoparsec" = callPackage + ({ mkDerivation, attoparsec, base, bytestring, pipes, pipes-parse + , stdenv, text, transformers + }: + mkDerivation { + pname = "pipes-attoparsec"; + version = "0.5.1.5"; + sha256 = "fe9eb446289dbc4c4acdde39620877b885417990d9774f622fa9d1daa591cafd"; + libraryHaskellDepends = [ + attoparsec base bytestring pipes pipes-parse text transformers + ]; + doHaddock = false; + doCheck = false; + homepage = "https://github.com/k0001/pipes-attoparsec"; + description = "Attoparsec and Pipes integration"; + license = stdenv.lib.licenses.bsd3; + }) {}; + "pipes-binary" = callPackage + ({ mkDerivation, base, binary, bytestring, ghc-prim, pipes + , pipes-bytestring, pipes-parse, stdenv, transformers + }: + mkDerivation { + pname = "pipes-binary"; + version = "0.4.2"; + sha256 = "f659d9fd4c816b65abe14a67eb86f7605d15ab5bca5514b25fa6fd82a23064e8"; + libraryHaskellDepends = [ + base binary bytestring ghc-prim pipes pipes-bytestring pipes-parse + transformers + ]; + doHaddock = false; + doCheck = false; + homepage = "https://github.com/k0001/pipes-binary"; + description = "Encode and decode binary streams using the pipes and binary libraries"; + license = stdenv.lib.licenses.bsd3; + }) {}; + "pipes-bytestring" = callPackage + ({ mkDerivation, base, bytestring, pipes, pipes-group, pipes-parse + , stdenv, stringsearch, transformers + }: + mkDerivation { + pname = "pipes-bytestring"; + version = "2.1.6"; + sha256 = "b1dc370680f3671759010caace183bce683d0481bd2c0e3f4906b78ac8623c18"; + libraryHaskellDepends = [ + base bytestring pipes pipes-group pipes-parse stringsearch + transformers + ]; + doHaddock = false; + doCheck = false; + description = "ByteString support for pipes"; + license = stdenv.lib.licenses.bsd3; + }) {}; + "pipes-category" = callPackage + ({ mkDerivation, base, lens, mtl, pipes, pipes-extras, stdenv }: + mkDerivation { + pname = "pipes-category"; + version = "0.3.0.0"; + sha256 = "4711d889ed2bf7244bbbc292af5746e0378d72a09929aa1e668056e7f0180701"; + libraryHaskellDepends = [ base lens mtl pipes pipes-extras ]; + doHaddock = false; + doCheck = false; + homepage = "https://github.com/louispan/pipes-category#readme"; + description = "Allows instances for Category, Arrow and ArrowChoice for Pipes"; + license = stdenv.lib.licenses.bsd3; + }) {}; + "pipes-concurrency" = callPackage + ({ mkDerivation, async, base, contravariant, pipes, semigroups + , stdenv, stm, void + }: + mkDerivation { + pname = "pipes-concurrency"; + version = "2.0.11"; + sha256 = "9534bc54ef695d8fda55608bb4b0fba0eb8cb7dceb758a84dc9e1816c23a080e"; + revision = "1"; + editedCabalFile = "10fdn7dg29q6k136l1b8whaa7pj4ccbix352gxb0d2x85wrwlmwa"; + libraryHaskellDepends = [ + async base contravariant pipes semigroups stm void + ]; + doHaddock = false; + doCheck = false; + description = "Concurrency for the pipes ecosystem"; + license = stdenv.lib.licenses.bsd3; + }) {}; + "pipes-csv" = callPackage + ({ mkDerivation, base, blaze-builder, bytestring, cassava, pipes + , stdenv, unordered-containers, vector + }: + mkDerivation { + pname = "pipes-csv"; + version = "1.4.3"; + sha256 = "9485f5ddd56ec9bb10d26cdf2b5b67754726e36b167652b11cb0a42acbda68b3"; + libraryHaskellDepends = [ + base blaze-builder bytestring cassava pipes unordered-containers + vector + ]; + doHaddock = false; + doCheck = false; + description = "Fast, streaming csv parser"; + license = stdenv.lib.licenses.mit; + }) {}; + "pipes-extras" = callPackage + ({ mkDerivation, base, foldl, lens, pipes, stdenv, transformers }: + mkDerivation { + pname = "pipes-extras"; + version = "1.0.15"; + sha256 = "02a9633ac912fd48e9a5ca0e6b48a6e9541ce59d11243096ca6af6b25701cbb3"; + libraryHaskellDepends = [ base foldl lens pipes transformers ]; + doHaddock = false; + doCheck = false; + description = "Extra utilities for pipes"; + license = stdenv.lib.licenses.bsd3; + }) {}; + "pipes-fastx" = callPackage + ({ mkDerivation, attoparsec, base, bytestring, pipes + , pipes-attoparsec, pipes-bytestring, stdenv + }: + mkDerivation { + pname = "pipes-fastx"; + version = "0.3.0.0"; + sha256 = "31264ba760bae1df3170a7d8da32f3e3fcb289545a33f369a94732e55e08ba75"; + libraryHaskellDepends = [ + attoparsec base bytestring pipes pipes-attoparsec pipes-bytestring + ]; + doHaddock = false; + doCheck = false; + description = "Streaming parsers for Fasta and Fastq"; + license = stdenv.lib.licenses.bsd3; + }) {}; + "pipes-fluid" = callPackage + ({ mkDerivation, base, constraints, lens, lifted-async + , monad-control, pipes, semigroups, stdenv, stm, these + , transformers, transformers-base + }: + mkDerivation { + pname = "pipes-fluid"; + version = "0.6.0.1"; + sha256 = "105d8e8df7e731e2d272a22891eb68db1ca3ec9f425b67af77c5d91e3f032f06"; + libraryHaskellDepends = [ + base constraints lens lifted-async monad-control pipes semigroups + stm these transformers transformers-base + ]; + doHaddock = false; + doCheck = false; + homepage = "https://github.com/louispan/pipes-fluid#readme"; + description = "Reactively combines Producers so that a value is yielded as soon as possible"; + license = stdenv.lib.licenses.bsd3; + }) {}; + "pipes-group" = callPackage + ({ mkDerivation, base, free, pipes, pipes-parse, stdenv + , transformers + }: + mkDerivation { + pname = "pipes-group"; + version = "1.0.12"; + sha256 = "1373e89fbeb127c31461042cdda848da2048eda2700ddbd872d444af87745ac7"; + libraryHaskellDepends = [ + base free pipes pipes-parse transformers + ]; + doHaddock = false; + doCheck = false; + description = "Group streams into substreams"; + license = stdenv.lib.licenses.bsd3; + }) {}; + "pipes-http" = callPackage + ({ mkDerivation, base, bytestring, http-client, http-client-tls + , pipes, stdenv + }: + mkDerivation { + pname = "pipes-http"; + version = "1.0.5"; + sha256 = "49a196466de1638f3806a49bf10fef9eb3c06456ababf09ffd025b6b64f23055"; + libraryHaskellDepends = [ + base bytestring http-client http-client-tls pipes + ]; + doHaddock = false; + doCheck = false; + description = "HTTP client with pipes interface"; + license = stdenv.lib.licenses.bsd3; + }) {}; + "pipes-misc" = callPackage + ({ mkDerivation, base, clock, Decimal, lens, mmorph, mtl, pipes + , pipes-category, pipes-concurrency, semigroups, stdenv, stm + , transformers + }: + mkDerivation { + pname = "pipes-misc"; + version = "0.5.0.0"; + sha256 = "4e2e7e396ee0c659ae3742388d06b69e3b5146a5563cd3f4ba56f9a1febb8d26"; + libraryHaskellDepends = [ + base clock Decimal lens mmorph mtl pipes pipes-category + pipes-concurrency semigroups stm transformers + ]; + doHaddock = false; + doCheck = false; + homepage = "https://github.com/louispan/pipes-misc#readme"; + description = "Miscellaneous utilities for pipes, required by glazier-tutorial"; + license = stdenv.lib.licenses.bsd3; + }) {}; + "pipes-network" = callPackage + ({ mkDerivation, base, bytestring, exceptions, network + , network-simple, pipes, pipes-safe, stdenv, transformers + }: + mkDerivation { + pname = "pipes-network"; + version = "0.6.5"; + sha256 = "74a461153a2f650e9e15037002b6d9177b132f409e3204824655ffbb939dc795"; + libraryHaskellDepends = [ + base bytestring exceptions network network-simple pipes pipes-safe + transformers + ]; + doHaddock = false; + doCheck = false; + homepage = "https://github.com/k0001/pipes-network"; + description = "Use network sockets together with the pipes library"; + license = stdenv.lib.licenses.bsd3; + }) {}; + "pipes-network-tls" = callPackage + ({ mkDerivation, base, bytestring, network, network-simple + , network-simple-tls, pipes, pipes-network, pipes-safe, stdenv, tls + , transformers + }: + mkDerivation { + pname = "pipes-network-tls"; + version = "0.3"; + sha256 = "a2694a6b15d71a8cae898dd8e6a085a4e1ae317c40f2752ceed2b991dfb6bab2"; + libraryHaskellDepends = [ + base bytestring network network-simple network-simple-tls pipes + pipes-network pipes-safe tls transformers + ]; + doHaddock = false; + doCheck = false; + homepage = "https://github.com/k0001/pipes-network-tls"; + description = "TLS-secured network connections support for pipes"; + license = stdenv.lib.licenses.bsd3; + }) {}; + "pipes-parse" = callPackage + ({ mkDerivation, base, pipes, stdenv, transformers }: + mkDerivation { + pname = "pipes-parse"; + version = "3.0.8"; + sha256 = "d28f831b2c8229cca567ee95570787d2dd3f5cfcff3b3c44ee308360a8c107a9"; + libraryHaskellDepends = [ base pipes transformers ]; + doHaddock = false; + doCheck = false; + description = "Parsing infrastructure for the pipes ecosystem"; + license = stdenv.lib.licenses.bsd3; + }) {}; + "pipes-random" = callPackage + ({ mkDerivation, base, mwc-random, pipes, stdenv, vector }: + mkDerivation { + pname = "pipes-random"; + version = "1.0.0.4"; + sha256 = "542a07e7d7aafa87201c1f00c4e98ac8f59707f776ea03b1f6f117273608659e"; + revision = "2"; + editedCabalFile = "0czw2qfi05d5kbnwzhzr75j1ag6hfbn9nvbjyifdjradfzjxl2s9"; + libraryHaskellDepends = [ base mwc-random pipes vector ]; + doHaddock = false; + doCheck = false; + homepage = "https://github.com/fosskers/pipes-random"; + description = "Producers for handling randomness"; + license = stdenv.lib.licenses.bsd3; + }) {}; + "pipes-safe" = callPackage + ({ mkDerivation, base, containers, exceptions, monad-control, mtl + , pipes, primitive, stdenv, transformers, transformers-base + }: + mkDerivation { + pname = "pipes-safe"; + version = "2.2.9"; + sha256 = "17f16403794a2517eb283dd8b34a17c3485143b7fb66870d0a305294815a1898"; + revision = "2"; + editedCabalFile = "1crpzg72nahmffw468d31l23bw3wgi0p3w7ad2pv3jxhy1432c71"; + libraryHaskellDepends = [ + base containers exceptions monad-control mtl pipes primitive + transformers transformers-base + ]; + doHaddock = false; + doCheck = false; + description = "Safety for the pipes ecosystem"; + license = stdenv.lib.licenses.bsd3; + }) {}; + "pipes-wai" = callPackage + ({ mkDerivation, base, blaze-builder, bytestring, http-types, pipes + , stdenv, transformers, wai + }: + mkDerivation { + pname = "pipes-wai"; + version = "3.2.0"; + sha256 = "04a670df140c12b64f6f0d04b3c5571527f144ee429e7030bb62ec8785056d2a"; + libraryHaskellDepends = [ + base blaze-builder bytestring http-types pipes transformers wai + ]; + doHaddock = false; + doCheck = false; + homepage = "http://github.com/iand675/pipes-wai"; + description = "A port of wai-conduit for the pipes ecosystem"; + license = stdenv.lib.licenses.mit; + }) {}; + "pkcs10" = callPackage + ({ mkDerivation, asn1-encoding, asn1-parse, asn1-types, base + , bytestring, cryptonite, pem, stdenv, x509 + }: + mkDerivation { + pname = "pkcs10"; + version = "0.2.0.0"; + sha256 = "896e923f67bac4c7f0e48c9afca60f9ef5178e00fca9f179e8fdae3c12476294"; + libraryHaskellDepends = [ + asn1-encoding asn1-parse asn1-types base bytestring cryptonite pem + x509 + ]; + doHaddock = false; + doCheck = false; + homepage = "https://github.com/fcomb/pkcs10-hs#readme"; + description = "PKCS#10 library"; + license = stdenv.lib.licenses.asl20; + }) {}; + "placeholders" = callPackage + ({ mkDerivation, base, stdenv, template-haskell }: + mkDerivation { + pname = "placeholders"; + version = "0.1"; + sha256 = "652a78553dcaf6e11b4cd8f0e60010b32da299fbe57721df4bf9157e852d0346"; + libraryHaskellDepends = [ base template-haskell ]; + doHaddock = false; + doCheck = false; + homepage = "http://github.com/ahammar/placeholders"; + description = "Placeholders for use while developing Haskell code"; + license = stdenv.lib.licenses.bsd3; + }) {}; + "plot-light" = callPackage + ({ mkDerivation, base, blaze-markup, blaze-svg, colour, containers + , exceptions, histogram-fill, mtl, scientific, stdenv, text, time + , vector + }: + mkDerivation { + pname = "plot-light"; + version = "0.4.3"; + sha256 = "abbc116ff80d1e7ee0ed4dd0ba90baf907da7f347fa678767ff9402714399fbb"; + libraryHaskellDepends = [ + base blaze-markup blaze-svg colour containers exceptions + histogram-fill mtl scientific text time vector + ]; + doHaddock = false; + doCheck = false; + homepage = "https://github.com/ocramz/plot-light"; + description = "A lightweight plotting library, exporting to SVG"; + license = stdenv.lib.licenses.bsd3; + }) {}; + "plotlyhs" = callPackage + ({ mkDerivation, aeson, base, blaze-html, blaze-markup, bytestring + , lucid, microlens, microlens-th, stdenv, text + }: + mkDerivation { + pname = "plotlyhs"; + version = "0.2"; + sha256 = "85fb0446b3e92267357dc52b770da90b222b85337f3db593e0350021d1e53259"; + libraryHaskellDepends = [ + aeson base blaze-html blaze-markup bytestring lucid microlens + microlens-th text + ]; + doHaddock = false; + doCheck = false; + homepage = "https://github.com/filopodia/open/plotlyhs"; + description = "Haskell bindings to Plotly.js"; + license = stdenv.lib.licenses.mit; + }) {}; + "pointed" = callPackage + ({ mkDerivation, base, comonad, containers, data-default-class + , hashable, kan-extensions, semigroupoids, semigroups, stdenv, stm + , tagged, transformers, transformers-compat, unordered-containers + }: + mkDerivation { + pname = "pointed"; + version = "5.0.1"; + sha256 = "b94635a5c8779238501a9156015422ce2fb4d5efd45d68999e8cbe2ecc5121dd"; + revision = "1"; + editedCabalFile = "1ccjmzz3jf5ybrzv7qdwm3qb8rz0yskvi4ackrixyhdk8bg5f3nc"; + libraryHaskellDepends = [ + base comonad containers data-default-class hashable kan-extensions + semigroupoids semigroups stm tagged transformers + transformers-compat unordered-containers + ]; + doHaddock = false; + doCheck = false; + homepage = "http://github.com/ekmett/pointed/"; + description = "Pointed and copointed data"; + license = stdenv.lib.licenses.bsd3; + }) {}; + "pointedlist" = callPackage + ({ mkDerivation, base, binary, stdenv }: + mkDerivation { + pname = "pointedlist"; + version = "0.6.1"; + sha256 = "743cb0f89cbb128f8aa24c4519b262b561bf2cd607f83e94f9241e8af1cfba9b"; + libraryHaskellDepends = [ base binary ]; + doHaddock = false; + doCheck = false; + description = "A zipper-like comonad which works as a list, tracking a position"; + license = stdenv.lib.licenses.bsd3; + }) {}; + "pointless-fun" = callPackage + ({ mkDerivation, base, stdenv }: + mkDerivation { + pname = "pointless-fun"; + version = "1.1.0.6"; + sha256 = "d05c59dac408a81766d676da2fb98025e75e0c3d0a07bdb458759d5c41e3b054"; + libraryHaskellDepends = [ base ]; + doHaddock = false; + doCheck = false; + homepage = "http://code.haskell.org/~wren/"; + description = "Some common point-free combinators"; + license = stdenv.lib.licenses.bsd3; + }) {}; + "poll" = callPackage + ({ mkDerivation, base, enumset, stdenv, utility-ht }: + mkDerivation { + pname = "poll"; + version = "0.0.0.1"; + sha256 = "b9fe87fe1b4d3ecb2ad3c1c290e231b0c93d498f0d318f67018a1dde97a0ed29"; + libraryHaskellDepends = [ base enumset utility-ht ]; + doHaddock = false; + doCheck = false; + description = "Bindings to poll.h"; + license = stdenv.lib.licenses.bsd3; + }) {}; + "poly-arity" = callPackage + ({ mkDerivation, base, constraints, stdenv }: + mkDerivation { + pname = "poly-arity"; + version = "0.1.0"; + sha256 = "cb10a644fe04de8e703942f4bd0d97c4df0f9e3915d33a494994e85830cfdd29"; + libraryHaskellDepends = [ base constraints ]; + doHaddock = false; + doCheck = false; + description = "Tools for working with functions of undetermined arity"; + license = stdenv.lib.licenses.bsd3; + }) {}; + "polynomials-bernstein" = callPackage + ({ mkDerivation, base, stdenv, vector }: + mkDerivation { + pname = "polynomials-bernstein"; + version = "1.1.2"; + sha256 = "6950f2e791533a40e7e41ff98679f680f27c7b66258b57871027bf0e5adc7062"; + libraryHaskellDepends = [ base vector ]; + doHaddock = false; + doCheck = false; + description = "A solver for systems of polynomial equations in bernstein form"; + license = "GPL"; + }) {}; + "polyparse" = callPackage + ({ mkDerivation, base, bytestring, stdenv, text }: + mkDerivation { + pname = "polyparse"; + version = "1.12"; + sha256 = "f54c63584ace968381de4a06bd7328b6adc3e1a74fd336e18449e0dd7650be15"; + revision = "1"; + editedCabalFile = "18daiyj3009wx0bhr87fbgy7xfh68ss9qzn6k3lgmh1z9dfsryrd"; + libraryHaskellDepends = [ base bytestring text ]; + doHaddock = false; + doCheck = false; + homepage = "http://code.haskell.org/~malcolm/polyparse/"; + description = "A variety of alternative parser combinator libraries"; + license = "LGPL"; + }) {}; + "pooled-io" = callPackage + ({ mkDerivation, base, concurrent-split, containers, deepseq + , stdenv, transformers, unsafe, utility-ht + }: + mkDerivation { + pname = "pooled-io"; + version = "0.0.2.1"; + sha256 = "7d405a8876d55a9c077a304dd378854bc9e6e20f643c357c82bd3f38297ff9d0"; + isLibrary = true; + isExecutable = true; + libraryHaskellDepends = [ + base concurrent-split containers deepseq transformers unsafe + utility-ht + ]; + doHaddock = false; + doCheck = false; + homepage = "http://hub.darcs.net/thielema/pooled-io/"; + description = "Run jobs on a limited number of threads and support data dependencies"; + license = stdenv.lib.licenses.bsd3; + }) {}; + "portable-lines" = callPackage + ({ mkDerivation, base, bytestring, stdenv }: + mkDerivation { + pname = "portable-lines"; + version = "0.1"; + sha256 = "5053f5bc42d4362062e0ec55dd111b0f6611be280c7f871876732853f4b824d1"; + libraryHaskellDepends = [ base bytestring ]; + doHaddock = false; + doCheck = false; + description = "Alternative 'lines' implementation that understands CR-LF and CR"; + license = stdenv.lib.licenses.bsd3; + }) {}; + "posix-pty" = callPackage + ({ mkDerivation, base, bytestring, process, stdenv, unix, util }: + mkDerivation { + pname = "posix-pty"; + version = "0.2.1.1"; + sha256 = "a2c50cec87434afa5758fe79efa95ac730843be689dac8a1d78a9e7d66fdbbb9"; + revision = "1"; + editedCabalFile = "1dhxxwlv69bczi7mbhdd9f3s9nnjb4b3jf9mlgdjg7wxqh84zrgi"; + libraryHaskellDepends = [ base bytestring process unix ]; + librarySystemDepends = [ util ]; + doHaddock = false; + doCheck = false; + homepage = "https://bitbucket.org/merijnv/posix-pty"; + description = "Pseudo terminal interaction with subprocesses"; + license = stdenv.lib.licenses.bsd3; + }) {}; + "post-mess-age" = callPackage + ({ mkDerivation, base, stdenv }: + mkDerivation { + pname = "post-mess-age"; + version = "0.2.1.0"; + sha256 = "d0f69ab1cb130a9f8bb54cd1f3b0167184af885fedba89ff32fec8e54e95d64c"; + libraryHaskellDepends = [ base ]; + doHaddock = false; + doCheck = false; + description = "Send messages to a handle concurrently without getting them mixed"; + license = stdenv.lib.licenses.bsd3; + }) {}; + "postgresql-binary" = callPackage + ({ mkDerivation, aeson, base, base-prelude, binary-parser + , bytestring, bytestring-strict-builder, containers, loch-th + , network-ip, placeholders, scientific, stdenv, text, time + , transformers, unordered-containers, uuid, vector + }: + mkDerivation { + pname = "postgresql-binary"; + version = "0.12.1.1"; + sha256 = "fb00b37b213e00369ae17145ed8487ac0bfe295f35b3ef24afaba76f9dbf36a0"; + libraryHaskellDepends = [ + aeson base base-prelude binary-parser bytestring + bytestring-strict-builder containers loch-th network-ip + placeholders scientific text time transformers unordered-containers + uuid vector + ]; + doHaddock = false; + doCheck = false; + homepage = "https://github.com/nikita-volkov/postgresql-binary"; + description = "Encoders and decoders for the PostgreSQL's binary format"; + license = stdenv.lib.licenses.mit; + }) {}; + "postgresql-libpq" = callPackage + ({ mkDerivation, base, bytestring, Cabal, postgresql, stdenv, unix + }: + mkDerivation { + pname = "postgresql-libpq"; + version = "0.9.4.1"; + sha256 = "0d9fa338b67c54786ea123cb9f75f3362aad01057aaa4857687610a39908566b"; + setupHaskellDepends = [ base Cabal ]; + libraryHaskellDepends = [ base bytestring unix ]; + librarySystemDepends = [ postgresql ]; + doHaddock = false; + doCheck = false; + homepage = "https://github.com/lpsmith/postgresql-libpq"; + description = "low-level binding to libpq"; + license = stdenv.lib.licenses.bsd3; + }) {inherit (pkgs) postgresql;}; + "postgresql-schema" = callPackage + ({ mkDerivation, base, basic-prelude, optparse-applicative + , postgresql-simple, shelly, stdenv, text, time + }: + mkDerivation { + pname = "postgresql-schema"; + version = "0.1.14"; + sha256 = "73decc70c9fc349d0162c253eb0e92a1add5964c28ef89abfe30e97f1184d572"; + isLibrary = true; + isExecutable = true; + enableSeparateDataOutput = true; + libraryHaskellDepends = [ + base basic-prelude postgresql-simple shelly text + ]; + executableHaskellDepends = [ + base basic-prelude optparse-applicative shelly text time + ]; + doHaddock = false; + doCheck = false; + homepage = "https://github.com/mfine/postgresql-schema"; + description = "PostgreSQL Schema Management"; + license = stdenv.lib.licenses.bsd3; + }) {}; + "postgresql-simple" = callPackage + ({ mkDerivation, aeson, attoparsec, base, bytestring + , bytestring-builder, case-insensitive, containers, hashable + , postgresql-libpq, scientific, stdenv, template-haskell, text + , time, transformers, uuid-types, vector + }: + mkDerivation { + pname = "postgresql-simple"; + version = "0.5.4.0"; + sha256 = "f5d11ae7907307a1a32d62add9ed88cccf4dc7a25c0c1f3f36e0975d44f73a77"; + libraryHaskellDepends = [ + aeson attoparsec base bytestring bytestring-builder + case-insensitive containers hashable postgresql-libpq scientific + template-haskell text time transformers uuid-types vector + ]; + doHaddock = false; + doCheck = false; + description = "Mid-Level PostgreSQL client library"; + license = stdenv.lib.licenses.bsd3; + }) {}; + "postgresql-simple-migration" = callPackage + ({ mkDerivation, base, base64-bytestring, bytestring, cryptohash + , directory, postgresql-simple, stdenv, text, time + }: + mkDerivation { + pname = "postgresql-simple-migration"; + version = "0.1.12.0"; + sha256 = "98f8b2eab06474e63c76b2d048d6a08d818d086b66e84caa27f3f0a368445da3"; + isLibrary = true; + isExecutable = true; + libraryHaskellDepends = [ + base base64-bytestring bytestring cryptohash directory + postgresql-simple time + ]; + executableHaskellDepends = [ + base base64-bytestring bytestring cryptohash directory + postgresql-simple text time + ]; + doHaddock = false; + doCheck = false; + homepage = "https://github.com/ameingast/postgresql-simple-migration"; + description = "PostgreSQL Schema Migrations"; + license = stdenv.lib.licenses.bsd3; + }) {}; + "postgresql-simple-queue" = callPackage + ({ mkDerivation, aeson, base, bytestring, exceptions, monad-control + , pg-transact, postgresql-simple, random, stdenv, stm, text, time + , transformers + }: + mkDerivation { + pname = "postgresql-simple-queue"; + version = "1.0.1"; + sha256 = "330b69c54e075104171758117e714b7da6c740dff8ca09fbe33bd3ab854e5a3f"; + libraryHaskellDepends = [ + aeson base bytestring exceptions monad-control pg-transact + postgresql-simple random stm text time transformers + ]; + doHaddock = false; + doCheck = false; + homepage = "https://github.com/jfischoff/postgresql-queue#readme"; + description = "A PostgreSQL backed queue"; + license = stdenv.lib.licenses.bsd3; + }) {}; + "postgresql-simple-url" = callPackage + ({ mkDerivation, base, network-uri, postgresql-simple, split + , stdenv + }: + mkDerivation { + pname = "postgresql-simple-url"; + version = "0.2.1.0"; + sha256 = "1307f57cde2bd7f6d795a860deab53d3d64043f51af31e3114dee516ef7ee9c9"; + revision = "1"; + editedCabalFile = "0ck0vrlsyj3vm8sk59jnyyqpvnv1l9mciifdnrzwr981pha147qp"; + libraryHaskellDepends = [ + base network-uri postgresql-simple split + ]; + doHaddock = false; + doCheck = false; + homepage = "https://github.com/futurice/postgresql-simple-url"; + description = "Parse postgres:// url into ConnectInfo"; + license = stdenv.lib.licenses.mit; + }) {}; + "postgresql-transactional" = callPackage + ({ mkDerivation, base, monad-control, mtl, postgresql-simple + , stdenv + }: + mkDerivation { + pname = "postgresql-transactional"; + version = "1.1.1"; + sha256 = "f9302a1e134b31f2e9bd243c4fe36a25b3a9a9d6984288be1bc9c29882545ed3"; + libraryHaskellDepends = [ + base monad-control mtl postgresql-simple + ]; + doHaddock = false; + doCheck = false; + description = "a transactional monad on top of postgresql-simple"; + license = stdenv.lib.licenses.mit; + }) {}; + "postgresql-typed" = callPackage + ({ mkDerivation, aeson, array, attoparsec, base, binary, bytestring + , containers, cryptonite, haskell-src-meta, HDBC, memory, network + , old-locale, postgresql-binary, scientific, stdenv + , template-haskell, text, time, utf8-string, uuid + }: + mkDerivation { + pname = "postgresql-typed"; + version = "0.5.3.0"; + sha256 = "b3c01c0821e96a83163f919aff86aba603f13d10ff5245680f4c4e488531f82a"; + libraryHaskellDepends = [ + aeson array attoparsec base binary bytestring containers cryptonite + haskell-src-meta HDBC memory network old-locale postgresql-binary + scientific template-haskell text time utf8-string uuid + ]; + doHaddock = false; + doCheck = false; + homepage = "https://github.com/dylex/postgresql-typed"; + description = "PostgreSQL interface with compile-time SQL type checking, optional HDBC backend"; + license = stdenv.lib.licenses.bsd3; + }) {}; + "pptable" = callPackage + ({ mkDerivation, base, boxes, containers, generic-deriving, pretty + , stdenv, syb, vector + }: + mkDerivation { + pname = "pptable"; + version = "0.3.0.0"; + sha256 = "98b7ff404eceaad834b16187af44db37324d3bfaa631347794bb0f28a6dd9317"; + revision = "1"; + editedCabalFile = "0c1srvgwyczbfnw3zw5pbsjqgxifq9yb1h60w3aq91q7iamrvdgb"; + libraryHaskellDepends = [ + base boxes containers generic-deriving pretty syb vector + ]; + doHaddock = false; + doCheck = false; + homepage = "https://github.com/gdevanla/pptable#readme"; + description = "Pretty Print containers in a tabular format"; + license = stdenv.lib.licenses.mit; + }) {}; + "pqueue" = callPackage + ({ mkDerivation, base, deepseq, stdenv }: + mkDerivation { + pname = "pqueue"; + version = "1.4.1.1"; + sha256 = "3ddc53ea30111047efeacfe0b85d721979b51e9479051d40b00563cc7ea87cff"; + libraryHaskellDepends = [ base deepseq ]; + doHaddock = false; + doCheck = false; + description = "Reliable, persistent, fast priority queues"; + license = stdenv.lib.licenses.bsd3; + }) {}; + "prefix-units" = callPackage + ({ mkDerivation, base, stdenv }: + mkDerivation { + pname = "prefix-units"; + version = "0.2.0"; + sha256 = "050abdf827a5bd014a2628b195fbd59bb226020612c99e86a082ac1c8274e384"; + libraryHaskellDepends = [ base ]; + doHaddock = false; + doCheck = false; + homepage = "https://github.com/iustin/prefix-units"; + description = "A basic library for SI/binary prefix units"; + license = stdenv.lib.licenses.bsd3; + }) {}; + "prelude-compat" = callPackage + ({ mkDerivation, base, stdenv }: + mkDerivation { + pname = "prelude-compat"; + version = "0.0.0.1"; + sha256 = "7bdc875d5b7265a87f06866dc00da69edcd4ae36ea9687c8c6e643833ffb40d4"; + libraryHaskellDepends = [ base ]; + doHaddock = false; + doCheck = false; + description = "Provide Prelude and Data.List with fixed content across GHC versions"; + license = stdenv.lib.licenses.bsd3; + }) {}; + "prelude-extras" = callPackage + ({ mkDerivation, base, stdenv }: + mkDerivation { + pname = "prelude-extras"; + version = "0.4.0.3"; + sha256 = "09bb087f0870a353ec1e7e1a08017b9a766d430d956afb88ca000a6a876bf877"; + libraryHaskellDepends = [ base ]; + doHaddock = false; + doCheck = false; + homepage = "http://github.com/ekmett/prelude-extras"; + description = "Higher order versions of Prelude classes"; + license = stdenv.lib.licenses.bsd3; + }) {}; + "prelude-safeenum" = callPackage + ({ mkDerivation, base, stdenv }: + mkDerivation { + pname = "prelude-safeenum"; + version = "0.1.1.2"; + sha256 = "d4f9f195d31198fa1a5e1edfb50684971cc5dc2695bf38c1e7e2dabdce329727"; + libraryHaskellDepends = [ base ]; + doHaddock = false; + doCheck = false; + homepage = "http://code.haskell.org/~wren/"; + description = "A redefinition of the Prelude's Enum class in order to render it safe"; + license = stdenv.lib.licenses.bsd3; + }) {}; + "present" = callPackage + ({ mkDerivation, base, stdenv, template-haskell }: + mkDerivation { + pname = "present"; + version = "4.1.0"; + sha256 = "bae8b334817a31572cc0e771f40e89b976e72b2b55d0955e4e198502dd8a427b"; + libraryHaskellDepends = [ base template-haskell ]; + doHaddock = false; + doCheck = false; + homepage = "https://github.com/chrisdone/present"; + description = "Make presentations for data types"; + license = stdenv.lib.licenses.bsd3; + }) {}; + "pretty-class" = callPackage + ({ mkDerivation, base, pretty, stdenv }: + mkDerivation { + pname = "pretty-class"; + version = "1.0.1.1"; + sha256 = "558d1b506ff58afb0a5fb9d85ea93a94687cc1aabcc5a112a6ee4375a7b8aee1"; + libraryHaskellDepends = [ base pretty ]; + doHaddock = false; + doCheck = false; + homepage = "https://github.com/ddssff/pretty-class"; + description = "Pretty printing class similar to Show"; + license = stdenv.lib.licenses.bsd3; + }) {}; + "pretty-hex" = callPackage + ({ mkDerivation, base, bytestring, stdenv }: + mkDerivation { + pname = "pretty-hex"; + version = "1.0"; + sha256 = "ff9a5f2023d6a4454f06cc395726b4cac3f9d0ea03759b14ccf7d62df79e9c7a"; + libraryHaskellDepends = [ base bytestring ]; + doHaddock = false; + doCheck = false; + description = "A library for hex dumps of ByteStrings"; + license = stdenv.lib.licenses.bsd3; + }) {}; + "pretty-show" = callPackage + ({ mkDerivation, array, base, filepath, ghc-prim, happy + , haskell-lexer, pretty, stdenv, text + }: + mkDerivation { + pname = "pretty-show"; + version = "1.7"; + sha256 = "382b6ef4a78e4059611b5c86674ad72a6bfce821e8852da4f00b628cfbbc272f"; + isLibrary = true; + isExecutable = true; + enableSeparateDataOutput = true; + libraryHaskellDepends = [ + array base filepath ghc-prim haskell-lexer pretty text + ]; + libraryToolDepends = [ happy ]; + executableHaskellDepends = [ base ]; + doHaddock = false; + doCheck = false; + homepage = "http://wiki.github.com/yav/pretty-show"; + description = "Tools for working with derived `Show` instances and generic inspection of values"; + license = stdenv.lib.licenses.mit; + }) {}; + "pretty-simple" = callPackage + ({ mkDerivation, ansi-terminal, base, containers, mtl, parsec + , stdenv, text, transformers + }: + mkDerivation { + pname = "pretty-simple"; + version = "2.1.0.1"; + sha256 = "9aa92eea9cd76e4623fda6759a9f0ccf9e8e3accf1c2dd4b483bfac7ae5cd3d1"; + isLibrary = true; + isExecutable = true; + libraryHaskellDepends = [ + ansi-terminal base containers mtl parsec text transformers + ]; + doHaddock = false; + doCheck = false; + homepage = "https://github.com/cdepillabout/pretty-simple"; + description = "pretty printer for data types with a 'Show' instance"; + license = stdenv.lib.licenses.bsd3; + }) {}; + "pretty-types" = callPackage + ({ mkDerivation, base, mtl, stdenv, tagged }: + mkDerivation { + pname = "pretty-types"; + version = "0.2.3.1"; + sha256 = "e56c49d1099aaeafe0b982ef9e60cb7194fd987c4b659a8d7bcde380d3b8784f"; + libraryHaskellDepends = [ base mtl tagged ]; + doHaddock = false; + doCheck = false; + homepage = "https://github.com/sheyll/pretty-types#readme"; + description = "A small pretty printing DSL for complex types"; + license = stdenv.lib.licenses.bsd3; + }) {}; + "prettyclass" = callPackage + ({ mkDerivation, base, pretty, stdenv }: + mkDerivation { + pname = "prettyclass"; + version = "1.0.0.0"; + sha256 = "e537446e7a346e5e0872ed8281db2bb0220c737f10757848c901da1399548986"; + libraryHaskellDepends = [ base pretty ]; + doHaddock = false; + doCheck = false; + description = "Pretty printing class similar to Show"; + license = stdenv.lib.licenses.bsd3; + }) {}; + "prettyprinter" = callPackage + ({ mkDerivation, base, stdenv, text }: + mkDerivation { + pname = "prettyprinter"; + version = "1.2.1"; + sha256 = "e7653e0ba87cc06553a50e4780dde81c5dd156196c0199511d03d972e5517fcf"; + isLibrary = true; + isExecutable = true; + libraryHaskellDepends = [ base text ]; + doHaddock = false; + doCheck = false; + homepage = "http://github.com/quchen/prettyprinter"; + description = "A modern, easy to use, well-documented, extensible pretty-printer"; + license = stdenv.lib.licenses.bsd2; + }) {}; + "prettyprinter-ansi-terminal" = callPackage + ({ mkDerivation, ansi-terminal, base, prettyprinter, stdenv, text + }: + mkDerivation { + pname = "prettyprinter-ansi-terminal"; + version = "1.1.1.2"; + sha256 = "d3e0b420df2904ae1ef23daf9bbb6de2c1fbbee056b779fc2cebe303cedf4641"; + libraryHaskellDepends = [ ansi-terminal base prettyprinter text ]; + doHaddock = false; + doCheck = false; + homepage = "http://github.com/quchen/prettyprinter"; + description = "ANSI terminal backend for the »prettyprinter« package"; + license = stdenv.lib.licenses.bsd2; + }) {}; + "prettyprinter-compat-annotated-wl-pprint" = callPackage + ({ mkDerivation, base, prettyprinter, stdenv, text }: + mkDerivation { + pname = "prettyprinter-compat-annotated-wl-pprint"; + version = "1"; + sha256 = "2c259bac999d75b071a077f218a433c070783e9f40b67796e31a776fefbaf57e"; + revision = "3"; + editedCabalFile = "0vzi7id60pfj35xp61akzvfx9x6py45r5b8343i48ljpir91rvgw"; + libraryHaskellDepends = [ base prettyprinter text ]; + doHaddock = false; + doCheck = false; + homepage = "http://github.com/quchen/prettyprinter"; + description = "Prettyprinter compatibility module for previous users of the annotated-wl-pprint package"; + license = stdenv.lib.licenses.bsd2; + }) {}; + "prettyprinter-compat-ansi-wl-pprint" = callPackage + ({ mkDerivation, base, prettyprinter, prettyprinter-ansi-terminal + , stdenv, text + }: + mkDerivation { + pname = "prettyprinter-compat-ansi-wl-pprint"; + version = "1.0.1"; + sha256 = "012d6bb711da25cc38260f4d00d26c24e52547a0ca53b0f6459fd06e5b93f73f"; + revision = "1"; + editedCabalFile = "0rzvap56ygygzs95091ipmcdc7n76sczc2dk88g4nr7zskb2nf1k"; + libraryHaskellDepends = [ + base prettyprinter prettyprinter-ansi-terminal text + ]; + doHaddock = false; + doCheck = false; + homepage = "http://github.com/quchen/prettyprinter"; + description = "Drop-in compatibility package to migrate from »ansi-wl-pprint« to »prettyprinter«"; + license = stdenv.lib.licenses.bsd2; + }) {}; + "prettyprinter-compat-wl-pprint" = callPackage + ({ mkDerivation, base, prettyprinter, stdenv, text }: + mkDerivation { + pname = "prettyprinter-compat-wl-pprint"; + version = "1.0.0.1"; + sha256 = "75221f5064e69eead5807a62894e8b5aa768f979c7f8fb75d0e1b2a15345529e"; + revision = "3"; + editedCabalFile = "0cb1i1hmr6wl8lacy3w822h273lapqhp537snxgbmhf9xvfckbpr"; + libraryHaskellDepends = [ base prettyprinter text ]; + doHaddock = false; + doCheck = false; + homepage = "http://github.com/quchen/prettyprinter"; + description = "Prettyprinter compatibility module for previous users of the wl-pprint package"; + license = stdenv.lib.licenses.bsd2; + }) {}; + "prettyprinter-convert-ansi-wl-pprint" = callPackage + ({ mkDerivation, ansi-terminal, ansi-wl-pprint, base, prettyprinter + , prettyprinter-ansi-terminal, stdenv, text + }: + mkDerivation { + pname = "prettyprinter-convert-ansi-wl-pprint"; + version = "1.1"; + sha256 = "b8982d38776249d3d29a4ede426a27a02f7cbb6843722b5ec8ede18d032fa60c"; + revision = "1"; + editedCabalFile = "1c4zcscmvq0vbdgnp7n0avv8si5jshl4kw2qd1lqmhr28kj8x45f"; + libraryHaskellDepends = [ + ansi-terminal ansi-wl-pprint base prettyprinter + prettyprinter-ansi-terminal text + ]; + doHaddock = false; + doCheck = false; + homepage = "http://github.com/quchen/prettyprinter"; + description = "Converter from »ansi-wl-pprint« documents to »prettyprinter«-based ones"; + license = stdenv.lib.licenses.bsd2; + }) {}; + "prim-uniq" = callPackage + ({ mkDerivation, base, dependent-sum, primitive, stdenv }: + mkDerivation { + pname = "prim-uniq"; + version = "0.1.0.1"; + sha256 = "fb059785133fe5ecaa57c6c840192f252c4c5a1a598160d5704ac2a83e895aff"; + libraryHaskellDepends = [ base dependent-sum primitive ]; + doHaddock = false; + doCheck = false; + homepage = "https://github.com/mokus0/prim-uniq"; + description = "Opaque unique identifiers in primitive state monads"; + license = stdenv.lib.licenses.publicDomain; + }) {}; + "primes" = callPackage + ({ mkDerivation, base, stdenv }: + mkDerivation { + pname = "primes"; + version = "0.2.1.0"; + sha256 = "74d66558fb638ea4d31eae2fe1a294cb5a9d64491314305d74a11d93f277c65b"; + libraryHaskellDepends = [ base ]; + doHaddock = false; + doCheck = false; + homepage = "http://github.com/sebfisch/primes"; + description = "Efficient, purely functional generation of prime numbers"; + license = stdenv.lib.licenses.bsd3; + }) {}; + "primitive" = callPackage + ({ mkDerivation, base, ghc-prim, stdenv, transformers }: + mkDerivation { + pname = "primitive"; + version = "0.6.3.0"; + sha256 = "cddeff804e0f577f1be0179d5d145dfc170f8bfb66f663b9fba67104a45d9555"; + libraryHaskellDepends = [ base ghc-prim transformers ]; + doHaddock = false; + doCheck = false; + homepage = "https://github.com/haskell/primitive"; + description = "Primitive memory-related operations"; + license = stdenv.lib.licenses.bsd3; + }) {}; + "probability" = callPackage + ({ mkDerivation, base, containers, random, stdenv, transformers + , utility-ht + }: + mkDerivation { + pname = "probability"; + version = "0.2.5.1"; + sha256 = "d3e67c8b32dda838c455ddd532a668bc464cfe1d49dc74f4502175614af7ed2d"; + enableSeparateDataOutput = true; + libraryHaskellDepends = [ + base containers random transformers utility-ht + ]; + doHaddock = false; + doCheck = false; + homepage = "http://www.haskell.org/haskellwiki/Probabilistic_Functional_Programming"; + description = "Probabilistic Functional Programming"; + license = stdenv.lib.licenses.bsd3; + }) {}; + "process-extras" = callPackage + ({ mkDerivation, base, bytestring, data-default, deepseq + , generic-deriving, ListLike, mtl, process, stdenv, text + }: + mkDerivation { + pname = "process-extras"; + version = "0.7.4"; + sha256 = "293e75f849254ce0ce0d7fa659681917e07a557c602505a2f9e20777467e984e"; + libraryHaskellDepends = [ + base bytestring data-default deepseq generic-deriving ListLike mtl + process text + ]; + doHaddock = false; + doCheck = false; + homepage = "https://github.com/seereason/process-extras"; + description = "Process extras"; + license = stdenv.lib.licenses.mit; + }) {}; + "product-isomorphic" = callPackage + ({ mkDerivation, base, stdenv, template-haskell, th-data-compat }: + mkDerivation { + pname = "product-isomorphic"; + version = "0.0.3.2"; + sha256 = "b4cba495f0779c619f466cdcc7914a4c2a209543dabebb6a32f003dc567317fb"; + libraryHaskellDepends = [ base template-haskell th-data-compat ]; + doHaddock = false; + doCheck = false; + homepage = "http://github.com/khibino/haskell-product-isomorphic"; + description = "Weaken applicative functor on products"; + license = stdenv.lib.licenses.bsd3; + }) {}; + "product-profunctors" = callPackage + ({ mkDerivation, base, bifunctors, contravariant, profunctors + , stdenv, tagged, template-haskell + }: + mkDerivation { + pname = "product-profunctors"; + version = "0.10.0.0"; + sha256 = "ad8d7687c2eee4bcd2f3925a74f53d743c9f678b80be2a523221039004d51a68"; + revision = "1"; + editedCabalFile = "17zi38fzg7yf9i5da2hlch6jw2qhmjcvs9wwkhyvra520605mlya"; + libraryHaskellDepends = [ + base bifunctors contravariant profunctors tagged template-haskell + ]; + doHaddock = false; + doCheck = false; + homepage = "https://github.com/tomjaguarpaw/product-profunctors"; + description = "product-profunctors"; + license = stdenv.lib.licenses.bsd3; + }) {}; + "profiterole" = callPackage + ({ mkDerivation, base, containers, directory, extra, filepath + , ghc-prof, hashable, scientific, stdenv, text + }: + mkDerivation { + pname = "profiterole"; + version = "0.1"; + sha256 = "c688d8c4f04e7a674832b39add365cee8eb99ae83643a849529e2ec56a46d2f1"; + isLibrary = false; + isExecutable = true; + executableHaskellDepends = [ + base containers directory extra filepath ghc-prof hashable + scientific text + ]; + doHaddock = false; + doCheck = false; + homepage = "https://github.com/ndmitchell/profiterole#readme"; + description = "Restructure GHC profile reports"; + license = stdenv.lib.licenses.bsd3; + }) {}; + "profunctors" = callPackage + ({ mkDerivation, base, base-orphans, bifunctors, comonad + , contravariant, distributive, semigroups, stdenv, tagged + , transformers + }: + mkDerivation { + pname = "profunctors"; + version = "5.2.2"; + sha256 = "e981e6a33ac99d38a947a749179bbea3c294ecf6bfde41660fe6d8d5a2e43768"; + revision = "2"; + editedCabalFile = "1ywlg9z8nlhd2avgb8c6gbkv8zyk7hvc25926bafyg0m0k8y1amq"; + libraryHaskellDepends = [ + base base-orphans bifunctors comonad contravariant distributive + semigroups tagged transformers + ]; + doHaddock = false; + doCheck = false; + homepage = "http://github.com/ekmett/profunctors/"; + description = "Profunctors"; + license = stdenv.lib.licenses.bsd3; + }) {}; + "project-template" = callPackage + ({ mkDerivation, base, base64-bytestring, bytestring, conduit + , conduit-extra, containers, directory, filepath, mtl, resourcet + , stdenv, text, transformers + }: + mkDerivation { + pname = "project-template"; + version = "0.2.0.1"; + sha256 = "eb52496fa7448f5fed445525c05327b31a45282fc1d0a772c7022a9809e7c9dc"; + libraryHaskellDepends = [ + base base64-bytestring bytestring conduit conduit-extra containers + directory filepath mtl resourcet text transformers + ]; + doHaddock = false; + doCheck = false; + homepage = "https://github.com/fpco/haskell-ide"; + description = "Specify Haskell project templates and generate files"; + license = stdenv.lib.licenses.bsd3; + }) {}; + "projectroot" = callPackage + ({ mkDerivation, base, directory, stdenv }: + mkDerivation { + pname = "projectroot"; + version = "0.2.0.1"; + sha256 = "53753086543ed199cf6f0d76852660f5d74c0874bfdee21c0f4e0d845b7e1ab8"; + libraryHaskellDepends = [ base directory ]; + doHaddock = false; + doCheck = false; + homepage = "https://github.com/yamadapc/haskell-projectroot"; + description = "Bindings to the projectroot C logic"; + license = stdenv.lib.licenses.mit; + }) {}; + "prometheus-client" = callPackage + ({ mkDerivation, atomic-primops, base, bytestring, clock + , containers, mtl, stdenv, stm, transformers, utf8-string + }: + mkDerivation { + pname = "prometheus-client"; + version = "0.3.0"; + sha256 = "5f28c40b864d4773d019725e9f0dd7c06610c676250c8f1126e511d72348d05b"; + libraryHaskellDepends = [ + atomic-primops base bytestring clock containers mtl stm + transformers utf8-string + ]; + doHaddock = false; + doCheck = false; + homepage = "https://github.com/fimad/prometheus-haskell"; + description = "Haskell client library for http://prometheus.io."; + license = stdenv.lib.licenses.asl20; + }) {}; + "promises" = callPackage + ({ mkDerivation, base, primitive, stdenv }: + mkDerivation { + pname = "promises"; + version = "0.3"; + sha256 = "bf7c901915c122e7ab270f4c90cf02e83a703bf78f246948dc2452dcd294f260"; + libraryHaskellDepends = [ base primitive ]; + doHaddock = false; + doCheck = false; + homepage = "http://github.com/ekmett/promises/"; + description = "Lazy demand-driven promises"; + license = stdenv.lib.licenses.bsd3; + }) {}; + "prompt" = callPackage + ({ mkDerivation, base, base-compat, mtl, stdenv, transformers + , transformers-compat + }: + mkDerivation { + pname = "prompt"; + version = "0.1.1.2"; + sha256 = "67b5711ef4c650747645b6d9de16a8bb04e04d1c2e4d39e3a8d4099873a151f2"; + libraryHaskellDepends = [ + base base-compat mtl transformers transformers-compat + ]; + doHaddock = false; + doCheck = false; + homepage = "https://github.com/mstksg/prompt"; + description = "Monad (and transformer) for deferred-effect pure prompt-response queries"; + license = stdenv.lib.licenses.mit; + }) {}; + "proto-lens" = callPackage + ({ mkDerivation, attoparsec, base, bytestring, containers + , data-default-class, deepseq, lens-family, lens-labels, parsec + , pretty, stdenv, text, transformers, void + }: + mkDerivation { + pname = "proto-lens"; + version = "0.3.1.0"; + sha256 = "87bf1aa7d7754ca06ccbfb0daf4a77de53345c1d098e0fa17018ee00c2b994ab"; + enableSeparateDataOutput = true; + libraryHaskellDepends = [ + attoparsec base bytestring containers data-default-class deepseq + lens-family lens-labels parsec pretty text transformers void + ]; + doHaddock = false; + doCheck = false; + homepage = "https://github.com/google/proto-lens#readme"; + description = "A lens-based implementation of protocol buffers in Haskell"; + license = stdenv.lib.licenses.bsd3; + }) {}; + "proto-lens-arbitrary" = callPackage + ({ mkDerivation, base, bytestring, containers, lens-family + , proto-lens, QuickCheck, stdenv, text + }: + mkDerivation { + pname = "proto-lens-arbitrary"; + version = "0.1.2.1"; + sha256 = "824e013d1f7c4d52434ea318aef63544491cf0e89f63dbcda4c4c07881b11c23"; + libraryHaskellDepends = [ + base bytestring containers lens-family proto-lens QuickCheck text + ]; + doHaddock = false; + doCheck = false; + homepage = "https://github.com/google/proto-lens#readme"; + description = "Arbitrary instances for proto-lens"; + license = stdenv.lib.licenses.bsd3; + }) {}; + "proto-lens-combinators" = callPackage + ({ mkDerivation, base, Cabal, data-default-class, lens-family + , proto-lens-protoc, stdenv, transformers + }: + mkDerivation { + pname = "proto-lens-combinators"; + version = "0.1.0.10"; + sha256 = "395a8626e75ed17dedcfce2de5b6b769d1fa521b56005e4f30e66a3e5ee6667b"; + setupHaskellDepends = [ base Cabal proto-lens-protoc ]; + libraryHaskellDepends = [ + base data-default-class lens-family proto-lens-protoc transformers + ]; + doHaddock = false; + doCheck = false; + homepage = "https://github.com/google/proto-lens#readme"; + description = "Utilities functions to proto-lens"; + license = stdenv.lib.licenses.bsd3; + }) {}; + "proto-lens-optparse" = callPackage + ({ mkDerivation, base, optparse-applicative, proto-lens, stdenv + , text + }: + mkDerivation { + pname = "proto-lens-optparse"; + version = "0.1.1.1"; + sha256 = "1c8706f789809bda1ad9db8b18b2a9c309e6040ded6ce1d85a2b0da7cc9e26fe"; + libraryHaskellDepends = [ + base optparse-applicative proto-lens text + ]; + doHaddock = false; + doCheck = false; + homepage = "https://github.com/google/proto-lens#readme"; + description = "Adapting proto-lens to optparse-applicative ReadMs"; + license = stdenv.lib.licenses.bsd3; + }) {}; + "proto-lens-protobuf-types" = callPackage + ({ mkDerivation, base, Cabal, lens-family, proto-lens + , proto-lens-protoc, protobuf, stdenv, text + }: + mkDerivation { + pname = "proto-lens-protobuf-types"; + version = "0.3.0.1"; + sha256 = "8a19053eabdff8e84b65181dd1beb4fafe5a84bae5af1bb3b32d043d0ef56018"; + setupHaskellDepends = [ base Cabal proto-lens-protoc ]; + libraryHaskellDepends = [ + base lens-family proto-lens proto-lens-protoc text + ]; + libraryToolDepends = [ protobuf ]; + doHaddock = false; + doCheck = false; + homepage = "https://github.com/google/proto-lens#readme"; + description = "Basic protocol buffer message types"; + license = stdenv.lib.licenses.bsd3; + }) {}; + "proto-lens-protoc" = callPackage + ({ mkDerivation, base, bytestring, Cabal, containers + , data-default-class, deepseq, directory, filepath + , haskell-src-exts, lens-family, lens-labels, pretty, process + , proto-lens, protobuf, stdenv, text + }: + mkDerivation { + pname = "proto-lens-protoc"; + version = "0.3.1.0"; + sha256 = "7dbfa924db9014caf7bf0bb2dd1eb9f0960b9ef2fa6c80c4610b768aade73042"; + isLibrary = true; + isExecutable = true; + libraryHaskellDepends = [ + base bytestring Cabal containers data-default-class deepseq + directory filepath haskell-src-exts lens-family lens-labels pretty + process proto-lens text + ]; + libraryToolDepends = [ protobuf ]; + executableHaskellDepends = [ + base bytestring containers data-default-class deepseq filepath + haskell-src-exts lens-family proto-lens text + ]; + doHaddock = false; + doCheck = false; + homepage = "https://github.com/google/proto-lens#readme"; + description = "Protocol buffer compiler for the proto-lens library"; + license = stdenv.lib.licenses.bsd3; + }) {}; + "protobuf" = callPackage + ({ mkDerivation, base, base-orphans, bytestring, cereal + , data-binary-ieee754, deepseq, mtl, stdenv, text + , unordered-containers + }: + mkDerivation { + pname = "protobuf"; + version = "0.2.1.2"; + sha256 = "b3c871918a665f0543fde247ab8af61c4fc451103140d34bf652c0d5fc4d17de"; + libraryHaskellDepends = [ + base base-orphans bytestring cereal data-binary-ieee754 deepseq mtl + text unordered-containers + ]; + doHaddock = false; + doCheck = false; + homepage = "https://github.com/alphaHeavy/protobuf"; + description = "Google Protocol Buffers via GHC.Generics"; + license = stdenv.lib.licenses.bsd3; + }) {}; + "protobuf-simple" = callPackage + ({ mkDerivation, base, binary, bytestring, containers + , data-binary-ieee754, directory, filepath, mtl, parsec, split + , stdenv, text + }: + mkDerivation { + pname = "protobuf-simple"; + version = "0.1.0.5"; + sha256 = "6b46b427f14eacb814dfce0a678e7cb7742d1583d14f9540ca00fb0bc0e916f1"; + isLibrary = true; + isExecutable = true; + libraryHaskellDepends = [ + base binary bytestring containers data-binary-ieee754 mtl text + ]; + executableHaskellDepends = [ + base containers directory filepath mtl parsec split text + ]; + doHaddock = false; + doCheck = false; + homepage = "https://github.com/sru-systems/protobuf-simple"; + description = "Simple Protocol Buffers library (proto2)"; + license = stdenv.lib.licenses.mit; + }) {}; + "protocol-buffers" = callPackage + ({ mkDerivation, array, base, binary, bytestring, containers + , directory, filepath, mtl, parsec, stdenv, syb, utf8-string + }: + mkDerivation { + pname = "protocol-buffers"; + version = "2.4.11"; + sha256 = "47cb492a1d2b3ee7d1c8dc7d7b8c1656c754968854bd0caf29cf70c2f38d81e8"; + libraryHaskellDepends = [ + array base binary bytestring containers directory filepath mtl + parsec syb utf8-string + ]; + doHaddock = false; + doCheck = false; + homepage = "https://github.com/k-bx/protocol-buffers"; + description = "Parse Google Protocol Buffer specifications"; + license = stdenv.lib.licenses.bsd3; + }) {}; + "protocol-buffers-descriptor" = callPackage + ({ mkDerivation, base, bytestring, containers, protocol-buffers + , stdenv + }: + mkDerivation { + pname = "protocol-buffers-descriptor"; + version = "2.4.11"; + sha256 = "a090bdc834cf4351ebabf15e2eed31877104f6e93900f8da8f350810c1d7681a"; + enableSeparateDataOutput = true; + libraryHaskellDepends = [ + base bytestring containers protocol-buffers + ]; + doHaddock = false; + doCheck = false; + homepage = "https://github.com/k-bx/protocol-buffers"; + description = "Text.DescriptorProto.Options and code generated from the Google Protocol Buffer specification"; + license = stdenv.lib.licenses.bsd3; + }) {}; + "protocol-radius" = callPackage + ({ mkDerivation, base, bytestring, cereal, containers, cryptonite + , dlist, memory, stdenv, template-haskell, text, transformers + }: + mkDerivation { + pname = "protocol-radius"; + version = "0.0.1.0"; + sha256 = "ae0c5ec142edb37df6bb51421b29e0a6c25013057e45e22159afb66cda3cf6f9"; + libraryHaskellDepends = [ + base bytestring cereal containers cryptonite dlist memory + template-haskell text transformers + ]; + doHaddock = false; + doCheck = false; + description = "parser and printer for radius protocol packet"; + license = stdenv.lib.licenses.bsd3; + }) {}; + "protocol-radius-test" = callPackage + ({ mkDerivation, base, bytestring, cereal, containers + , protocol-radius, QuickCheck, quickcheck-simple, stdenv + , transformers + }: + mkDerivation { + pname = "protocol-radius-test"; + version = "0.0.1.0"; + sha256 = "b5cc9a15e7910ecb449d3bbb142b809fa34bee2079e772ca63d4bb975a41ada0"; + libraryHaskellDepends = [ + base bytestring cereal containers protocol-radius QuickCheck + quickcheck-simple transformers + ]; + doHaddock = false; + doCheck = false; + description = "testsuit of protocol-radius haskell package"; + license = stdenv.lib.licenses.bsd3; + }) {}; + "protolude" = callPackage + ({ mkDerivation, array, async, base, bytestring, containers + , deepseq, ghc-prim, hashable, mtl, mtl-compat, stdenv, stm, text + , transformers, transformers-compat + }: + mkDerivation { + pname = "protolude"; + version = "0.2.2"; + sha256 = "685d0cf34b63482be84b785561009b8229327233ae311550d20d66b47b0f457c"; + libraryHaskellDepends = [ + array async base bytestring containers deepseq ghc-prim hashable + mtl mtl-compat stm text transformers transformers-compat + ]; + doHaddock = false; + doCheck = false; + homepage = "https://github.com/sdiehl/protolude"; + description = "A small prelude"; + license = stdenv.lib.licenses.mit; + }) {}; + "proxied" = callPackage + ({ mkDerivation, base, stdenv }: + mkDerivation { + pname = "proxied"; + version = "0.3"; + sha256 = "534d4d425f2834b39689e2af301bd5ff81d1619e65664a5efd797a0c88dbeb26"; + libraryHaskellDepends = [ base ]; + doHaddock = false; + doCheck = false; + homepage = "https://github.com/RyanGlScott/proxied"; + description = "Make functions consume Proxy instead of undefined"; + license = stdenv.lib.licenses.bsd3; + }) {}; + "psql-helpers" = callPackage + ({ mkDerivation, base, postgresql-simple, stdenv }: + mkDerivation { + pname = "psql-helpers"; + version = "0.1.0.0"; + sha256 = "f13ca642072477d3ab0246c514e3fc78e0c5cb419345240fbad994ed2a3219f4"; + libraryHaskellDepends = [ base postgresql-simple ]; + doHaddock = false; + doCheck = false; + homepage = "http://github.com/agrafix/psql-helpers#readme"; + description = "A small collection of helper functions to generate postgresql queries"; + license = stdenv.lib.licenses.mit; + }) {}; + "psqueues" = callPackage + ({ mkDerivation, base, deepseq, ghc-prim, hashable, stdenv }: + mkDerivation { + pname = "psqueues"; + version = "0.2.7.0"; + sha256 = "4cf3628884015b091471e4425f5414207fd547cf71d9546e9b7318d857624fea"; + libraryHaskellDepends = [ base deepseq ghc-prim hashable ]; + doHaddock = false; + doCheck = false; + description = "Pure priority search queues"; + license = stdenv.lib.licenses.bsd3; + }) {}; + "publicsuffix" = callPackage + ({ mkDerivation, base, filepath, stdenv, template-haskell }: + mkDerivation { + pname = "publicsuffix"; + version = "0.20180513"; + sha256 = "b51f193089fbdadeaecf062047b377e597ef6d72caff13e62d8a88f4c3870973"; + libraryHaskellDepends = [ base filepath template-haskell ]; + doHaddock = false; + doCheck = false; + homepage = "https://github.com/wereHamster/publicsuffix-haskell/"; + description = "The publicsuffix list exposed as proper Haskell types"; + license = stdenv.lib.licenses.mit; + }) {}; + "pure-zlib" = callPackage + ({ mkDerivation, array, base, base-compat, bytestring + , bytestring-builder, containers, fingertree, stdenv + }: + mkDerivation { + pname = "pure-zlib"; + version = "0.6.4"; + sha256 = "eb679aecb3fa310d28a31549cf83c29fba6f6e3c78bcdea82c9e22db36dc3017"; + isLibrary = true; + isExecutable = true; + libraryHaskellDepends = [ + array base base-compat bytestring bytestring-builder containers + fingertree + ]; + executableHaskellDepends = [ base base-compat bytestring ]; + doHaddock = false; + doCheck = false; + homepage = "http://github.com/GaloisInc/pure-zlib"; + description = "A Haskell-only implementation of zlib / DEFLATE"; + license = stdenv.lib.licenses.bsd3; + }) {}; + "pureMD5" = callPackage + ({ mkDerivation, base, binary, bytestring, cereal, crypto-api + , stdenv, tagged + }: + mkDerivation { + pname = "pureMD5"; + version = "2.1.3"; + sha256 = "bef3358a5e3a45b649860a5792f052e2f927c0492a7056cf64425116c8a7b17d"; + libraryHaskellDepends = [ + base binary bytestring cereal crypto-api tagged + ]; + doHaddock = false; + doCheck = false; + description = "A Haskell-only implementation of the MD5 digest (hash) algorithm"; + license = stdenv.lib.licenses.bsd3; + }) {}; + "purescript-bridge" = callPackage + ({ mkDerivation, base, containers, directory, filepath + , generic-deriving, lens, mtl, stdenv, text, transformers + }: + mkDerivation { + pname = "purescript-bridge"; + version = "0.13.0.0"; + sha256 = "2b1a6bbc0e1c155b20bb02356821185c7661d15cc8042ddfe12725eef2065149"; + libraryHaskellDepends = [ + base containers directory filepath generic-deriving lens mtl text + transformers + ]; + doHaddock = false; + doCheck = false; + description = "Generate PureScript data types from Haskell data types"; + license = stdenv.lib.licenses.bsd3; + }) {}; + "pushbullet-types" = callPackage + ({ mkDerivation, aeson, base, http-api-data, microlens + , microlens-th, scientific, stdenv, text, time + , unordered-containers + }: + mkDerivation { + pname = "pushbullet-types"; + version = "0.4.1.0"; + sha256 = "6461a2cf5ff0b74f7caaf295ca7601922e9527f5bc9f37e3fbc6325026b5c85b"; + libraryHaskellDepends = [ + aeson base http-api-data microlens microlens-th scientific text + time unordered-containers + ]; + doHaddock = false; + doCheck = false; + description = "Datatypes used by the Pushbullet APIs"; + license = stdenv.lib.licenses.mit; + }) {}; + "qm-interpolated-string" = callPackage + ({ mkDerivation, base, bytestring, haskell-src-meta, stdenv + , template-haskell, text + }: + mkDerivation { + pname = "qm-interpolated-string"; + version = "0.3.0.0"; + sha256 = "e86b337d1531e75d448f7ab9101f8703b19fa5bc3a94c7ea5c26accd31d12baf"; + libraryHaskellDepends = [ + base bytestring haskell-src-meta template-haskell text + ]; + doHaddock = false; + doCheck = false; + homepage = "https://github.com/unclechu/haskell-qm-interpolated-string"; + description = "Implementation of interpolated multiline strings"; + license = stdenv.lib.licenses.publicDomain; + }) {}; + "qnap-decrypt" = callPackage + ({ mkDerivation, base, binary, bytestring, cipher-aes128, conduit + , conduit-extra, crypto-api, directory, filepath + , optparse-applicative, stdenv, streaming-commons, tagged + , utf8-string + }: + mkDerivation { + pname = "qnap-decrypt"; + version = "0.3.2"; + sha256 = "da930b2e821d3a1de08e6f85262793d4cbdd0d63dca017c7b2e3ad63ed6501e3"; + isLibrary = true; + isExecutable = true; + enableSeparateDataOutput = true; + libraryHaskellDepends = [ + base binary bytestring cipher-aes128 conduit conduit-extra + crypto-api directory streaming-commons tagged utf8-string + ]; + executableHaskellDepends = [ + base binary bytestring cipher-aes128 conduit conduit-extra + crypto-api directory filepath optparse-applicative + streaming-commons tagged utf8-string + ]; + doHaddock = false; + doCheck = false; + homepage = "https://github.com/alexkazik/qnap-decrypt#readme"; + description = "Decrypt files encrypted by QNAP's Hybrid Backup Sync"; + license = stdenv.lib.licenses.bsd3; + }) {}; + "quickbench" = callPackage + ({ mkDerivation, base, containers, directory, docopt, pretty-show + , process, safe, split, stdenv, tabular, time + }: + mkDerivation { + pname = "quickbench"; + version = "1.0"; + sha256 = "8bfe252e50a683346e753db312e9542f8d43256947ab215fcfd24af03787b926"; + isLibrary = true; + isExecutable = true; + libraryHaskellDepends = [ + base containers directory docopt pretty-show process safe split + tabular time + ]; + executableHaskellDepends = [ base process ]; + doHaddock = false; + doCheck = false; + homepage = "https://github.com/simonmichael/quickbench#readme"; + description = "quick & easy benchmarking of command-line programs"; + license = "GPL"; + }) {}; + "quickcheck-arbitrary-adt" = callPackage + ({ mkDerivation, base, QuickCheck, stdenv }: + mkDerivation { + pname = "quickcheck-arbitrary-adt"; + version = "0.3.1.0"; + sha256 = "5c4a2e20366def76ba851211ac554e9a0f60535efcd0940606e4d410c27a45b9"; + libraryHaskellDepends = [ base QuickCheck ]; + doHaddock = false; + doCheck = false; + homepage = "https://github.com/plow-technologies/quickcheck-arbitrary-adt#readme"; + description = "Generic typeclasses for generating arbitrary ADTs"; + license = stdenv.lib.licenses.bsd3; + }) {}; + "quickcheck-assertions" = callPackage + ({ mkDerivation, base, ieee754, pretty-show, QuickCheck, stdenv }: + mkDerivation { + pname = "quickcheck-assertions"; + version = "0.3.0"; + sha256 = "9b0328a788dcac0824a7d7496ab403eef04170551255c9e58fb6e2e319a9cacf"; + libraryHaskellDepends = [ base ieee754 pretty-show QuickCheck ]; + doHaddock = false; + doCheck = false; + homepage = "https://github.com/s9gf4ult/quickcheck-assertions"; + description = "HUnit like assertions for QuickCheck"; + license = stdenv.lib.licenses.lgpl3; + }) {}; + "quickcheck-instances" = callPackage + ({ mkDerivation, array, base, base-compat, bytestring + , case-insensitive, containers, hashable, old-time, QuickCheck + , scientific, stdenv, tagged, text, time, transformers + , transformers-compat, unordered-containers, uuid-types, vector + }: + mkDerivation { + pname = "quickcheck-instances"; + version = "0.3.18"; + sha256 = "a570437eb4e5a5244c38ad161bab00ba4aeb8cb21de7c8dadf983557febf01ae"; + revision = "2"; + editedCabalFile = "02mhzd7dkhmbd8ljm114j7ixp1lcllblz3zfkz0i7n976rac86w7"; + libraryHaskellDepends = [ + array base base-compat bytestring case-insensitive containers + hashable old-time QuickCheck scientific tagged text time + transformers transformers-compat unordered-containers uuid-types + vector + ]; + doHaddock = false; + doCheck = false; + homepage = "https://github.com/phadej/qc-instances"; + description = "Common quickcheck instances"; + license = stdenv.lib.licenses.bsd3; + }) {}; + "quickcheck-io" = callPackage + ({ mkDerivation, base, HUnit, QuickCheck, stdenv }: + mkDerivation { + pname = "quickcheck-io"; + version = "0.2.0"; + sha256 = "fb779119d79fe08ff4d502fb6869a70c9a8d5fd8ae0959f605c3c937efd96422"; + libraryHaskellDepends = [ base HUnit QuickCheck ]; + doHaddock = false; + doCheck = false; + homepage = "https://github.com/hspec/quickcheck-io#readme"; + description = "Use HUnit assertions as QuickCheck properties"; + license = stdenv.lib.licenses.mit; + }) {}; + "quickcheck-simple" = callPackage + ({ mkDerivation, base, QuickCheck, stdenv }: + mkDerivation { + pname = "quickcheck-simple"; + version = "0.1.0.4"; + sha256 = "808eb5966a97bd38a3992b280428a0b289ccb46c38397ea8e34661d1e1ec4414"; + libraryHaskellDepends = [ base QuickCheck ]; + doHaddock = false; + doCheck = false; + description = "Test properties and default-mains for QuickCheck"; + license = stdenv.lib.licenses.bsd3; + }) {}; + "quickcheck-special" = callPackage + ({ mkDerivation, base, QuickCheck, special-values, stdenv }: + mkDerivation { + pname = "quickcheck-special"; + version = "0.1.0.6"; + sha256 = "9573898509bd30613bdf59338a5754251081420c59fb658727973e2e837f1cb6"; + revision = "1"; + editedCabalFile = "1whwmij115vw0qwkzlkc4z4yhj7iwwqjhf5aaxn5np0gh2gzihb3"; + libraryHaskellDepends = [ base QuickCheck special-values ]; + doHaddock = false; + doCheck = false; + homepage = "https://github.com/minad/quickcheck-special#readme"; + description = "Edge cases and special values for QuickCheck Arbitrary instances"; + license = stdenv.lib.licenses.mit; + }) {}; + "quickcheck-text" = callPackage + ({ mkDerivation, base, binary, bytestring, QuickCheck, stdenv, text + }: + mkDerivation { + pname = "quickcheck-text"; + version = "0.1.2.1"; + sha256 = "4442fdb8ae6cd469c04957d34fee46039c9dc0ddce23ce6050babe6826d0ab09"; + libraryHaskellDepends = [ base binary bytestring QuickCheck text ]; + doHaddock = false; + doCheck = false; + homepage = "https://github.com/olorin/quickcheck-text"; + description = "Alternative arbitrary instance for Text"; + license = stdenv.lib.licenses.mit; + }) {}; + "quickcheck-unicode" = callPackage + ({ mkDerivation, base, QuickCheck, stdenv }: + mkDerivation { + pname = "quickcheck-unicode"; + version = "1.0.1.0"; + sha256 = "132005ea7edff35e95139c36232a70698cd0f4f4d79dfaa4e66fbcf557d08368"; + libraryHaskellDepends = [ base QuickCheck ]; + doHaddock = false; + doCheck = false; + homepage = "https://github.com/bos/quickcheck-unicode"; + description = "Generator and shrink functions for testing Unicode-related software"; + license = stdenv.lib.licenses.bsd2; + }) {}; + "quicklz" = callPackage + ({ mkDerivation, base, bytestring, stdenv }: + mkDerivation { + pname = "quicklz"; + version = "1.5.0.11"; + sha256 = "0d0b23370a848efa86da80f835d036f468cdb1b201809351116945729b5b699f"; + libraryHaskellDepends = [ base bytestring ]; + doHaddock = false; + doCheck = false; + homepage = "http://github.com/thoughtpolice/hs-quicklz"; + description = "QuickLZ compression for ByteStrings"; + license = stdenv.lib.licenses.gpl2; + }) {}; + "rainbow" = callPackage + ({ mkDerivation, base, bytestring, lens-simple, process, stdenv + , text + }: + mkDerivation { + pname = "rainbow"; + version = "0.30.0.2"; + sha256 = "be021eb05bc3e6a00b4fc10e1af941afa0c0a69ab83e5204e8455cfd5c0f5ec7"; + libraryHaskellDepends = [ + base bytestring lens-simple process text + ]; + doHaddock = false; + doCheck = false; + homepage = "https://www.github.com/massysett/rainbow"; + description = "Print text to terminal with colors and effects"; + license = stdenv.lib.licenses.bsd3; + }) {}; + "rainbox" = callPackage + ({ mkDerivation, base, bytestring, containers, lens-simple, rainbow + , stdenv, text + }: + mkDerivation { + pname = "rainbox"; + version = "0.20.0.0"; + sha256 = "937f61d2fbc7b41f065cec9bb9d6550b54346e52b788d30f73ef78cf8545b61f"; + libraryHaskellDepends = [ + base bytestring containers lens-simple rainbow text + ]; + doHaddock = false; + doCheck = false; + homepage = "https://www.github.com/massysett/rainbox"; + description = "Two-dimensional box pretty printing, with colors"; + license = stdenv.lib.licenses.bsd3; + }) {}; + "rakuten" = callPackage + ({ mkDerivation, aeson, base, bytestring, connection, constraints + , data-default-class, extensible, http-api-data, http-client + , http-client-tls, http-types, lens, req, stdenv, text + }: + mkDerivation { + pname = "rakuten"; + version = "0.1.1.4"; + sha256 = "094cc1f5a271c304d736ba98ceca46df05347012d41b96976a0c2e02ed751b04"; + libraryHaskellDepends = [ + aeson base bytestring connection constraints data-default-class + extensible http-api-data http-client http-client-tls http-types + lens req text + ]; + doHaddock = false; + doCheck = false; + homepage = "https://github.com/matsubara0507/rakuten#readme"; + description = "The Rakuten API in Haskell"; + license = stdenv.lib.licenses.mit; + }) {}; + "ramus" = callPackage + ({ mkDerivation, base, stdenv }: + mkDerivation { + pname = "ramus"; + version = "0.1.2"; + sha256 = "dcddddc416e79c401604565b7297a945f814edeed056fb3b897eda5f4f0b794e"; + libraryHaskellDepends = [ base ]; + doHaddock = false; + doCheck = false; + homepage = "https://github.com/NickSeagull/ramus#readme"; + description = "Elm signal system for Haskell"; + license = stdenv.lib.licenses.mit; + }) {}; + "random" = callPackage + ({ mkDerivation, base, stdenv, time }: + mkDerivation { + pname = "random"; + version = "1.1"; + sha256 = "b718a41057e25a3a71df693ab0fe2263d492e759679b3c2fea6ea33b171d3a5a"; + revision = "1"; + editedCabalFile = "1pv5d7bm2rgap7llp5vjsplrg048gvf0226y0v19gpvdsx7n4rvv"; + libraryHaskellDepends = [ base time ]; + doHaddock = false; + doCheck = false; + description = "random number library"; + license = stdenv.lib.licenses.bsd3; + }) {}; + "random-bytestring" = callPackage + ({ mkDerivation, base, bytestring, mwc-random, pcg-random, stdenv + }: + mkDerivation { + pname = "random-bytestring"; + version = "0.1.3.1"; + sha256 = "33a826fd04068902acb62b04cb88c5a0c47e483b88053be9f6de1d64911f0eb4"; + revision = "1"; + editedCabalFile = "0gk5hcx1j06rklfd2cv63kh5dzjk8hr184riam784c7s9zg3s9a4"; + libraryHaskellDepends = [ base bytestring mwc-random pcg-random ]; + doHaddock = false; + doCheck = false; + homepage = "https://www.github.com/larskuhtz/random-bytestring"; + description = "Efficient generation of random bytestrings"; + license = stdenv.lib.licenses.mit; + }) {}; + "random-fu" = callPackage + ({ mkDerivation, base, erf, log-domain, math-functions, monad-loops + , mtl, random-shuffle, random-source, rvar, stdenv, syb + , template-haskell, transformers, vector + }: + mkDerivation { + pname = "random-fu"; + version = "0.2.7.0"; + sha256 = "b6b3a4b3ede34991d26e0447f90b14fa66af61f376fa0aed2e0899fdc879b0c4"; + libraryHaskellDepends = [ + base erf log-domain math-functions monad-loops mtl random-shuffle + random-source rvar syb template-haskell transformers vector + ]; + doHaddock = false; + doCheck = false; + homepage = "https://github.com/mokus0/random-fu"; + description = "Random number generation"; + license = stdenv.lib.licenses.publicDomain; + }) {}; + "random-shuffle" = callPackage + ({ mkDerivation, base, MonadRandom, random, stdenv }: + mkDerivation { + pname = "random-shuffle"; + version = "0.0.4"; + sha256 = "52704411f040fd0bf2361dad162e35dc13caa6535b2e4908d3513c00a95d0615"; + libraryHaskellDepends = [ base MonadRandom random ]; + doHaddock = false; + doCheck = false; + description = "Random shuffle implementation"; + license = stdenv.lib.licenses.bsd3; + }) {}; + "random-source" = callPackage + ({ mkDerivation, base, flexible-defaults, mersenne-random-pure64 + , mtl, mwc-random, random, stateref, stdenv, syb, template-haskell + , th-extras + }: + mkDerivation { + pname = "random-source"; + version = "0.3.0.6"; + sha256 = "f3dfec3aef0614ff856abbba018f3bc3446295157895ea09a015737d67205b73"; + libraryHaskellDepends = [ + base flexible-defaults mersenne-random-pure64 mtl mwc-random random + stateref syb template-haskell th-extras + ]; + doHaddock = false; + doCheck = false; + homepage = "https://github.com/mokus0/random-fu"; + description = "Generic basis for random number generators"; + license = stdenv.lib.licenses.publicDomain; + }) {}; + "random-tree" = callPackage + ({ mkDerivation, base, containers, lens, MonadRandom, mtl, random + , random-shuffle, stdenv, transformers, tree-fun + }: + mkDerivation { + pname = "random-tree"; + version = "0.6.0.5"; + sha256 = "2b604e7ce184e2c877fac63dbac1df3060cdc023427b8eb5844106a826591cc2"; + libraryHaskellDepends = [ + base containers lens MonadRandom mtl random random-shuffle + transformers tree-fun + ]; + doHaddock = false; + doCheck = false; + description = "Create random trees"; + license = stdenv.lib.licenses.gpl3; + }) {}; + "range-set-list" = callPackage + ({ mkDerivation, base, containers, deepseq, hashable, stdenv }: + mkDerivation { + pname = "range-set-list"; + version = "0.1.3"; + sha256 = "e51b393d2c09e3c2b0c21523389a48ce8e6090413abdfff1c623815c76cc96df"; + revision = "1"; + editedCabalFile = "00ddj7if8lcrqf5c882m4slm15sdwcghz7d2fz222c7jcw1ahvdr"; + libraryHaskellDepends = [ base containers deepseq hashable ]; + doHaddock = false; + doCheck = false; + homepage = "https://github.com/phadej/range-set-list#readme"; + description = "Memory efficient sets with ranges of elements"; + license = stdenv.lib.licenses.mit; + }) {}; + "rank1dynamic" = callPackage + ({ mkDerivation, base, binary, stdenv }: + mkDerivation { + pname = "rank1dynamic"; + version = "0.4.0"; + sha256 = "3c424bfe52b7d4766fd66ea34c204cf920b146455711d8d10d580ca6c175ab1d"; + revision = "1"; + editedCabalFile = "1idh1iz15pzdhrhy19584i9ahz41ijbmf56wbb2wns2kipy6w9lr"; + libraryHaskellDepends = [ base binary ]; + doHaddock = false; + doCheck = false; + homepage = "http://haskell-distributed.github.com"; + description = "Like Data.Dynamic/Data.Typeable but with support for rank-1 polymorphic types"; + license = stdenv.lib.licenses.bsd3; + }) {}; + "rank2classes" = callPackage + ({ mkDerivation, base, distributive, stdenv, template-haskell + , transformers + }: + mkDerivation { + pname = "rank2classes"; + version = "1.1.0.1"; + sha256 = "7c24a53f447fde044a071f0a7bda225a0e2ae76e800daf4b4a3c9fedadea82c7"; + libraryHaskellDepends = [ + base distributive template-haskell transformers + ]; + doHaddock = false; + doCheck = false; + homepage = "https://github.com/blamario/grampa/tree/master/rank2classes"; + description = "standard type constructor class hierarchy, only with methods of rank 2 types"; + license = stdenv.lib.licenses.bsd3; + }) {}; + "rasterific-svg" = callPackage + ({ mkDerivation, base, binary, bytestring, containers, directory + , filepath, FontyFruity, JuicyPixels, lens, linear, mtl + , optparse-applicative, primitive, Rasterific, scientific, stdenv + , svg-tree, text, transformers, vector + }: + mkDerivation { + pname = "rasterific-svg"; + version = "0.3.3.1"; + sha256 = "d6b5ea1318b6cca165fee1fae91116878ef72918eca6e7a118624bf56add1184"; + revision = "1"; + editedCabalFile = "0mhg2k786zx1cmblijnz73cf12h1s5grmkc0wb63612hnxxz53i7"; + isLibrary = true; + isExecutable = true; + libraryHaskellDepends = [ + base binary bytestring containers directory filepath FontyFruity + JuicyPixels lens linear mtl primitive Rasterific scientific + svg-tree text transformers vector + ]; + executableHaskellDepends = [ + base bytestring directory filepath FontyFruity JuicyPixels + optparse-applicative Rasterific svg-tree + ]; + doHaddock = false; + doCheck = false; + description = "SVG renderer based on Rasterific"; + license = stdenv.lib.licenses.bsd3; + }) {}; + "ratel" = callPackage + ({ mkDerivation, aeson, base, bytestring, case-insensitive + , containers, http-client, http-client-tls, http-types, stdenv + , text, uuid + }: + mkDerivation { + pname = "ratel"; + version = "1.0.5"; + sha256 = "993ce9a8d58619802d286e3be152e295cb38c9dba85ffa0904ed6044972bc52a"; + libraryHaskellDepends = [ + aeson base bytestring case-insensitive containers http-client + http-client-tls http-types text uuid + ]; + doHaddock = false; + doCheck = false; + homepage = "https://github.com/tfausak/ratel#readme"; + description = "Notify Honeybadger about exceptions"; + license = stdenv.lib.licenses.mit; + }) {}; + "ratel-wai" = callPackage + ({ mkDerivation, base, bytestring, case-insensitive, containers + , http-client, ratel, stdenv, wai + }: + mkDerivation { + pname = "ratel-wai"; + version = "1.0.3"; + sha256 = "04558e3e91e873080810f4441940293ef0874cf2b330bdb4518000307120732e"; + libraryHaskellDepends = [ + base bytestring case-insensitive containers http-client ratel wai + ]; + doHaddock = false; + doCheck = false; + homepage = "https://github.com/tfausak/ratel-wai#readme"; + description = "Notify Honeybadger about exceptions via a WAI middleware"; + license = stdenv.lib.licenses.mit; + }) {}; + "ratio-int" = callPackage + ({ mkDerivation, base, stdenv }: + mkDerivation { + pname = "ratio-int"; + version = "0.1.2"; + sha256 = "efe86052c5979261d9aa6861c6297205ee0b60e1b36de191d20485e823c9781a"; + libraryHaskellDepends = [ base ]; + doHaddock = false; + doCheck = false; + homepage = "https://github.com/RaphaelJ/ratio-int"; + description = "Fast specialisation of Data.Ratio for Int."; + license = stdenv.lib.licenses.bsd3; + }) {}; + "rattletrap" = callPackage + ({ mkDerivation, aeson, aeson-pretty, base, binary, binary-bits + , bytestring, containers, filepath, http-client, http-client-tls + , stdenv, template-haskell, text, transformers + }: + mkDerivation { + pname = "rattletrap"; + version = "4.1.2"; + sha256 = "62cdbb4d34e5b90ab7a2e3bcf2114990e40f9f7c7bce9cebb6b5cce05a67aa7e"; + isLibrary = true; + isExecutable = true; + libraryHaskellDepends = [ + aeson aeson-pretty base binary binary-bits bytestring containers + filepath http-client http-client-tls template-haskell text + transformers + ]; + executableHaskellDepends = [ + aeson aeson-pretty base binary binary-bits bytestring containers + filepath http-client http-client-tls template-haskell text + transformers + ]; + doHaddock = false; + doCheck = false; + homepage = "https://github.com/tfausak/rattletrap#readme"; + description = "Parse and generate Rocket League replays"; + license = stdenv.lib.licenses.mit; + }) {}; + "raw-strings-qq" = callPackage + ({ mkDerivation, base, stdenv, template-haskell }: + mkDerivation { + pname = "raw-strings-qq"; + version = "1.1"; + sha256 = "2e011ec26aeaa53ab43c30b7d9b5b0f661f24b4ebef8884c12c571353c0fbed3"; + libraryHaskellDepends = [ base template-haskell ]; + doHaddock = false; + doCheck = false; + homepage = "https://github.com/23Skidoo/raw-strings-qq"; + description = "Raw string literals for Haskell"; + license = stdenv.lib.licenses.bsd3; + }) {}; + "rawfilepath" = callPackage + ({ mkDerivation, base, bytestring, stdenv, unix }: + mkDerivation { + pname = "rawfilepath"; + version = "0.2.4"; + sha256 = "cbb01b49f7ff0271a8c6e4124f93515e6cdabf9581278594e19dd916b6bd5bd3"; + libraryHaskellDepends = [ base bytestring unix ]; + doHaddock = false; + doCheck = false; + homepage = "https://github.com/xtendo-org/rawfilepath#readme"; + description = "Use RawFilePath instead of FilePath"; + license = stdenv.lib.licenses.asl20; + }) {}; + "rawstring-qm" = callPackage + ({ mkDerivation, base, bytestring, stdenv, template-haskell, text + }: + mkDerivation { + pname = "rawstring-qm"; + version = "0.2.3.0"; + sha256 = "11a177bb7d685fb6a98390630196bd544e877b7460648e61a2905c21a71268fe"; + libraryHaskellDepends = [ base bytestring template-haskell text ]; + doHaddock = false; + doCheck = false; + homepage = "https://github.com/tolysz/rawstring-qm"; + description = "Simple raw string quotation and dictionary interpolation"; + license = stdenv.lib.licenses.bsd3; + }) {}; + "rcu" = callPackage + ({ mkDerivation, atomic-primops, base, Cabal, cabal-doctest + , ghc-prim, parallel, primitive, stdenv, transformers + }: + mkDerivation { + pname = "rcu"; + version = "0.2.2"; + sha256 = "93264621dc372c6180aa12324435deeac36946cdca7f77270ef0a3e162474852"; + revision = "4"; + editedCabalFile = "18gaaz7pj7x9yv2na1zbqavirrj93c7q6z28r4502if0w1w8wk8f"; + isLibrary = true; + isExecutable = true; + setupHaskellDepends = [ base Cabal cabal-doctest ]; + libraryHaskellDepends = [ + atomic-primops base ghc-prim parallel primitive transformers + ]; + executableHaskellDepends = [ base transformers ]; + doHaddock = false; + doCheck = false; + homepage = "http://github.com/ekmett/rcu/"; + description = "Read-Copy-Update for Haskell"; + license = stdenv.lib.licenses.bsd3; + }) {}; + "rdf" = callPackage + ({ mkDerivation, attoparsec, base, bytestring, deepseq, dlist, fgl + , stdenv, text, transformers + }: + mkDerivation { + pname = "rdf"; + version = "0.1.0.2"; + sha256 = "889d93b6f54c791e62cd93ec404bb171d7e3bdbba0a085a4c7f4e4d2f3b51f6f"; + libraryHaskellDepends = [ + attoparsec base bytestring deepseq dlist fgl text transformers + ]; + doHaddock = false; + doCheck = false; + homepage = "https://github.com/traviswhitaker/rdf"; + description = "Representation and Incremental Processing of RDF Data"; + license = stdenv.lib.licenses.mit; + }) {}; + "rdtsc" = callPackage + ({ mkDerivation, base, stdenv }: + mkDerivation { + pname = "rdtsc"; + version = "1.3.0.1"; + sha256 = "54c9a925f68d6c60b405e92f9d3bd9ebfc25cce0c72d2313a6c7e1b7cc2ed950"; + libraryHaskellDepends = [ base ]; + doHaddock = false; + doCheck = false; + homepage = "https://github.com/mgrabmueller/rdtsc"; + description = "Binding for the rdtsc machine instruction"; + license = stdenv.lib.licenses.bsd3; + }) {}; + "re2" = callPackage + ({ mkDerivation, base, bytestring, re2, stdenv, vector }: + mkDerivation { + pname = "re2"; + version = "0.2"; + sha256 = "6906d80ed6834162f74ceb056230f7b1d1cd3423f05f67c65107b1493c8fd561"; + libraryHaskellDepends = [ base bytestring vector ]; + librarySystemDepends = [ re2 ]; + doHaddock = false; + doCheck = false; + homepage = "https://github.com/rblaze/haskell-re2#readme"; + description = "Bindings to the re2 regular expression library"; + license = stdenv.lib.licenses.mit; + }) {inherit (pkgs) re2;}; + "read-editor" = callPackage + ({ mkDerivation, base, directory, process, stdenv }: + mkDerivation { + pname = "read-editor"; + version = "0.1.0.2"; + sha256 = "ed8aeca86823fbaf11a0a543fd106c9c3abe65216ea974ed56050cbebf777085"; + isLibrary = true; + isExecutable = true; + libraryHaskellDepends = [ base directory process ]; + doHaddock = false; + doCheck = false; + homepage = "https://github.com/yamadapc/haskell-read-editor"; + description = "Opens a temporary file on the system's EDITOR and returns the resulting edits"; + license = stdenv.lib.licenses.mit; + }) {}; + "read-env-var" = callPackage + ({ mkDerivation, base, exceptions, stdenv, transformers }: + mkDerivation { + pname = "read-env-var"; + version = "1.0.0.0"; + sha256 = "03f3c8176fc08ce838ae772f13991258e2b496712cc71edb1a00336e7ce0b75c"; + libraryHaskellDepends = [ base exceptions transformers ]; + doHaddock = false; + doCheck = false; + homepage = "https://github.com/cdepillabout/read-env-var#readme"; + description = "Functions for safely reading environment variables"; + license = stdenv.lib.licenses.bsd3; + }) {}; + "readable" = callPackage + ({ mkDerivation, base, bytestring, stdenv, text }: + mkDerivation { + pname = "readable"; + version = "0.3.1"; + sha256 = "703037ad2cca4d6d42ba23e2758d1911cd82e3e922c4078076c273231e4b43c9"; + libraryHaskellDepends = [ base bytestring text ]; + doHaddock = false; + doCheck = false; + homepage = "https://github.com/mightybyte/readable"; + description = "Reading from Text and ByteString"; + license = stdenv.lib.licenses.bsd3; + }) {}; + "rebase" = callPackage + ({ mkDerivation, base, base-prelude, bifunctors, bytestring + , containers, contravariant, contravariant-extras, deepseq, dlist + , either, fail, hashable, mtl, profunctors, scientific + , semigroupoids, semigroups, stdenv, stm, text, time, transformers + , unordered-containers, uuid, vector, void + }: + mkDerivation { + pname = "rebase"; + version = "1.2.4"; + sha256 = "ca6be557b4437d43d25133c566024c7bbf66b625b0b035a3ad8affeb381650bd"; + libraryHaskellDepends = [ + base base-prelude bifunctors bytestring containers contravariant + contravariant-extras deepseq dlist either fail hashable mtl + profunctors scientific semigroupoids semigroups stm text time + transformers unordered-containers uuid vector void + ]; + doHaddock = false; + doCheck = false; + homepage = "https://github.com/nikita-volkov/rebase"; + description = "A more progressive alternative to the \"base\" package"; + license = stdenv.lib.licenses.mit; + }) {}; + "record-dot-preprocessor" = callPackage + ({ mkDerivation, base, extra, filepath, stdenv }: + mkDerivation { + pname = "record-dot-preprocessor"; + version = "0.1.1"; + sha256 = "35e9162b2ef895253574d953686a86a57bcbf7568c943d2828c319fb5e0566d1"; + isLibrary = false; + isExecutable = true; + executableHaskellDepends = [ base extra filepath ]; + doHaddock = false; + doCheck = false; + homepage = "https://github.com/ndmitchell/record-dot-preprocessor#readme"; + description = "Preprocessor to allow record.field syntax"; + license = stdenv.lib.licenses.bsd3; + }) {}; + "recursion-schemes" = callPackage + ({ mkDerivation, base, base-orphans, comonad, free, stdenv + , template-haskell, th-abstraction, transformers + }: + mkDerivation { + pname = "recursion-schemes"; + version = "5.0.3"; + sha256 = "db207037a5a89eb0002df1fe878d8b84bf20bc4703ad4a86e856613fa89ca09f"; + revision = "3"; + editedCabalFile = "05fvpi3dc44h2a097fb9cq1jqdjq2b3sdf5hzfn9g00bid37bb5q"; + libraryHaskellDepends = [ + base base-orphans comonad free template-haskell th-abstraction + transformers + ]; + doHaddock = false; + doCheck = false; + homepage = "http://github.com/ekmett/recursion-schemes/"; + description = "Generalized bananas, lenses and barbed wire"; + license = stdenv.lib.licenses.bsd3; + }) {}; + "reducers" = callPackage + ({ mkDerivation, array, base, bytestring, containers, fingertree + , hashable, semigroupoids, semigroups, stdenv, text, transformers + , unordered-containers + }: + mkDerivation { + pname = "reducers"; + version = "3.12.3"; + sha256 = "7186733767405984c1eda96b18908f458b379f116a1589cd66f4319fe8458e27"; + libraryHaskellDepends = [ + array base bytestring containers fingertree hashable semigroupoids + semigroups text transformers unordered-containers + ]; + doHaddock = false; + doCheck = false; + homepage = "http://github.com/ekmett/reducers/"; + description = "Semigroups, specialized containers and a general map/reduce framework"; + license = stdenv.lib.licenses.bsd3; + }) {}; + "ref-fd" = callPackage + ({ mkDerivation, base, stdenv, stm, transformers }: + mkDerivation { + pname = "ref-fd"; + version = "0.4.0.1"; + sha256 = "e416f1afba149e3af9cbe1011381d0b89609c240d812127bd03b8a922a5f6037"; + libraryHaskellDepends = [ base stm transformers ]; + doHaddock = false; + doCheck = false; + description = "A type class for monads with references using functional dependencies"; + license = stdenv.lib.licenses.bsd3; + }) {}; + "refact" = callPackage + ({ mkDerivation, base, stdenv }: + mkDerivation { + pname = "refact"; + version = "0.3.0.2"; + sha256 = "0ad029727797c8ca5d179c7abf1bfc135d86a7d72cf93785ee12ad243aeb1f6c"; + libraryHaskellDepends = [ base ]; + doHaddock = false; + doCheck = false; + description = "Specify refactorings to perform with apply-refact"; + license = stdenv.lib.licenses.bsd3; + }) {}; + "references" = callPackage + ({ mkDerivation, array, base, containers, directory, either + , filepath, instance-control, mtl, stdenv, template-haskell, text + , transformers, uniplate + }: + mkDerivation { + pname = "references"; + version = "0.3.3.1"; + sha256 = "bc07606d36639148374e7a29a67ac489c7a0ed02655311b5d633a144a746c10e"; + libraryHaskellDepends = [ + array base containers directory either filepath instance-control + mtl template-haskell text transformers uniplate + ]; + doHaddock = false; + doCheck = false; + homepage = "https://github.com/lazac/references"; + description = "Selectors for reading and updating data"; + license = stdenv.lib.licenses.bsd3; + }) {}; + "refined" = callPackage + ({ mkDerivation, base, containers, exceptions, mtl, prettyprinter + , stdenv, template-haskell, these, transformers + }: + mkDerivation { + pname = "refined"; + version = "0.2.3.0"; + sha256 = "664abf6de7c010416cfe2666c61b910c155dae1652f2662690c2add8c5c384f5"; + libraryHaskellDepends = [ + base containers exceptions mtl prettyprinter template-haskell these + transformers + ]; + doHaddock = false; + doCheck = false; + homepage = "https://github.com/nikita-volkov/refined"; + description = "Refinement types with static and runtime checking"; + license = stdenv.lib.licenses.mit; + }) {}; + "reflection" = callPackage + ({ mkDerivation, base, stdenv, template-haskell }: + mkDerivation { + pname = "reflection"; + version = "2.1.4"; + sha256 = "f22fc478d43a36ec3d6c48c57ec53636c0bf936f3733b9a2b34e1a2e6351c44d"; + libraryHaskellDepends = [ base template-haskell ]; + doHaddock = false; + doCheck = false; + homepage = "http://github.com/ekmett/reflection"; + description = "Reifies arbitrary terms into types that can be reflected back into terms"; + license = stdenv.lib.licenses.bsd3; + }) {}; + "regex-applicative" = callPackage + ({ mkDerivation, base, containers, stdenv, transformers }: + mkDerivation { + pname = "regex-applicative"; + version = "0.3.3"; + sha256 = "6659a2cc1c8137d77ef57f75027723b075d473354d935233d98b1ae1b03c3be6"; + libraryHaskellDepends = [ base containers transformers ]; + doHaddock = false; + doCheck = false; + homepage = "https://github.com/feuerbach/regex-applicative"; + description = "Regex-based parsing with applicative interface"; + license = stdenv.lib.licenses.mit; + }) {}; + "regex-applicative-text" = callPackage + ({ mkDerivation, base, regex-applicative, stdenv, text }: + mkDerivation { + pname = "regex-applicative-text"; + version = "0.1.0.1"; + sha256 = "b093051f80865d257da2ded8ad1b566927b01b3d2f86d41da2ffee4a26c4e2d9"; + revision = "3"; + editedCabalFile = "1h911harqgfgkhdr22cndj2fdsl48sqhn8q0akgjngpf3p8z0bvv"; + libraryHaskellDepends = [ base regex-applicative text ]; + doHaddock = false; + doCheck = false; + homepage = "https://github.com/phadej/regex-applicative-text#readme"; + description = "regex-applicative on text"; + license = stdenv.lib.licenses.bsd3; + }) {}; + "regex-base" = callPackage + ({ mkDerivation, array, base, bytestring, containers, mtl, stdenv + }: + mkDerivation { + pname = "regex-base"; + version = "0.93.2"; + sha256 = "20dc5713a16f3d5e2e6d056b4beb9cfdc4368cd09fd56f47414c847705243278"; + libraryHaskellDepends = [ array base bytestring containers mtl ]; + doHaddock = false; + doCheck = false; + homepage = "http://sourceforge.net/projects/lazy-regex"; + description = "Replaces/Enhances Text.Regex"; + license = stdenv.lib.licenses.bsd3; + }) {}; + "regex-compat" = callPackage + ({ mkDerivation, array, base, regex-base, regex-posix, stdenv }: + mkDerivation { + pname = "regex-compat"; + version = "0.95.1"; + sha256 = "d57cb1a5a4d66753b18eaa37a1621246f660472243b001894f970037548d953b"; + libraryHaskellDepends = [ array base regex-base regex-posix ]; + doHaddock = false; + doCheck = false; + homepage = "http://sourceforge.net/projects/lazy-regex"; + description = "Replaces/Enhances Text.Regex"; + license = stdenv.lib.licenses.bsd3; + }) {}; + "regex-compat-tdfa" = callPackage + ({ mkDerivation, array, base, regex-base, regex-tdfa, stdenv }: + mkDerivation { + pname = "regex-compat-tdfa"; + version = "0.95.1.4"; + sha256 = "4fa38ed24ae390eeffe6eef04bbe632d7ecd02b9123729e976e7420f927520dd"; + libraryHaskellDepends = [ array base regex-base regex-tdfa ]; + doHaddock = false; + doCheck = false; + homepage = "http://hub.darcs.net/shelarcy/regex-compat-tdfa"; + description = "Unicode Support version of Text.Regex, using regex-tdfa"; + license = stdenv.lib.licenses.bsd3; + }) {}; + "regex-pcre" = callPackage + ({ mkDerivation, array, base, bytestring, containers, pcre + , regex-base, stdenv + }: + mkDerivation { + pname = "regex-pcre"; + version = "0.94.4"; + sha256 = "8eaa7d4ac6c0a4ba35aa59fc3f6b8f8e252bb25a47e136791446a74752e226c0"; + libraryHaskellDepends = [ + array base bytestring containers regex-base + ]; + librarySystemDepends = [ pcre ]; + doHaddock = false; + doCheck = false; + homepage = "http://hackage.haskell.org/package/regex-pcre"; + description = "Replaces/Enhances Text.Regex"; + license = stdenv.lib.licenses.bsd3; + }) {inherit (pkgs) pcre;}; + "regex-pcre-builtin" = callPackage + ({ mkDerivation, array, base, bytestring, containers, regex-base + , stdenv + }: + mkDerivation { + pname = "regex-pcre-builtin"; + version = "0.94.4.8.8.35"; + sha256 = "0bd1b695de953ba4b6e6e0de007021c346cb2a6c8e09356fbcd34f8a79d2ea78"; + libraryHaskellDepends = [ + array base bytestring containers regex-base + ]; + doHaddock = false; + doCheck = false; + homepage = "http://hackage.haskell.org/package/regex-pcre"; + description = "Replaces/Enhances Text.Regex"; + license = stdenv.lib.licenses.bsd3; + }) {}; + "regex-pcre-text" = callPackage + ({ mkDerivation, array, base, bytestring, regex-base + , regex-pcre-builtin, regex-tdfa-text, stdenv, text + }: + mkDerivation { + pname = "regex-pcre-text"; + version = "0.94.0.1"; + sha256 = "17991ed7b00da5cfb2efa0cefac16f9e0452fc794fe538d26d5cc802f0d8e9bd"; + libraryHaskellDepends = [ + array base bytestring regex-base regex-pcre-builtin regex-tdfa-text + text + ]; + doHaddock = false; + doCheck = false; + homepage = "https://github.com/cdornan/regex-pcre-text"; + description = "Text-based PCRE API for regex-base"; + license = stdenv.lib.licenses.bsd3; + }) {}; + "regex-posix" = callPackage + ({ mkDerivation, array, base, bytestring, containers, regex-base + , stdenv + }: + mkDerivation { + pname = "regex-posix"; + version = "0.95.2"; + sha256 = "56019921cd4a4c9682b81ec614236fea816ba8ed8785a1640cd66d8b24fc703e"; + libraryHaskellDepends = [ + array base bytestring containers regex-base + ]; + doHaddock = false; + doCheck = false; + homepage = "http://sourceforge.net/projects/lazy-regex"; + description = "Replaces/Enhances Text.Regex"; + license = stdenv.lib.licenses.bsd3; + }) {}; + "regex-tdfa" = callPackage + ({ mkDerivation, array, base, bytestring, containers, ghc-prim, mtl + , parsec, regex-base, stdenv + }: + mkDerivation { + pname = "regex-tdfa"; + version = "1.2.3.1"; + sha256 = "8aaaeeecf050807c7c514d4dd1763ac63bd121782de5a0847bef5d48a095ea50"; + libraryHaskellDepends = [ + array base bytestring containers ghc-prim mtl parsec regex-base + ]; + doHaddock = false; + doCheck = false; + homepage = "https://github.com/ChrisKuklewicz/regex-tdfa"; + description = "Replaces/Enhances Text.Regex"; + license = stdenv.lib.licenses.bsd3; + }) {}; + "regex-tdfa-text" = callPackage + ({ mkDerivation, array, base, regex-base, regex-tdfa, stdenv, text + }: + mkDerivation { + pname = "regex-tdfa-text"; + version = "1.0.0.3"; + sha256 = "38d77a0d225c306c52c6d4eed12d11d05a4bc4194d547cb9a7a9b6f5a8792001"; + libraryHaskellDepends = [ array base regex-base regex-tdfa text ]; + doHaddock = false; + doCheck = false; + description = "Text interface for regex-tdfa"; + license = stdenv.lib.licenses.bsd3; + }) {}; + "reinterpret-cast" = callPackage + ({ mkDerivation, array, base, stdenv }: + mkDerivation { + pname = "reinterpret-cast"; + version = "0.1.0"; + sha256 = "5654622c904b42c62f2473c64624715dbd458ea00209ed9ab39396eabc1353e4"; + libraryHaskellDepends = [ array base ]; + doHaddock = false; + doCheck = false; + homepage = "https://github.com/nh2/reinterpret-cast"; + description = "Memory reinterpretation casts for Float/Double and Word32/Word64"; + license = stdenv.lib.licenses.mit; + }) {}; + "relational-query" = callPackage + ({ mkDerivation, array, base, bytestring, containers, dlist + , names-th, persistable-record, product-isomorphic, sql-words + , stdenv, template-haskell, text, th-reify-compat, time + , time-locale-compat, transformers + }: + mkDerivation { + pname = "relational-query"; + version = "0.12.0.1"; + sha256 = "1ff2055d892fb9c89013a4cdb90070f6bac15e9ac43730eac6299104c4b8555a"; + libraryHaskellDepends = [ + array base bytestring containers dlist names-th persistable-record + product-isomorphic sql-words template-haskell text th-reify-compat + time time-locale-compat transformers + ]; + doHaddock = false; + doCheck = false; + homepage = "http://khibino.github.io/haskell-relational-record/"; + description = "Typeful, Modular, Relational, algebraic query engine"; + license = stdenv.lib.licenses.bsd3; + }) {}; + "relational-query-HDBC" = callPackage + ({ mkDerivation, base, containers, convertible, dlist, HDBC + , HDBC-session, names-th, persistable-record, product-isomorphic + , relational-query, relational-schemas, sql-words, stdenv + , template-haskell, th-data-compat, transformers + }: + mkDerivation { + pname = "relational-query-HDBC"; + version = "0.7.0.1"; + sha256 = "a05ed895ccc4bcb35055a646833e60be8ef183d6b0e72d98c8d20328a7278f36"; + libraryHaskellDepends = [ + base containers convertible dlist HDBC HDBC-session names-th + persistable-record product-isomorphic relational-query + relational-schemas sql-words template-haskell th-data-compat + transformers + ]; + doHaddock = false; + doCheck = false; + homepage = "http://khibino.github.io/haskell-relational-record/"; + description = "HDBC instance of relational-query and typed query interface for HDBC"; + license = stdenv.lib.licenses.bsd3; + }) {}; + "relational-record" = callPackage + ({ mkDerivation, base, persistable-record + , persistable-types-HDBC-pg, product-isomorphic, relational-query + , relational-query-HDBC, stdenv + }: + mkDerivation { + pname = "relational-record"; + version = "0.2.2.0"; + sha256 = "0bbd2663c394a39a7b3d9bcd257d91e3312be7f3c8df562b6868e82c0b96b3da"; + libraryHaskellDepends = [ + base persistable-record persistable-types-HDBC-pg + product-isomorphic relational-query relational-query-HDBC + ]; + doHaddock = false; + doCheck = false; + homepage = "http://khibino.github.io/haskell-relational-record/"; + description = "Meta package of Relational Record"; + license = stdenv.lib.licenses.bsd3; + }) {}; + "relational-schemas" = callPackage + ({ mkDerivation, base, bytestring, containers, relational-query + , stdenv, template-haskell, time + }: + mkDerivation { + pname = "relational-schemas"; + version = "0.1.6.2"; + sha256 = "5522efa683c5da8c37b09d2ebc636bc8d60804ed2372912ca7cc80793e45a7b0"; + libraryHaskellDepends = [ + base bytestring containers relational-query template-haskell time + ]; + doHaddock = false; + doCheck = false; + homepage = "http://khibino.github.io/haskell-relational-record/"; + description = "RDBMSs' schema templates for relational-query"; + license = stdenv.lib.licenses.bsd3; + }) {}; + "renderable" = callPackage + ({ mkDerivation, base, containers, hashable, stdenv, transformers + }: + mkDerivation { + pname = "renderable"; + version = "0.2.0.1"; + sha256 = "d1ea5a8d2da8913700c326c3e757c8c4c8a87f1353125bbc9ea372729e04b6c5"; + libraryHaskellDepends = [ base containers hashable transformers ]; + doHaddock = false; + doCheck = false; + homepage = "https://github.com/schell/renderable"; + description = "An API for managing renderable resources"; + license = stdenv.lib.licenses.mit; + }) {}; + "repa" = callPackage + ({ mkDerivation, base, bytestring, ghc-prim, QuickCheck, stdenv + , template-haskell, vector + }: + mkDerivation { + pname = "repa"; + version = "3.4.1.3"; + sha256 = "3e32d7b2964994d6edd3eabcce38f0c08ff474b3d4acb0d9b3f3b75c76e67a70"; + revision = "2"; + editedCabalFile = "0kmypfnpzjszdzhpd1lskp0plja8zyr8r2y9xyscx4g5md9hh0zp"; + libraryHaskellDepends = [ + base bytestring ghc-prim QuickCheck template-haskell vector + ]; + doHaddock = false; + doCheck = false; + homepage = "http://repa.ouroborus.net"; + description = "High performance, regular, shape polymorphic parallel arrays"; + license = stdenv.lib.licenses.bsd3; + }) {}; + "repline" = callPackage + ({ mkDerivation, base, containers, haskeline, mtl, process, stdenv + }: + mkDerivation { + pname = "repline"; + version = "0.1.7.0"; + sha256 = "503a035d8a380ac21c532e48c0f47006ff1c20ed9683f4906fdb304b4b9e55de"; + libraryHaskellDepends = [ base containers haskeline mtl process ]; + doHaddock = false; + doCheck = false; + homepage = "https://github.com/sdiehl/repline"; + description = "Haskeline wrapper for GHCi-like REPL interfaces"; + license = stdenv.lib.licenses.mit; + }) {}; + "req" = callPackage + ({ mkDerivation, aeson, authenticate-oauth, base, blaze-builder + , bytestring, case-insensitive, connection, data-default-class + , http-api-data, http-client, http-client-tls, http-types + , monad-control, mtl, retry, stdenv, text, time, transformers + , transformers-base + }: + mkDerivation { + pname = "req"; + version = "1.1.0"; + sha256 = "87cd886d295e2df38baebd63045be306e07bb910cf11aed9a1a734ac5dc04e22"; + revision = "1"; + editedCabalFile = "1qb458sldda1msrx8hyp31a5ybny2kdymsxhmsyk9i9c5gk0qqib"; + enableSeparateDataOutput = true; + libraryHaskellDepends = [ + aeson authenticate-oauth base blaze-builder bytestring + case-insensitive connection data-default-class http-api-data + http-client http-client-tls http-types monad-control mtl retry text + time transformers transformers-base + ]; + doHaddock = false; + doCheck = false; + homepage = "https://github.com/mrkkrp/req"; + description = "Easy-to-use, type-safe, expandable, high-level HTTP client library"; + license = stdenv.lib.licenses.bsd3; + }) {}; + "req-conduit" = callPackage + ({ mkDerivation, base, bytestring, conduit, http-client, req + , resourcet, stdenv, transformers + }: + mkDerivation { + pname = "req-conduit"; + version = "1.0.0"; + sha256 = "1da764e4bdc5454aef3d79cff2d72c9fa393a8d049ab14c3ba2be77325d96ba4"; + revision = "3"; + editedCabalFile = "1gnaq7ya4grjwadz58r9g10dybgg50ch89bhbnhyicdins2aa9b2"; + libraryHaskellDepends = [ + base bytestring conduit http-client req resourcet transformers + ]; + doHaddock = false; + doCheck = false; + homepage = "https://github.com/mrkkrp/req-conduit"; + description = "Conduit helpers for the req HTTP client library"; + license = stdenv.lib.licenses.bsd3; + }) {}; + "req-url-extra" = callPackage + ({ mkDerivation, aeson, base, data-default-class, modern-uri, req + , stdenv, text + }: + mkDerivation { + pname = "req-url-extra"; + version = "0.1.0.0"; + sha256 = "b3de266ad49fb3c03ff26d589d89f81ddea7f319900b07e59843e57986d37d84"; + isLibrary = true; + isExecutable = true; + libraryHaskellDepends = [ base modern-uri req ]; + executableHaskellDepends = [ + aeson base data-default-class modern-uri req text + ]; + doHaddock = false; + doCheck = false; + homepage = "https://github.com/rcook/req-url-extra#readme"; + description = "Provides URI/URL helper functions for use with Req"; + license = stdenv.lib.licenses.mit; + }) {}; + "require" = callPackage + ({ mkDerivation, base, bytestring, megaparsec, stdenv, text + , universum + }: + mkDerivation { + pname = "require"; + version = "0.2.1"; + sha256 = "a2b79c763f85ac22a436104c11cf5a467da48f59623027fe03c5e22a594dc131"; + isLibrary = true; + isExecutable = true; + libraryHaskellDepends = [ + base bytestring megaparsec text universum + ]; + executableHaskellDepends = [ + base bytestring megaparsec text universum + ]; + doHaddock = false; + doCheck = false; + homepage = "https://github.com/theam/require#readme"; + description = "Scrap your qualified import clutter"; + license = stdenv.lib.licenses.asl20; + }) {}; + "resolv" = callPackage + ({ mkDerivation, base, base16-bytestring, binary, bytestring + , containers, stdenv + }: + mkDerivation { + pname = "resolv"; + version = "0.1.1.1"; + sha256 = "49b12ed2b175cca3f885c06ca6906cde1245c02b6f98f2a95fc20d6a8ae40772"; + revision = "3"; + editedCabalFile = "0r1i7zrnynqxd3nzq4cz9648s3dmj29w63mcip57620d0fimyghm"; + libraryHaskellDepends = [ + base base16-bytestring binary bytestring containers + ]; + doHaddock = false; + doCheck = false; + description = "Domain Name Service (DNS) lookup via the libresolv standard library routines"; + license = stdenv.lib.licenses.gpl3; + }) {}; + "resource-pool" = callPackage + ({ mkDerivation, base, hashable, monad-control, stdenv, stm, time + , transformers, transformers-base, vector + }: + mkDerivation { + pname = "resource-pool"; + version = "0.2.3.2"; + sha256 = "8627eea2bea8824af2723646e74e2af0c73f583dd0c496c9fd242cd9d242bc12"; + libraryHaskellDepends = [ + base hashable monad-control stm time transformers transformers-base + vector + ]; + doHaddock = false; + doCheck = false; + homepage = "http://github.com/bos/pool"; + description = "A high-performance striped resource pooling implementation"; + license = stdenv.lib.licenses.bsd3; + }) {}; + "resourcet" = callPackage + ({ mkDerivation, base, containers, exceptions, mtl, primitive + , stdenv, transformers, unliftio-core + }: + mkDerivation { + pname = "resourcet"; + version = "1.2.1"; + sha256 = "e765c12a6ec0f70efc3c938750060bc17569b99578aa635fd4da0c4d06fcf267"; + libraryHaskellDepends = [ + base containers exceptions mtl primitive transformers unliftio-core + ]; + doHaddock = false; + doCheck = false; + homepage = "http://github.com/snoyberg/conduit"; + description = "Deterministic allocation and freeing of scarce resources"; + license = stdenv.lib.licenses.bsd3; + }) {}; + "rest-stringmap" = callPackage + ({ mkDerivation, aeson, base, containers, hashable, hxt + , json-schema, stdenv, tostring, unordered-containers + }: + mkDerivation { + pname = "rest-stringmap"; + version = "0.2.0.7"; + sha256 = "62d4644f5f7e4ad85688feafaea48b577907a382729f11e1c1fde21a98215450"; + libraryHaskellDepends = [ + aeson base containers hashable hxt json-schema tostring + unordered-containers + ]; + doHaddock = false; + doCheck = false; + description = "Maps with stringy keys that can be transcoded to JSON and XML"; + license = stdenv.lib.licenses.bsd3; + }) {}; + "result" = callPackage + ({ mkDerivation, base, bifunctors, keys, mtl, stdenv, transformers + }: + mkDerivation { + pname = "result"; + version = "0.2.6.0"; + sha256 = "f526d97cdab851f24e215e346f6d54d3a504a6ac5d9264f580c4f72d606178c5"; + libraryHaskellDepends = [ base bifunctors keys mtl transformers ]; + doHaddock = false; + doCheck = false; + homepage = "https://github.com/srijs/haskell-result"; + description = "Encode success or at least one error"; + license = stdenv.lib.licenses.mit; + }) {}; + "rethinkdb-client-driver" = callPackage + ({ mkDerivation, aeson, base, binary, bytestring, containers + , hashable, mtl, network, old-locale, scientific, stdenv, stm + , template-haskell, text, time, unordered-containers, vector + }: + mkDerivation { + pname = "rethinkdb-client-driver"; + version = "0.0.25"; + sha256 = "0f9dc156cd61b866b847b1b1a60a2345b4b5556b8b75a9e8499b0514e7f98996"; + revision = "3"; + editedCabalFile = "1g4shgl944fd3qbqkd68jv6vh65plaivci4vjzfs4py7a2p62db1"; + libraryHaskellDepends = [ + aeson base binary bytestring containers hashable mtl network + old-locale scientific stm template-haskell text time + unordered-containers vector + ]; + doHaddock = false; + doCheck = false; + homepage = "https://github.com/wereHamster/rethinkdb-client-driver"; + description = "Client driver for RethinkDB"; + license = stdenv.lib.licenses.mit; + }) {}; + "retry" = callPackage + ({ mkDerivation, base, data-default-class, exceptions, ghc-prim + , random, stdenv, transformers + }: + mkDerivation { + pname = "retry"; + version = "0.7.6.2"; + sha256 = "4d99f0598762de530200477efdba80a51cde2316a698a64f8683b86ba0b8b92e"; + libraryHaskellDepends = [ + base data-default-class exceptions ghc-prim random transformers + ]; + doHaddock = false; + doCheck = false; + homepage = "http://github.com/Soostone/retry"; + description = "Retry combinators for monadic actions that may fail"; + license = stdenv.lib.licenses.bsd3; + }) {}; + "rev-state" = callPackage + ({ mkDerivation, base, mtl, stdenv }: + mkDerivation { + pname = "rev-state"; + version = "0.1.2"; + sha256 = "ee070e39d7f7d673593e2f356ab317bc2fdd0d8a283f8316c0e5b5adbdf0f919"; + revision = "2"; + editedCabalFile = "0dfiwf4808vjhayv7xr058rzwl6jmsmhzy03mk48m9kmlqibk3fy"; + libraryHaskellDepends = [ base mtl ]; + doHaddock = false; + doCheck = false; + homepage = "https://github.com/DanBurton/rev-state#readme"; + description = "Reverse State monad transformer"; + license = stdenv.lib.licenses.bsd3; + }) {}; + "rfc5051" = callPackage + ({ mkDerivation, base, bytestring, containers, stdenv }: + mkDerivation { + pname = "rfc5051"; + version = "0.1.0.3"; + sha256 = "e38dab28a5625774be60545c8c99e647b79bbc0ac0bc9c65fe6b2ebef160642b"; + isLibrary = true; + isExecutable = true; + libraryHaskellDepends = [ base bytestring containers ]; + doHaddock = false; + doCheck = false; + description = "Simple unicode collation as per RFC5051"; + license = stdenv.lib.licenses.bsd3; + }) {}; + "rhine" = callPackage + ({ mkDerivation, base, containers, dunai, free, stdenv, time + , transformers + }: + mkDerivation { + pname = "rhine"; + version = "0.4.0.1"; + sha256 = "d21b320095c36c43a76b76f5f510089854e73e18304bbb27fa04e1b782c1b503"; + isLibrary = true; + isExecutable = true; + libraryHaskellDepends = [ + base containers dunai free time transformers + ]; + executableHaskellDepends = [ base ]; + doHaddock = false; + doCheck = false; + description = "Functional Reactive Programming with type-level clocks"; + license = stdenv.lib.licenses.bsd3; + }) {}; + "riak" = callPackage + ({ mkDerivation, aeson, async, attoparsec, base, bifunctors, binary + , blaze-builder, bytestring, containers, data-default-class + , deepseq, enclosed-exceptions, exceptions, hashable + , mersenne-random-pure64, monad-control, network, protocol-buffers + , pureMD5, random, resource-pool, riak-protobuf, semigroups, stdenv + , stm, text, time, transformers, transformers-base + , unordered-containers, vector + }: + mkDerivation { + pname = "riak"; + version = "1.1.2.5"; + sha256 = "c752fee9859c0c45daae4e0a3c6a231c625b25983781109823d9229a4dc5c7d2"; + libraryHaskellDepends = [ + aeson async attoparsec base bifunctors binary blaze-builder + bytestring containers data-default-class deepseq + enclosed-exceptions exceptions hashable mersenne-random-pure64 + monad-control network protocol-buffers pureMD5 random resource-pool + riak-protobuf semigroups stm text time transformers + transformers-base unordered-containers vector + ]; + doHaddock = false; + doCheck = false; + homepage = "http://github.com/riak-haskell-client/riak-haskell-client"; + description = "A Haskell client for the Riak decentralized data store"; + license = "unknown"; + }) {}; + "riak-protobuf" = callPackage + ({ mkDerivation, array, base, parsec, protocol-buffers + , protocol-buffers-descriptor, stdenv + }: + mkDerivation { + pname = "riak-protobuf"; + version = "0.23.0.0"; + sha256 = "5dcbd06bdb66a1e43881a62a44d92e47d3f16f9ea1b4d53e4a92622faecdca33"; + libraryHaskellDepends = [ + array base parsec protocol-buffers protocol-buffers-descriptor + ]; + doHaddock = false; + doCheck = false; + homepage = "http://github.com/riak-haskell-client/riak-haskell-client"; + description = "Haskell types for the Riak protocol buffer API"; + license = "unknown"; + }) {}; + "rio" = callPackage + ({ mkDerivation, base, bytestring, containers, deepseq, directory + , exceptions, filepath, hashable, microlens, mtl, primitive + , process, stdenv, text, time, typed-process, unix, unliftio + , unordered-containers, vector + }: + mkDerivation { + pname = "rio"; + version = "0.1.4.0"; + sha256 = "0fce0a8f903658c429da6a88c67a2544c260520a3332a9e6fe122fb0ebe8521a"; + libraryHaskellDepends = [ + base bytestring containers deepseq directory exceptions filepath + hashable microlens mtl primitive process text time typed-process + unix unliftio unordered-containers vector + ]; + doHaddock = false; + doCheck = false; + homepage = "https://github.com/commercialhaskell/rio#readme"; + description = "A standard library for Haskell"; + license = stdenv.lib.licenses.mit; + }) {}; + "rio-orphans" = callPackage + ({ mkDerivation, base, exceptions, fast-logger, monad-control + , monad-logger, resourcet, rio, stdenv, transformers-base + }: + mkDerivation { + pname = "rio-orphans"; + version = "0.1.1.0"; + sha256 = "7e8d2c6df6e7afdbca5b344c6e57c754e2d6b9c0cfb4f00e1df88dad1bd48b4e"; + libraryHaskellDepends = [ + base exceptions fast-logger monad-control monad-logger resourcet + rio transformers-base + ]; + doHaddock = false; + doCheck = false; + homepage = "https://github.com/commercialhaskell/rio#readme"; + description = "Orphan instances for the RIO type in the rio package"; + license = stdenv.lib.licenses.mit; + }) {}; + "rng-utils" = callPackage + ({ mkDerivation, base, bytestring, random, stdenv }: + mkDerivation { + pname = "rng-utils"; + version = "0.3.0"; + sha256 = "0886acb1e0ae6c6ad5f594a9d4d57ea5af69c566ccc5763d0b7c690963e946ba"; + libraryHaskellDepends = [ base bytestring random ]; + doHaddock = false; + doCheck = false; + homepage = "https://bitbucket.org/soostone/rng-utils"; + description = "RNG within an IORef for convenient concurrent use"; + license = stdenv.lib.licenses.bsd3; + }) {}; + "roles" = callPackage + ({ mkDerivation, base, containers, stdenv }: + mkDerivation { + pname = "roles"; + version = "0.2.0.0"; + sha256 = "e29d2f31b21b2d8ce3507e17211e70a61d2e434a8e19f80b2e4898bdabac34a0"; + libraryHaskellDepends = [ base containers ]; + doHaddock = false; + doCheck = false; + homepage = "http://github.com/matt-noonan/roles/"; + description = "Composable class-based roles"; + license = stdenv.lib.licenses.bsd3; + }) {}; + "rot13" = callPackage + ({ mkDerivation, base, bytestring, stdenv, text }: + mkDerivation { + pname = "rot13"; + version = "0.2.0.1"; + sha256 = "e026d418cc6a1ce83ba11e811387e62ad49ffb1cbd6ae7f58b72fd179fccd4dc"; + libraryHaskellDepends = [ base bytestring text ]; + doHaddock = false; + doCheck = false; + homepage = "https://github.com/kvanberendonck/codec-rot13"; + description = "Fast ROT13 cipher for Haskell"; + license = stdenv.lib.licenses.bsd3; + }) {}; + "rss-conduit" = callPackage + ({ mkDerivation, atom-conduit, base, conduit, conduit-combinators + , containers, dublincore-xml-conduit, lens-simple, safe + , safe-exceptions, singletons, stdenv, text, time, timerep + , uri-bytestring, vinyl, xml-conduit, xml-types + }: + mkDerivation { + pname = "rss-conduit"; + version = "0.4.2.1"; + sha256 = "b8f52cc3e899477c6f2642ea6d4abc6fa9c74fc6c08a8f990d50a79aff605712"; + revision = "1"; + editedCabalFile = "07y37q2a8wlgx9ay62bl0z6fgyqiypmfq0nzbnz766ac3jy7l42m"; + libraryHaskellDepends = [ + atom-conduit base conduit conduit-combinators containers + dublincore-xml-conduit lens-simple safe safe-exceptions singletons + text time timerep uri-bytestring vinyl xml-conduit xml-types + ]; + doHaddock = false; + doCheck = false; + description = "Streaming parser/renderer for the RSS standard"; + license = stdenv.lib.licenses.publicDomain; + }) {}; + "runmemo" = callPackage + ({ mkDerivation, stdenv }: + mkDerivation { + pname = "runmemo"; + version = "1.0.0.1"; + sha256 = "ba5ef3177f8fe5f443808e44f62d03b23ac19bbef7f708e40532031a3505d689"; + doHaddock = false; + doCheck = false; + homepage = "https://github.com/DanBurton/runmemo"; + description = "A simple memoization helper library"; + license = stdenv.lib.licenses.bsd3; + }) {}; + "rvar" = callPackage + ({ mkDerivation, base, MonadPrompt, mtl, random-source, stdenv + , transformers + }: + mkDerivation { + pname = "rvar"; + version = "0.2.0.3"; + sha256 = "d78aaf2ffdba182dda95d1692fec7abc5d77fa371120618a397b5675438c6bc0"; + libraryHaskellDepends = [ + base MonadPrompt mtl random-source transformers + ]; + doHaddock = false; + doCheck = false; + homepage = "https://github.com/mokus0/random-fu"; + description = "Random Variables"; + license = stdenv.lib.licenses.publicDomain; + }) {}; + "s3-signer" = callPackage + ({ mkDerivation, base, base64-bytestring, blaze-builder, byteable + , bytestring, case-insensitive, cryptohash, http-types, stdenv + , time, utf8-string + }: + mkDerivation { + pname = "s3-signer"; + version = "0.5.0.0"; + sha256 = "d73671d5bda0f5f627bbd876916341985c281c3572e6f8406cdf2f14ed9188e4"; + libraryHaskellDepends = [ + base base64-bytestring blaze-builder byteable bytestring + case-insensitive cryptohash http-types time utf8-string + ]; + doHaddock = false; + doCheck = false; + homepage = "https://github.com/dmjio/s3-signer"; + description = "Pre-signed Amazon S3 URLs"; + license = stdenv.lib.licenses.bsd3; + }) {}; + "safe" = callPackage + ({ mkDerivation, base, stdenv }: + mkDerivation { + pname = "safe"; + version = "0.3.17"; + sha256 = "79c5c41e7151906969133ea21af9f7e8d25c18315886e23d0bdf6faa8b537e5c"; + libraryHaskellDepends = [ base ]; + doHaddock = false; + doCheck = false; + homepage = "https://github.com/ndmitchell/safe#readme"; + description = "Library of safe (exception free) functions"; + license = stdenv.lib.licenses.bsd3; + }) {}; + "safe-exceptions" = callPackage + ({ mkDerivation, base, deepseq, exceptions, stdenv, transformers }: + mkDerivation { + pname = "safe-exceptions"; + version = "0.1.7.0"; + sha256 = "18cddc587b52b6faa0287fb6ad6c964d1562571ea2c8ff57a194dd54b5fba069"; + revision = "4"; + editedCabalFile = "0fid41gishzsyb47wzxhd5falandfirqcp760hcja81qjpfmqd32"; + libraryHaskellDepends = [ base deepseq exceptions transformers ]; + doHaddock = false; + doCheck = false; + homepage = "https://github.com/fpco/safe-exceptions#readme"; + description = "Safe, consistent, and easy exception handling"; + license = stdenv.lib.licenses.mit; + }) {}; + "safe-exceptions-checked" = callPackage + ({ mkDerivation, base, deepseq, safe-exceptions, stdenv + , transformers + }: + mkDerivation { + pname = "safe-exceptions-checked"; + version = "0.1.0"; + sha256 = "d807552b828de308d80805f65ee41f3e25571506b10e6b28b0b81de4aec0ca3f"; + revision = "3"; + editedCabalFile = "004id0k46j545zvkldfcv5qjgxzl35brm9h6fq72y43b9hl2y55f"; + libraryHaskellDepends = [ + base deepseq safe-exceptions transformers + ]; + doHaddock = false; + doCheck = false; + homepage = "https://github.com/mitchellwrosen/safe-exceptions-checked#readme"; + description = "Safe, checked exceptions"; + license = stdenv.lib.licenses.bsd3; + }) {}; + "safe-foldable" = callPackage + ({ mkDerivation, base, stdenv }: + mkDerivation { + pname = "safe-foldable"; + version = "0.1.0.0"; + sha256 = "ca7f2ecc0e799c239df8ce56e8592fb8b8264c229ab4e1c66e0f821d299007d1"; + libraryHaskellDepends = [ base ]; + doHaddock = false; + doCheck = false; + homepage = "https://github.com/tejon/safe-foldable#readme"; + description = "Safe wrappers for null-partial Foldable operations"; + license = stdenv.lib.licenses.mit; + }) {}; + "safe-money" = callPackage + ({ mkDerivation, aeson, base, binary, cereal, constraints, deepseq + , hashable, serialise, stdenv, store, text, vector-space, xmlbf + }: + mkDerivation { + pname = "safe-money"; + version = "0.6"; + sha256 = "f9fccbbce2b81d8b54c920156ed9b77298598a7242bad98216e959a677b20fd1"; + libraryHaskellDepends = [ + aeson base binary cereal constraints deepseq hashable serialise + store text vector-space xmlbf + ]; + doHaddock = false; + doCheck = false; + homepage = "https://github.com/k0001/safe-money"; + description = "Type-safe and lossless encoding and manipulation of money, fiat currencies, crypto currencies and precious metals"; + license = stdenv.lib.licenses.bsd3; + }) {}; + "safecopy" = callPackage + ({ mkDerivation, array, base, bytestring, cereal, containers + , old-time, stdenv, template-haskell, text, time, vector + }: + mkDerivation { + pname = "safecopy"; + version = "0.9.4.1"; + sha256 = "1476c8c135baaca93ba232495b8d2a86047954e7f4439eafa28ee0763a500e84"; + libraryHaskellDepends = [ + array base bytestring cereal containers old-time template-haskell + text time vector + ]; + doHaddock = false; + doCheck = false; + homepage = "https://github.com/acid-state/safecopy"; + description = "Binary serialization with version control"; + license = stdenv.lib.licenses.publicDomain; + }) {}; + "safeio" = callPackage + ({ mkDerivation, base, bytestring, conduit, conduit-combinators + , directory, exceptions, filepath, resourcet, stdenv, unix + }: + mkDerivation { + pname = "safeio"; + version = "0.0.5.0"; + sha256 = "d5799b6a6cd36e8f5442d991ed3a2076b10e0e3131269a2090b8c9c5c001e311"; + libraryHaskellDepends = [ + base bytestring conduit conduit-combinators directory exceptions + filepath resourcet unix + ]; + doHaddock = false; + doCheck = false; + homepage = "https://github.com/luispedro/safeio#readme"; + description = "Write output to disk atomically"; + license = stdenv.lib.licenses.mit; + }) {}; + "saltine" = callPackage + ({ mkDerivation, base, bytestring, libsodium, profunctors, stdenv + }: + mkDerivation { + pname = "saltine"; + version = "0.1.0.1"; + sha256 = "85290686e6482fdef5af566e7f51142e6d28bcb03f9ffb211f13da153be0a316"; + libraryHaskellDepends = [ base bytestring profunctors ]; + libraryPkgconfigDepends = [ libsodium ]; + doHaddock = false; + doCheck = false; + description = "Cryptography that's easy to digest (NaCl/libsodium bindings)"; + license = stdenv.lib.licenses.mit; + }) {inherit (pkgs) libsodium;}; + "salve" = callPackage + ({ mkDerivation, base, stdenv }: + mkDerivation { + pname = "salve"; + version = "1.0.4"; + sha256 = "6d4b6b0e58c009b182897f1c762f0b67c38670864fa084e9188e0eadab3e3f61"; + libraryHaskellDepends = [ base ]; + doHaddock = false; + doCheck = false; + homepage = "https://github.com/tfausak/salve#readme"; + description = "Semantic version numbers and constraints"; + license = stdenv.lib.licenses.mit; + }) {}; + "sample-frame" = callPackage + ({ mkDerivation, base, QuickCheck, stdenv, storable-record }: + mkDerivation { + pname = "sample-frame"; + version = "0.0.3"; + sha256 = "5baf301a4f7b2d52e6b9b9c06b10afd3938de0be6d09736d0188616cd9027247"; + isLibrary = true; + isExecutable = true; + libraryHaskellDepends = [ base QuickCheck storable-record ]; + doHaddock = false; + doCheck = false; + homepage = "http://www.haskell.org/haskellwiki/Synthesizer"; + description = "Handling of samples in an (audio) signal"; + license = stdenv.lib.licenses.bsd3; + }) {}; + "sample-frame-np" = callPackage + ({ mkDerivation, base, numeric-prelude, sample-frame, stdenv }: + mkDerivation { + pname = "sample-frame-np"; + version = "0.0.4.1"; + sha256 = "b1db7621b07503f5fe49390bf1e1b4257c49f4760d617121a23d845278f93624"; + libraryHaskellDepends = [ base numeric-prelude sample-frame ]; + doHaddock = false; + doCheck = false; + homepage = "http://www.haskell.org/haskellwiki/Synthesizer"; + description = "Orphan instances for types from sample-frame and numericprelude"; + license = stdenv.lib.licenses.bsd3; + }) {}; + "sampling" = callPackage + ({ mkDerivation, base, containers, foldl, mwc-random, primitive + , stdenv, vector + }: + mkDerivation { + pname = "sampling"; + version = "0.3.3"; + sha256 = "c8bedc93d61e6b1939f6802d7e21003e9e36abdd6f21a9651179d4d82aa00e0d"; + revision = "1"; + editedCabalFile = "168k8ykppa8pikfxy1gmby63kfzr833vswh8wcchz8li9vkd4w2h"; + libraryHaskellDepends = [ + base containers foldl mwc-random primitive vector + ]; + doHaddock = false; + doCheck = false; + homepage = "https://github.com/jtobin/sampling"; + description = "Sample values from collections"; + license = stdenv.lib.licenses.mit; + }) {}; + "sandi" = callPackage + ({ mkDerivation, base, bytestring, conduit, exceptions, stdenv + , stringsearch + }: + mkDerivation { + pname = "sandi"; + version = "0.4.2"; + sha256 = "2bc1fc4f8e71009adc9f38304f63684f2795c31077670214147f261bd2bc7337"; + libraryHaskellDepends = [ + base bytestring conduit exceptions stringsearch + ]; + doHaddock = false; + doCheck = false; + homepage = "http://hackage.haskell.org/package/sandi"; + description = "Data encoding library"; + license = stdenv.lib.licenses.bsd3; + }) {}; + "sandman" = callPackage + ({ mkDerivation, base, Cabal, containers, directory, filepath + , optparse-applicative, process, stdenv, text, unix-compat + }: + mkDerivation { + pname = "sandman"; + version = "0.2.0.1"; + sha256 = "407d283e1fc4a2a369615bac569683bf399ac14ddbce1331850bfe1d7837ce64"; + isLibrary = false; + isExecutable = true; + executableHaskellDepends = [ + base Cabal containers directory filepath optparse-applicative + process text unix-compat + ]; + doHaddock = false; + doCheck = false; + homepage = "https://github.com/abhinav/sandman#readme"; + description = "Manages Cabal sandboxes to avoid rebuilding packages"; + license = stdenv.lib.licenses.mit; + }) {}; + "say" = callPackage + ({ mkDerivation, base, bytestring, stdenv, text, transformers }: + mkDerivation { + pname = "say"; + version = "0.1.0.0"; + sha256 = "f26fdb94ed81a2ae503beca0dcea74da7ee37408ba2e41ab3fdcaa9a7622fc40"; + libraryHaskellDepends = [ base bytestring text transformers ]; + doHaddock = false; + doCheck = false; + homepage = "https://github.com/fpco/say#readme"; + description = "Initial project template from stack"; + license = stdenv.lib.licenses.mit; + }) {}; + "sbp" = callPackage + ({ mkDerivation, aeson, array, base, base64-bytestring + , basic-prelude, binary, binary-conduit, bytestring, conduit + , conduit-extra, data-binary-ieee754, lens, lens-aeson, monad-loops + , resourcet, stdenv, template-haskell, text, time, yaml + }: + mkDerivation { + pname = "sbp"; + version = "2.3.16"; + sha256 = "e3b9aec3bd3caeece563cce902862ceac9f50f55131a7ccb7591fe75882d1155"; + isLibrary = true; + isExecutable = true; + libraryHaskellDepends = [ + aeson array base base64-bytestring basic-prelude binary bytestring + data-binary-ieee754 lens lens-aeson monad-loops template-haskell + text + ]; + executableHaskellDepends = [ + aeson base basic-prelude binary-conduit bytestring conduit + conduit-extra resourcet time yaml + ]; + doHaddock = false; + doCheck = false; + homepage = "https://github.com/swift-nav/libsbp"; + description = "SwiftNav's SBP Library"; + license = stdenv.lib.licenses.lgpl3; + }) {}; + "scalendar" = callPackage + ({ mkDerivation, base, containers, stdenv, text, time }: + mkDerivation { + pname = "scalendar"; + version = "1.2.0"; + sha256 = "f5c85e8da39e7eb22068032c4c5c32751ebbed61d0ee9679cadac904dde163ac"; + libraryHaskellDepends = [ base containers text time ]; + doHaddock = false; + doCheck = false; + homepage = "https://github.com/stackbuilders/scalendar"; + description = "A library for handling calendars and resource availability over time"; + license = stdenv.lib.licenses.mit; + }) {}; + "scalpel" = callPackage + ({ mkDerivation, base, bytestring, curl, data-default, scalpel-core + , stdenv, tagsoup, text + }: + mkDerivation { + pname = "scalpel"; + version = "0.5.1"; + sha256 = "20df66433570a2ca754f14058a47fb00519d9a75bb822fc3fd1769a83c608b0d"; + libraryHaskellDepends = [ + base bytestring curl data-default scalpel-core tagsoup text + ]; + doHaddock = false; + doCheck = false; + homepage = "https://github.com/fimad/scalpel"; + description = "A high level web scraping library for Haskell"; + license = stdenv.lib.licenses.asl20; + }) {}; + "scalpel-core" = callPackage + ({ mkDerivation, base, bytestring, containers, data-default, fail + , regex-base, regex-tdfa, stdenv, tagsoup, text, vector + }: + mkDerivation { + pname = "scalpel-core"; + version = "0.5.1"; + sha256 = "8c05b86853b737fbed4144dc9c7bbb7743525c305f9529f59776df97bfe229a9"; + libraryHaskellDepends = [ + base bytestring containers data-default fail regex-base regex-tdfa + tagsoup text vector + ]; + doHaddock = false; + doCheck = false; + homepage = "https://github.com/fimad/scalpel"; + description = "A high level web scraping library for Haskell"; + license = stdenv.lib.licenses.asl20; + }) {}; + "scanner" = callPackage + ({ mkDerivation, base, bytestring, stdenv }: + mkDerivation { + pname = "scanner"; + version = "0.2"; + sha256 = "3a020d68a0372a5211c72e55eeb299738ea608d17184bc68f74d31ebe667a5e9"; + libraryHaskellDepends = [ base bytestring ]; + doHaddock = false; + doCheck = false; + homepage = "https://github.com/Yuras/scanner"; + description = "Fast non-backtracking incremental combinator parsing for bytestrings"; + license = stdenv.lib.licenses.bsd3; + }) {}; + "scientific" = callPackage + ({ mkDerivation, base, binary, bytestring, containers, deepseq + , hashable, integer-gmp, integer-logarithms, primitive, stdenv + , text + }: + mkDerivation { + pname = "scientific"; + version = "0.3.6.2"; + sha256 = "278d0afc87450254f8a76eab21b5583af63954efc9b74844a17a21a68013140f"; + libraryHaskellDepends = [ + base binary bytestring containers deepseq hashable integer-gmp + integer-logarithms primitive text + ]; + doHaddock = false; + doCheck = false; + homepage = "https://github.com/basvandijk/scientific"; + description = "Numbers represented using scientific notation"; + license = stdenv.lib.licenses.bsd3; + }) {}; + "scotty" = callPackage + ({ mkDerivation, aeson, base, blaze-builder, bytestring + , case-insensitive, data-default-class, exceptions, fail + , http-types, monad-control, mtl, nats, network, regex-compat + , stdenv, text, transformers, transformers-base + , transformers-compat, wai, wai-extra, warp + }: + mkDerivation { + pname = "scotty"; + version = "0.11.2"; + sha256 = "1dd86f545e415baa6780fef3be8b3a68d8267e5c042972ef9990dc02a47d9da2"; + revision = "1"; + editedCabalFile = "1h4fk7q8x7cvlqq4bbmdh465s6a8955bgchm121fvk08x7rm3yz3"; + libraryHaskellDepends = [ + aeson base blaze-builder bytestring case-insensitive + data-default-class exceptions fail http-types monad-control mtl + nats network regex-compat text transformers transformers-base + transformers-compat wai wai-extra warp + ]; + doHaddock = false; + doCheck = false; + homepage = "https://github.com/scotty-web/scotty"; + description = "Haskell web framework inspired by Ruby's Sinatra, using WAI and Warp"; + license = stdenv.lib.licenses.bsd3; + }) {}; + "scrypt" = callPackage + ({ mkDerivation, base, base64-bytestring, bytestring, entropy + , stdenv + }: + mkDerivation { + pname = "scrypt"; + version = "0.5.0"; + sha256 = "3ec0a622393e2a4dbbce4c899602c848d924f8516688491b1162331b7093d9b2"; + libraryHaskellDepends = [ + base base64-bytestring bytestring entropy + ]; + doHaddock = false; + doCheck = false; + homepage = "http://github.com/informatikr/scrypt"; + description = "Stronger password hashing via sequential memory-hard functions"; + license = stdenv.lib.licenses.bsd3; + }) {}; + "sdl2" = callPackage + ({ mkDerivation, base, bytestring, exceptions, linear, SDL2 + , StateVar, stdenv, text, transformers, vector + }: + mkDerivation { + pname = "sdl2"; + version = "2.4.1.0"; + sha256 = "21a569c0c19f8ff2bbe1cf1d3eb32f65e8143806de353cedd240df5e9d088b5c"; + isLibrary = true; + isExecutable = true; + enableSeparateDataOutput = true; + libraryHaskellDepends = [ + base bytestring exceptions linear StateVar text transformers vector + ]; + librarySystemDepends = [ SDL2 ]; + libraryPkgconfigDepends = [ SDL2 ]; + doHaddock = false; + doCheck = false; + description = "Both high- and low-level bindings to the SDL library (version 2.0.4+)."; + license = stdenv.lib.licenses.bsd3; + }) {inherit (pkgs) SDL2;}; + "sdl2-gfx" = callPackage + ({ mkDerivation, base, bytestring, lifted-base, linear + , monad-control, SDL2, sdl2, SDL2_gfx, stdenv, template-haskell + , text, transformers, vector + }: + mkDerivation { + pname = "sdl2-gfx"; + version = "0.2"; + sha256 = "8c1e10b7a675d782cd650820c75c4ef9225718ad6aaa3f8db02e869b7720c50d"; + isLibrary = true; + isExecutable = true; + libraryHaskellDepends = [ + base bytestring lifted-base linear monad-control sdl2 + template-haskell text transformers vector + ]; + libraryPkgconfigDepends = [ SDL2 SDL2_gfx ]; + executableHaskellDepends = [ base linear sdl2 vector ]; + doHaddock = false; + doCheck = false; + description = "Bindings to SDL2_gfx"; + license = stdenv.lib.licenses.mit; + }) {inherit (pkgs) SDL2; inherit (pkgs) SDL2_gfx;}; + "sdl2-image" = callPackage + ({ mkDerivation, base, bytestring, SDL2, sdl2, SDL2_image, stdenv + , template-haskell, text, transformers + }: + mkDerivation { + pname = "sdl2-image"; + version = "2.0.0"; + sha256 = "399742b2b7e64fe4e58c9d8a44ad29b2c355589233535238f8c9b371de6c26df"; + isLibrary = true; + isExecutable = true; + libraryHaskellDepends = [ + base bytestring sdl2 template-haskell text transformers + ]; + libraryPkgconfigDepends = [ SDL2 SDL2_image ]; + executableHaskellDepends = [ base sdl2 text ]; + doHaddock = false; + doCheck = false; + description = "Bindings to SDL2_image"; + license = stdenv.lib.licenses.mit; + }) {inherit (pkgs) SDL2; inherit (pkgs) SDL2_image;}; + "sdl2-mixer" = callPackage + ({ mkDerivation, base, bytestring, data-default-class, lifted-base + , monad-control, sdl2, SDL2_mixer, stdenv, template-haskell, vector + }: + mkDerivation { + pname = "sdl2-mixer"; + version = "1.1.0"; + sha256 = "0f4c15a1bda7b265923278641d686756292fc2a8f1c5ced7f98916cc98df0acd"; + isLibrary = true; + isExecutable = true; + libraryHaskellDepends = [ + base bytestring data-default-class lifted-base monad-control sdl2 + template-haskell vector + ]; + librarySystemDepends = [ SDL2_mixer ]; + libraryPkgconfigDepends = [ SDL2_mixer ]; + doHaddock = false; + doCheck = false; + description = "Bindings to SDL2_mixer"; + license = stdenv.lib.licenses.bsd3; + }) {inherit (pkgs) SDL2_mixer;}; + "sdl2-ttf" = callPackage + ({ mkDerivation, base, bytestring, SDL2, sdl2, SDL2_ttf, stdenv + , template-haskell, text, transformers + }: + mkDerivation { + pname = "sdl2-ttf"; + version = "2.1.0"; + sha256 = "c7656fe923e618d3919d47ac753451b08e6d709372380e15bd3d75b39f2c80f7"; + isLibrary = true; + isExecutable = true; + libraryHaskellDepends = [ + base bytestring sdl2 template-haskell text transformers + ]; + libraryPkgconfigDepends = [ SDL2 SDL2_ttf ]; + doHaddock = false; + doCheck = false; + description = "Bindings to SDL2_ttf"; + license = stdenv.lib.licenses.bsd3; + }) {inherit (pkgs) SDL2; inherit (pkgs) SDL2_ttf;}; + "search-algorithms" = callPackage + ({ mkDerivation, base, containers, stdenv }: + mkDerivation { + pname = "search-algorithms"; + version = "0.3.0"; + sha256 = "4a9d03c97abfd83fae582e4c3425a105b8649b8e69a2c1e170dbbabd8820db10"; + libraryHaskellDepends = [ base containers ]; + doHaddock = false; + doCheck = false; + homepage = "https://github.com/devonhollowood/search-algorithms#readme"; + description = "Common graph search algorithms"; + license = stdenv.lib.licenses.bsd3; + }) {}; + "securemem" = callPackage + ({ mkDerivation, base, byteable, bytestring, ghc-prim, memory + , stdenv + }: + mkDerivation { + pname = "securemem"; + version = "0.1.10"; + sha256 = "32895a4748508da58207b4867266601af6259b7109af80bbf5d2e9e598e016a6"; + libraryHaskellDepends = [ + base byteable bytestring ghc-prim memory + ]; + doHaddock = false; + doCheck = false; + homepage = "https://github.com/vincenthz/hs-securemem"; + description = "abstraction to an auto scrubbing and const time eq, memory chunk"; + license = stdenv.lib.licenses.bsd3; + }) {}; + "selda" = callPackage + ({ mkDerivation, base, bytestring, exceptions, hashable, mtl + , psqueues, stdenv, text, time, unordered-containers + }: + mkDerivation { + pname = "selda"; + version = "0.2.0.0"; + sha256 = "d226aff054c80864ffab2b50898a6109d0d8adeaee42f06074d4831a1a692ad1"; + libraryHaskellDepends = [ + base bytestring exceptions hashable mtl psqueues text time + unordered-containers + ]; + doHaddock = false; + doCheck = false; + homepage = "https://selda.link"; + description = "Multi-backend, high-level EDSL for interacting with SQL databases"; + license = stdenv.lib.licenses.mit; + }) {}; + "selda-postgresql" = callPackage + ({ mkDerivation, base, bytestring, exceptions, postgresql-libpq + , selda, stdenv, text + }: + mkDerivation { + pname = "selda-postgresql"; + version = "0.1.7.2"; + sha256 = "ff781255b5faa9e9197fd3d298e8e11f81c13a0f01d072c72028003563fee51b"; + revision = "1"; + editedCabalFile = "08f2xdfpmbwhrwkjaqfmd9k25c3xn3p477d7a1mnnn7kf7328782"; + libraryHaskellDepends = [ + base bytestring exceptions postgresql-libpq selda text + ]; + doHaddock = false; + doCheck = false; + homepage = "https://github.com/valderman/selda"; + description = "PostgreSQL backend for the Selda database EDSL"; + license = stdenv.lib.licenses.mit; + }) {}; + "selda-sqlite" = callPackage + ({ mkDerivation, base, direct-sqlite, directory, exceptions, selda + , stdenv, text + }: + mkDerivation { + pname = "selda-sqlite"; + version = "0.1.6.0"; + sha256 = "c67ba89114a82ece42b7e478bcf480ae0241cefb41e2e9b340a268f9f08be390"; + revision = "2"; + editedCabalFile = "198pg9i0lfx3fwf7b7cw0x5kial6vbf0dqwh18jnh7na3pyn1jr6"; + libraryHaskellDepends = [ + base direct-sqlite directory exceptions selda text + ]; + doHaddock = false; + doCheck = false; + homepage = "https://github.com/valderman/selda"; + description = "SQLite backend for the Selda database EDSL"; + license = stdenv.lib.licenses.mit; + }) {}; + "semigroupoid-extras" = callPackage + ({ mkDerivation, base, profunctors, semigroupoids, stdenv }: + mkDerivation { + pname = "semigroupoid-extras"; + version = "5"; + sha256 = "102e33b55cc3b15a1b714825a3703f3fc2bb09d8038404af442d35c0ac0c3832"; + libraryHaskellDepends = [ base profunctors semigroupoids ]; + doHaddock = false; + doCheck = false; + homepage = "http://github.com/ekmett/semigroupoid-extras"; + description = "Semigroupoids that depend on PolyKinds"; + license = stdenv.lib.licenses.bsd3; + }) {}; + "semigroupoids" = callPackage + ({ mkDerivation, base, base-orphans, bifunctors, Cabal + , cabal-doctest, comonad, containers, contravariant, distributive + , hashable, semigroups, stdenv, tagged, template-haskell + , transformers, transformers-compat, unordered-containers + }: + mkDerivation { + pname = "semigroupoids"; + version = "5.2.2"; + sha256 = "e4def54834cda65ac1e74e6f12a435410e19c1348e820434a30c491c8937299e"; + revision = "4"; + editedCabalFile = "0pqfrxzypjq6z8lgdkzq4vhcyqkpk5326hny0r6snpc3gm78r4ij"; + setupHaskellDepends = [ base Cabal cabal-doctest ]; + libraryHaskellDepends = [ + base base-orphans bifunctors comonad containers contravariant + distributive hashable semigroups tagged template-haskell + transformers transformers-compat unordered-containers + ]; + doHaddock = false; + doCheck = false; + homepage = "http://github.com/ekmett/semigroupoids"; + description = "Semigroupoids: Category sans id"; + license = stdenv.lib.licenses.bsd3; + }) {}; + "semigroups" = callPackage + ({ mkDerivation, base, stdenv }: + mkDerivation { + pname = "semigroups"; + version = "0.18.5"; + sha256 = "ab2a96af6e81e31b909c37ba65f436f1493dbf387cfe0de10b6586270c4ce29d"; + libraryHaskellDepends = [ base ]; + doHaddock = false; + doCheck = false; + homepage = "http://github.com/ekmett/semigroups/"; + description = "Anything that associates"; + license = stdenv.lib.licenses.bsd3; + }) {}; + "semiring-simple" = callPackage + ({ mkDerivation, base, stdenv }: + mkDerivation { + pname = "semiring-simple"; + version = "1.0.0.1"; + sha256 = "c08d1b533f4559fc55119f563a6cf3d74ad7c6f5916c2efe00b50d2a5169fd28"; + libraryHaskellDepends = [ base ]; + doHaddock = false; + doCheck = false; + description = "A module for dealing with semirings"; + license = stdenv.lib.licenses.bsd3; + }) {}; + "semver" = callPackage + ({ mkDerivation, attoparsec, base, deepseq, stdenv, text }: + mkDerivation { + pname = "semver"; + version = "0.3.3.1"; + sha256 = "36d3369706836d60f3bc517f30c6860734481866363723904b8768823b6bc8b1"; + libraryHaskellDepends = [ attoparsec base deepseq text ]; + doHaddock = false; + doCheck = false; + homepage = "https://github.com/brendanhay/semver"; + description = "Representation, manipulation, and de/serialisation of Semantic Versions"; + license = "unknown"; + }) {}; + "sendfile" = callPackage + ({ mkDerivation, base, bytestring, network, stdenv }: + mkDerivation { + pname = "sendfile"; + version = "0.7.9"; + sha256 = "102fdf6db8c00f5a5981c6eed5acba1368a2d79b2970ce5b22ceb180aa0fdc42"; + libraryHaskellDepends = [ base bytestring network ]; + doHaddock = false; + doCheck = false; + homepage = "http://hub.darcs.net/stepcut/sendfile"; + description = "A portable sendfile library"; + license = stdenv.lib.licenses.bsd3; + }) {}; + "seqalign" = callPackage + ({ mkDerivation, base, bytestring, stdenv, vector }: + mkDerivation { + pname = "seqalign"; + version = "0.2.0.4"; + sha256 = "4ea194658d865890157d3df882ed21b0c089cdff7f80ea613ae25c5f3d744305"; + libraryHaskellDepends = [ base bytestring vector ]; + doHaddock = false; + doCheck = false; + description = "Sequence Alignment"; + license = stdenv.lib.licenses.bsd3; + }) {}; + "serf" = callPackage + ({ mkDerivation, attoparsec, base, conduit, conduit-extra, mtl + , operational, process, resourcet, stdenv, text + }: + mkDerivation { + pname = "serf"; + version = "0.1.1.0"; + sha256 = "d6c9c6ddf99a2119c6686732caf9f04ef8e9c4df5519a8bbd4ac7f5531d4c067"; + libraryHaskellDepends = [ + attoparsec base conduit conduit-extra mtl operational process + resourcet text + ]; + doHaddock = false; + doCheck = false; + homepage = "http://github.com/sanetracker/serf"; + description = "Interact with Serf via Haskell"; + license = stdenv.lib.licenses.mit; + }) {}; + "servant" = callPackage + ({ mkDerivation, aeson, attoparsec, base, base-compat, bytestring + , Cabal, cabal-doctest, case-insensitive, http-api-data, http-media + , http-types, mmorph, mtl, natural-transformation, network-uri + , singleton-bool, stdenv, string-conversions, tagged, text, vault + }: + mkDerivation { + pname = "servant"; + version = "0.14.1"; + sha256 = "a7fa2f19dd8af4deec873290c29fac46cdfe716347cc44fcc0949a83b7577420"; + revision = "1"; + editedCabalFile = "1n9lwm77w0xi6jzqrhyn6akf71z140wngj4s5x2zkndq8wmg4rg4"; + setupHaskellDepends = [ base Cabal cabal-doctest ]; + libraryHaskellDepends = [ + aeson attoparsec base base-compat bytestring case-insensitive + http-api-data http-media http-types mmorph mtl + natural-transformation network-uri singleton-bool + string-conversions tagged text vault + ]; + doHaddock = false; + doCheck = false; + homepage = "http://haskell-servant.readthedocs.org/"; + description = "A family of combinators for defining webservices APIs"; + license = stdenv.lib.licenses.bsd3; + }) {}; + "servant-JuicyPixels" = callPackage + ({ mkDerivation, base, bytestring, http-media, JuicyPixels, servant + , servant-server, stdenv, wai, warp + }: + mkDerivation { + pname = "servant-JuicyPixels"; + version = "0.3.0.4"; + sha256 = "7b02f00ac8b78ffda49a96f2d1f39619ec19f244822d177928e75cd533cb9981"; + revision = "1"; + editedCabalFile = "185ym0ac6gx7f98pd92ykc1ib305lswzjzvykly4ij9vk85jn0ax"; + isLibrary = true; + isExecutable = true; + libraryHaskellDepends = [ + base bytestring http-media JuicyPixels servant + ]; + executableHaskellDepends = [ + base JuicyPixels servant servant-server wai warp + ]; + doHaddock = false; + doCheck = false; + homepage = "https://github.com/tvh/servant-JuicyPixels"; + description = "Servant support for JuicyPixels"; + license = stdenv.lib.licenses.bsd3; + }) {}; + "servant-auth" = callPackage + ({ mkDerivation, base, stdenv }: + mkDerivation { + pname = "servant-auth"; + version = "0.3.2.0"; + sha256 = "7bb4d5118c072cb3845aaba4287b2d5e34e5ccca96916895456a828bf7a9418b"; + revision = "1"; + editedCabalFile = "10ss4v45lclf5n0k6rch22zzs59v7p5ppd04dbc97pqxiygpbnd9"; + libraryHaskellDepends = [ base ]; + doHaddock = false; + doCheck = false; + homepage = "http://github.com/haskell-servant/servant-auth#readme"; + description = "Authentication combinators for servant"; + license = stdenv.lib.licenses.bsd3; + }) {}; + "servant-auth-client" = callPackage + ({ mkDerivation, base, bytestring, containers, servant + , servant-auth, servant-client-core, stdenv, text + }: + mkDerivation { + pname = "servant-auth-client"; + version = "0.3.3.0"; + sha256 = "490ac57150b59c567ef567120a6704cfc2184f7be8e6edaab26ad818dee5b3df"; + revision = "2"; + editedCabalFile = "05ibhx700r0xn746g691ypysnjgxqb0lkq2gjrih5ylzc7nfvv2s"; + libraryHaskellDepends = [ + base bytestring containers servant servant-auth servant-client-core + text + ]; + doHaddock = false; + doCheck = false; + homepage = "http://github.com/haskell-servant/servant-auth#readme"; + description = "servant-client/servant-auth compatibility"; + license = stdenv.lib.licenses.bsd3; + }) {}; + "servant-auth-docs" = callPackage + ({ mkDerivation, base, Cabal, cabal-doctest, lens, servant + , servant-auth, servant-docs, stdenv, text + }: + mkDerivation { + pname = "servant-auth-docs"; + version = "0.2.10.0"; + sha256 = "adf3c33ce4134a78ae7a5c06092ea5812c99d4b942ff2dd685995eb3b2b53e48"; + revision = "2"; + editedCabalFile = "0309a6pc8jj24xwqmzj1yslgij9g212hnaqh2qkcvlm6k6riffil"; + setupHaskellDepends = [ base Cabal cabal-doctest ]; + libraryHaskellDepends = [ + base lens servant servant-auth servant-docs text + ]; + doHaddock = false; + doCheck = false; + homepage = "http://github.com/haskell-servant/servant-auth#readme"; + description = "servant-docs/servant-auth compatibility"; + license = stdenv.lib.licenses.bsd3; + }) {}; + "servant-auth-server" = callPackage + ({ mkDerivation, aeson, base, base64-bytestring, blaze-builder + , bytestring, bytestring-conversion, case-insensitive, cookie + , crypto-api, data-default-class, entropy, http-api-data + , http-types, jose, lens, monad-time, mtl, servant, servant-auth + , servant-server, stdenv, tagged, text, time, unordered-containers + , wai + }: + mkDerivation { + pname = "servant-auth-server"; + version = "0.4.0.0"; + sha256 = "37122dc5e51a7ead49d6e8e727ec6df3d5026754c0697273e719fa69cf1e8a3b"; + revision = "1"; + editedCabalFile = "17lhmg8jgr7xgv6s6ybvyvbjpapfs7v2icjpgnk70nx0f3mbz808"; + libraryHaskellDepends = [ + aeson base base64-bytestring blaze-builder bytestring + bytestring-conversion case-insensitive cookie crypto-api + data-default-class entropy http-api-data http-types jose lens + monad-time mtl servant servant-auth servant-server tagged text time + unordered-containers wai + ]; + doHaddock = false; + doCheck = false; + homepage = "http://github.com/haskell-servant/servant-auth#readme"; + description = "servant-server/servant-auth compatibility"; + license = stdenv.lib.licenses.bsd3; + }) {}; + "servant-auth-swagger" = callPackage + ({ mkDerivation, base, lens, servant, servant-auth, servant-swagger + , stdenv, swagger2, text + }: + mkDerivation { + pname = "servant-auth-swagger"; + version = "0.2.10.0"; + sha256 = "50a783639eb882fd5047d69245f7770817658814d8c409b547ebdddae05acd12"; + revision = "1"; + editedCabalFile = "105rniz4cmmwr0ynyv75s4ap1fgfwxy2k5mvvj66gwpvzmj55cnx"; + libraryHaskellDepends = [ + base lens servant servant-auth servant-swagger swagger2 text + ]; + doHaddock = false; + doCheck = false; + homepage = "http://github.com/haskell-servant/servant-auth#readme"; + description = "servant-swagger/servant-auth compatibility"; + license = stdenv.lib.licenses.bsd3; + }) {}; + "servant-blaze" = callPackage + ({ mkDerivation, base, blaze-html, http-media, servant, stdenv }: + mkDerivation { + pname = "servant-blaze"; + version = "0.8"; + sha256 = "46ea88550123d765b2d09073370d0530a51878e7fdf2cf20b070be1f2f10ae94"; + revision = "2"; + editedCabalFile = "1cfla60vn4kk5gb7fawlp34jr2k6b2fprysq05561wdfv990x4bj"; + libraryHaskellDepends = [ base blaze-html http-media servant ]; + doHaddock = false; + doCheck = false; + homepage = "http://haskell-servant.readthedocs.org/"; + description = "Blaze-html support for servant"; + license = stdenv.lib.licenses.bsd3; + }) {}; + "servant-cassava" = callPackage + ({ mkDerivation, base, base-compat, bytestring, cassava, http-media + , servant, stdenv, vector + }: + mkDerivation { + pname = "servant-cassava"; + version = "0.10"; + sha256 = "9b2c5d906f3a4bb2767b2ce91f12a74e24adceadd296220b5d7216c5e1f3560e"; + revision = "4"; + editedCabalFile = "0kk7vqnh5ycrvhrvhi3ahva6v56fvi17k3qrh8a8qnhx25094jaj"; + libraryHaskellDepends = [ + base base-compat bytestring cassava http-media servant vector + ]; + doHaddock = false; + doCheck = false; + homepage = "http://haskell-servant.readthedocs.org/"; + description = "Servant CSV content-type for cassava"; + license = stdenv.lib.licenses.bsd3; + }) {}; + "servant-checked-exceptions" = callPackage + ({ mkDerivation, aeson, base, bytestring, deepseq, http-media + , http-types, profunctors, servant, servant-checked-exceptions-core + , servant-client, servant-client-core, servant-docs, servant-server + , stdenv, tagged, text, wai, world-peace + }: + mkDerivation { + pname = "servant-checked-exceptions"; + version = "2.0.0.0"; + sha256 = "a7f282857e56d5d1a59d055cf1936cab96a2cdc2f94a79ff736f7ef1cf56f688"; + isLibrary = true; + isExecutable = true; + libraryHaskellDepends = [ + aeson base bytestring deepseq http-media http-types profunctors + servant servant-checked-exceptions-core servant-client + servant-client-core servant-docs servant-server tagged text wai + world-peace + ]; + doHaddock = false; + doCheck = false; + homepage = "https://github.com/cdepillabout/servant-checked-exceptions"; + description = "Checked exceptions for Servant APIs"; + license = stdenv.lib.licenses.bsd3; + }) {}; + "servant-checked-exceptions-core" = callPackage + ({ mkDerivation, aeson, base, bytestring, deepseq, http-media + , http-types, profunctors, servant, servant-docs, stdenv, tagged + , text, world-peace + }: + mkDerivation { + pname = "servant-checked-exceptions-core"; + version = "2.0.0.0"; + sha256 = "aad3513403241bb06aadc605e6af88a5f3aaa0f1f208aafed6d69e15a23ab248"; + isLibrary = true; + isExecutable = true; + libraryHaskellDepends = [ + aeson base bytestring deepseq http-media http-types profunctors + servant servant-docs tagged text world-peace + ]; + doHaddock = false; + doCheck = false; + homepage = "https://github.com/cdepillabout/servant-checked-exceptions"; + description = "Checked exceptions for Servant APIs"; + license = stdenv.lib.licenses.bsd3; + }) {}; + "servant-client" = callPackage + ({ mkDerivation, base, base-compat, bytestring, containers + , exceptions, http-client, http-media, http-types, monad-control + , mtl, semigroupoids, servant-client-core, stdenv, stm, text, time + , transformers, transformers-base, transformers-compat + }: + mkDerivation { + pname = "servant-client"; + version = "0.14"; + sha256 = "c6860bd46c2ee52412cc8c080091a9d8da28d5e44a47cba468e6eee34f01224b"; + revision = "3"; + editedCabalFile = "1rjjqxyyf51bjq8li8yilng5pjd9a5n3d8zniqmfw3hys6dz8n8g"; + libraryHaskellDepends = [ + base base-compat bytestring containers exceptions http-client + http-media http-types monad-control mtl semigroupoids + servant-client-core stm text time transformers transformers-base + transformers-compat + ]; + doHaddock = false; + doCheck = false; + homepage = "http://haskell-servant.readthedocs.org/"; + description = "automatical derivation of querying functions for servant webservices"; + license = stdenv.lib.licenses.bsd3; + }) {}; + "servant-client-core" = callPackage + ({ mkDerivation, base, base-compat, base64-bytestring, bytestring + , containers, exceptions, free, generics-sop, http-api-data + , http-media, http-types, network-uri, safe, servant, stdenv, text + }: + mkDerivation { + pname = "servant-client-core"; + version = "0.14.1"; + sha256 = "c24e7b6d1a9d6b33ca35fcea671791f5dbb381fe49f19497a0467a43f954d761"; + revision = "2"; + editedCabalFile = "02pvrccfwvvy53gma56jcqnbia3pm1pncyghdkjp519bwff9iwvb"; + libraryHaskellDepends = [ + base base-compat base64-bytestring bytestring containers exceptions + free generics-sop http-api-data http-media http-types network-uri + safe servant text + ]; + doHaddock = false; + doCheck = false; + homepage = "http://haskell-servant.readthedocs.org/"; + description = "Core functionality and class for client function generation for servant APIs"; + license = stdenv.lib.licenses.bsd3; + }) {}; + "servant-dhall" = callPackage + ({ mkDerivation, base, base-compat, bytestring, dhall, http-media + , megaparsec, prettyprinter, servant, stdenv, text + }: + mkDerivation { + pname = "servant-dhall"; + version = "0.1.0.1"; + sha256 = "940eca05ad268137082478009c752c6333c0b1d92e57b13770046eeaac8b31fb"; + revision = "3"; + editedCabalFile = "13mq4pwffxqpjirb6rfhzd2xqhm0xyycl98h6kf4j0ic38g3saz1"; + libraryHaskellDepends = [ + base base-compat bytestring dhall http-media megaparsec + prettyprinter servant text + ]; + doHaddock = false; + doCheck = false; + homepage = "http://haskell-servant.readthedocs.org/"; + description = "Servant Dhall content-type"; + license = stdenv.lib.licenses.bsd3; + }) {}; + "servant-docs" = callPackage + ({ mkDerivation, aeson, aeson-pretty, base, base-compat, bytestring + , case-insensitive, control-monad-omega, hashable, http-media + , http-types, lens, servant, stdenv, string-conversions, text + , unordered-containers + }: + mkDerivation { + pname = "servant-docs"; + version = "0.11.2"; + sha256 = "6b280a8d97d295933f5b4a5442b0c54567299bcc8dd62b7c2890864af7ddd4f4"; + revision = "6"; + editedCabalFile = "0w9yi4rmfq4irmnia9rl9pb66ix086ic9nd0grspnk54ib7970cl"; + isLibrary = true; + isExecutable = true; + libraryHaskellDepends = [ + aeson aeson-pretty base base-compat bytestring case-insensitive + control-monad-omega hashable http-media http-types lens servant + string-conversions text unordered-containers + ]; + executableHaskellDepends = [ + aeson base lens servant string-conversions text + ]; + doHaddock = false; + doCheck = false; + homepage = "http://haskell-servant.readthedocs.org/"; + description = "generate API docs for your servant webservice"; + license = stdenv.lib.licenses.bsd3; + }) {}; + "servant-elm" = callPackage + ({ mkDerivation, base, elm-export, lens, servant, servant-foreign + , stdenv, text, wl-pprint-text + }: + mkDerivation { + pname = "servant-elm"; + version = "0.5.0.0"; + sha256 = "d9d96eeaf209f93791f3c81a5b2afad7be443f9af29f362ec17661436895b950"; + isLibrary = true; + isExecutable = true; + libraryHaskellDepends = [ + base elm-export lens servant servant-foreign text wl-pprint-text + ]; + doHaddock = false; + doCheck = false; + homepage = "http://github.com/mattjbray/servant-elm#readme"; + description = "Automatically derive Elm functions to query servant webservices"; + license = stdenv.lib.licenses.bsd3; + }) {}; + "servant-exceptions" = callPackage + ({ mkDerivation, aeson, base, exceptions, http-media, http-types + , mtl, servant, servant-server, stdenv, text, wai, warp + }: + mkDerivation { + pname = "servant-exceptions"; + version = "0.1.1"; + sha256 = "652b9fdc463200ebb8c2b2e0757f9d90662408bf45a657b3f719d0a36d34abe1"; + isLibrary = true; + isExecutable = true; + libraryHaskellDepends = [ + aeson base exceptions http-media http-types mtl servant + servant-server text wai + ]; + executableHaskellDepends = [ + aeson base exceptions http-types servant-server text warp + ]; + doHaddock = false; + doCheck = false; + homepage = "https://github.com/ch1bo/servant-exceptions#readme"; + license = stdenv.lib.licenses.bsd3; + }) {}; + "servant-foreign" = callPackage + ({ mkDerivation, base, base-compat, http-types, lens, servant + , stdenv, text + }: + mkDerivation { + pname = "servant-foreign"; + version = "0.11.1"; + sha256 = "659cb1033b022869bb5b725cfbb82c02ab0424ca9130e4aeb2fb6bb2d0489805"; + revision = "4"; + editedCabalFile = "1alal6ps1lwl8yd2vwkpmkn4a69blr1ws2cba7mc7a2w63lg1pyz"; + libraryHaskellDepends = [ + base base-compat http-types lens servant text + ]; + doHaddock = false; + doCheck = false; + description = "Helpers for generating clients for servant APIs in any programming language"; + license = stdenv.lib.licenses.bsd3; + }) {}; + "servant-github-webhook" = callPackage + ({ mkDerivation, aeson, base, base16-bytestring, bytestring + , cryptonite, github, github-webhooks, http-types, memory, servant + , servant-server, stdenv, string-conversions, text, transformers + , unordered-containers, wai + }: + mkDerivation { + pname = "servant-github-webhook"; + version = "0.4.1.0"; + sha256 = "8bbe9bfe7b7f256fd3e40bcbf36ab9a11ba68aadacac85f5e8a850c8f569cf6c"; + libraryHaskellDepends = [ + aeson base base16-bytestring bytestring cryptonite github + github-webhooks http-types memory servant servant-server + string-conversions text transformers unordered-containers wai + ]; + doHaddock = false; + doCheck = false; + homepage = "https://github.com/tsani/servant-github-webhook"; + description = "Servant combinators to facilitate writing GitHub webhooks"; + license = stdenv.lib.licenses.mit; + }) {}; + "servant-js" = callPackage + ({ mkDerivation, base, base-compat, charset, lens, servant + , servant-foreign, stdenv, text + }: + mkDerivation { + pname = "servant-js"; + version = "0.9.3.2"; + sha256 = "02e0ec27a44a1e5794aacfbf745a815a68854d077e7d056d3e2f17d4812867dc"; + revision = "3"; + editedCabalFile = "0j5kmqzhkyb1wmvyxz0r20473myzp9bqcdgjbi8i4k1lfvcjsigq"; + isLibrary = true; + isExecutable = true; + libraryHaskellDepends = [ + base base-compat charset lens servant servant-foreign text + ]; + doHaddock = false; + doCheck = false; + homepage = "http://haskell-servant.readthedocs.org/"; + description = "Automatically derive javascript functions to query servant webservices"; + license = stdenv.lib.licenses.bsd3; + }) {}; + "servant-lucid" = callPackage + ({ mkDerivation, base, http-media, lucid, servant, stdenv, text }: + mkDerivation { + pname = "servant-lucid"; + version = "0.8.1"; + sha256 = "6671d5d5e29b05911bb8855f42168839c2dbb8ee113a10cef6dd372fc267113d"; + revision = "1"; + editedCabalFile = "0jna96jy6nmhk6w5zxdd3qn3vlrnhnvh4s3f2bqkn3c0had5py7d"; + libraryHaskellDepends = [ base http-media lucid servant text ]; + doHaddock = false; + doCheck = false; + homepage = "http://haskell-servant.readthedocs.org/"; + description = "Servant support for lucid"; + license = stdenv.lib.licenses.bsd3; + }) {}; + "servant-mock" = callPackage + ({ mkDerivation, aeson, base, base-compat, bytestring, http-types + , QuickCheck, servant, servant-server, stdenv, transformers, wai + , warp + }: + mkDerivation { + pname = "servant-mock"; + version = "0.8.4"; + sha256 = "d9d6392461f57324208e3a227c88e81da35686a38d5d1f783afc673a0c77059c"; + revision = "3"; + editedCabalFile = "13sbgnzr0yfrbrbvzc6v66lxrgvg3pb7h9alvmg77kmm95gmx8mm"; + isLibrary = true; + isExecutable = true; + libraryHaskellDepends = [ + base base-compat bytestring http-types QuickCheck servant + servant-server transformers wai + ]; + executableHaskellDepends = [ + aeson base QuickCheck servant-server warp + ]; + doHaddock = false; + doCheck = false; + homepage = "http://haskell-servant.readthedocs.org/"; + description = "Derive a mock server for free from your servant API types"; + license = stdenv.lib.licenses.bsd3; + }) {}; + "servant-pandoc" = callPackage + ({ mkDerivation, base, bytestring, case-insensitive, http-media + , lens, pandoc-types, servant-docs, stdenv, string-conversions + , text, unordered-containers + }: + mkDerivation { + pname = "servant-pandoc"; + version = "0.5.0.0"; + sha256 = "12d709fced47bb3e017b83dcc5dafb1186720e5318c1b5ebeb886d4439540463"; + libraryHaskellDepends = [ + base bytestring case-insensitive http-media lens pandoc-types + servant-docs string-conversions text unordered-containers + ]; + doHaddock = false; + doCheck = false; + description = "Use Pandoc to render servant API documentation"; + license = stdenv.lib.licenses.mit; + }) {}; + "servant-ruby" = callPackage + ({ mkDerivation, base, casing, servant-foreign, stdenv, text }: + mkDerivation { + pname = "servant-ruby"; + version = "0.8.0.1"; + sha256 = "a5047e8f7b957f12a8112461a53f779f721f976460f495e32e8174d5bef9ed1e"; + libraryHaskellDepends = [ base casing servant-foreign text ]; + doHaddock = false; + doCheck = false; + homepage = "https://github.com/joneshf/servant-ruby#readme"; + description = "Generate a Ruby client from a Servant API with Net::HTTP"; + license = stdenv.lib.licenses.bsd3; + }) {}; + "servant-server" = callPackage + ({ mkDerivation, aeson, base, base-compat, base64-bytestring + , bytestring, Cabal, cabal-doctest, containers, exceptions + , filepath, http-api-data, http-media, http-types, monad-control + , mtl, network, network-uri, resourcet, servant, stdenv + , string-conversions, tagged, text, transformers, transformers-base + , transformers-compat, wai, wai-app-static, warp, word8 + }: + mkDerivation { + pname = "servant-server"; + version = "0.14.1"; + sha256 = "024010b1ef238099d4e8dc1cf000bb5de5bbed149d305506088156308dafddba"; + revision = "1"; + editedCabalFile = "028vqbmqkc9gjsk34n74ssi0xfn085v26zdvpixgfi5yd7cvfg03"; + isLibrary = true; + isExecutable = true; + setupHaskellDepends = [ base Cabal cabal-doctest ]; + libraryHaskellDepends = [ + base base-compat base64-bytestring bytestring containers exceptions + filepath http-api-data http-media http-types monad-control mtl + network network-uri resourcet servant string-conversions tagged + text transformers transformers-base transformers-compat wai + wai-app-static word8 + ]; + executableHaskellDepends = [ aeson base servant text wai warp ]; + doHaddock = false; + doCheck = false; + homepage = "http://haskell-servant.readthedocs.org/"; + description = "A family of combinators for defining webservices APIs and serving them"; + license = stdenv.lib.licenses.bsd3; + }) {}; + "servant-static-th" = callPackage + ({ mkDerivation, base, blaze-html, bytestring, containers + , directory, filepath, http-media, semigroups, servant + , servant-blaze, servant-server, stdenv, template-haskell, text + }: + mkDerivation { + pname = "servant-static-th"; + version = "0.2.2.0"; + sha256 = "5bec0129407580bde3b5bc49fc75737c916b6eaf0ea421bf72f5bf029342741b"; + isLibrary = true; + isExecutable = true; + libraryHaskellDepends = [ + base blaze-html bytestring containers directory filepath http-media + semigroups servant servant-blaze servant-server template-haskell + text + ]; + doHaddock = false; + doCheck = false; + homepage = "https://github.com/cdepillabout/servant-static-th"; + description = "Embed a directory of static files in your Servant server"; + license = stdenv.lib.licenses.bsd3; + }) {}; + "servant-streaming" = callPackage + ({ mkDerivation, base, http-types, servant, stdenv }: + mkDerivation { + pname = "servant-streaming"; + version = "0.3.0.0"; + sha256 = "980d486577658697891360479195ed493859e2279f76334101a45c880f7c5a4c"; + revision = "1"; + editedCabalFile = "1a9lg7cxbkj658hc76r5yk104q0hm3q9mkjzk17dwkwlnvdfq6m2"; + libraryHaskellDepends = [ base http-types servant ]; + doHaddock = false; + doCheck = false; + homepage = "http://github.com/plow-technologies/servant-streaming#readme"; + description = "Servant combinators for the 'streaming' package"; + license = stdenv.lib.licenses.bsd3; + }) {}; + "servant-streaming-client" = callPackage + ({ mkDerivation, base, bytestring, http-media, http-types + , resourcet, servant, servant-client-core, servant-streaming + , stdenv, streaming + }: + mkDerivation { + pname = "servant-streaming-client"; + version = "0.3.0.0"; + sha256 = "42e2b229fa37538466dafa1992ab735c8342801dc07e1fff2706d460345770c0"; + revision = "1"; + editedCabalFile = "07xkgnhi8aspnqms5gx67ssw5m595gda8yqypdg2q59wwc6ib68d"; + libraryHaskellDepends = [ + base bytestring http-media http-types resourcet servant + servant-client-core servant-streaming streaming + ]; + doHaddock = false; + doCheck = false; + homepage = "http://github.com/plow-technologies/servant-streaming#readme"; + description = "Client instances for the 'servant-streaming' package"; + license = stdenv.lib.licenses.bsd3; + }) {}; + "servant-streaming-server" = callPackage + ({ mkDerivation, base, bytestring, http-media, http-types + , resourcet, servant, servant-server, servant-streaming, stdenv + , streaming, streaming-wai, wai + }: + mkDerivation { + pname = "servant-streaming-server"; + version = "0.3.0.0"; + sha256 = "c6e0a846e0156e097bb6a60710009fb4935241a3e7ce5b12b867ae094d1f5053"; + revision = "1"; + editedCabalFile = "1xfx22a83xwq2bzv7gm3z9drd5hiq6wz7yyvfpjz1c2dcicwflvm"; + libraryHaskellDepends = [ + base bytestring http-media http-types resourcet servant + servant-server servant-streaming streaming streaming-wai wai + ]; + doHaddock = false; + doCheck = false; + homepage = "http://github.com/plow-technologies/servant-streaming-server#readme"; + description = "Server instances for the 'servant-streaming' package"; + license = stdenv.lib.licenses.bsd3; + }) {}; + "servant-swagger" = callPackage + ({ mkDerivation, aeson, base, bytestring, Cabal, cabal-doctest + , hspec, http-media, insert-ordered-containers, lens, QuickCheck + , servant, singleton-bool, stdenv, swagger2, text + , unordered-containers + }: + mkDerivation { + pname = "servant-swagger"; + version = "1.1.5"; + sha256 = "4f7a442bccf2df8a9980129d83bbcd3e73cfec374919ecb8389709c5df0ca50a"; + revision = "5"; + editedCabalFile = "1c160wf4q0jyjg03w7hkwkbz0aprvmvzpwa5m944msik2kbvnyl5"; + setupHaskellDepends = [ base Cabal cabal-doctest ]; + libraryHaskellDepends = [ + aeson base bytestring hspec http-media insert-ordered-containers + lens QuickCheck servant singleton-bool swagger2 text + unordered-containers + ]; + doHaddock = false; + doCheck = false; + homepage = "https://github.com/haskell-servant/servant-swagger"; + description = "Generate Swagger specification for your servant API"; + license = stdenv.lib.licenses.bsd3; + }) {}; + "servant-swagger-ui" = callPackage + ({ mkDerivation, base, bytestring, file-embed-lzma, servant + , servant-server, servant-swagger-ui-core, stdenv, swagger2, text + }: + mkDerivation { + pname = "servant-swagger-ui"; + version = "0.3.0.3.13.2"; + sha256 = "b6dcb349d845e5a4fa357cb358f44814f30ba23129abd64cb41bda959e629352"; + revision = "2"; + editedCabalFile = "0sz08w56f7p74saass6xdzmbpyk78hpa9d79kkd2nclwinajpkgr"; + libraryHaskellDepends = [ + base bytestring file-embed-lzma servant servant-server + servant-swagger-ui-core swagger2 text + ]; + doHaddock = false; + doCheck = false; + homepage = "https://github.com/haskell-servant/servant-swagger-ui"; + description = "Servant swagger ui"; + license = stdenv.lib.licenses.bsd3; + }) {}; + "servant-swagger-ui-core" = callPackage + ({ mkDerivation, base, blaze-markup, bytestring, http-media + , servant, servant-blaze, servant-server, stdenv, swagger2, text + , transformers, transformers-compat, wai-app-static + }: + mkDerivation { + pname = "servant-swagger-ui-core"; + version = "0.3.1"; + sha256 = "ab379f8dec934c573c62c72ad49cc04c7e3c77a93fb8f375cfa965836eaa9616"; + revision = "1"; + editedCabalFile = "10p5yjzvfdn764mszlsx49kb55ygzi5m2mq32l9m91imvj1926b1"; + libraryHaskellDepends = [ + base blaze-markup bytestring http-media servant servant-blaze + servant-server swagger2 text transformers transformers-compat + wai-app-static + ]; + doHaddock = false; + doCheck = false; + homepage = "https://github.com/haskell-servant/servant-swagger-ui"; + description = "Servant swagger ui core components"; + license = stdenv.lib.licenses.bsd3; + }) {}; + "servant-tracing" = callPackage + ({ mkDerivation, aeson, async, base, bytestring, bytestring-lexing + , containers, hashable, http-api-data, http-client, lifted-base + , monad-control, mtl, random, servant, servant-server, stdenv, text + , time, transformers, unordered-containers, wai, warp + }: + mkDerivation { + pname = "servant-tracing"; + version = "0.1.0.2"; + sha256 = "3edf2e58c60b6624a81c57bbc606889d779ba0cc57fc785240cb353f9caaea62"; + isLibrary = true; + isExecutable = true; + libraryHaskellDepends = [ + aeson async base bytestring bytestring-lexing containers hashable + http-api-data http-client lifted-base monad-control mtl random + servant servant-server text time unordered-containers wai + ]; + executableHaskellDepends = [ + async base bytestring containers http-client lifted-base + monad-control mtl servant servant-server text transformers wai warp + ]; + doHaddock = false; + doCheck = false; + homepage = "https://github.com/ChrisCoffey/haskell-opentracing-light#readme"; + license = stdenv.lib.licenses.mit; + }) {}; + "servant-websockets" = callPackage + ({ mkDerivation, aeson, async, base, bytestring, conduit + , exceptions, resourcet, servant-server, stdenv, text, wai + , wai-websockets, warp, websockets + }: + mkDerivation { + pname = "servant-websockets"; + version = "1.1.0"; + sha256 = "63384c89db83bd03e00f2f6796c391fc133ffb3c2bc72976778d476ed82f0a51"; + isLibrary = true; + isExecutable = true; + libraryHaskellDepends = [ + aeson async base bytestring conduit exceptions resourcet + servant-server text wai wai-websockets warp websockets + ]; + executableHaskellDepends = [ + aeson base conduit servant-server text wai warp websockets + ]; + doHaddock = false; + doCheck = false; + homepage = "https://github.com/moesenle/servant-websockets#readme"; + description = "Small library providing WebSocket endpoints for servant"; + license = stdenv.lib.licenses.bsd3; + }) {}; + "servant-yaml" = callPackage + ({ mkDerivation, base, bytestring, http-media, servant, stdenv + , yaml + }: + mkDerivation { + pname = "servant-yaml"; + version = "0.1.0.0"; + sha256 = "c917d9b046b06a9c4386f743a78142c27cf7f0ec1ad8562770ab9828f2ee3204"; + revision = "22"; + editedCabalFile = "1mi52j2c7960k0qmxqd7238yxgbccb0xgfj3ahh0zfckficn9bk7"; + libraryHaskellDepends = [ + base bytestring http-media servant yaml + ]; + doHaddock = false; + doCheck = false; + homepage = "https://github.com/haskell-servant/servant-yaml#readme"; + description = "Servant support for yaml"; + license = stdenv.lib.licenses.bsd3; + }) {}; + "serverless-haskell" = callPackage + ({ mkDerivation, aeson, aeson-casing, aeson-extra, amazonka-core + , amazonka-kinesis, amazonka-s3, base, bytestring, case-insensitive + , http-types, iproute, lens, stdenv, text, time, unix + , unordered-containers + }: + mkDerivation { + pname = "serverless-haskell"; + version = "0.6.2"; + sha256 = "659390e33b14506aad035c4dd76a0a514a1a93675f534e5da37172640df08bda"; + libraryHaskellDepends = [ + aeson aeson-casing aeson-extra amazonka-core amazonka-kinesis + amazonka-s3 base bytestring case-insensitive http-types iproute + lens text time unix unordered-containers + ]; + doHaddock = false; + doCheck = false; + homepage = "https://github.com/seek-oss/serverless-haskell#readme"; + description = "Deploying Haskell code onto AWS Lambda using Serverless"; + license = stdenv.lib.licenses.mit; + }) {}; + "serversession" = callPackage + ({ mkDerivation, aeson, base, base64-bytestring, bytestring + , data-default, hashable, nonce, path-pieces, stdenv, text, time + , transformers, unordered-containers + }: + mkDerivation { + pname = "serversession"; + version = "1.0.1"; + sha256 = "3ffbefd87017e8d46fbbe380f59e24672aa9c06b999da5f9ae0b052094d94822"; + libraryHaskellDepends = [ + aeson base base64-bytestring bytestring data-default hashable nonce + path-pieces text time transformers unordered-containers + ]; + doHaddock = false; + doCheck = false; + homepage = "https://github.com/yesodweb/serversession"; + description = "Secure, modular server-side sessions"; + license = stdenv.lib.licenses.mit; + }) {}; + "serversession-frontend-wai" = callPackage + ({ mkDerivation, base, bytestring, cookie, data-default + , path-pieces, serversession, stdenv, text, time, transformers + , unordered-containers, vault, wai, wai-session + }: + mkDerivation { + pname = "serversession-frontend-wai"; + version = "1.0"; + sha256 = "0b48130e3d3915dc46ec2392984e7862d066f6ddd454127a98b0c21c2574b167"; + libraryHaskellDepends = [ + base bytestring cookie data-default path-pieces serversession text + time transformers unordered-containers vault wai wai-session + ]; + doHaddock = false; + doCheck = false; + homepage = "https://github.com/yesodweb/serversession"; + description = "wai-session bindings for serversession"; + license = stdenv.lib.licenses.mit; + }) {}; + "servius" = callPackage + ({ mkDerivation, base, blaze-builder, blaze-html, bytestring + , cmark-gfm, http-types, shakespeare, stdenv, text, wai + , wai-app-static + }: + mkDerivation { + pname = "servius"; + version = "1.2.1.0"; + sha256 = "040c2870673998716fe90ff9d4a08e7b942dcb613ff38e352a26221963948741"; + isLibrary = false; + isExecutable = true; + executableHaskellDepends = [ + base blaze-builder blaze-html bytestring cmark-gfm http-types + shakespeare text wai wai-app-static + ]; + doHaddock = false; + doCheck = false; + homepage = "https://github.com/snoyberg/servius#readme"; + description = "Warp web server with template rendering"; + license = stdenv.lib.licenses.mit; + }) {}; + "ses-html" = callPackage + ({ mkDerivation, base, base64-bytestring, blaze-html, byteable + , bytestring, cryptohash, HsOpenSSL, http-streams, stdenv, tagsoup + , time + }: + mkDerivation { + pname = "ses-html"; + version = "0.4.0.0"; + sha256 = "cff76ee03b538e69a3d107cd63d577210cf0f9879d470bf55519e887e2a8a08f"; + libraryHaskellDepends = [ + base base64-bytestring blaze-html byteable bytestring cryptohash + HsOpenSSL http-streams tagsoup time + ]; + doHaddock = false; + doCheck = false; + description = "Send HTML formatted emails using Amazon's SES REST API with blaze"; + license = stdenv.lib.licenses.bsd3; + }) {}; + "set-cover" = callPackage + ({ mkDerivation, base, containers, enummapset, psqueues, semigroups + , stdenv, utility-ht + }: + mkDerivation { + pname = "set-cover"; + version = "0.0.9"; + sha256 = "afebfd20c00ff68cd99c7e457d15542003228a56d98af63565549a77852f73e1"; + revision = "1"; + editedCabalFile = "0mcg15645maj1ymfrgs9ghi8n3hwwd72441zxcg9gn1w3pq7zsaw"; + isLibrary = true; + isExecutable = true; + libraryHaskellDepends = [ + base containers enummapset psqueues semigroups utility-ht + ]; + doHaddock = false; + doCheck = false; + homepage = "http://hub.darcs.net/thielema/set-cover/"; + description = "Solve exact set cover problems like Sudoku, 8 Queens, Soma Cube, Tetris Cube"; + license = stdenv.lib.licenses.bsd3; + }) {}; + "setenv" = callPackage + ({ mkDerivation, base, stdenv, unix }: + mkDerivation { + pname = "setenv"; + version = "0.1.1.3"; + sha256 = "e358df39afc03d5a39e2ec650652d845c85c80cc98fe331654deafb4767ecb32"; + revision = "1"; + editedCabalFile = "0ny4g3kjys0hqg41mnwrsymy1bwhl8l169kis4y4fa58sb06m4f5"; + libraryHaskellDepends = [ base unix ]; + doHaddock = false; + doCheck = false; + description = "A cross-platform library for setting environment variables"; + license = stdenv.lib.licenses.mit; + }) {}; + "setlocale" = callPackage + ({ mkDerivation, base, stdenv }: + mkDerivation { + pname = "setlocale"; + version = "1.0.0.6"; + sha256 = "587af63153c1f3642de2c2f526b3a3c82c46ece3bd09ffd96a0eedbfd1c288e6"; + libraryHaskellDepends = [ base ]; + doHaddock = false; + doCheck = false; + homepage = "https://bitbucket.org/IchUndNichtDu/haskell-setlocale"; + description = "Haskell bindings to setlocale"; + license = stdenv.lib.licenses.bsd3; + }) {}; + "sexp-grammar" = callPackage + ({ mkDerivation, alex, array, base, bytestring, containers, deepseq + , happy, invertible-grammar, prettyprinter, recursion-schemes + , scientific, semigroups, stdenv, text, utf8-string + }: + mkDerivation { + pname = "sexp-grammar"; + version = "2.0.1"; + sha256 = "babe1c38e7ce20c6158b12ebf3cc31a2ca5c777ba37ebee40315fa0360ecdf7e"; + libraryHaskellDepends = [ + array base bytestring containers deepseq invertible-grammar + prettyprinter recursion-schemes scientific semigroups text + utf8-string + ]; + libraryToolDepends = [ alex happy ]; + doHaddock = false; + doCheck = false; + homepage = "https://github.com/esmolanka/sexp-grammar"; + description = "Invertible grammar combinators for S-expressions"; + license = stdenv.lib.licenses.bsd3; + }) {}; + "shake" = callPackage + ({ mkDerivation, base, binary, bytestring, deepseq, directory + , extra, filepath, hashable, js-flot, js-jquery, primitive, process + , random, stdenv, time, transformers, unix, unordered-containers + , utf8-string + }: + mkDerivation { + pname = "shake"; + version = "0.16.4"; + sha256 = "b732a3a46ceb3b4545a78c3733e0a7904763e7cd3ee8bf4fe2e1e91f2c9b1436"; + isLibrary = true; + isExecutable = true; + enableSeparateDataOutput = true; + libraryHaskellDepends = [ + base binary bytestring deepseq directory extra filepath hashable + js-flot js-jquery primitive process random time transformers unix + unordered-containers utf8-string + ]; + executableHaskellDepends = [ + base binary bytestring deepseq directory extra filepath hashable + js-flot js-jquery primitive process random time transformers unix + unordered-containers utf8-string + ]; + doHaddock = false; + doCheck = false; + homepage = "https://shakebuild.com"; + description = "Build system library, like Make, but more accurate dependencies"; + license = stdenv.lib.licenses.bsd3; + }) {}; + "shake-language-c" = callPackage + ({ mkDerivation, base, data-default-class, fclabels, process, shake + , split, stdenv, unordered-containers + }: + mkDerivation { + pname = "shake-language-c"; + version = "0.12.0"; + sha256 = "661e350179e55c930c3c36f53853db2bc2697d88c5265049085cea09f5aa1ab0"; + libraryHaskellDepends = [ + base data-default-class fclabels process shake split + unordered-containers + ]; + doHaddock = false; + doCheck = false; + homepage = "https://github.com/samplecount/shake-language-c"; + description = "Utilities for cross-compiling with Shake"; + license = stdenv.lib.licenses.asl20; + }) {}; + "shakespeare" = callPackage + ({ mkDerivation, aeson, base, blaze-html, blaze-markup, bytestring + , containers, directory, exceptions, ghc-prim, parsec, process + , scientific, stdenv, template-haskell, text, time, transformers + , unordered-containers, vector + }: + mkDerivation { + pname = "shakespeare"; + version = "2.0.15"; + sha256 = "4354c6eebbfa89103c8090aae3bc7be5fceae6a0e327acf8adc4f3fd535864ee"; + libraryHaskellDepends = [ + aeson base blaze-html blaze-markup bytestring containers directory + exceptions ghc-prim parsec process scientific template-haskell text + time transformers unordered-containers vector + ]; + doHaddock = false; + doCheck = false; + homepage = "http://www.yesodweb.com/book/shakespearean-templates"; + description = "A toolkit for making compile-time interpolated templates"; + license = stdenv.lib.licenses.mit; + }) {}; + "shell-conduit" = callPackage + ({ mkDerivation, async, base, bytestring, conduit, conduit-extra + , directory, filepath, monads-tf, process, resourcet, semigroups + , split, stdenv, template-haskell, text, transformers, unix + , unliftio + }: + mkDerivation { + pname = "shell-conduit"; + version = "4.7.0"; + sha256 = "6f31c5b6fb46219c4da575b4405f1a5af51eed1f22073d315df80c8a40ddbe30"; + libraryHaskellDepends = [ + async base bytestring conduit conduit-extra directory filepath + monads-tf process resourcet semigroups split template-haskell text + transformers unix unliftio + ]; + doHaddock = false; + doCheck = false; + homepage = "https://github.com/psibi/shell-conduit"; + description = "Write shell scripts with Conduit"; + license = stdenv.lib.licenses.bsd3; + }) {}; + "shell-escape" = callPackage + ({ mkDerivation, base, binary, bytestring, containers, stdenv + , vector + }: + mkDerivation { + pname = "shell-escape"; + version = "0.2.0"; + sha256 = "e23c9ba94a27e45430cb39e6bb236557e789d24129257c3def377f441b2cba4a"; + libraryHaskellDepends = [ + base binary bytestring containers vector + ]; + doHaddock = false; + doCheck = false; + homepage = "http://github.com/solidsnack/shell-escape"; + description = "Shell escaping library"; + license = stdenv.lib.licenses.bsd3; + }) {}; + "shelltestrunner" = callPackage + ({ mkDerivation, base, cmdargs, Diff, directory, filemanip + , filepath, HUnit, parsec, pretty-show, process, regex-tdfa, safe + , stdenv, test-framework, test-framework-hunit, utf8-string + }: + mkDerivation { + pname = "shelltestrunner"; + version = "1.9"; + sha256 = "cbc4358d447e32babe4572cda0d530c648cc4c67805f9f88002999c717feb3a8"; + isLibrary = false; + isExecutable = true; + executableHaskellDepends = [ + base cmdargs Diff directory filemanip filepath HUnit parsec + pretty-show process regex-tdfa safe test-framework + test-framework-hunit utf8-string + ]; + doHaddock = false; + doCheck = false; + homepage = "https://github.com/simonmichael/shelltestrunner"; + description = "Easy, repeatable testing of CLI programs/commands"; + license = "GPL"; + }) {}; + "shelly" = callPackage + ({ mkDerivation, async, base, bytestring, containers, directory + , enclosed-exceptions, exceptions, lifted-async, lifted-base + , monad-control, mtl, process, stdenv, system-fileio + , system-filepath, text, time, transformers, transformers-base + , unix, unix-compat + }: + mkDerivation { + pname = "shelly"; + version = "1.8.1"; + sha256 = "de8814879c7a5e7f1f7f0d9c56c1dfee30d6d63ba1140946e5ed158dd75e6e08"; + revision = "1"; + editedCabalFile = "0crf0m077wky76f5nav2p9q4fa5q4yhv5l4bq9hd073dzdaywhz0"; + isLibrary = true; + isExecutable = true; + libraryHaskellDepends = [ + async base bytestring containers directory enclosed-exceptions + exceptions lifted-async lifted-base monad-control mtl process + system-fileio system-filepath text time transformers + transformers-base unix unix-compat + ]; + doHaddock = false; + doCheck = false; + homepage = "https://github.com/yesodweb/Shelly.hs"; + description = "shell-like (systems) programming in Haskell"; + license = stdenv.lib.licenses.bsd3; + }) {}; + "shortcut-links" = callPackage + ({ mkDerivation, base, stdenv, text }: + mkDerivation { + pname = "shortcut-links"; + version = "0.4.2.0"; + sha256 = "1e6b75c5e94fddf9e2e665821ac70f5083e5d40d1fd55813e94943ce02335027"; + libraryHaskellDepends = [ base text ]; + doHaddock = false; + doCheck = false; + homepage = "http://github.com/aelve/shortcut-links"; + description = "Link shortcuts for use in text markup"; + license = stdenv.lib.licenses.bsd3; + }) {}; + "should-not-typecheck" = callPackage + ({ mkDerivation, base, deepseq, HUnit, stdenv }: + mkDerivation { + pname = "should-not-typecheck"; + version = "2.1.0"; + sha256 = "f538ac70ce07679bc2e6c1651db82a86866664ab995665fdc78e6cb12bd8d591"; + libraryHaskellDepends = [ base deepseq HUnit ]; + doHaddock = false; + doCheck = false; + homepage = "http://github.com/CRogers/should-not-typecheck"; + description = "A HUnit/hspec assertion library to verify that an expression does not typecheck"; + license = stdenv.lib.licenses.bsd3; + }) {}; + "show-combinators" = callPackage + ({ mkDerivation, base, stdenv }: + mkDerivation { + pname = "show-combinators"; + version = "0.1.0.0"; + sha256 = "22c45747c79055b5310c1da2af717bffded65ea39479c61783f8c1a22e953086"; + revision = "1"; + editedCabalFile = "09zd78jap17ralla3833gwv6bwmh93bpjgdshkyf7j06xg2c1mq8"; + libraryHaskellDepends = [ base ]; + doHaddock = false; + doCheck = false; + homepage = "https://github.com/Lysxia/show-combinators#readme"; + description = "Combinators to write Show instances"; + license = stdenv.lib.licenses.mit; + }) {}; + "show-prettyprint" = callPackage + ({ mkDerivation, ansi-wl-pprint, base, prettyprinter, stdenv + , trifecta + }: + mkDerivation { + pname = "show-prettyprint"; + version = "0.2.2"; + sha256 = "f07d860b9bb4176a4e46038c5100ecf07d443daa1b15455ca4c2bd4d10e9af55"; + libraryHaskellDepends = [ + ansi-wl-pprint base prettyprinter trifecta + ]; + doHaddock = false; + doCheck = false; + homepage = "https://github.com/quchen/show-prettyprint#readme"; + description = "Robust prettyprinter for output of auto-generated Show instances"; + license = stdenv.lib.licenses.bsd3; + }) {}; + "siggy-chardust" = callPackage + ({ mkDerivation, base, stdenv }: + mkDerivation { + pname = "siggy-chardust"; + version = "1.0.0"; + sha256 = "9f730c3cc04ea629e0b655bfff66f83e146eb3b9f0908d5dc00b4c558d5f5a43"; + revision = "1"; + editedCabalFile = "1lknm1jr6h5qpixc727aj3zbmj4ia21r9lb8gzj50iildgmfk33b"; + libraryHaskellDepends = [ base ]; + doHaddock = false; + doCheck = false; + homepage = "https://github.com/blockscope/flare-timing/tree/master/siggy-chardust#readme"; + description = "Rounding rationals to significant digits and decimal places"; + license = stdenv.lib.licenses.mpl20; + }) {}; + "signal" = callPackage + ({ mkDerivation, base, stdenv, unix }: + mkDerivation { + pname = "signal"; + version = "0.1.0.4"; + sha256 = "c4bfdd92b75347e02759c1a7d75963fbc7052e948ec96e25299ca5262e5d76e5"; + isLibrary = true; + isExecutable = true; + libraryHaskellDepends = [ base unix ]; + executableHaskellDepends = [ base ]; + doHaddock = false; + doCheck = false; + homepage = "http://github.com/pmlodawski/signal"; + description = "Multiplatform signal support for Haskell"; + license = stdenv.lib.licenses.mit; + }) {}; + "silently" = callPackage + ({ mkDerivation, base, deepseq, directory, stdenv }: + mkDerivation { + pname = "silently"; + version = "1.2.5"; + sha256 = "cef625635053a46032ca53b43d311921875a437910b6568ded17027fdca83839"; + libraryHaskellDepends = [ base deepseq directory ]; + doHaddock = false; + doCheck = false; + homepage = "https://github.com/hspec/silently"; + description = "Prevent or capture writing to stdout and other handles"; + license = stdenv.lib.licenses.bsd3; + }) {}; + "simple-reflect" = callPackage + ({ mkDerivation, base, stdenv }: + mkDerivation { + pname = "simple-reflect"; + version = "0.3.3"; + sha256 = "07825ea04c135298008cf080133e3bfc8e04cbacd24719c46ac6a2ca4acfdb2b"; + libraryHaskellDepends = [ base ]; + doHaddock = false; + doCheck = false; + homepage = "http://twanvl.nl/blog/haskell/simple-reflection-of-expressions"; + description = "Simple reflection of expressions containing variables"; + license = stdenv.lib.licenses.bsd3; + }) {}; + "simple-sendfile" = callPackage + ({ mkDerivation, base, bytestring, network, stdenv, unix }: + mkDerivation { + pname = "simple-sendfile"; + version = "0.2.27"; + sha256 = "f68572592099a2db3f7212ac7d133447ae5bbb2605285d3de1a29a52d9c79caf"; + libraryHaskellDepends = [ base bytestring network unix ]; + doHaddock = false; + doCheck = false; + description = "Cross platform library for the sendfile system call"; + license = stdenv.lib.licenses.bsd3; + }) {}; + "simple-vec3" = callPackage + ({ mkDerivation, base, QuickCheck, stdenv, vector }: + mkDerivation { + pname = "simple-vec3"; + version = "0.4.0.7"; + sha256 = "596d0f3c0e11fc93230528fb242b42387d9eee60101b498d9a26726a93dfd0ea"; + libraryHaskellDepends = [ base QuickCheck vector ]; + doHaddock = false; + doCheck = false; + homepage = "https://github.com/dzhus/simple-vec3#readme"; + description = "Three-dimensional vectors of doubles with basic operations"; + license = stdenv.lib.licenses.bsd3; + }) {}; + "simplest-sqlite" = callPackage + ({ mkDerivation, base, bytestring, exception-hierarchy, sqlite + , stdenv, template-haskell, text + }: + mkDerivation { + pname = "simplest-sqlite"; + version = "0.1.0.0"; + sha256 = "5f0bdee8a4ba2b5dea03ff8ecfc91827602624a91d62eb2b4ce90b4d57005d6e"; + libraryHaskellDepends = [ + base bytestring exception-hierarchy template-haskell text + ]; + librarySystemDepends = [ sqlite ]; + doHaddock = false; + doCheck = false; + homepage = "comming soon"; + description = "Simplest SQLite3 binding"; + license = stdenv.lib.licenses.bsd3; + }) {inherit (pkgs) sqlite;}; + "since" = callPackage + ({ mkDerivation, base, stdenv, time }: + mkDerivation { + pname = "since"; + version = "0.0.0"; + sha256 = "7aa713c0fc0b2a748c9b5ddc413b918f77335e45b56d3968100428a42cdfc1ff"; + libraryHaskellDepends = [ base time ]; + doHaddock = false; + doCheck = false; + homepage = "https://github.com/athanclark/since#readme"; + description = "Get the number of seconds since the last invocation"; + license = stdenv.lib.licenses.bsd3; + }) {}; + "singleton-bool" = callPackage + ({ mkDerivation, base, stdenv }: + mkDerivation { + pname = "singleton-bool"; + version = "0.1.4"; + sha256 = "0195c6e2be1e149e5b687ec3be84fd5089b377345fddd333a9d681eacdfafb2a"; + revision = "1"; + editedCabalFile = "0ccd49z9xwa8gr8sclmmn0zc4xq39yyjws4zr6lrw3xjql130nsx"; + libraryHaskellDepends = [ base ]; + doHaddock = false; + doCheck = false; + homepage = "https://github.com/phadej/singleton-bool#readme"; + description = "Type level booleans"; + license = stdenv.lib.licenses.bsd3; + }) {}; + "singleton-nats" = callPackage + ({ mkDerivation, base, singletons, stdenv }: + mkDerivation { + pname = "singleton-nats"; + version = "0.4.1"; + sha256 = "5a5328dd7b33bebbb90d19ef5db273798603da7194ddfc790ee397011f3e68b9"; + libraryHaskellDepends = [ base singletons ]; + doHaddock = false; + doCheck = false; + homepage = "https://github.com/AndrasKovacs/singleton-nats"; + description = "Unary natural numbers relying on the singletons infrastructure"; + license = stdenv.lib.licenses.bsd3; + }) {}; + "singletons" = callPackage + ({ mkDerivation, base, containers, ghc-boot-th, mtl, stdenv, syb + , template-haskell, text, th-desugar, transformers + }: + mkDerivation { + pname = "singletons"; + version = "2.4.1"; + sha256 = "5d7a200c814a5f1ac16db04456fdafbdea39fc0ee6c934a9ef7bcd2d6da2f9cf"; + libraryHaskellDepends = [ + base containers ghc-boot-th mtl syb template-haskell text + th-desugar transformers + ]; + doHaddock = false; + doCheck = false; + homepage = "http://www.github.com/goldfirere/singletons"; + description = "A framework for generating singleton types"; + license = stdenv.lib.licenses.bsd3; + }) {}; + "siphash" = callPackage + ({ mkDerivation, base, bytestring, cpu, stdenv }: + mkDerivation { + pname = "siphash"; + version = "1.0.3"; + sha256 = "cf81ce41c6ca40c4fec9add5dcebc161cb2d31f522f9ad727df23d30ac6a05f3"; + revision = "1"; + editedCabalFile = "1q2dy0ywngm9iv7k6d9gnf860m9hpf62q5qvdzmxw5s629gk4afn"; + enableSeparateDataOutput = true; + libraryHaskellDepends = [ base bytestring cpu ]; + doHaddock = false; + doCheck = false; + homepage = "http://github.com/vincenthz/hs-siphash"; + description = "siphash: a fast short input PRF"; + license = stdenv.lib.licenses.bsd3; + }) {}; + "size-based" = callPackage + ({ mkDerivation, base, dictionary-sharing, stdenv, template-haskell + , testing-type-modifiers + }: + mkDerivation { + pname = "size-based"; + version = "0.1.1.0"; + sha256 = "71f66046e46c8754b9f7ae1ef63b2d85aa62a1fe6901bd1ef18691d11b1edcfc"; + revision = "1"; + editedCabalFile = "1rw9ddw1vyv9k47p0d79qbvngym005fmz00hqrg3p1rq2vlfjdv2"; + libraryHaskellDepends = [ + base dictionary-sharing template-haskell testing-type-modifiers + ]; + doHaddock = false; + doCheck = false; + description = "Sized functors, for size-based enumerations"; + license = stdenv.lib.licenses.bsd3; + }) {}; + "skein" = callPackage + ({ mkDerivation, base, bytestring, cereal, crypto-api, stdenv + , tagged + }: + mkDerivation { + pname = "skein"; + version = "1.0.9.4"; + sha256 = "f882ca0cc5ed336ef898fb3c89579e392900259296b2320edf968b9fc16cb8c9"; + libraryHaskellDepends = [ + base bytestring cereal crypto-api tagged + ]; + doHaddock = false; + doCheck = false; + homepage = "https://github.com/meteficha/skein"; + description = "Skein, a family of cryptographic hash functions. Includes Skein-MAC as well."; + license = stdenv.lib.licenses.bsd3; + }) {}; + "skylighting" = callPackage + ({ mkDerivation, aeson, ansi-terminal, attoparsec, base + , base64-bytestring, binary, blaze-html, bytestring + , case-insensitive, colour, containers, directory, filepath, hxt + , mtl, regex-pcre-builtin, safe, skylighting-core, stdenv, text + , utf8-string + }: + mkDerivation { + pname = "skylighting"; + version = "0.7.2"; + sha256 = "90b57eb1fe55b9077948139c783d87ca4ddc61bd1407def4dc94117554f803e6"; + isLibrary = true; + isExecutable = true; + libraryHaskellDepends = [ + aeson ansi-terminal attoparsec base base64-bytestring binary + blaze-html bytestring case-insensitive colour containers directory + filepath hxt mtl regex-pcre-builtin safe skylighting-core text + utf8-string + ]; + doHaddock = false; + doCheck = false; + homepage = "https://github.com/jgm/skylighting"; + description = "syntax highlighting library"; + license = stdenv.lib.licenses.gpl2; + }) {}; + "skylighting-core" = callPackage + ({ mkDerivation, aeson, ansi-terminal, attoparsec, base + , base64-bytestring, binary, blaze-html, bytestring + , case-insensitive, colour, containers, directory, filepath, hxt + , mtl, regex-pcre-builtin, safe, stdenv, text, transformers + , utf8-string + }: + mkDerivation { + pname = "skylighting-core"; + version = "0.7.2"; + sha256 = "7832e5976f321cbaf45b969a789241b703fce98f623a1b29dfac9fa679e5ce18"; + revision = "1"; + editedCabalFile = "0qjmk3i9kjnd3195fhphjgqvsgbw6blfjl40mdyiblw1piyvc6yw"; + isLibrary = true; + isExecutable = true; + libraryHaskellDepends = [ + aeson ansi-terminal attoparsec base base64-bytestring binary + blaze-html bytestring case-insensitive colour containers directory + filepath hxt mtl regex-pcre-builtin safe text transformers + utf8-string + ]; + doHaddock = false; + doCheck = false; + homepage = "https://github.com/jgm/skylighting"; + description = "syntax highlighting library"; + license = stdenv.lib.licenses.bsd3; + }) {}; + "slack-web" = callPackage + ({ mkDerivation, aeson, base, containers, errors, http-api-data + , http-client, http-client-tls, megaparsec, mtl, servant + , servant-client, servant-client-core, stdenv, text, time + , transformers + }: + mkDerivation { + pname = "slack-web"; + version = "0.2.0.6"; + sha256 = "4ac076f713d66aabbe0fc069ba352baa345acdb01edba3bd8d161f65c3e1cde7"; + libraryHaskellDepends = [ + aeson base containers errors http-api-data http-client + http-client-tls megaparsec mtl servant servant-client + servant-client-core text time transformers + ]; + doHaddock = false; + doCheck = false; + homepage = "https://github.com/jpvillaisaza/slack-web"; + description = "Bindings for the Slack web API"; + license = stdenv.lib.licenses.mit; + }) {}; + "slave-thread" = callPackage + ({ mkDerivation, base, base-prelude, list-t, mmorph + , partial-handler, stdenv, stm-containers, transformers + }: + mkDerivation { + pname = "slave-thread"; + version = "1.0.2"; + sha256 = "e47120598dd65ebee33253911a31518021323a5ccfa52588e13c44fd5f5b4b13"; + libraryHaskellDepends = [ + base base-prelude list-t mmorph partial-handler stm-containers + transformers + ]; + doHaddock = false; + doCheck = false; + homepage = "https://github.com/nikita-volkov/slave-thread"; + description = "A principal solution to ghost threads and silent exceptions"; + license = stdenv.lib.licenses.mit; + }) {}; + "smallcheck" = callPackage + ({ mkDerivation, base, ghc-prim, logict, mtl, pretty, stdenv }: + mkDerivation { + pname = "smallcheck"; + version = "1.1.5"; + sha256 = "9020e67895a57bde02d7df2c0af06a4c769eff56d48b6a830f6d803df891aea4"; + libraryHaskellDepends = [ base ghc-prim logict mtl pretty ]; + doHaddock = false; + doCheck = false; + homepage = "https://github.com/feuerbach/smallcheck"; + description = "A property-based testing library"; + license = stdenv.lib.licenses.bsd3; + }) {}; + "smoothie" = callPackage + ({ mkDerivation, aeson, base, linear, stdenv, text, vector }: + mkDerivation { + pname = "smoothie"; + version = "0.4.2.9"; + sha256 = "d3cafbc34a5d03363ddd41e59bd681168cd2d0aa8be4678db9ae1904ad202a4f"; + enableSeparateDataOutput = true; + libraryHaskellDepends = [ aeson base linear text vector ]; + doHaddock = false; + doCheck = false; + homepage = "https://github.com/phaazon/smoothie"; + description = "Smooth curves via several interpolation modes"; + license = stdenv.lib.licenses.bsd3; + }) {}; + "smtp-mail" = callPackage + ({ mkDerivation, array, base, base16-bytestring, base64-bytestring + , bytestring, cryptohash, filepath, mime-mail, network, stdenv + , text + }: + mkDerivation { + pname = "smtp-mail"; + version = "0.1.4.6"; + sha256 = "86dacbef87a2519222a1165b49401a437887a249f5bfd63a99702198dad214bc"; + libraryHaskellDepends = [ + array base base16-bytestring base64-bytestring bytestring + cryptohash filepath mime-mail network text + ]; + doHaddock = false; + doCheck = false; + homepage = "http://github.com/jhickner/smtp-mail"; + description = "Simple email sending via SMTP"; + license = stdenv.lib.licenses.bsd3; + }) {}; + "snap-blaze" = callPackage + ({ mkDerivation, base, blaze-html, snap-core, stdenv }: + mkDerivation { + pname = "snap-blaze"; + version = "0.2.1.5"; + sha256 = "b36e35bd4ba3087b3de92702e488ba6570675719243b5dbdf4eae0b819988841"; + libraryHaskellDepends = [ base blaze-html snap-core ]; + doHaddock = false; + doCheck = false; + homepage = "http://github.com/jaspervdj/snap-blaze"; + description = "blaze-html integration for Snap"; + license = stdenv.lib.licenses.bsd3; + }) {}; + "snap-core" = callPackage + ({ mkDerivation, attoparsec, base, bytestring, bytestring-builder + , case-insensitive, containers, directory, filepath, hashable + , HUnit, io-streams, lifted-base, monad-control, mtl, network + , network-uri, old-locale, random, readable, regex-posix, stdenv + , text, time, transformers, transformers-base, unix-compat + , unordered-containers, vector + }: + mkDerivation { + pname = "snap-core"; + version = "1.0.3.2"; + sha256 = "4c4398476fe882122ce8adc03f69509588d071fc011f50162cd69706093dd88c"; + revision = "3"; + editedCabalFile = "0wlhn33r7c9g7j23y006ddq9d87lkmianvvfrbl8jd8mvjvj2gfa"; + libraryHaskellDepends = [ + attoparsec base bytestring bytestring-builder case-insensitive + containers directory filepath hashable HUnit io-streams lifted-base + monad-control mtl network network-uri old-locale random readable + regex-posix text time transformers transformers-base unix-compat + unordered-containers vector + ]; + doHaddock = false; + doCheck = false; + homepage = "http://snapframework.com/"; + description = "Snap: A Haskell Web Framework (core interfaces and types)"; + license = stdenv.lib.licenses.bsd3; + }) {}; + "snap-server" = callPackage + ({ mkDerivation, attoparsec, base, blaze-builder, bytestring + , bytestring-builder, case-insensitive, clock, containers, filepath + , HsOpenSSL, io-streams, io-streams-haproxy, lifted-base, mtl + , network, old-locale, openssl-streams, snap-core, stdenv, text + , time, unix, unix-compat, vector + }: + mkDerivation { + pname = "snap-server"; + version = "1.1.0.0"; + sha256 = "249ea390a4e54899b310c0dd13b91af007a2b685bd0d9769c3e208dd914d7c6f"; + revision = "3"; + editedCabalFile = "0a9d3nqb5rvgm25nak68lp6yj9m6cwhbgdbg5l7ib5i2czcg7yjh"; + configureFlags = [ "-fopenssl" ]; + isLibrary = true; + isExecutable = true; + libraryHaskellDepends = [ + attoparsec base blaze-builder bytestring bytestring-builder + case-insensitive clock containers filepath HsOpenSSL io-streams + io-streams-haproxy lifted-base mtl network old-locale + openssl-streams snap-core text time unix unix-compat vector + ]; + doHaddock = false; + doCheck = false; + homepage = "http://snapframework.com/"; + description = "A web server for the Snap Framework"; + license = stdenv.lib.licenses.bsd3; + }) {}; + "snappy" = callPackage + ({ mkDerivation, base, bytestring, snappy, stdenv }: + mkDerivation { + pname = "snappy"; + version = "0.2.0.2"; + sha256 = "0565df326a87c6ea67f8fb638e01acb0562cabd16a67fc6f9ea9cd191de8cd91"; + libraryHaskellDepends = [ base bytestring ]; + librarySystemDepends = [ snappy ]; + doHaddock = false; + doCheck = false; + homepage = "http://github.com/bos/snappy"; + description = "Bindings to the Google Snappy library for fast compression/decompression"; + license = stdenv.lib.licenses.bsd3; + }) {inherit (pkgs) snappy;}; + "snowflake" = callPackage + ({ mkDerivation, base, stdenv, time }: + mkDerivation { + pname = "snowflake"; + version = "0.1.1.1"; + sha256 = "f156ca321ae17033fe1cbe7e676fea403136198e1c3a132924a080cd3145cddd"; + revision = "1"; + editedCabalFile = "1y5v3nsin8iyxvh0abfhs7ma75p5zjvha0lp41801pdiikacfzha"; + libraryHaskellDepends = [ base time ]; + doHaddock = false; + doCheck = false; + description = "A loose port of Twitter Snowflake to Haskell. Generates arbitrary precision, unique, time-sortable identifiers."; + license = stdenv.lib.licenses.asl20; + }) {}; + "soap" = callPackage + ({ mkDerivation, base, bytestring, conduit, configurator + , data-default, exceptions, http-client, http-types, iconv, mtl + , resourcet, stdenv, text, unordered-containers, xml-conduit + , xml-conduit-writer, xml-types + }: + mkDerivation { + pname = "soap"; + version = "0.2.3.6"; + sha256 = "cdfc8ee01d3adb0334521a954e32e64f52a3e404fb469679e39904d4ed52b176"; + libraryHaskellDepends = [ + base bytestring conduit configurator data-default exceptions + http-client http-types iconv mtl resourcet text + unordered-containers xml-conduit xml-conduit-writer xml-types + ]; + doHaddock = false; + doCheck = false; + homepage = "https://bitbucket.org/dpwiz/haskell-soap"; + description = "SOAP client tools"; + license = stdenv.lib.licenses.mit; + }) {}; + "soap-openssl" = callPackage + ({ mkDerivation, base, configurator, data-default, HsOpenSSL + , http-client, http-client-openssl, soap, stdenv, text + }: + mkDerivation { + pname = "soap-openssl"; + version = "0.1.0.2"; + sha256 = "2008547f4fd22063479ce1cd1c483db926f5f08a2ff6fb0c60fb2f0f7d42830f"; + revision = "1"; + editedCabalFile = "1b3aivn9jfaax00id7x4cqvpmd6lgynslchlry0qsmq1lj466cdf"; + libraryHaskellDepends = [ + base configurator data-default HsOpenSSL http-client + http-client-openssl soap text + ]; + doHaddock = false; + doCheck = false; + homepage = "https://bitbucket.org/dpwiz/haskell-soap"; + description = "TLS-enabled SOAP transport (using openssl bindings)"; + license = stdenv.lib.licenses.mit; + }) {}; + "soap-tls" = callPackage + ({ mkDerivation, base, configurator, connection, data-default + , http-client, http-client-tls, soap, stdenv, text, tls, x509 + , x509-store, x509-validation + }: + mkDerivation { + pname = "soap-tls"; + version = "0.1.1.4"; + sha256 = "ce8b33cd4bb2cc60093df4de231967edd789fd9da44a261a539a221116853a14"; + libraryHaskellDepends = [ + base configurator connection data-default http-client + http-client-tls soap text tls x509 x509-store x509-validation + ]; + doHaddock = false; + doCheck = false; + homepage = "https://bitbucket.org/dpwiz/haskell-soap"; + description = "TLS-enabled SOAP transport (using tls package)"; + license = stdenv.lib.licenses.mit; + }) {}; + "socket-activation" = callPackage + ({ mkDerivation, base, network, stdenv, transformers, unix }: + mkDerivation { + pname = "socket-activation"; + version = "0.1.0.2"; + sha256 = "b99e7b4f296cd462aac84e5bb61fb02953e2080d1351e9e10a63d35dc34eb43b"; + libraryHaskellDepends = [ base network transformers unix ]; + doHaddock = false; + doCheck = false; + homepage = "https://github.com/ddfisher/haskell-socket-activation"; + description = "systemd socket activation library"; + license = stdenv.lib.licenses.bsd3; + }) {}; + "socks" = callPackage + ({ mkDerivation, base, bytestring, cereal, network, stdenv }: + mkDerivation { + pname = "socks"; + version = "0.5.6"; + sha256 = "fa63cd838025e18864c59755750c0cfc4ea76e140a542f07a5c682488ec78438"; + libraryHaskellDepends = [ base bytestring cereal network ]; + doHaddock = false; + doCheck = false; + homepage = "http://github.com/vincenthz/hs-socks"; + description = "Socks proxy (ver 5)"; + license = stdenv.lib.licenses.bsd3; + }) {}; + "sort" = callPackage + ({ mkDerivation, base, stdenv }: + mkDerivation { + pname = "sort"; + version = "1.0.0.0"; + sha256 = "cee3894879cb4b2150331eca96d5d27f51a6114bcb082d1d8dded55881f5770d"; + libraryHaskellDepends = [ base ]; + doHaddock = false; + doCheck = false; + homepage = "https://github.com/cdornan/sort"; + description = "A Haskell sorting toolkit"; + license = stdenv.lib.licenses.bsd3; + }) {}; + "sorted-list" = callPackage + ({ mkDerivation, base, deepseq, stdenv }: + mkDerivation { + pname = "sorted-list"; + version = "0.2.1.0"; + sha256 = "b4e476157cf0df745eb3c39921357ffb2bf411cd169e755e99536031e07c5ef4"; + libraryHaskellDepends = [ base deepseq ]; + doHaddock = false; + doCheck = false; + homepage = "https://github.com/Daniel-Diaz/sorted-list/blob/master/README.md"; + description = "Type-enforced sorted lists and related functions"; + license = stdenv.lib.licenses.bsd3; + }) {}; + "sourcemap" = callPackage + ({ mkDerivation, aeson, attoparsec, base, bytestring, process + , stdenv, text, unordered-containers, utf8-string + }: + mkDerivation { + pname = "sourcemap"; + version = "0.1.6"; + sha256 = "b9a04cccb4fe7eea8b37a2eaf2bc776eae5640038ab76fb948c5a3ea09a9ce7a"; + revision = "1"; + editedCabalFile = "1f7q44ar6qfip8fsllg43jyn7r15ifn2r0vz32cbmx0sb0d38dax"; + libraryHaskellDepends = [ + aeson attoparsec base bytestring process text unordered-containers + utf8-string + ]; + doHaddock = false; + doCheck = false; + description = "Implementation of source maps as proposed by Google and Mozilla"; + license = stdenv.lib.licenses.bsd3; + }) {}; + "sox" = callPackage + ({ mkDerivation, base, containers, explicit-exception + , extensible-exceptions, process, sample-frame, semigroups, stdenv + , transformers, unix, utility-ht + }: + mkDerivation { + pname = "sox"; + version = "0.2.3"; + sha256 = "6075a191c7715cc27be60a21d5fcdfcbcfb54eb659b5d86ce6a8c89d24abad90"; + libraryHaskellDepends = [ + base containers explicit-exception extensible-exceptions process + sample-frame semigroups transformers unix utility-ht + ]; + doHaddock = false; + doCheck = false; + homepage = "http://www.haskell.org/haskellwiki/Sox"; + description = "Play, write, read, convert audio signals using Sox"; + license = "GPL"; + }) {}; + "soxlib" = callPackage + ({ mkDerivation, base, bytestring, containers, explicit-exception + , extensible-exceptions, sample-frame, sox, stdenv, storablevector + , transformers, utility-ht + }: + mkDerivation { + pname = "soxlib"; + version = "0.0.3"; + sha256 = "18b555beb0eaafce25550feea23575ec68477728654bd2fbaad67d448f5dcd8b"; + isLibrary = true; + isExecutable = true; + libraryHaskellDepends = [ + base bytestring containers explicit-exception extensible-exceptions + sample-frame storablevector transformers utility-ht + ]; + libraryPkgconfigDepends = [ sox ]; + doHaddock = false; + doCheck = false; + homepage = "http://www.haskell.org/haskellwiki/Sox"; + description = "Write, read, convert audio signals using libsox"; + license = stdenv.lib.licenses.bsd3; + }) {inherit (pkgs) sox;}; + "sparse-linear-algebra" = callPackage + ({ mkDerivation, base, containers, exceptions, hspec, mtl + , primitive, QuickCheck, stdenv, transformers, vector + , vector-algorithms + }: + mkDerivation { + pname = "sparse-linear-algebra"; + version = "0.3.1"; + sha256 = "c762778b2e45bdba24336be58375871963d4c2ad76cb03c548f0fe0b72f3dcc9"; + enableSeparateDataOutput = true; + libraryHaskellDepends = [ + base containers exceptions hspec mtl primitive QuickCheck + transformers vector vector-algorithms + ]; + doHaddock = false; + doCheck = false; + homepage = "https://github.com/ocramz/sparse-linear-algebra"; + description = "Numerical computing in native Haskell"; + license = stdenv.lib.licenses.gpl3; + }) {}; + "special-values" = callPackage + ({ mkDerivation, base, bytestring, ieee754, scientific, stdenv + , text + }: + mkDerivation { + pname = "special-values"; + version = "0.1.0.0"; + sha256 = "3c14dd1304dacc8e54c2dcf95ebb3bb74b172b5409b9b45352108a4698e06dce"; + libraryHaskellDepends = [ + base bytestring ieee754 scientific text + ]; + doHaddock = false; + doCheck = false; + homepage = "https://github.com/minad/special-values#readme"; + description = "Typeclass providing special values"; + license = stdenv.lib.licenses.mit; + }) {}; + "speculate" = callPackage + ({ mkDerivation, base, cmdargs, containers, leancheck, stdenv }: + mkDerivation { + pname = "speculate"; + version = "0.3.2"; + sha256 = "d34d66e5487698e1a80b5fbd7d8439a1102cee0a51383ab30cd257078308c831"; + libraryHaskellDepends = [ base cmdargs containers leancheck ]; + doHaddock = false; + doCheck = false; + homepage = "https://github.com/rudymatela/speculate#readme"; + description = "discovery of properties about Haskell functions"; + license = stdenv.lib.licenses.bsd3; + }) {}; + "speculation" = callPackage + ({ mkDerivation, base, ghc-prim, stdenv, stm, transformers }: + mkDerivation { + pname = "speculation"; + version = "1.5.0.3"; + sha256 = "73bf641a87e0d28a2ba233922db936e0776c3dc24ed421f6f963f015e2eb4d3f"; + libraryHaskellDepends = [ base ghc-prim stm transformers ]; + doHaddock = false; + doCheck = false; + homepage = "http://github.com/ekmett/speculation"; + description = "A framework for safe, programmable, speculative parallelism"; + license = stdenv.lib.licenses.bsd3; + }) {}; + "speedy-slice" = callPackage + ({ mkDerivation, base, kan-extensions, lens, mcmc-types + , mwc-probability, pipes, primitive, stdenv, transformers + }: + mkDerivation { + pname = "speedy-slice"; + version = "0.3.0"; + sha256 = "efbf8a10b681b940078f70fb9aca43fec8ba436c82f3faf719bbe495ba152899"; + libraryHaskellDepends = [ + base kan-extensions lens mcmc-types mwc-probability pipes primitive + transformers + ]; + doHaddock = false; + doCheck = false; + homepage = "http://github.com/jtobin/speedy-slice"; + description = "Speedy slice sampling"; + license = stdenv.lib.licenses.mit; + }) {}; + "sphinx" = callPackage + ({ mkDerivation, base, binary, bytestring, data-binary-ieee754 + , network, stdenv, text, text-icu, xml + }: + mkDerivation { + pname = "sphinx"; + version = "0.6.0.2"; + sha256 = "76a977c6ce6e71c220bd5fed7acd0be500c2a1b5c8d081a29564a8e37ba7a6df"; + libraryHaskellDepends = [ + base binary bytestring data-binary-ieee754 network text text-icu + xml + ]; + doHaddock = false; + doCheck = false; + homepage = "https://github.com/gregwebs/haskell-sphinx-client"; + description = "Haskell bindings to the Sphinx full-text searching daemon"; + license = stdenv.lib.licenses.bsd3; + }) {}; + "splice" = callPackage + ({ mkDerivation, base, network, stdenv }: + mkDerivation { + pname = "splice"; + version = "0.6.1.1"; + sha256 = "81fabe6652571f0dbf6b8904bd782daaeccc9d89d40f77b15dff46b7499d4e53"; + libraryHaskellDepends = [ base network ]; + doHaddock = false; + doCheck = false; + homepage = "http://corsis.github.com/splice/"; + description = "Cross-platform Socket to Socket Data Splicing"; + license = stdenv.lib.licenses.bsd3; + }) {}; + "split" = callPackage + ({ mkDerivation, base, stdenv }: + mkDerivation { + pname = "split"; + version = "0.2.3.3"; + sha256 = "1dcd674f7c5f276f33300f5fd59e49d1ac6fc92ae949fd06a0f6d3e9d9ac1413"; + revision = "1"; + editedCabalFile = "0vz2ylx81nfq2981msig080j7n41xf2lrxzf3hj1x3g3cllb3izi"; + libraryHaskellDepends = [ base ]; + doHaddock = false; + doCheck = false; + description = "Combinator library for splitting lists"; + license = stdenv.lib.licenses.bsd3; + }) {}; + "splitmix" = callPackage + ({ mkDerivation, base, deepseq, random, stdenv, time }: + mkDerivation { + pname = "splitmix"; + version = "0.0.1"; + sha256 = "2a6c8003a941640ceab9dc358aadf69e08800e2cb10a267422e4436fe1e8772f"; + revision = "1"; + editedCabalFile = "0c38sajdpqcmicdh4lfy6vpg8wnzpiyamvbximdsqs605frs3mqs"; + libraryHaskellDepends = [ base deepseq random time ]; + doHaddock = false; + doCheck = false; + description = "Fast Splittable PRNG"; + license = stdenv.lib.licenses.bsd3; + }) {}; + "spoon" = callPackage + ({ mkDerivation, base, deepseq, stdenv }: + mkDerivation { + pname = "spoon"; + version = "0.3.1"; + sha256 = "b9b350b6730e34c246bbf7e228a86b3d4925b52c95542f7676d719ef2a9881d4"; + revision = "1"; + editedCabalFile = "09s5jjcsg4g4qxchq9g2l4i9d5zh3rixpkbiysqcgl69kj8mwv74"; + libraryHaskellDepends = [ base deepseq ]; + doHaddock = false; + doCheck = false; + description = "Catch errors thrown from pure computations"; + license = stdenv.lib.licenses.bsd3; + }) {}; + "spreadsheet" = callPackage + ({ mkDerivation, base, explicit-exception, stdenv, transformers + , utility-ht + }: + mkDerivation { + pname = "spreadsheet"; + version = "0.1.3.7"; + sha256 = "840a66ccbfa0f08851e292e0b6a3f1de652f62d66d9b17e83b69153597d81ba0"; + isLibrary = true; + isExecutable = true; + libraryHaskellDepends = [ + base explicit-exception transformers utility-ht + ]; + doHaddock = false; + doCheck = false; + homepage = "http://www.haskell.org/haskellwiki/Spreadsheet"; + description = "Read and write spreadsheets from and to CSV files in a lazy way"; + license = stdenv.lib.licenses.bsd3; + }) {}; + "sql-words" = callPackage + ({ mkDerivation, base, stdenv }: + mkDerivation { + pname = "sql-words"; + version = "0.1.6.2"; + sha256 = "3f6a5a0cf8f8aaf452caa2389db54e09494be3fd9dce111fbf06df2b7eddeb38"; + libraryHaskellDepends = [ base ]; + doHaddock = false; + doCheck = false; + homepage = "http://khibino.github.io/haskell-relational-record/"; + description = "SQL keywords data constructors into OverloadedString"; + license = stdenv.lib.licenses.bsd3; + }) {}; + "sqlite-simple" = callPackage + ({ mkDerivation, attoparsec, base, blaze-builder, blaze-textual + , bytestring, containers, direct-sqlite, Only, semigroups, stdenv + , template-haskell, text, time, transformers + }: + mkDerivation { + pname = "sqlite-simple"; + version = "0.4.16.0"; + sha256 = "60d2a188d1967ebc0d3ec9175776c45a6e1e6e7a4d44567548cb7fe6961d30de"; + libraryHaskellDepends = [ + attoparsec base blaze-builder blaze-textual bytestring containers + direct-sqlite Only semigroups template-haskell text time + transformers + ]; + doHaddock = false; + doCheck = false; + homepage = "http://github.com/nurpax/sqlite-simple"; + description = "Mid-Level SQLite client library"; + license = stdenv.lib.licenses.bsd3; + }) {}; + "sqlite-simple-errors" = callPackage + ({ mkDerivation, base, parsec, sqlite-simple, stdenv, text }: + mkDerivation { + pname = "sqlite-simple-errors"; + version = "0.6.1.0"; + sha256 = "5101f84a6d74d658398cc4ef557ad3c6158d53e9c948301cc47ed0cc3eaa716f"; + libraryHaskellDepends = [ base parsec sqlite-simple text ]; + doHaddock = false; + doCheck = false; + homepage = "https://github.com/caneroj1/sqlite-simple-errors"; + description = "Wrapper around errors from sqlite-simple"; + license = stdenv.lib.licenses.bsd3; + }) {}; + "squeal-postgresql" = callPackage + ({ mkDerivation, aeson, base, binary-parser, bytestring + , bytestring-strict-builder, deepseq, generics-sop, lifted-base + , mmorph, monad-control, mtl, network-ip, postgresql-binary + , postgresql-libpq, profunctors, resource-pool, scientific, stdenv + , text, time, transformers, transformers-base, uuid-types, vector + }: + mkDerivation { + pname = "squeal-postgresql"; + version = "0.3.1.0"; + sha256 = "179d88ece27e247d42573cb75568c19b5da666b74fe768170590cc62c61c1fec"; + isLibrary = true; + isExecutable = true; + libraryHaskellDepends = [ + aeson base binary-parser bytestring bytestring-strict-builder + deepseq generics-sop lifted-base mmorph monad-control mtl + network-ip postgresql-binary postgresql-libpq profunctors + resource-pool scientific text time transformers transformers-base + uuid-types vector + ]; + executableHaskellDepends = [ + base bytestring generics-sop mtl text transformers + transformers-base vector + ]; + doHaddock = false; + doCheck = false; + homepage = "https://github.com/morphismtech/squeal"; + description = "Squeal PostgreSQL Library"; + license = stdenv.lib.licenses.bsd3; + }) {}; + "srcloc" = callPackage + ({ mkDerivation, base, stdenv }: + mkDerivation { + pname = "srcloc"; + version = "0.5.1.2"; + sha256 = "069edbce6bb72e0771cece3aa5a6b67b9e0b0bd0148e9404842fa43035fec06e"; + libraryHaskellDepends = [ base ]; + doHaddock = false; + doCheck = false; + homepage = "https://github.com/mainland/srcloc"; + description = "Data types for managing source code locations"; + license = stdenv.lib.licenses.bsd3; + }) {}; + "stache" = callPackage + ({ mkDerivation, aeson, base, bytestring, containers, deepseq + , directory, filepath, megaparsec, mtl, stdenv, template-haskell + , text, unordered-containers, vector + }: + mkDerivation { + pname = "stache"; + version = "1.2.1"; + sha256 = "6bfbdd2755c606f7b146243db1eefc2f49c720264ba9072a9d170a1bbdbc113b"; + revision = "8"; + editedCabalFile = "0jz9cg3w71nvxc4y6hrwjayxl2291q5xm5r4qrhz1ag1lvzk26yn"; + enableSeparateDataOutput = true; + libraryHaskellDepends = [ + aeson base bytestring containers deepseq directory filepath + megaparsec mtl template-haskell text unordered-containers vector + ]; + doHaddock = false; + doCheck = false; + homepage = "https://github.com/stackbuilders/stache"; + description = "Mustache templates for Haskell"; + license = stdenv.lib.licenses.bsd3; + }) {}; + "stack" = callPackage + ({ mkDerivation, aeson, annotated-wl-pprint, ansi-terminal, async + , attoparsec, base, base64-bytestring, bindings-uname, bytestring + , Cabal, conduit, conduit-extra, containers, cryptonite + , cryptonite-conduit, deepseq, directory, echo, exceptions, extra + , file-embed, filelock, filepath, fsnotify, generic-deriving + , gitrev, hackage-security, hashable, hpack, hpc, http-client + , http-client-tls, http-conduit, http-types, memory, microlens + , mintty, monad-logger, mono-traversable, mtl, mustache + , neat-interpolation, network-uri, open-browser + , optparse-applicative, optparse-simple, path, path-io, persistent + , persistent-sqlite, persistent-template, pretty, primitive + , process, project-template, regex-applicative-text, resourcet + , retry, rio, semigroups, split, stdenv, stm, store, store-core + , streaming-commons, tar, template-haskell, temporary, text + , text-metrics, th-reify-many, time, tls, transformers + , typed-process, unicode-transforms, unix, unix-compat, unliftio + , unordered-containers, vector, yaml, zip-archive, zlib + }: + mkDerivation { + pname = "stack"; + version = "1.7.1"; + sha256 = "19c4f2e02975bb797a339cfe2893c9e1f40241a910da45be34c5c2f05d62329f"; + revision = "10"; + editedCabalFile = "1985lm9m6pm9mi4h4m2nrn9v2rnnfh14slcnqgyxy6k934xqvg35"; + isLibrary = true; + isExecutable = true; + setupHaskellDepends = [ base Cabal filepath ]; + libraryHaskellDepends = [ + aeson annotated-wl-pprint ansi-terminal async attoparsec base + base64-bytestring bindings-uname bytestring Cabal conduit + conduit-extra containers cryptonite cryptonite-conduit deepseq + directory echo exceptions extra file-embed filelock filepath + fsnotify generic-deriving hackage-security hashable hpack hpc + http-client http-client-tls http-conduit http-types memory + microlens mintty monad-logger mono-traversable mtl mustache + neat-interpolation network-uri open-browser optparse-applicative + path path-io persistent persistent-sqlite persistent-template + pretty primitive process project-template regex-applicative-text + resourcet retry rio semigroups split stm store store-core + streaming-commons tar template-haskell temporary text text-metrics + th-reify-many time tls transformers typed-process + unicode-transforms unix unix-compat unliftio unordered-containers + vector yaml zip-archive zlib + ]; + executableHaskellDepends = [ + aeson annotated-wl-pprint ansi-terminal async attoparsec base + base64-bytestring bindings-uname bytestring Cabal conduit + conduit-extra containers cryptonite cryptonite-conduit deepseq + directory echo exceptions extra file-embed filelock filepath + fsnotify generic-deriving gitrev hackage-security hashable hpack + hpc http-client http-client-tls http-conduit http-types memory + microlens mintty monad-logger mono-traversable mtl mustache + neat-interpolation network-uri open-browser optparse-applicative + optparse-simple path path-io persistent persistent-sqlite + persistent-template pretty primitive process project-template + regex-applicative-text resourcet retry rio semigroups split stm + store store-core streaming-commons tar template-haskell temporary + text text-metrics th-reify-many time tls transformers typed-process + unicode-transforms unix unix-compat unliftio unordered-containers + vector yaml zip-archive zlib + ]; + doHaddock = false; + doCheck = false; + preCheck = "export HOME=$TMPDIR"; + postInstall = '' + exe=$out/bin/stack + mkdir -p $out/share/bash-completion/completions + $exe --bash-completion-script $exe >$out/share/bash-completion/completions/stack + ''; + homepage = "http://haskellstack.org"; + description = "The Haskell Tool Stack"; + license = stdenv.lib.licenses.bsd3; + }) {}; + "starter" = callPackage + ({ mkDerivation, base, fsnotify, stdenv }: + mkDerivation { + pname = "starter"; + version = "0.3.0"; + sha256 = "fd569cd27cfd62fb9d3e544e222450ec2734c44a3293994f35a26af982ce3d93"; + libraryHaskellDepends = [ base fsnotify ]; + doHaddock = false; + doCheck = false; + homepage = "https://github.com/rkaippully/starter#readme"; + description = "Develop applications without restarts"; + license = stdenv.lib.licenses.mpl20; + }) {}; + "state-codes" = callPackage + ({ mkDerivation, aeson, base, shakespeare, stdenv, text }: + mkDerivation { + pname = "state-codes"; + version = "0.1.3"; + sha256 = "1667dc977607fc89a0ca736294b2f0a19608fbe861f03f404c3f8ee91fd0f4a1"; + libraryHaskellDepends = [ aeson base shakespeare text ]; + doHaddock = false; + doCheck = false; + homepage = "https://github.com/acamino/state-codes#README"; + description = "ISO 3166-2:US state codes and i18n names"; + license = stdenv.lib.licenses.mit; + }) {}; + "stateref" = callPackage + ({ mkDerivation, base, mtl, stdenv, stm }: + mkDerivation { + pname = "stateref"; + version = "0.3"; + sha256 = "7dd390aab346ca877cde1217d5b62145cdfa6f9390e3b7a53c9296229ee1b741"; + libraryHaskellDepends = [ base mtl stm ]; + doHaddock = false; + doCheck = false; + homepage = "http://code.haskell.org/~mokus/stateref/"; + description = "Abstraction for things that work like IORef"; + license = stdenv.lib.licenses.publicDomain; + }) {}; + "statestack" = callPackage + ({ mkDerivation, base, mtl, stdenv, transformers + , transformers-compat + }: + mkDerivation { + pname = "statestack"; + version = "0.2.0.5"; + sha256 = "f4eadcf9b08c14cb084436f81e16edf78d6eeda77a3f93e38ba5d7e263ea5f66"; + revision = "3"; + editedCabalFile = "0s9v88gcc5wnfj4c6xq86asadmh4y8z8ycv2wz5nwfwfazfgzcy3"; + libraryHaskellDepends = [ + base mtl transformers transformers-compat + ]; + doHaddock = false; + doCheck = false; + description = "Simple State-like monad transformer with saveable and restorable state"; + license = stdenv.lib.licenses.bsd3; + }) {}; + "static-canvas" = callPackage + ({ mkDerivation, base, double-conversion, free, mtl, stdenv, text + }: + mkDerivation { + pname = "static-canvas"; + version = "0.2.0.3"; + sha256 = "370824df08cedef2aacbbc8b855fd5cd3c80cfcc07ae2931e0f25397a61dd749"; + revision = "1"; + editedCabalFile = "1z3mi5z590xxmipd5fxylcmf39rrwvmwva2rkk6km1nxb5kfasl7"; + libraryHaskellDepends = [ base double-conversion free mtl text ]; + doHaddock = false; + doCheck = false; + homepage = "https://github.com/jeffreyrosenbluth/static-canvas"; + description = "DSL to generate HTML5 Canvas javascript"; + license = stdenv.lib.licenses.bsd3; + }) {}; + "static-text" = callPackage + ({ mkDerivation, base, bytestring, stdenv, template-haskell, text + , vector + }: + mkDerivation { + pname = "static-text"; + version = "0.2.0.1"; + sha256 = "ed5d12d1bc9d6c91241007278746be07fcdcf30babc4d0705a2253b646499229"; + libraryHaskellDepends = [ + base bytestring template-haskell text vector + ]; + doHaddock = false; + doCheck = false; + homepage = "https://github.com/dzhus/static-text#readme"; + description = "Lists, Texts, ByteStrings and Vectors of statically known length"; + license = stdenv.lib.licenses.bsd3; + }) {}; + "statistics" = callPackage + ({ mkDerivation, aeson, base, base-orphans, binary, deepseq, erf + , math-functions, monad-par, mwc-random, primitive, stdenv, vector + , vector-algorithms, vector-binary-instances, vector-th-unbox + }: + mkDerivation { + pname = "statistics"; + version = "0.14.0.2"; + sha256 = "3495df2da42c9fcc5b594b97f16c02353bfd6616d6e134ac031dac389d7a4778"; + revision = "2"; + editedCabalFile = "1bx70yqkn62ii17fjv3pig4hklrzkqd09zj67zzjiyjzmn04fir3"; + libraryHaskellDepends = [ + aeson base base-orphans binary deepseq erf math-functions monad-par + mwc-random primitive vector vector-algorithms + vector-binary-instances vector-th-unbox + ]; + doHaddock = false; + doCheck = false; + homepage = "https://github.com/bos/statistics"; + description = "A library of statistical types, data, and functions"; + license = stdenv.lib.licenses.bsd2; + }) {}; + "stb-image-redux" = callPackage + ({ mkDerivation, base, stdenv, vector }: + mkDerivation { + pname = "stb-image-redux"; + version = "0.2.1.2"; + sha256 = "3bf41af8950ecf0ac5645634fdd233f941a904c6c56222ff4efb03f5d17043e8"; + libraryHaskellDepends = [ base vector ]; + doHaddock = false; + doCheck = false; + homepage = "https://github.com/typedrat/stb-image-redux#readme"; + description = "Image loading and writing microlibrary"; + license = stdenv.lib.licenses.bsd3; + }) {}; + "step-function" = callPackage + ({ mkDerivation, base, base-compat-batteries, containers, deepseq + , QuickCheck, stdenv + }: + mkDerivation { + pname = "step-function"; + version = "0.2"; + sha256 = "d260fcb72bd3afe3c2b0a80f3f3a5c7afae63d98138d137a80ed8ba131fee7d5"; + revision = "1"; + editedCabalFile = "03ga9vwaxsf0c73fciavkm925l7lkgya1a6xghyb8ainrav0bfq4"; + libraryHaskellDepends = [ + base base-compat-batteries containers deepseq QuickCheck + ]; + doHaddock = false; + doCheck = false; + homepage = "https://github.com/jonpetterbergman/step-function"; + description = "Staircase functions or piecewise constant functions"; + license = stdenv.lib.licenses.bsd3; + }) {}; + "stm" = callPackage + ({ mkDerivation, array, base, stdenv }: + mkDerivation { + pname = "stm"; + version = "2.4.5.0"; + sha256 = "31d7db183f13beed5c71409d12747a7f4cf3e145630553dc86336208540859a7"; + libraryHaskellDepends = [ array base ]; + doHaddock = false; + doCheck = false; + homepage = "https://wiki.haskell.org/Software_transactional_memory"; + description = "Software Transactional Memory"; + license = stdenv.lib.licenses.bsd3; + }) {}; + "stm-chans" = callPackage + ({ mkDerivation, base, Cabal, stdenv, stm }: + mkDerivation { + pname = "stm-chans"; + version = "3.0.0.4"; + sha256 = "2344fc5bfa33d565bad7b009fc0e2c5a7a595060ba149c661f44419fc0d54738"; + revision = "1"; + editedCabalFile = "0v9axxcfszqdmf3dhjxy34ybh22x3r5c48mdnbvjh5i5lp7g7vp2"; + setupHaskellDepends = [ base Cabal ]; + libraryHaskellDepends = [ base stm ]; + doHaddock = false; + doCheck = false; + homepage = "http://code.haskell.org/~wren/"; + description = "Additional types of channels for STM"; + license = stdenv.lib.licenses.bsd3; + }) {}; + "stm-conduit" = callPackage + ({ mkDerivation, async, base, cereal, cereal-conduit, conduit + , conduit-extra, directory, exceptions, monad-loops, resourcet + , stdenv, stm, stm-chans, transformers, unliftio + }: + mkDerivation { + pname = "stm-conduit"; + version = "4.0.0"; + sha256 = "ffe46c8848f002b016c86f76155b4523b2af35b2c027847afe0edb6325bd4a5d"; + libraryHaskellDepends = [ + async base cereal cereal-conduit conduit conduit-extra directory + exceptions monad-loops resourcet stm stm-chans transformers + unliftio + ]; + doHaddock = false; + doCheck = false; + homepage = "https://github.com/cgaebel/stm-conduit"; + description = "Introduces conduits to channels, and promotes using conduits concurrently"; + license = stdenv.lib.licenses.bsd3; + }) {}; + "stm-containers" = callPackage + ({ mkDerivation, base, base-prelude, focus, hashable, list-t + , primitive, stdenv, transformers + }: + mkDerivation { + pname = "stm-containers"; + version = "0.2.16"; + sha256 = "69042f06647cdc69e1ecf83863d88d67acd377f631d8a15966df67245152502f"; + libraryHaskellDepends = [ + base base-prelude focus hashable list-t primitive transformers + ]; + doHaddock = false; + doCheck = false; + homepage = "https://github.com/nikita-volkov/stm-containers"; + description = "Containers for STM"; + license = stdenv.lib.licenses.mit; + }) {}; + "stm-delay" = callPackage + ({ mkDerivation, base, stdenv, stm }: + mkDerivation { + pname = "stm-delay"; + version = "0.1.1.1"; + sha256 = "b132581aac47e6cba6a1691a485e1700fbb047c02b7e1e43ae9bbd8476108a32"; + libraryHaskellDepends = [ base stm ]; + doHaddock = false; + doCheck = false; + homepage = "https://github.com/joeyadams/haskell-stm-delay"; + description = "Updatable one-shot timer polled with STM"; + license = stdenv.lib.licenses.bsd3; + }) {}; + "stm-extras" = callPackage + ({ mkDerivation, base, stdenv, stm }: + mkDerivation { + pname = "stm-extras"; + version = "0.1.0.3"; + sha256 = "88210a157d5a5a2c3bd10b3b9f0ead9bef91f47ecfe6fd56deca058c7270b75e"; + libraryHaskellDepends = [ base stm ]; + doHaddock = false; + doCheck = false; + homepage = "https://github.com/louispan/stm-extras#readme"; + description = "Extra STM functions"; + license = stdenv.lib.licenses.bsd3; + }) {}; + "stm-split" = callPackage + ({ mkDerivation, base, stdenv, stm }: + mkDerivation { + pname = "stm-split"; + version = "0.0.2"; + sha256 = "3c06a43889acc02425b7a5299f71de86ebba6245a92a507db976dc7256713807"; + libraryHaskellDepends = [ base stm ]; + doHaddock = false; + doCheck = false; + description = "TMVars, TVars and TChans with distinguished input and output side"; + license = stdenv.lib.licenses.bsd3; + }) {}; + "stm-stats" = callPackage + ({ mkDerivation, base, containers, stdenv, stm, template-haskell + , time + }: + mkDerivation { + pname = "stm-stats"; + version = "0.2.0.0"; + sha256 = "0a4f39b1e9fffe50d6dfaa9c0b04977e510fae8b6bd3d7abb7076e8aa8f01345"; + libraryHaskellDepends = [ + base containers stm template-haskell time + ]; + doHaddock = false; + doCheck = false; + description = "retry statistics for STM transactions"; + license = stdenv.lib.licenses.bsd3; + }) {}; + "stopwatch" = callPackage + ({ mkDerivation, base, clock, stdenv, transformers }: + mkDerivation { + pname = "stopwatch"; + version = "0.1.0.5"; + sha256 = "461ed69edf8d68cdadd8d0c6159e9c2fef71d1a440c6feded0b07c77d9113461"; + libraryHaskellDepends = [ base clock transformers ]; + doHaddock = false; + doCheck = false; + homepage = "https://github.com/debug-ito/stopwatch"; + description = "A simple stopwatch utility"; + license = stdenv.lib.licenses.bsd3; + }) {}; + "storable-complex" = callPackage + ({ mkDerivation, base, stdenv }: + mkDerivation { + pname = "storable-complex"; + version = "0.2.2"; + sha256 = "ab076f15c47a2a324a2119c8feee0a78e1d2af488d0d24b7113b4bb7eee47c06"; + libraryHaskellDepends = [ base ]; + doHaddock = false; + doCheck = false; + homepage = "https://github.com/cartazio/storable-complex"; + description = "Storable instance for Complex"; + license = stdenv.lib.licenses.bsd3; + }) {}; + "storable-endian" = callPackage + ({ mkDerivation, base, byteorder, stdenv }: + mkDerivation { + pname = "storable-endian"; + version = "0.2.6"; + sha256 = "3743ac8f084ed3187b83f17b4fac280e77c5df01f7910f42b6a1bf09d5a65489"; + revision = "1"; + editedCabalFile = "12f8sscsvsarlwz3p6kk9vbvqsbyhs8lhafgn9h7c0z6pz1amrya"; + libraryHaskellDepends = [ base byteorder ]; + doHaddock = false; + doCheck = false; + description = "Storable instances with endianness"; + license = stdenv.lib.licenses.bsd3; + }) {}; + "storable-record" = callPackage + ({ mkDerivation, base, semigroups, stdenv, transformers, utility-ht + }: + mkDerivation { + pname = "storable-record"; + version = "0.0.4"; + sha256 = "ceffb2f08d8abc37e338ad924b264c230d5e54ecccaf1c22802c3107ea0c5a42"; + isLibrary = true; + isExecutable = true; + libraryHaskellDepends = [ + base semigroups transformers utility-ht + ]; + doHaddock = false; + doCheck = false; + homepage = "http://code.haskell.org/~thielema/storable-record/"; + description = "Elegant definition of Storable instances for records"; + license = stdenv.lib.licenses.bsd3; + }) {}; + "storable-tuple" = callPackage + ({ mkDerivation, base, base-orphans, stdenv, storable-record + , utility-ht + }: + mkDerivation { + pname = "storable-tuple"; + version = "0.0.3.3"; + sha256 = "dcfac049527a45c386c80a7c40ec211455b83d74311af88fa686063b5f87df35"; + libraryHaskellDepends = [ + base base-orphans storable-record utility-ht + ]; + doHaddock = false; + doCheck = false; + homepage = "http://code.haskell.org/~thielema/storable-tuple/"; + description = "Storable instance for pairs and triples"; + license = stdenv.lib.licenses.bsd3; + }) {}; + "storablevector" = callPackage + ({ mkDerivation, base, deepseq, non-negative, QuickCheck + , semigroups, stdenv, syb, transformers, unsafe, utility-ht + }: + mkDerivation { + pname = "storablevector"; + version = "0.2.13"; + sha256 = "f83742d572aca9431f8ee6325d29169bc630beb2d8ab1957f7165abed138b9fe"; + libraryHaskellDepends = [ + base deepseq non-negative QuickCheck semigroups syb transformers + unsafe utility-ht + ]; + doHaddock = false; + doCheck = false; + homepage = "http://www.haskell.org/haskellwiki/Storable_Vector"; + description = "Fast, packed, strict storable arrays with a list interface like ByteString"; + license = stdenv.lib.licenses.bsd3; + }) {}; + "store" = callPackage + ({ mkDerivation, array, async, base, base-orphans + , base64-bytestring, bifunctors, bytestring, containers + , contravariant, cryptohash, deepseq, directory, filepath, free + , ghc-prim, hashable, hspec, hspec-smallcheck, integer-gmp + , lifted-base, monad-control, mono-traversable, network, primitive + , resourcet, safe, semigroups, smallcheck, stdenv, store-core, syb + , template-haskell, text, th-lift, th-lift-instances, th-orphans + , th-reify-many, th-utilities, time, transformers + , unordered-containers, vector, void + }: + mkDerivation { + pname = "store"; + version = "0.5.0"; + sha256 = "32ee23c58cf8fbc6250dc38d719baffb90b668da9217612ea45728e9f61579c7"; + libraryHaskellDepends = [ + array async base base-orphans base64-bytestring bifunctors + bytestring containers contravariant cryptohash deepseq directory + filepath free ghc-prim hashable hspec hspec-smallcheck integer-gmp + lifted-base monad-control mono-traversable network primitive + resourcet safe semigroups smallcheck store-core syb + template-haskell text th-lift th-lift-instances th-orphans + th-reify-many th-utilities time transformers unordered-containers + vector void + ]; + doHaddock = false; + doCheck = false; + homepage = "https://github.com/fpco/store#readme"; + description = "Fast binary serialization"; + license = stdenv.lib.licenses.mit; + }) {}; + "store-core" = callPackage + ({ mkDerivation, base, bytestring, ghc-prim, primitive, stdenv + , text, transformers + }: + mkDerivation { + pname = "store-core"; + version = "0.4.4"; + sha256 = "5baecf8c074ff8dca4633630adc979696d7e8ee0a58e143e4d6d0f5c79f30991"; + libraryHaskellDepends = [ + base bytestring ghc-prim primitive text transformers + ]; + doHaddock = false; + doCheck = false; + homepage = "https://github.com/fpco/store#readme"; + description = "Fast and lightweight binary serialization"; + license = stdenv.lib.licenses.mit; + }) {}; + "stratosphere" = callPackage + ({ mkDerivation, aeson, aeson-pretty, base, bytestring, containers + , hashable, lens, stdenv, template-haskell, text + , unordered-containers + }: + mkDerivation { + pname = "stratosphere"; + version = "0.24.3"; + sha256 = "bfed5d9bf3af64b77e4cdc9239ae65ba9ea947c2b03e3527a433b2ef12626ab7"; + isLibrary = true; + isExecutable = true; + libraryHaskellDepends = [ + aeson aeson-pretty base bytestring containers hashable lens + template-haskell text unordered-containers + ]; + doHaddock = false; + doCheck = false; + homepage = "https://github.com/frontrowed/stratosphere#readme"; + description = "EDSL for AWS CloudFormation"; + license = stdenv.lib.licenses.mit; + }) {}; + "streaming" = callPackage + ({ mkDerivation, base, containers, ghc-prim, mmorph, mtl + , semigroups, stdenv, transformers, transformers-base + }: + mkDerivation { + pname = "streaming"; + version = "0.2.1.0"; + sha256 = "e11d5e38c4c350cc95180cb0cf80efc0a6051ee8dd17c54961b837112c135075"; + revision = "2"; + editedCabalFile = "124nccw28cwzjzl82anbwk7phcyfzlz8yx6wyl4baymzdikvbpgq"; + libraryHaskellDepends = [ + base containers ghc-prim mmorph mtl semigroups transformers + transformers-base + ]; + doHaddock = false; + doCheck = false; + homepage = "https://github.com/haskell-streaming/streaming"; + description = "an elementary streaming prelude and general stream type"; + license = stdenv.lib.licenses.bsd3; + }) {}; + "streaming-attoparsec" = callPackage + ({ mkDerivation, attoparsec, base, bytestring, stdenv, streaming + , streaming-bytestring + }: + mkDerivation { + pname = "streaming-attoparsec"; + version = "1.0.0"; + sha256 = "ff28925269ed98f03ef10a482980030dd7c8ef4c05ef6e32d147db9331df6102"; + revision = "1"; + editedCabalFile = "0ssikp3ckvlgh9px4v6ppjlyi7ch319j0l3s9a5z07j6fg3j4wkp"; + libraryHaskellDepends = [ + attoparsec base bytestring streaming streaming-bytestring + ]; + doHaddock = false; + doCheck = false; + homepage = "https://github.com/haskell-streaming/streaming-attoparsec"; + description = "Attoparsec integration for the streaming ecosystem"; + license = stdenv.lib.licenses.bsd3; + }) {}; + "streaming-bytestring" = callPackage + ({ mkDerivation, base, bytestring, deepseq, exceptions, mmorph, mtl + , resourcet, stdenv, streaming, transformers, transformers-base + }: + mkDerivation { + pname = "streaming-bytestring"; + version = "0.1.6"; + sha256 = "c1d723fc9676b85f62f9fc937d756af61d81f69c9c6591e5d38c9b09b7a253d3"; + libraryHaskellDepends = [ + base bytestring deepseq exceptions mmorph mtl resourcet streaming + transformers transformers-base + ]; + doHaddock = false; + doCheck = false; + homepage = "https://github.com/haskell-streaming/streaming-bytestring"; + description = "effectful byte steams, or: bytestring io done right"; + license = stdenv.lib.licenses.bsd3; + }) {}; + "streaming-commons" = callPackage + ({ mkDerivation, array, async, base, bytestring, directory, network + , process, random, stdenv, stm, text, transformers, unix, zlib + }: + mkDerivation { + pname = "streaming-commons"; + version = "0.2.1.0"; + sha256 = "d8d1fe588924479ea7eefce8c6af77dfb373ee6bde7f4691bdfcbd782b36d68d"; + libraryHaskellDepends = [ + array async base bytestring directory network process random stm + text transformers unix zlib + ]; + doHaddock = false; + doCheck = false; + homepage = "https://github.com/fpco/streaming-commons"; + description = "Common lower-level functions needed by various streaming data libraries"; + license = stdenv.lib.licenses.mit; + }) {}; + "streaming-wai" = callPackage + ({ mkDerivation, base, bytestring, bytestring-builder, http-types + , stdenv, streaming, wai + }: + mkDerivation { + pname = "streaming-wai"; + version = "0.1.1"; + sha256 = "35b4182386cc1d23731b3eac78dda79a1b7878c0b6bd78fd99907c776dbfaf30"; + libraryHaskellDepends = [ + base bytestring bytestring-builder http-types streaming wai + ]; + doHaddock = false; + doCheck = false; + homepage = "http://github.com/jb55/streaming-wai"; + description = "Streaming Wai utilities"; + license = stdenv.lib.licenses.mit; + }) {}; + "streamly" = callPackage + ({ mkDerivation, atomic-primops, base, containers, exceptions + , heaps, lockfree-queue, monad-control, mtl, stdenv, transformers + , transformers-base + }: + mkDerivation { + pname = "streamly"; + version = "0.3.0"; + sha256 = "33d4b3d03e6e7b66a25c3259b0c80a51a0366e6bfb35686eeacb2d8cb831576b"; + isLibrary = true; + isExecutable = true; + libraryHaskellDepends = [ + atomic-primops base containers exceptions heaps lockfree-queue + monad-control mtl transformers transformers-base + ]; + doHaddock = false; + doCheck = false; + homepage = "https://github.com/composewell/streamly"; + description = "Beautiful Streaming, Concurrent and Reactive Composition"; + license = stdenv.lib.licenses.bsd3; + }) {}; + "streamproc" = callPackage + ({ mkDerivation, base, stdenv }: + mkDerivation { + pname = "streamproc"; + version = "1.6.2"; + sha256 = "e76effaaff83e6a066df949415db109b405bda0aaeb95f0710906c65892584f2"; + libraryHaskellDepends = [ base ]; + doHaddock = false; + doCheck = false; + homepage = "http://github.com/peti/streamproc"; + description = "Stream Processer Arrow"; + license = stdenv.lib.licenses.bsd3; + }) {}; + "streams" = callPackage + ({ mkDerivation, adjunctions, base, comonad, distributive + , semigroupoids, semigroups, stdenv + }: + mkDerivation { + pname = "streams"; + version = "3.3"; + sha256 = "2933f80d6a83fed326af5588b0cce93985b07233359c311bd69c5bac19954e40"; + libraryHaskellDepends = [ + adjunctions base comonad distributive semigroupoids semigroups + ]; + doHaddock = false; + doCheck = false; + homepage = "http://github.com/ekmett/streams/issues"; + description = "Various Haskell 2010 stream comonads"; + license = stdenv.lib.licenses.bsd3; + }) {}; + "strict" = callPackage + ({ mkDerivation, array, base, stdenv }: + mkDerivation { + pname = "strict"; + version = "0.3.2"; + sha256 = "2cd35a67938db635a87617d9576d5df0158b581e8e5694f07487c0f4b1549221"; + libraryHaskellDepends = [ array base ]; + doHaddock = false; + doCheck = false; + homepage = "http://www.cse.unsw.edu.au/~rl/code/strict.html"; + description = "Strict data types and String IO"; + license = stdenv.lib.licenses.bsd3; + }) {}; + "strict-base-types" = callPackage + ({ mkDerivation, aeson, base, bifunctors, binary, deepseq, ghc-prim + , hashable, lens, QuickCheck, stdenv, strict + }: + mkDerivation { + pname = "strict-base-types"; + version = "0.6.1"; + sha256 = "f8866a3acc7d61f1fbffc2823c24d35b4f63f90612bf0c63292f3d25a3dc307a"; + libraryHaskellDepends = [ + aeson base bifunctors binary deepseq ghc-prim hashable lens + QuickCheck strict + ]; + doHaddock = false; + doCheck = false; + homepage = "https://github.com/meiersi/strict-base-types"; + description = "Strict variants of the types provided in base"; + license = stdenv.lib.licenses.bsd3; + }) {}; + "strict-concurrency" = callPackage + ({ mkDerivation, base, deepseq, stdenv }: + mkDerivation { + pname = "strict-concurrency"; + version = "0.2.4.2"; + sha256 = "bf5ad5d14134b57908966322d6b4a07925569b1f351ffe47644233ac4183f86f"; + revision = "1"; + editedCabalFile = "12m1jbf01d4k7w1wiqcpdsbhlxi6ssbz9nx0ax2mrjjq2l0011ny"; + libraryHaskellDepends = [ base deepseq ]; + doHaddock = false; + doCheck = false; + homepage = "https://github.com/ygale/strict-concurrency"; + description = "Strict concurrency abstractions"; + license = stdenv.lib.licenses.bsd3; + }) {}; + "string-class" = callPackage + ({ mkDerivation, base, bytestring, stdenv, tagged, text }: + mkDerivation { + pname = "string-class"; + version = "0.1.7.0"; + sha256 = "8e5b00563ec2a62120036ab5e06cade5eb7ff8c9caa86f42213c66be39900be8"; + libraryHaskellDepends = [ base bytestring tagged text ]; + doHaddock = false; + doCheck = false; + homepage = "https://github.com/string-class/string-class"; + description = "String class library"; + license = stdenv.lib.licenses.bsd3; + }) {}; + "string-combinators" = callPackage + ({ mkDerivation, base, stdenv }: + mkDerivation { + pname = "string-combinators"; + version = "0.6.0.5"; + sha256 = "94914abfbd7d17051edab4bc9927c191fd05a652d9ef3cf259b5d0e0ca177e1e"; + libraryHaskellDepends = [ base ]; + doHaddock = false; + doCheck = false; + homepage = "https://github.com/basvandijk/string-combinators"; + description = "Polymorphic functions to build and combine stringlike values"; + license = stdenv.lib.licenses.bsd3; + }) {}; + "string-conv" = callPackage + ({ mkDerivation, base, bytestring, stdenv, text }: + mkDerivation { + pname = "string-conv"; + version = "0.1.2"; + sha256 = "f259a03e6f296af19a71c07ab9a98a38661dfe40679f360f8e371334ea226039"; + libraryHaskellDepends = [ base bytestring text ]; + doHaddock = false; + doCheck = false; + homepage = "https://github.com/Soostone/string-conv"; + description = "Standardized conversion between string types"; + license = stdenv.lib.licenses.bsd3; + }) {}; + "string-conversions" = callPackage + ({ mkDerivation, base, bytestring, stdenv, text, utf8-string }: + mkDerivation { + pname = "string-conversions"; + version = "0.4.0.1"; + sha256 = "46bcce6d9ce62c558b7658a75d9c6a62f7259d6b0473d011d8078234ad6a1994"; + libraryHaskellDepends = [ base bytestring text utf8-string ]; + doHaddock = false; + doCheck = false; + homepage = "https://github.com/soenkehahn/string-conversions#readme"; + description = "Simplifies dealing with different types for strings"; + license = stdenv.lib.licenses.bsd3; + }) {}; + "string-qq" = callPackage + ({ mkDerivation, base, Cabal, process, stdenv, template-haskell }: + mkDerivation { + pname = "string-qq"; + version = "0.0.2"; + sha256 = "9757cad387856a313729caffe0639215a10be7d72b09c44bcab9e55ee2a8c218"; + revision = "1"; + editedCabalFile = "1flc6mr1nnv8mx69cy1ilwk5gxsidcns82vjdg8dcs8z5axg95kp"; + enableSeparateDataOutput = true; + setupHaskellDepends = [ base Cabal process ]; + libraryHaskellDepends = [ base template-haskell ]; + doHaddock = false; + doCheck = false; + description = "QuasiQuoter for non-interpolated strings, texts and bytestrings"; + license = stdenv.lib.licenses.publicDomain; + }) {}; + "string-transform" = callPackage + ({ mkDerivation, base, bytestring, stdenv, text, utf8-string }: + mkDerivation { + pname = "string-transform"; + version = "1.1.0"; + sha256 = "4d7daffe1d58671af5111c7179905653d692884cac21f09061768a5a6354e6b8"; + libraryHaskellDepends = [ base bytestring text utf8-string ]; + doHaddock = false; + doCheck = false; + homepage = "https://github.com/ncaq/string-transform#readme"; + description = "simple and easy haskell string transform wrapper"; + license = stdenv.lib.licenses.mit; + }) {}; + "stringbuilder" = callPackage + ({ mkDerivation, base, stdenv }: + mkDerivation { + pname = "stringbuilder"; + version = "0.5.1"; + sha256 = "d878bdc4da806dbce5ab684ef13d2634c17c15b991d0ed3bb25a331eba6603ba"; + libraryHaskellDepends = [ base ]; + doHaddock = false; + doCheck = false; + description = "A writer monad for multi-line string literals"; + license = stdenv.lib.licenses.mit; + }) {}; + "stringsearch" = callPackage + ({ mkDerivation, array, base, bytestring, containers, stdenv }: + mkDerivation { + pname = "stringsearch"; + version = "0.3.6.6"; + sha256 = "295f1971920bc52263d8275d7054ad223a7e1aefe75533f9887735c9644ffe4a"; + revision = "1"; + editedCabalFile = "0z5pz5dccapz9k39r2zmf056m0x2m2lj3jahhnw3mfxlmps07378"; + libraryHaskellDepends = [ array base bytestring containers ]; + doHaddock = false; + doCheck = false; + homepage = "https://bitbucket.org/dafis/stringsearch"; + description = "Fast searching, splitting and replacing of ByteStrings"; + license = stdenv.lib.licenses.bsd3; + }) {}; + "strive" = callPackage + ({ mkDerivation, aeson, base, bytestring, data-default, gpolyline + , http-client, http-client-tls, http-types, stdenv + , template-haskell, text, time, transformers + }: + mkDerivation { + pname = "strive"; + version = "5.0.6"; + sha256 = "67a4db92a419f027e4af0545f8ecb72089eff138c008da0e91e5eb650d4aee36"; + libraryHaskellDepends = [ + aeson base bytestring data-default gpolyline http-client + http-client-tls http-types template-haskell text time transformers + ]; + doHaddock = false; + doCheck = false; + homepage = "https://github.com/tfausak/strive#readme"; + description = "A client for the Strava V3 API"; + license = stdenv.lib.licenses.mit; + }) {}; + "structs" = callPackage + ({ mkDerivation, base, Cabal, cabal-doctest, deepseq, ghc-prim + , primitive, stdenv, template-haskell + }: + mkDerivation { + pname = "structs"; + version = "0.1.1"; + sha256 = "df60ac419775ad96959338c7f14e93a3d47b82728234df206b0145d33694aa41"; + revision = "2"; + editedCabalFile = "1v9gmnj17cm4p491rizvw9xdj255lk1y24gz6s8bqcz56sdb4d4s"; + setupHaskellDepends = [ base Cabal cabal-doctest ]; + libraryHaskellDepends = [ + base deepseq ghc-prim primitive template-haskell + ]; + doHaddock = false; + doCheck = false; + homepage = "http://github.com/ekmett/structs/"; + description = "Strict GC'd imperative object-oriented programming with cheap pointers"; + license = stdenv.lib.licenses.bsd3; + }) {}; + "stylish-haskell" = callPackage + ({ mkDerivation, aeson, base, bytestring, containers, directory + , file-embed, filepath, haskell-src-exts, mtl, optparse-applicative + , semigroups, stdenv, strict, syb, yaml + }: + mkDerivation { + pname = "stylish-haskell"; + version = "0.9.2.0"; + sha256 = "db9f10056a949ad361b5fe3c6fc189601eec2c0058ff2b705ebe68e043b5229b"; + isLibrary = true; + isExecutable = true; + libraryHaskellDepends = [ + aeson base bytestring containers directory file-embed filepath + haskell-src-exts mtl semigroups syb yaml + ]; + executableHaskellDepends = [ + aeson base bytestring containers directory file-embed filepath + haskell-src-exts mtl optparse-applicative strict syb yaml + ]; + doHaddock = false; + doCheck = false; + homepage = "https://github.com/jaspervdj/stylish-haskell"; + description = "Haskell code prettifier"; + license = stdenv.lib.licenses.bsd3; + }) {}; + "sum-type-boilerplate" = callPackage + ({ mkDerivation, base, stdenv, template-haskell }: + mkDerivation { + pname = "sum-type-boilerplate"; + version = "0.1.1"; + sha256 = "3169da14c604e19afdcbf721ef1749b9486618ba23bbec14e86ae9862bf0ab9f"; + libraryHaskellDepends = [ base template-haskell ]; + doHaddock = false; + doCheck = false; + homepage = "https://github.com/jdreaver/sum-type-boilerplate#readme"; + description = "Library for reducing the boilerplate involved with sum types"; + license = stdenv.lib.licenses.mit; + }) {}; + "summoner" = callPackage + ({ mkDerivation, aeson, ansi-terminal, base, bytestring, directory + , filepath, generic-deriving, neat-interpolation + , optparse-applicative, process, stdenv, text, time, tomland + , universum + }: + mkDerivation { + pname = "summoner"; + version = "1.0.4"; + sha256 = "d64359adcfef8e422d5fbacfe2f4e0d1e32dcee81bd4a20e1626bd4d4da78fbf"; + isLibrary = true; + isExecutable = true; + libraryHaskellDepends = [ + aeson ansi-terminal base bytestring directory filepath + generic-deriving neat-interpolation optparse-applicative process + text time tomland universum + ]; + executableHaskellDepends = [ base universum ]; + doHaddock = false; + doCheck = false; + homepage = "https://github.com/kowainik/summoner"; + description = "Tool for creating completely configured production Haskell projects"; + license = stdenv.lib.licenses.mpl20; + }) {}; + "sundown" = callPackage + ({ mkDerivation, base, bytestring, stdenv, text }: + mkDerivation { + pname = "sundown"; + version = "0.6"; + sha256 = "cb9b7e98138311375148ffe0fa4c4b04eb7a9f8ec2ae13a674d465e5d71db027"; + libraryHaskellDepends = [ base bytestring text ]; + doHaddock = false; + doCheck = false; + homepage = "https://github.com/bitonic/sundown"; + description = "Bindings to the sundown markdown library"; + license = stdenv.lib.licenses.publicDomain; + }) {}; + "superbuffer" = callPackage + ({ mkDerivation, base, bytestring, stdenv }: + mkDerivation { + pname = "superbuffer"; + version = "0.3.1.1"; + sha256 = "d7a5fb5478731deab80f89233e4f85511949c04b96ad6284f99f16c5c4166c78"; + libraryHaskellDepends = [ base bytestring ]; + doHaddock = false; + doCheck = false; + homepage = "https://github.com/agrafix/superbuffer#readme"; + description = "Efficiently build a bytestring from smaller chunks"; + license = stdenv.lib.licenses.bsd3; + }) {}; + "svg-builder" = callPackage + ({ mkDerivation, base, blaze-builder, bytestring, hashable, stdenv + , text, unordered-containers + }: + mkDerivation { + pname = "svg-builder"; + version = "0.1.1"; + sha256 = "4fd0e3f2cbc5601fc69e7eab41588cbfa1150dc508d9d86bf5f3d393880382cc"; + revision = "1"; + editedCabalFile = "1bhp9gvid2iis411k1vvyj5krzc4ahxcqcd9cwx9h37jxg180xw1"; + libraryHaskellDepends = [ + base blaze-builder bytestring hashable text unordered-containers + ]; + doHaddock = false; + doCheck = false; + homepage = "https://github.com/diagrams/svg-builder.git"; + description = "DSL for building SVG"; + license = stdenv.lib.licenses.bsd3; + }) {}; + "svg-tree" = callPackage + ({ mkDerivation, attoparsec, base, bytestring, containers + , JuicyPixels, lens, linear, mtl, scientific, stdenv, text + , transformers, vector, xml + }: + mkDerivation { + pname = "svg-tree"; + version = "0.6.2.2"; + sha256 = "3a6840993765dc235322c51c9de6adfe3b06e1fa6140ba9f57547c73d62e6ac7"; + libraryHaskellDepends = [ + attoparsec base bytestring containers JuicyPixels lens linear mtl + scientific text transformers vector xml + ]; + doHaddock = false; + doCheck = false; + description = "SVG file loader and serializer"; + license = stdenv.lib.licenses.bsd3; + }) {}; + "swagger" = callPackage + ({ mkDerivation, aeson, base, bytestring, stdenv, text, time + , transformers + }: + mkDerivation { + pname = "swagger"; + version = "0.3.0"; + sha256 = "c7144fb22a0d223eb2463a896200936eab665dc01f39affc103d2ee6a38f54d0"; + libraryHaskellDepends = [ + aeson base bytestring text time transformers + ]; + doHaddock = false; + doCheck = false; + description = "Implementation of swagger data model"; + license = "unknown"; + }) {}; + "swagger2" = callPackage + ({ mkDerivation, aeson, base, base-compat-batteries, bytestring + , Cabal, cabal-doctest, containers, generics-sop, hashable + , http-media, insert-ordered-containers, lens, mtl, network + , scientific, stdenv, template-haskell, text, time, transformers + , transformers-compat, unordered-containers, uuid-types, vector + }: + mkDerivation { + pname = "swagger2"; + version = "2.2.2"; + sha256 = "82d352881041baaaa1ed63cc3262953df101dad5e401272dc62ee346b3ab6eca"; + revision = "3"; + editedCabalFile = "187jl8slpyr6blcxnhdp7wf85ab54pgqnbl11n816xg6fyqy7ylk"; + setupHaskellDepends = [ base Cabal cabal-doctest ]; + libraryHaskellDepends = [ + aeson base base-compat-batteries bytestring containers generics-sop + hashable http-media insert-ordered-containers lens mtl network + scientific template-haskell text time transformers + transformers-compat unordered-containers uuid-types vector + ]; + doHaddock = false; + doCheck = false; + homepage = "https://github.com/GetShopTV/swagger2"; + description = "Swagger 2.0 data model"; + license = stdenv.lib.licenses.bsd3; + }) {}; + "swish" = callPackage + ({ mkDerivation, base, containers, directory, filepath, hashable + , intern, mtl, network-uri, old-locale, polyparse, semigroups + , stdenv, text, time + }: + mkDerivation { + pname = "swish"; + version = "0.9.2.1"; + sha256 = "ef43bedf12c4f9c9b379a8aa00f339d9487769e4388a57ff108f16cb1f8c3f7f"; + isLibrary = true; + isExecutable = true; + enableSeparateDataOutput = true; + libraryHaskellDepends = [ + base containers directory filepath hashable intern mtl network-uri + old-locale polyparse semigroups text time + ]; + executableHaskellDepends = [ base ]; + doHaddock = false; + doCheck = false; + homepage = "https://bitbucket.org/doug_burke/swish/wiki/Home"; + description = "A semantic web toolkit"; + license = stdenv.lib.licenses.lgpl21; + }) {}; + "syb" = callPackage + ({ mkDerivation, base, stdenv }: + mkDerivation { + pname = "syb"; + version = "0.7"; + sha256 = "b8757dce5ab4045c49a0ae90407d575b87ee5523a7dd5dfa5c9d54fcceff42b5"; + libraryHaskellDepends = [ base ]; + doHaddock = false; + doCheck = false; + homepage = "http://www.cs.uu.nl/wiki/GenericProgramming/SYB"; + description = "Scrap Your Boilerplate"; + license = stdenv.lib.licenses.bsd3; + }) {}; + "symbol" = callPackage + ({ mkDerivation, base, containers, deepseq, stdenv }: + mkDerivation { + pname = "symbol"; + version = "0.2.4"; + sha256 = "d074a7741f6ce0f2a604e4467c1c46e1acc2b707db107b3458395e646a9b8831"; + revision = "2"; + editedCabalFile = "0jdbaap11pkgb6m98v57k7qnx62pqxy7pa2i7293ywa4q305qgm1"; + libraryHaskellDepends = [ base containers deepseq ]; + doHaddock = false; + doCheck = false; + homepage = "http://www.cs.drexel.edu/~mainland/"; + description = "A 'Symbol' type for fast symbol comparison"; + license = stdenv.lib.licenses.bsd3; + }) {}; + "symengine" = callPackage + ({ mkDerivation, base, stdenv }: + mkDerivation { + pname = "symengine"; + version = "0.1.2.0"; + sha256 = "0a59f76a924686ae84b1873c8783eb80f6e4092c90f3c971340053c1e6ca82f4"; + libraryHaskellDepends = [ base ]; + doHaddock = false; + doCheck = false; + homepage = "http://github.com/symengine/symengine.hs#readme"; + description = "SymEngine symbolic mathematics engine for Haskell"; + license = stdenv.lib.licenses.mit; + }) {}; + "sysinfo" = callPackage + ({ mkDerivation, base, stdenv }: + mkDerivation { + pname = "sysinfo"; + version = "0.1.1"; + sha256 = "46db40f2d186956547cca98f5583b28828a2b50255fbd404272c381db64dca29"; + libraryHaskellDepends = [ base ]; + doHaddock = false; + doCheck = false; + homepage = "https://github.com/psibi/sysinfo#readme"; + description = "Haskell Interface for getting overall system statistics"; + license = stdenv.lib.licenses.bsd3; + }) {}; + "system-argv0" = callPackage + ({ mkDerivation, base, bytestring, stdenv, system-filepath, text }: + mkDerivation { + pname = "system-argv0"; + version = "0.1.1"; + sha256 = "6d51da9d2157be14a83f8dca3e9d4196d420e667cd685effb8d7b39185cf4ec6"; + libraryHaskellDepends = [ base bytestring system-filepath text ]; + doHaddock = false; + doCheck = false; + homepage = "https://john-millikin.com/software/haskell-filesystem/"; + description = "Get argv[0] as a FilePath"; + license = stdenv.lib.licenses.mit; + }) {}; + "system-fileio" = callPackage + ({ mkDerivation, base, bytestring, stdenv, system-filepath, text + , time, unix + }: + mkDerivation { + pname = "system-fileio"; + version = "0.3.16.3"; + sha256 = "3175707cb322c65760fa2eb2ab17327f251c8294ad688efc6258e82328830491"; + libraryHaskellDepends = [ + base bytestring system-filepath text time unix + ]; + doHaddock = false; + doCheck = false; + homepage = "https://github.com/fpco/haskell-filesystem"; + description = "Consistent filesystem interaction across GHC versions (deprecated)"; + license = stdenv.lib.licenses.mit; + }) {}; + "system-filepath" = callPackage + ({ mkDerivation, base, bytestring, Cabal, deepseq, stdenv, text }: + mkDerivation { + pname = "system-filepath"; + version = "0.4.14"; + sha256 = "1656ce3c0d585650784ceb3f794748286e19fb635f557e7b29b0897f8956d993"; + revision = "1"; + editedCabalFile = "18llfvisghrn9w9yfgacqn51gs50a0lngah3bmg852h0swj7vkp8"; + setupHaskellDepends = [ base Cabal ]; + libraryHaskellDepends = [ base bytestring deepseq text ]; + doHaddock = false; + doCheck = false; + homepage = "https://github.com/fpco/haskell-filesystem"; + description = "High-level, byte-based file and directory path manipulations (deprecated)"; + license = stdenv.lib.licenses.mit; + }) {}; + "tabular" = callPackage + ({ mkDerivation, base, csv, html, mtl, stdenv }: + mkDerivation { + pname = "tabular"; + version = "0.2.2.7"; + sha256 = "13f8da12108dafcf3194eb6bf25febf0081c7e4734f66d2d4aeee899f3c14ffb"; + libraryHaskellDepends = [ base csv html mtl ]; + doHaddock = false; + doCheck = false; + homepage = "http://hub.darcs.net/kowey/tabular"; + description = "Two-dimensional data tables with rendering functions"; + license = stdenv.lib.licenses.bsd3; + }) {}; + "tagchup" = callPackage + ({ mkDerivation, base, bytestring, containers, data-accessor + , explicit-exception, non-empty, stdenv, transformers, utility-ht + , xml-basic + }: + mkDerivation { + pname = "tagchup"; + version = "0.4.1"; + sha256 = "122c975d73a6bcbe98b3352144ec249494fcd30b6ed23eff19acc562d7ee24c0"; + isLibrary = true; + isExecutable = true; + enableSeparateDataOutput = true; + libraryHaskellDepends = [ + base bytestring containers data-accessor explicit-exception + non-empty transformers utility-ht xml-basic + ]; + doHaddock = false; + doCheck = false; + homepage = "http://code.haskell.org/~thielema/tagchup/"; + description = "alternative package for processing of tag soups"; + license = "GPL"; + }) {}; + "tagged" = callPackage + ({ mkDerivation, base, deepseq, stdenv, template-haskell + , transformers, transformers-compat + }: + mkDerivation { + pname = "tagged"; + version = "0.8.5"; + sha256 = "e47c51c955ed77b0fa36897f652df990aa0a8c4eb278efaddcd604be00fc8d99"; + revision = "2"; + editedCabalFile = "0r2knfcq0b4s652vlvlnfwxlc2mkc2ra9kl8bp4zdn1awmfy0ia5"; + libraryHaskellDepends = [ + base deepseq template-haskell transformers transformers-compat + ]; + doHaddock = false; + doCheck = false; + homepage = "http://github.com/ekmett/tagged"; + description = "Haskell 98 phantom types to avoid unsafely passing dummy arguments"; + license = stdenv.lib.licenses.bsd3; + }) {}; + "tagged-binary" = callPackage + ({ mkDerivation, base, base-compat, binary, bytestring, pureMD5 + , stdenv + }: + mkDerivation { + pname = "tagged-binary"; + version = "0.2.0.1"; + sha256 = "72cfaa0995838dfb7f0cda897175c469d6b7aef6fd396fc56abc70194b0f645b"; + libraryHaskellDepends = [ + base base-compat binary bytestring pureMD5 + ]; + doHaddock = false; + doCheck = false; + description = "Provides tools for serializing data tagged with type information"; + license = stdenv.lib.licenses.mit; + }) {}; + "tagged-identity" = callPackage + ({ mkDerivation, base, mtl, stdenv, transformers }: + mkDerivation { + pname = "tagged-identity"; + version = "0.1.2"; + sha256 = "916dd7fdd15452f3d760c345e023ce99496806b813ab01b03ff1b240bbd50210"; + libraryHaskellDepends = [ base mtl transformers ]; + doHaddock = false; + doCheck = false; + homepage = "https://github.com/mrkkrp/tagged-identity"; + description = "Trivial monad transformer that allows identical monad stacks have different types"; + license = stdenv.lib.licenses.bsd3; + }) {}; + "tagged-transformer" = callPackage + ({ mkDerivation, base, comonad, contravariant, distributive + , exceptions, mtl, reflection, semigroupoids, stdenv, tagged + }: + mkDerivation { + pname = "tagged-transformer"; + version = "0.8.1"; + sha256 = "a0ff6121e852c78f6428e583c18e90e3bf899f59a529fb2076236e1146eedcb9"; + libraryHaskellDepends = [ + base comonad contravariant distributive exceptions mtl reflection + semigroupoids tagged + ]; + doHaddock = false; + doCheck = false; + homepage = "http://github.com/ekmett/tagged-transformer"; + description = "Monad transformer carrying an extra phantom type tag"; + license = stdenv.lib.licenses.bsd3; + }) {}; + "tagshare" = callPackage + ({ mkDerivation, base, containers, mtl, stdenv }: + mkDerivation { + pname = "tagshare"; + version = "0.0"; + sha256 = "d2314bae2e6820700f2a61db9c9f7976e1b53547a49cdd3352bdf29ac3856ce0"; + libraryHaskellDepends = [ base containers mtl ]; + doHaddock = false; + doCheck = false; + description = "TagShare - explicit sharing with tags"; + license = stdenv.lib.licenses.bsd3; + }) {}; + "tagsoup" = callPackage + ({ mkDerivation, base, bytestring, containers, stdenv, text }: + mkDerivation { + pname = "tagsoup"; + version = "0.14.6"; + sha256 = "4b4ed4db1428e859389d628dd5755074f659a424ec49934ec53e44b0fc6a63fb"; + libraryHaskellDepends = [ base bytestring containers text ]; + doHaddock = false; + doCheck = false; + homepage = "https://github.com/ndmitchell/tagsoup#readme"; + description = "Parsing and extracting information from (possibly malformed) HTML/XML documents"; + license = stdenv.lib.licenses.bsd3; + }) {}; + "tagstream-conduit" = callPackage + ({ mkDerivation, attoparsec, base, blaze-builder, bytestring + , case-insensitive, conduit, conduit-extra, data-default, resourcet + , stdenv, text, transformers, xml-conduit + }: + mkDerivation { + pname = "tagstream-conduit"; + version = "0.5.5.3"; + sha256 = "b296e8f0ba18ae951b5bb3fc2d9d964954666df61ea9363d667f251af17134ab"; + libraryHaskellDepends = [ + attoparsec base blaze-builder bytestring case-insensitive conduit + conduit-extra data-default resourcet text transformers xml-conduit + ]; + doHaddock = false; + doCheck = false; + homepage = "http://github.com/yihuang/tagstream-conduit"; + description = "streamlined html tag parser"; + license = stdenv.lib.licenses.bsd3; + }) {}; + "tao" = callPackage + ({ mkDerivation, base, stdenv }: + mkDerivation { + pname = "tao"; + version = "1.0.0"; + sha256 = "0b0a1e9606b15eb3bd334eaaf09f01a52f5cb086e5947959116d1d4409541a47"; + libraryHaskellDepends = [ base ]; + doHaddock = false; + doCheck = false; + homepage = "https://github.com/jship/tao#readme"; + description = "Type-level assertion operators"; + license = stdenv.lib.licenses.mit; + }) {}; + "tao-example" = callPackage + ({ mkDerivation, base, stdenv, tao }: + mkDerivation { + pname = "tao-example"; + version = "1.0.0"; + sha256 = "65de395b78e922d95ce7badf6588c00c6d01ea5c14b33c062cde19229f4b00b2"; + libraryHaskellDepends = [ base tao ]; + doHaddock = false; + doCheck = false; + homepage = "https://github.com/jship/tao#readme"; + description = "Example usage of the tao package"; + license = stdenv.lib.licenses.mit; + }) {}; + "tar" = callPackage + ({ mkDerivation, array, base, bytestring, containers, deepseq + , directory, filepath, stdenv, time + }: + mkDerivation { + pname = "tar"; + version = "0.5.1.0"; + sha256 = "c89d697b6472b739db50e61201251fcaf8a8f5b595b1d9a488d395d7d5ce4b68"; + revision = "1"; + editedCabalFile = "1lydbwsmccf2av0g61j07bx7r5mzbcfgwvmh0qwg3a91857x264x"; + libraryHaskellDepends = [ + array base bytestring containers deepseq directory filepath time + ]; + doHaddock = false; + doCheck = false; + description = "Reading, writing and manipulating \".tar\" archive files."; + license = stdenv.lib.licenses.bsd3; + }) {}; + "tar-conduit" = callPackage + ({ mkDerivation, base, bytestring, conduit, conduit-combinators + , directory, filepath, safe-exceptions, stdenv, text, unix + }: + mkDerivation { + pname = "tar-conduit"; + version = "0.2.3.1"; + sha256 = "ec72cd49a921a145df15be8da2fc8492f8059719b45f357d3b2813b8ff45207c"; + libraryHaskellDepends = [ + base bytestring conduit conduit-combinators directory filepath + safe-exceptions text unix + ]; + doHaddock = false; + doCheck = false; + homepage = "https://github.com/snoyberg/tar-conduit#readme"; + description = "Extract and create tar files using conduit for streaming"; + license = stdenv.lib.licenses.mit; + }) {}; + "tardis" = callPackage + ({ mkDerivation, base, mmorph, mtl, stdenv }: + mkDerivation { + pname = "tardis"; + version = "0.4.1.0"; + sha256 = "e672abadd75055c2372d722c98058f7f3403fcca18258565d1cdd8e0dc25a5d9"; + revision = "1"; + editedCabalFile = "1wp6vp90g19hv8r2l83ava7qxf0933gb7ni2zgyfa66vlvxvhibv"; + libraryHaskellDepends = [ base mmorph mtl ]; + doHaddock = false; + doCheck = false; + homepage = "https://github.com/DanBurton/tardis"; + description = "Bidirectional state monad transformer"; + license = stdenv.lib.licenses.bsd3; + }) {}; + "tasty" = callPackage + ({ mkDerivation, ansi-terminal, async, base, clock, containers, mtl + , optparse-applicative, stdenv, stm, tagged, unbounded-delays, unix + , wcwidth + }: + mkDerivation { + pname = "tasty"; + version = "1.1.0.2"; + sha256 = "473745a8af7042c98a881f8c68158c55f105420d171250c7b31d61a382d770e0"; + revision = "1"; + editedCabalFile = "0hvy91ws7nqvpzmj5zsnzza0kfdcm3l22b3lf21cfjkkwx9cv31g"; + libraryHaskellDepends = [ + ansi-terminal async base clock containers mtl optparse-applicative + stm tagged unbounded-delays unix wcwidth + ]; + doHaddock = false; + doCheck = false; + homepage = "https://github.com/feuerbach/tasty"; + description = "Modern and extensible testing framework"; + license = stdenv.lib.licenses.mit; + }) {}; + "tasty-ant-xml" = callPackage + ({ mkDerivation, base, containers, directory, filepath + , generic-deriving, ghc-prim, mtl, stdenv, stm, tagged, tasty + , transformers, xml + }: + mkDerivation { + pname = "tasty-ant-xml"; + version = "1.1.4"; + sha256 = "a88aee8127f424155d8cb0237b9c378cfba935579fb2d51fe5d0c009d2d20f6c"; + libraryHaskellDepends = [ + base containers directory filepath generic-deriving ghc-prim mtl + stm tagged tasty transformers xml + ]; + doHaddock = false; + doCheck = false; + homepage = "http://github.com/ocharles/tasty-ant-xml"; + description = "Render tasty output to XML for Jenkins"; + license = stdenv.lib.licenses.bsd3; + }) {}; + "tasty-dejafu" = callPackage + ({ mkDerivation, base, dejafu, random, stdenv, tagged, tasty }: + mkDerivation { + pname = "tasty-dejafu"; + version = "1.2.0.7"; + sha256 = "8c0bbf8636fa8c00c450d051278ee7ba81488cd90a84bca4e285d29cb85ae6f1"; + libraryHaskellDepends = [ base dejafu random tagged tasty ]; + doHaddock = false; + doCheck = false; + homepage = "https://github.com/barrucadu/dejafu"; + description = "Deja Fu support for the Tasty test framework"; + license = stdenv.lib.licenses.mit; + }) {}; + "tasty-discover" = callPackage + ({ mkDerivation, base, containers, directory, filepath, Glob + , stdenv + }: + mkDerivation { + pname = "tasty-discover"; + version = "4.2.1"; + sha256 = "be6c5b384614a592fb056e2e4f7806416aa37f114db77d0f8986938ba7cc1d3e"; + isLibrary = true; + isExecutable = true; + libraryHaskellDepends = [ + base containers directory filepath Glob + ]; + executableHaskellDepends = [ + base containers directory filepath Glob + ]; + doHaddock = false; + doCheck = false; + homepage = "http://git.coop/lwm/tasty-discover"; + description = "Test discovery for the tasty framework"; + license = stdenv.lib.licenses.mit; + }) {}; + "tasty-expected-failure" = callPackage + ({ mkDerivation, base, stdenv, tagged, tasty }: + mkDerivation { + pname = "tasty-expected-failure"; + version = "0.11.1.1"; + sha256 = "519a5c0d2ef9dd60355479f11ca47423133364f20ad3151f3c8b105313405ac4"; + revision = "1"; + editedCabalFile = "1b3fn7d3zwhhwm3gp8cmmsdcrvn9dhshd665xrx1mk6cmy4m8k16"; + libraryHaskellDepends = [ base tagged tasty ]; + doHaddock = false; + doCheck = false; + homepage = "http://github.com/nomeata/tasty-expected-failure"; + description = "Mark tasty tests as failure expected"; + license = stdenv.lib.licenses.mit; + }) {}; + "tasty-golden" = callPackage + ({ mkDerivation, async, base, bytestring, containers, deepseq + , directory, filepath, mtl, optparse-applicative, process, stdenv + , tagged, tasty, temporary + }: + mkDerivation { + pname = "tasty-golden"; + version = "2.3.2"; + sha256 = "04103d2a2fd6acc8f66b67d943060e88a2ea36b799502bf3e76c2726a15c714c"; + libraryHaskellDepends = [ + async base bytestring containers deepseq directory filepath mtl + optparse-applicative process tagged tasty temporary + ]; + doHaddock = false; + doCheck = false; + homepage = "https://github.com/feuerbach/tasty-golden"; + description = "Golden tests support for tasty"; + license = stdenv.lib.licenses.mit; + }) {}; + "tasty-hedgehog" = callPackage + ({ mkDerivation, base, hedgehog, stdenv, tagged, tasty }: + mkDerivation { + pname = "tasty-hedgehog"; + version = "0.2.0.0"; + sha256 = "5a107fc3094efc50663e4634331a296281318b38c9902969c2d2d215d754a182"; + revision = "5"; + editedCabalFile = "1ykmjb00whqq1hap4l8d4187qflxi6xdnm86czxrzmz4l3lj33gr"; + libraryHaskellDepends = [ base hedgehog tagged tasty ]; + doHaddock = false; + doCheck = false; + homepage = "https://github.com/qfpl/tasty-hedgehog"; + description = "Integration for tasty and hedgehog"; + license = stdenv.lib.licenses.bsd3; + }) {}; + "tasty-hspec" = callPackage + ({ mkDerivation, base, hspec, hspec-core, QuickCheck, stdenv, tasty + , tasty-quickcheck, tasty-smallcheck + }: + mkDerivation { + pname = "tasty-hspec"; + version = "1.1.5"; + sha256 = "db0cdcf71d534cfa32a1698f1eb6be03192af09a5dd63177b697bc4ca8b81154"; + revision = "3"; + editedCabalFile = "14198y7w9y4h36b6agzmsyappkhz4gmmi6nlzj137z5siwic7igm"; + libraryHaskellDepends = [ + base hspec hspec-core QuickCheck tasty tasty-quickcheck + tasty-smallcheck + ]; + doHaddock = false; + doCheck = false; + homepage = "https://github.com/mitchellwrosen/tasty-hspec"; + description = "Hspec support for the Tasty test framework"; + license = stdenv.lib.licenses.bsd3; + }) {}; + "tasty-hunit" = callPackage + ({ mkDerivation, base, call-stack, stdenv, tasty }: + mkDerivation { + pname = "tasty-hunit"; + version = "0.10.0.1"; + sha256 = "8f903bef276ef503e4ef8b66a1e201c224588e426bc76f7581480f66d47b7048"; + libraryHaskellDepends = [ base call-stack tasty ]; + doHaddock = false; + doCheck = false; + homepage = "https://github.com/feuerbach/tasty"; + description = "HUnit support for the Tasty test framework"; + license = stdenv.lib.licenses.mit; + }) {}; + "tasty-kat" = callPackage + ({ mkDerivation, base, bytestring, stdenv, tasty }: + mkDerivation { + pname = "tasty-kat"; + version = "0.0.3"; + sha256 = "a72501f0f77db372648566bbba1dd1d6d0d0c975b42238875d663313e9a5db93"; + libraryHaskellDepends = [ base bytestring tasty ]; + doHaddock = false; + doCheck = false; + homepage = "https://github.com/vincenthz/tasty-kat"; + description = "Known Answer Tests (KAT) framework for tasty"; + license = stdenv.lib.licenses.mit; + }) {}; + "tasty-program" = callPackage + ({ mkDerivation, base, deepseq, directory, filepath, process + , stdenv, tasty + }: + mkDerivation { + pname = "tasty-program"; + version = "1.0.5"; + sha256 = "4cb255ad5f037029cc6ae244fffdfb0ed7c65a4b0575d98ec61c067d6f5829c4"; + libraryHaskellDepends = [ + base deepseq directory filepath process tasty + ]; + doHaddock = false; + doCheck = false; + homepage = "https://github.com/jstolarek/tasty-program"; + description = "Use tasty framework to test whether a program executes correctly"; + license = stdenv.lib.licenses.bsd3; + }) {}; + "tasty-quickcheck" = callPackage + ({ mkDerivation, base, optparse-applicative, QuickCheck, random + , stdenv, tagged, tasty + }: + mkDerivation { + pname = "tasty-quickcheck"; + version = "0.10"; + sha256 = "10fd30cef4a0c2cefb70afecef5adcee1f32f0fd287f108321458fbfd6d7266f"; + revision = "1"; + editedCabalFile = "1ndkkywcqgb2wj339vgckjv5915da5kd4ixlkaww9fsba3qsrnwx"; + libraryHaskellDepends = [ + base optparse-applicative QuickCheck random tagged tasty + ]; + doHaddock = false; + doCheck = false; + homepage = "https://github.com/feuerbach/tasty"; + description = "QuickCheck support for the Tasty test framework"; + license = stdenv.lib.licenses.mit; + }) {}; + "tasty-silver" = callPackage + ({ mkDerivation, ansi-terminal, async, base, bytestring, containers + , deepseq, directory, filepath, mtl, optparse-applicative, process + , process-extras, regex-tdfa, semigroups, stdenv, stm, tagged + , tasty, temporary, text + }: + mkDerivation { + pname = "tasty-silver"; + version = "3.1.11"; + sha256 = "5f2170cee1f3104d1e8d6937bb032b57ca712704500286aae5e7e8608cf073e7"; + libraryHaskellDepends = [ + ansi-terminal async base bytestring containers deepseq directory + filepath mtl optparse-applicative process process-extras regex-tdfa + semigroups stm tagged tasty temporary text + ]; + doHaddock = false; + doCheck = false; + homepage = "https://github.com/phile314/tasty-silver"; + description = "A fancy test runner, including support for golden tests"; + license = stdenv.lib.licenses.mit; + }) {}; + "tasty-smallcheck" = callPackage + ({ mkDerivation, async, base, smallcheck, stdenv, tagged, tasty }: + mkDerivation { + pname = "tasty-smallcheck"; + version = "0.8.1"; + sha256 = "314ba7acdb7793730e7677f553a72dd6a4a8f9a45ff3e931cd7d384affb3c6d8"; + libraryHaskellDepends = [ async base smallcheck tagged tasty ]; + doHaddock = false; + doCheck = false; + homepage = "http://documentup.com/feuerbach/tasty"; + description = "SmallCheck support for the Tasty test framework"; + license = stdenv.lib.licenses.mit; + }) {}; + "tasty-stats" = callPackage + ({ mkDerivation, base, containers, directory, process, stdenv, stm + , tagged, tasty, time + }: + mkDerivation { + pname = "tasty-stats"; + version = "0.2.0.4"; + sha256 = "a64d018056c746efde87e830ff2e7bcd0b65b6582de96d493ca706ea0325447c"; + libraryHaskellDepends = [ + base containers directory process stm tagged tasty time + ]; + doHaddock = false; + doCheck = false; + homepage = "https://github.com/minad/tasty-stats#readme"; + description = "Collect statistics of your Tasty testsuite"; + license = stdenv.lib.licenses.mit; + }) {}; + "tasty-th" = callPackage + ({ mkDerivation, base, haskell-src-exts, stdenv, tasty + , template-haskell + }: + mkDerivation { + pname = "tasty-th"; + version = "0.1.7"; + sha256 = "435aac8f317e2f8cb1aa96fb3f7c9003c1ac28e6d3ca4c3c23f5142178de512c"; + libraryHaskellDepends = [ + base haskell-src-exts tasty template-haskell + ]; + doHaddock = false; + doCheck = false; + homepage = "http://github.com/bennofs/tasty-th"; + description = "Automatic tasty test case discovery using TH"; + license = stdenv.lib.licenses.bsd3; + }) {}; + "tce-conf" = callPackage + ({ mkDerivation, base, containers, stdenv }: + mkDerivation { + pname = "tce-conf"; + version = "1.3"; + sha256 = "b051843bb941ed137242edfcfb28b1c15083951272fe292e82c140c9e1ad26a2"; + isLibrary = true; + isExecutable = true; + libraryHaskellDepends = [ base containers ]; + executableHaskellDepends = [ base containers ]; + doHaddock = false; + doCheck = false; + homepage = "http://hub.darcs.net/dino/tce-conf"; + description = "Very simple config file reading"; + license = stdenv.lib.licenses.bsd3; + }) {}; + "tcp-streams" = callPackage + ({ mkDerivation, base, bytestring, data-default-class, io-streams + , network, pem, stdenv, tls, x509, x509-store, x509-system + }: + mkDerivation { + pname = "tcp-streams"; + version = "1.0.1.0"; + sha256 = "77d812e5db567875ca26c2682ceddf4bcf825d90dd10dcb171279bd7e96e4861"; + enableSeparateDataOutput = true; + libraryHaskellDepends = [ + base bytestring data-default-class io-streams network pem tls x509 + x509-store x509-system + ]; + doHaddock = false; + doCheck = false; + homepage = "https://github.com/didi-FP/tcp-streams"; + description = "One stop solution for tcp client and server with tls support"; + license = stdenv.lib.licenses.bsd3; + }) {}; + "tcp-streams-openssl" = callPackage + ({ mkDerivation, base, bytestring, HsOpenSSL, HsOpenSSL-x509-system + , io-streams, network, stdenv, tcp-streams + }: + mkDerivation { + pname = "tcp-streams-openssl"; + version = "1.0.1.0"; + sha256 = "c3e7588ba7348fac87a9dcc531909f90bb3b4a1c01da9eb871a918d02b146afe"; + libraryHaskellDepends = [ + base bytestring HsOpenSSL HsOpenSSL-x509-system io-streams network + tcp-streams + ]; + doHaddock = false; + doCheck = false; + homepage = "https://github.com/didi-FP/tcp-streams"; + description = "Tcp streams using openssl for tls support"; + license = stdenv.lib.licenses.bsd3; + }) {}; + "tdigest" = callPackage + ({ mkDerivation, base, base-compat, binary, Cabal, cabal-doctest + , deepseq, reducers, semigroupoids, stdenv, transformers, vector + , vector-algorithms + }: + mkDerivation { + pname = "tdigest"; + version = "0.2.1"; + sha256 = "d46e38067c4d064f3c9c77219f570ba4e9dbbd7273a5edc4860610cde4afb84e"; + revision = "1"; + editedCabalFile = "1jrq22j9jbvx31pspwjvyb539gix7vfb8cinqkkb2abmr0jrhibn"; + setupHaskellDepends = [ base Cabal cabal-doctest ]; + libraryHaskellDepends = [ + base base-compat binary deepseq reducers semigroupoids transformers + vector vector-algorithms + ]; + doHaddock = false; + doCheck = false; + homepage = "https://github.com/futurice/haskell-tdigest#readme"; + description = "On-line accumulation of rank-based statistics"; + license = stdenv.lib.licenses.bsd3; + }) {}; + "teardown" = callPackage + ({ mkDerivation, base, prettyprinter, rio, stdenv, typed-process + , unliftio + }: + mkDerivation { + pname = "teardown"; + version = "0.5.0.0"; + sha256 = "50eac07b244bd2d662731929e8b1785df3e8a5014b4bb62f6e843e33e896395c"; + libraryHaskellDepends = [ + base prettyprinter rio typed-process unliftio + ]; + doHaddock = false; + doCheck = false; + homepage = "https://github.com/roman/Haskell-teardown#readme"; + description = "Build safe and composable teardown sub-routines for resources"; + license = stdenv.lib.licenses.mit; + }) {}; + "telegram-bot-simple" = callPackage + ({ mkDerivation, aeson, aeson-pretty, base, bytestring, cron + , hashable, http-api-data, http-client, http-client-tls + , monad-control, mtl, pretty-show, profunctors, servant + , servant-client, split, stdenv, stm, template-haskell, text, time + , transformers, unordered-containers + }: + mkDerivation { + pname = "telegram-bot-simple"; + version = "0.2.0"; + sha256 = "8a8cc572880a792d1ed722bd0ac961892d79113c9fa1b2fbdf3019f98f904ea9"; + revision = "1"; + editedCabalFile = "1li6b3m9glhfg8agr9h0mrbxpr8zr46l57mzjfdqndm248ddbklv"; + isLibrary = true; + isExecutable = true; + libraryHaskellDepends = [ + aeson aeson-pretty base bytestring cron hashable http-api-data + http-client http-client-tls monad-control mtl pretty-show + profunctors servant servant-client split stm template-haskell text + time transformers unordered-containers + ]; + executableHaskellDepends = [ + aeson aeson-pretty base bytestring cron hashable http-api-data + http-client http-client-tls monad-control mtl pretty-show + profunctors servant servant-client split stm template-haskell text + time transformers unordered-containers + ]; + doHaddock = false; + doCheck = false; + homepage = "https://github.com/fizruk/telegram-bot-simple#readme"; + description = "Easy to use library for building Telegram bots"; + license = stdenv.lib.licenses.bsd3; + }) {}; + "temporary" = callPackage + ({ mkDerivation, base, directory, exceptions, filepath, random + , stdenv, transformers, unix + }: + mkDerivation { + pname = "temporary"; + version = "1.3"; + sha256 = "8c442993694b5ffca823ce864af95bd2841fb5264ee511c61cf48cc71d879890"; + libraryHaskellDepends = [ + base directory exceptions filepath random transformers unix + ]; + doHaddock = false; + doCheck = false; + homepage = "https://github.com/feuerbach/temporary"; + description = "Portable temporary file and directory support"; + license = stdenv.lib.licenses.bsd3; + }) {}; + "temporary-rc" = callPackage + ({ mkDerivation, base, directory, exceptions, filepath, stdenv + , transformers, unix + }: + mkDerivation { + pname = "temporary-rc"; + version = "1.2.0.3"; + sha256 = "1a4f8dd65f7db92316a68ef64c3518873799115babce92ef9869103d318011db"; + libraryHaskellDepends = [ + base directory exceptions filepath transformers unix + ]; + doHaddock = false; + doCheck = false; + homepage = "http://www.github.com/feuerbach/temporary"; + description = "Portable temporary file and directory support for Windows and Unix, based on code from Cabal"; + license = stdenv.lib.licenses.bsd3; + }) {}; + "tensorflow-test" = callPackage + ({ mkDerivation, base, HUnit, stdenv, vector }: + mkDerivation { + pname = "tensorflow-test"; + version = "0.1.0.0"; + sha256 = "378217dde895daf6599a8d3fb07ed59de5e2d8024958277558faca190bb44afc"; + libraryHaskellDepends = [ base HUnit vector ]; + doHaddock = false; + doCheck = false; + homepage = "https://github.com/tensorflow/haskell#readme"; + description = "Some common functions for test suites"; + license = stdenv.lib.licenses.asl20; + }) {}; + "terminal-size" = callPackage + ({ mkDerivation, base, stdenv }: + mkDerivation { + pname = "terminal-size"; + version = "0.3.2.1"; + sha256 = "b5c23e964756bc13914649a67d63233f59ad0a813abe7cadeb2fc9d586dc9658"; + libraryHaskellDepends = [ base ]; + doHaddock = false; + doCheck = false; + description = "Get terminal window height and width"; + license = stdenv.lib.licenses.bsd3; + }) {}; + "test-framework" = callPackage + ({ mkDerivation, ansi-terminal, ansi-wl-pprint, base, containers + , hostname, old-locale, random, regex-posix, stdenv, time, xml + }: + mkDerivation { + pname = "test-framework"; + version = "0.8.2.0"; + sha256 = "f5aec7a15dbcb39e951bcf6502606fd99d751197b5510f41706899aa7e660ac2"; + revision = "1"; + editedCabalFile = "1af61pnf2vrkvs3hcqla5ddsrd0hd2pylv6l545yn3dcvl665rcc"; + libraryHaskellDepends = [ + ansi-terminal ansi-wl-pprint base containers hostname old-locale + random regex-posix time xml + ]; + doHaddock = false; + doCheck = false; + homepage = "http://haskell.github.io/test-framework/"; + description = "Framework for running and organising tests, with HUnit and QuickCheck support"; + license = stdenv.lib.licenses.bsd3; + }) {}; + "test-framework-hunit" = callPackage + ({ mkDerivation, base, extensible-exceptions, HUnit, stdenv + , test-framework + }: + mkDerivation { + pname = "test-framework-hunit"; + version = "0.3.0.2"; + sha256 = "95cb8ee02a850b164bfdabdf4dbc839d621361f3ac770ad21ea43a8bde360bf8"; + revision = "3"; + editedCabalFile = "0i9mlalv7cl1iq43ld5myrnpszq5rxmd79hk495dcb08rglhgl3z"; + libraryHaskellDepends = [ + base extensible-exceptions HUnit test-framework + ]; + doHaddock = false; + doCheck = false; + homepage = "https://batterseapower.github.io/test-framework/"; + description = "HUnit support for the test-framework package"; + license = stdenv.lib.licenses.bsd3; + }) {}; + "test-framework-quickcheck2" = callPackage + ({ mkDerivation, base, extensible-exceptions, QuickCheck, random + , stdenv, test-framework + }: + mkDerivation { + pname = "test-framework-quickcheck2"; + version = "0.3.0.4"; + sha256 = "d763afb99fa14cffaccbfad259534a656be129329ba12246fed2e4330619486e"; + revision = "1"; + editedCabalFile = "147ngmfdkskyg7mwsp5w73a4dbx3rp5s38bci3z03kn1m093lxff"; + libraryHaskellDepends = [ + base extensible-exceptions QuickCheck random test-framework + ]; + doHaddock = false; + doCheck = false; + homepage = "http://haskell.github.io/test-framework/"; + description = "QuickCheck-2 support for the test-framework package"; + license = stdenv.lib.licenses.bsd3; + }) {}; + "test-framework-smallcheck" = callPackage + ({ mkDerivation, base, smallcheck, stdenv, test-framework + , transformers + }: + mkDerivation { + pname = "test-framework-smallcheck"; + version = "0.2"; + sha256 = "6081c4f35967b0d0cb92ac09a915fa9e2da01c401266b20ce18793fbc2bceff6"; + libraryHaskellDepends = [ + base smallcheck test-framework transformers + ]; + doHaddock = false; + doCheck = false; + homepage = "https://github.com/feuerbach/smallcheck"; + description = "Support for SmallCheck tests in test-framework"; + license = stdenv.lib.licenses.bsd3; + }) {}; + "test-framework-th" = callPackage + ({ mkDerivation, base, haskell-src-exts, language-haskell-extract + , regex-posix, stdenv, template-haskell, test-framework + }: + mkDerivation { + pname = "test-framework-th"; + version = "0.2.4"; + sha256 = "8b780d9e3edd8d91e24f72d9fa1f80420e52959428ad7c22d0694901a43f9c8a"; + libraryHaskellDepends = [ + base haskell-src-exts language-haskell-extract regex-posix + template-haskell test-framework + ]; + doHaddock = false; + doCheck = false; + homepage = "http://github.com/finnsson/test-generator"; + description = "Automagically generate the HUnit- and Quickcheck-bulk-code using Template Haskell"; + license = stdenv.lib.licenses.bsd3; + }) {}; + "testing-feat" = callPackage + ({ mkDerivation, base, QuickCheck, size-based, stdenv + , testing-type-modifiers + }: + mkDerivation { + pname = "testing-feat"; + version = "1.1.0.0"; + sha256 = "1904d31ddce611474e8c836582efbca1ae7d1c7dc76083cf4300e8e0eeff58ec"; + libraryHaskellDepends = [ + base QuickCheck size-based testing-type-modifiers + ]; + doHaddock = false; + doCheck = false; + homepage = "https://github.com/JonasDuregard/testing-feat"; + description = "Functional Enumeration of Algebraic Types"; + license = stdenv.lib.licenses.bsd3; + }) {}; + "testing-type-modifiers" = callPackage + ({ mkDerivation, base, stdenv }: + mkDerivation { + pname = "testing-type-modifiers"; + version = "0.1.0.1"; + sha256 = "050bdade2c6f0122b1a04a3833ab7eea2399ffda8258bca6d93ba6614bb202f2"; + libraryHaskellDepends = [ base ]; + doHaddock = false; + doCheck = false; + description = "Data type modifiers for property based testing"; + license = stdenv.lib.licenses.publicDomain; + }) {}; + "texmath" = callPackage + ({ mkDerivation, base, containers, mtl, pandoc-types, parsec + , stdenv, syb, xml + }: + mkDerivation { + pname = "texmath"; + version = "0.11.0.1"; + sha256 = "4ec7f6ec41b38d184ca5069440f09ff2b50ff8318809c880f8da79eb6002ac85"; + revision = "1"; + editedCabalFile = "12cjvir2nn71s2q052075llvh9px8p6qh2h88ym6d6l0qhd5dl6i"; + isLibrary = true; + isExecutable = true; + libraryHaskellDepends = [ + base containers mtl pandoc-types parsec syb xml + ]; + doHaddock = false; + doCheck = false; + homepage = "http://github.com/jgm/texmath"; + description = "Conversion between formats used to represent mathematics"; + license = stdenv.lib.licenses.gpl2; + }) {}; + "text" = callPackage + ({ mkDerivation, array, base, binary, bytestring, deepseq, ghc-prim + , integer-gmp, stdenv + }: + mkDerivation { + pname = "text"; + version = "1.2.3.0"; + sha256 = "20e0b1627f613b32cc7f2d2e8dcc48a4a61938b24f3d14fb77cee694f0c9311a"; + libraryHaskellDepends = [ + array base binary bytestring deepseq ghc-prim integer-gmp + ]; + doHaddock = false; + doCheck = false; + homepage = "https://github.com/haskell/text"; + description = "An efficient packed Unicode text type"; + license = stdenv.lib.licenses.bsd2; + }) {}; + "text-binary" = callPackage + ({ mkDerivation, base, binary, stdenv, text }: + mkDerivation { + pname = "text-binary"; + version = "0.2.1.1"; + sha256 = "b697b2bd09080643d4686705c779122129638904870df5c1d41c8fc72f08f4a1"; + libraryHaskellDepends = [ base binary text ]; + doHaddock = false; + doCheck = false; + homepage = "https://github.com/kawu/text-binary"; + description = "Binary instances for text types"; + license = stdenv.lib.licenses.bsd2; + }) {}; + "text-builder" = callPackage + ({ mkDerivation, base, base-prelude, bytestring, semigroups, stdenv + , text + }: + mkDerivation { + pname = "text-builder"; + version = "0.5.1.1"; + sha256 = "141fa5e134e9765e8ba1e73ad1e0b43522b803e1a51f1ca22adf975a963c020a"; + libraryHaskellDepends = [ + base base-prelude bytestring semigroups text + ]; + doHaddock = false; + doCheck = false; + homepage = "https://github.com/nikita-volkov/text-builder"; + description = "An efficient strict text builder"; + license = stdenv.lib.licenses.mit; + }) {}; + "text-conversions" = callPackage + ({ mkDerivation, base, base16-bytestring, base64-bytestring + , bytestring, errors, stdenv, text + }: + mkDerivation { + pname = "text-conversions"; + version = "0.3.0"; + sha256 = "1756be2f6b515fea9e00b383c00d1ee851f8b25ddbc2901dd6be27d9b6292c21"; + libraryHaskellDepends = [ + base base16-bytestring base64-bytestring bytestring errors text + ]; + doHaddock = false; + doCheck = false; + homepage = "https://github.com/cjdev/text-conversions#readme"; + description = "Safe conversions between textual types"; + license = stdenv.lib.licenses.isc; + }) {}; + "text-icu" = callPackage + ({ mkDerivation, base, bytestring, deepseq, icu, stdenv, text }: + mkDerivation { + pname = "text-icu"; + version = "0.7.0.1"; + sha256 = "e2764c2749033706eed5b9fb3cda11177ad15cdf11912028f551eca39a2c7f78"; + libraryHaskellDepends = [ base bytestring deepseq text ]; + librarySystemDepends = [ icu ]; + doHaddock = false; + doCheck = false; + homepage = "https://github.com/bos/text-icu"; + description = "Bindings to the ICU library"; + license = stdenv.lib.licenses.bsd3; + }) {inherit (pkgs) icu;}; + "text-latin1" = callPackage + ({ mkDerivation, base, bytestring, case-insensitive, data-checked + , hashable, semigroups, stdenv, text + }: + mkDerivation { + pname = "text-latin1"; + version = "0.3.1"; + sha256 = "6c7482ae0cfde06fe6ad8f0e6ea6b0d082d27a075370b5c018c31e53aad9abf3"; + libraryHaskellDepends = [ + base bytestring case-insensitive data-checked hashable semigroups + text + ]; + doHaddock = false; + doCheck = false; + homepage = "https://github.com/mvv/text-latin1"; + description = "Latin-1 (including ASCII) utility functions"; + license = stdenv.lib.licenses.bsd3; + }) {}; + "text-ldap" = callPackage + ({ mkDerivation, attoparsec, base, bytestring, containers, dlist + , memory, stdenv, transformers + }: + mkDerivation { + pname = "text-ldap"; + version = "0.1.1.12"; + sha256 = "7d65962e68c52c2785c779679ebd365c7c84b26c640c42a0897f5754ed39d7cd"; + isLibrary = true; + isExecutable = true; + libraryHaskellDepends = [ + attoparsec base bytestring containers dlist memory transformers + ]; + executableHaskellDepends = [ base bytestring ]; + doHaddock = false; + doCheck = false; + description = "Parser and Printer for LDAP text data stream"; + license = stdenv.lib.licenses.bsd3; + }) {}; + "text-manipulate" = callPackage + ({ mkDerivation, base, stdenv, text }: + mkDerivation { + pname = "text-manipulate"; + version = "0.2.0.1"; + sha256 = "e0e9c71d9b1cfb7d3bca3d0a500d939b3efc6684515c0d7bd685503aa4f49d2f"; + libraryHaskellDepends = [ base text ]; + doHaddock = false; + doCheck = false; + homepage = "https://github.com/brendanhay/text-manipulate"; + description = "Case conversion, word boundary manipulation, and textual subjugation"; + license = "unknown"; + }) {}; + "text-metrics" = callPackage + ({ mkDerivation, base, containers, stdenv, text, vector }: + mkDerivation { + pname = "text-metrics"; + version = "0.3.0"; + sha256 = "3874af74060e35f01702640b353ac2180d93bb5d292a204e0ee3cadd26efbfa2"; + revision = "4"; + editedCabalFile = "017drxq9x56b345d8w5m8xdsi1zzs0z16pbdx8j35cd1lsnh3kf1"; + libraryHaskellDepends = [ base containers text vector ]; + doHaddock = false; + doCheck = false; + homepage = "https://github.com/mrkkrp/text-metrics"; + description = "Calculate various string metrics efficiently"; + license = stdenv.lib.licenses.bsd3; + }) {}; + "text-postgresql" = callPackage + ({ mkDerivation, base, dlist, stdenv, transformers + , transformers-compat + }: + mkDerivation { + pname = "text-postgresql"; + version = "0.0.3.1"; + sha256 = "c6e26888d2751b78e3102747d0bccedeee4002a1eb6c76dd1fe6c3836b5082e8"; + libraryHaskellDepends = [ + base dlist transformers transformers-compat + ]; + doHaddock = false; + doCheck = false; + homepage = "http://khibino.github.io/haskell-relational-record/"; + description = "Parser and Printer of PostgreSQL extended types"; + license = stdenv.lib.licenses.bsd3; + }) {}; + "text-printer" = callPackage + ({ mkDerivation, base, bytestring, pretty, semigroups, stdenv, text + , text-latin1 + }: + mkDerivation { + pname = "text-printer"; + version = "0.5"; + sha256 = "8f0c01a6a15b4314c2d47ab5f0772d176ec38f1c1fe190b9fa7db5149a6c4a0b"; + libraryHaskellDepends = [ + base bytestring pretty semigroups text text-latin1 + ]; + doHaddock = false; + doCheck = false; + homepage = "https://github.com/mvv/text-printer"; + description = "Abstract interface for text builders/printers"; + license = stdenv.lib.licenses.bsd3; + }) {}; + "text-short" = callPackage + ({ mkDerivation, base, binary, bytestring, deepseq, ghc-prim + , hashable, stdenv, text + }: + mkDerivation { + pname = "text-short"; + version = "0.1.2"; + sha256 = "b3f2b867d14c7c2586ea580028606b6662293ad080726d5241def937e5e31167"; + revision = "1"; + editedCabalFile = "00w77idkh44m88vivkqsys0y1bbxrflh06yq66liq0wgjhhzdppj"; + libraryHaskellDepends = [ + base binary bytestring deepseq ghc-prim hashable text + ]; + doHaddock = false; + doCheck = false; + description = "Memory-efficient representation of Unicode text strings"; + license = stdenv.lib.licenses.bsd3; + }) {}; + "text-show" = callPackage + ({ mkDerivation, array, base, base-compat-batteries, bifunctors + , bytestring, bytestring-builder, containers, contravariant + , generic-deriving, ghc-boot-th, ghc-prim, integer-gmp, nats + , semigroups, stdenv, tagged, template-haskell, text + , th-abstraction, th-lift, transformers, transformers-compat, void + }: + mkDerivation { + pname = "text-show"; + version = "3.7.4"; + sha256 = "3efb643349e288f0d92dc2fd26a76d38d08686e827db1d99df707932c9b91e19"; + revision = "2"; + editedCabalFile = "10hmmrm5qjc1lhrqgbh7yyyij9v0rpsv9fakynm5myfcc2ayif82"; + libraryHaskellDepends = [ + array base base-compat-batteries bifunctors bytestring + bytestring-builder containers contravariant generic-deriving + ghc-boot-th ghc-prim integer-gmp nats semigroups tagged + template-haskell text th-abstraction th-lift transformers + transformers-compat void + ]; + doHaddock = false; + doCheck = false; + homepage = "https://github.com/RyanGlScott/text-show"; + description = "Efficient conversion of values into Text"; + license = stdenv.lib.licenses.bsd3; + }) {}; + "text-show-instances" = callPackage + ({ mkDerivation, base, base-compat-batteries, bifunctors, binary + , containers, directory, ghc-boot-th, haskeline, hoopl, hpc + , old-locale, old-time, pretty, random, semigroups, stdenv, tagged + , template-haskell, terminfo, text, text-show, time, transformers + , transformers-compat, unix, unordered-containers, vector, xhtml + }: + mkDerivation { + pname = "text-show-instances"; + version = "3.6.5"; + sha256 = "14b3f03f14b61bcbb633bf6c95eb279221e5d97b30b27b114f298c1a06c49242"; + revision = "2"; + editedCabalFile = "1lqvwm9ciazk13jabyr81rl4hsmwksjmks7ckxrdgz3jk201yr6i"; + libraryHaskellDepends = [ + base base-compat-batteries bifunctors binary containers directory + ghc-boot-th haskeline hoopl hpc old-locale old-time pretty random + semigroups tagged template-haskell terminfo text text-show time + transformers transformers-compat unix unordered-containers vector + xhtml + ]; + doHaddock = false; + doCheck = false; + homepage = "https://github.com/RyanGlScott/text-show-instances"; + description = "Additional instances for text-show"; + license = stdenv.lib.licenses.bsd3; + }) {}; + "text-zipper" = callPackage + ({ mkDerivation, base, deepseq, stdenv, text, vector }: + mkDerivation { + pname = "text-zipper"; + version = "0.10.1"; + sha256 = "9afaeb93d55b0bb6d0d6f495e3ff0789a60d0dee57fb6103f52e4c05ae64b14b"; + enableSeparateDataOutput = true; + libraryHaskellDepends = [ base deepseq text vector ]; + doHaddock = false; + doCheck = false; + homepage = "https://github.com/jtdaugherty/text-zipper/"; + description = "A text editor zipper library"; + license = stdenv.lib.licenses.bsd3; + }) {}; + "textlocal" = callPackage + ({ mkDerivation, aeson, base, bytestring, http-client + , http-client-tls, http-conduit, stdenv, text, unix-time + }: + mkDerivation { + pname = "textlocal"; + version = "0.1.0.5"; + sha256 = "8954ff6270c9920fc390be6b9f398975ea06dd6808a411cbf8fa5fb4a9cf3087"; + libraryHaskellDepends = [ + aeson base bytestring http-client http-client-tls http-conduit text + unix-time + ]; + doHaddock = false; + doCheck = false; + homepage = "https://github.com/just-chow/textlocal"; + description = "Haskell wrapper for textlocal SMS gateway"; + license = stdenv.lib.licenses.bsd3; + }) {}; + "tf-random" = callPackage + ({ mkDerivation, base, primitive, random, stdenv, time }: + mkDerivation { + pname = "tf-random"; + version = "0.5"; + sha256 = "2e30cec027b313c9e1794d326635d8fc5f79b6bf6e7580ab4b00186dadc88510"; + libraryHaskellDepends = [ base primitive random time ]; + doHaddock = false; + doCheck = false; + description = "High-quality splittable pseudorandom number generator"; + license = stdenv.lib.licenses.bsd3; + }) {}; + "tfp" = callPackage + ({ mkDerivation, base, stdenv, utility-ht }: + mkDerivation { + pname = "tfp"; + version = "1.0.0.2"; + sha256 = "9a817090cb91f78424affc3bfb6a7ea65b520087b779c9fd501fc9779e654cda"; + libraryHaskellDepends = [ base utility-ht ]; + doHaddock = false; + doCheck = false; + homepage = "http://www.haskell.org/haskellwiki/Type_arithmetic"; + description = "Type-level integers, booleans, lists using type families"; + license = stdenv.lib.licenses.bsd3; + }) {}; + "th-abstraction" = callPackage + ({ mkDerivation, base, containers, ghc-prim, stdenv + , template-haskell + }: + mkDerivation { + pname = "th-abstraction"; + version = "0.2.8.0"; + sha256 = "ca136bd3fa76230a288ba0a3a65c36a555f32c179369a258b4a04d2f30e12758"; + revision = "1"; + editedCabalFile = "0yr4bj9ypbls0ysmwrgn2nsjb1xpsb12bjaiwbkzp6nf3kljwnnv"; + libraryHaskellDepends = [ + base containers ghc-prim template-haskell + ]; + doHaddock = false; + doCheck = false; + homepage = "https://github.com/glguy/th-abstraction"; + description = "Nicer interface for reified information about data types"; + license = stdenv.lib.licenses.isc; + }) {}; + "th-data-compat" = callPackage + ({ mkDerivation, base, stdenv, template-haskell }: + mkDerivation { + pname = "th-data-compat"; + version = "0.0.2.6"; + sha256 = "422fa20a0df78a5c47d0867d3094e4f0a5ba9b3f7118300af7c580156fce78bd"; + libraryHaskellDepends = [ base template-haskell ]; + doHaddock = false; + doCheck = false; + description = "Compatibility for data definition template of TH"; + license = stdenv.lib.licenses.bsd3; + }) {}; + "th-desugar" = callPackage + ({ mkDerivation, base, containers, mtl, stdenv, syb + , template-haskell, th-expand-syns, th-lift, th-orphans + }: + mkDerivation { + pname = "th-desugar"; + version = "1.8"; + sha256 = "bb4d1f1f4f63b77f8b0fdb545f0fd90a4183c80f4bb61edc2052d64e877b7a59"; + revision = "1"; + editedCabalFile = "13jvl6ijxjwbd7df0cq5pnijs3wrs8x5r9ykyyj180dak66909wd"; + libraryHaskellDepends = [ + base containers mtl syb template-haskell th-expand-syns th-lift + th-orphans + ]; + doHaddock = false; + doCheck = false; + homepage = "https://github.com/goldfirere/th-desugar"; + description = "Functions to desugar Template Haskell"; + license = stdenv.lib.licenses.bsd3; + }) {}; + "th-expand-syns" = callPackage + ({ mkDerivation, base, containers, stdenv, syb, template-haskell }: + mkDerivation { + pname = "th-expand-syns"; + version = "0.4.4.0"; + sha256 = "cc0f52d1364ace9ba56f51afd9106a5fe01ed3f5ae45c958c1b0f83be0a6f906"; + revision = "1"; + editedCabalFile = "1zbdg3hrqv7rzlsrw4a2vjr3g4nzny32wvjcpxamlvx77b1jvsw9"; + libraryHaskellDepends = [ base containers syb template-haskell ]; + doHaddock = false; + doCheck = false; + homepage = "https://github.com/DanielSchuessler/th-expand-syns"; + description = "Expands type synonyms in Template Haskell ASTs"; + license = stdenv.lib.licenses.bsd3; + }) {}; + "th-extras" = callPackage + ({ mkDerivation, base, stdenv, syb, template-haskell }: + mkDerivation { + pname = "th-extras"; + version = "0.0.0.4"; + sha256 = "8feff450aaf28ec4f08c45a5656c62879861a8e7f45591cb367d5351ddc3fbed"; + libraryHaskellDepends = [ base syb template-haskell ]; + doHaddock = false; + doCheck = false; + homepage = "https://github.com/mokus0/th-extras"; + description = "A grab bag of functions for use with Template Haskell"; + license = stdenv.lib.licenses.publicDomain; + }) {}; + "th-lift" = callPackage + ({ mkDerivation, base, ghc-prim, stdenv, template-haskell + , th-abstraction + }: + mkDerivation { + pname = "th-lift"; + version = "0.7.10"; + sha256 = "b9ce47a1e5e50d273606e826c1210b724f1af2f302a1de71cd5c9297724d888d"; + libraryHaskellDepends = [ + base ghc-prim template-haskell th-abstraction + ]; + doHaddock = false; + doCheck = false; + homepage = "http://github.com/mboes/th-lift"; + description = "Derive Template Haskell's Lift class for datatypes"; + license = stdenv.lib.licenses.bsd3; + }) {}; + "th-lift-instances" = callPackage + ({ mkDerivation, base, bytestring, containers, stdenv + , template-haskell, text, th-lift, vector + }: + mkDerivation { + pname = "th-lift-instances"; + version = "0.1.11"; + sha256 = "1da46afabdc73c86f279a0557d5a8f9af1296f9f6043264ba354b1c9cc65a6b8"; + libraryHaskellDepends = [ + base bytestring containers template-haskell text th-lift vector + ]; + doHaddock = false; + doCheck = false; + homepage = "http://github.com/bennofs/th-lift-instances/"; + description = "Lift instances for template-haskell for common data types"; + license = stdenv.lib.licenses.bsd3; + }) {}; + "th-nowq" = callPackage + ({ mkDerivation, base, stdenv, template-haskell, time }: + mkDerivation { + pname = "th-nowq"; + version = "0.1.0.2"; + sha256 = "0112f4385eb0856fd186b43a491c6538331d74ca6f86d5dfef4d15ae86e438e5"; + libraryHaskellDepends = [ base template-haskell time ]; + doHaddock = false; + doCheck = false; + homepage = "https://github.com/dzhus/th-nowq#readme"; + description = "Template Haskell splice that expands to current time"; + license = stdenv.lib.licenses.bsd3; + }) {}; + "th-orphans" = callPackage + ({ mkDerivation, base, mtl, stdenv, template-haskell, th-lift + , th-lift-instances, th-reify-many + }: + mkDerivation { + pname = "th-orphans"; + version = "0.13.6"; + sha256 = "7745e6b93a73cbc0a6aa0da0a7b7377f0be4fffb4fd311e5502de199ec1dd469"; + libraryHaskellDepends = [ + base mtl template-haskell th-lift th-lift-instances th-reify-many + ]; + doHaddock = false; + doCheck = false; + description = "Orphan instances for TH datatypes"; + license = stdenv.lib.licenses.bsd3; + }) {}; + "th-printf" = callPackage + ({ mkDerivation, ansi-wl-pprint, attoparsec, base, charset + , containers, stdenv, template-haskell, text, transformers + , trifecta, utf8-string + }: + mkDerivation { + pname = "th-printf"; + version = "0.5.1"; + sha256 = "86921f308a9446da5fa0e87b25c2f397d4ab8c85df56d9750c91fdb1ee48f135"; + libraryHaskellDepends = [ + ansi-wl-pprint attoparsec base charset containers template-haskell + text transformers trifecta utf8-string + ]; + doHaddock = false; + doCheck = false; + homepage = "https://github.com/pikajude/th-printf"; + description = "Compile-time printf"; + license = stdenv.lib.licenses.mit; + }) {}; + "th-reify-compat" = callPackage + ({ mkDerivation, base, stdenv, template-haskell }: + mkDerivation { + pname = "th-reify-compat"; + version = "0.0.1.4"; + sha256 = "089f9dda73744c533badcf13bc8e7c6dece4518a3a0b3eb5309cf55808a28a22"; + libraryHaskellDepends = [ base template-haskell ]; + doHaddock = false; + doCheck = false; + homepage = "http://github.com/khibino/haskell-th-reify-compat/"; + description = "Compatibility for the result type of TH reify"; + license = stdenv.lib.licenses.bsd3; + }) {}; + "th-reify-many" = callPackage + ({ mkDerivation, base, containers, mtl, safe, stdenv + , template-haskell, th-expand-syns + }: + mkDerivation { + pname = "th-reify-many"; + version = "0.1.8"; + sha256 = "cecaae187df911de515d08929e1394d6d6f7ce129795be8189a6b10d3734fe43"; + libraryHaskellDepends = [ + base containers mtl safe template-haskell th-expand-syns + ]; + doHaddock = false; + doCheck = false; + homepage = "http://github.com/mgsloan/th-reify-many"; + description = "Recurseively reify template haskell datatype info"; + license = stdenv.lib.licenses.bsd3; + }) {}; + "th-strict-compat" = callPackage + ({ mkDerivation, base, stdenv, template-haskell }: + mkDerivation { + pname = "th-strict-compat"; + version = "0.1.0.1"; + sha256 = "c3fad31e4b657047d8dd248803e2206c6a5b7375e22d3940714d0cc42d93aa4a"; + libraryHaskellDepends = [ base template-haskell ]; + doHaddock = false; + doCheck = false; + homepage = "https://gitlab.com/igrep/th-strict-compat"; + description = "Compatibility shim for Bang and Strict in Template Haskell"; + license = stdenv.lib.licenses.asl20; + }) {}; + "th-utilities" = callPackage + ({ mkDerivation, base, bytestring, containers, directory, filepath + , primitive, stdenv, syb, template-haskell, text, th-orphans + }: + mkDerivation { + pname = "th-utilities"; + version = "0.2.0.1"; + sha256 = "65c64cee69c0d9bf8d0d5d4590aaea7dcf4177f97818526cbb3fac20901671d6"; + libraryHaskellDepends = [ + base bytestring containers directory filepath primitive syb + template-haskell text th-orphans + ]; + doHaddock = false; + doCheck = false; + homepage = "https://github.com/fpco/th-utilities#readme"; + description = "Collection of useful functions for use with Template Haskell"; + license = stdenv.lib.licenses.mit; + }) {}; + "these" = callPackage + ({ mkDerivation, aeson, base, bifunctors, binary, containers + , data-default-class, deepseq, hashable, keys, mtl, profunctors + , QuickCheck, semigroupoids, stdenv, transformers + , transformers-compat, unordered-containers, vector + , vector-instances + }: + mkDerivation { + pname = "these"; + version = "0.7.4"; + sha256 = "dcf37d7bab1780fc56663dac1f2eeee7890a4511f66e268aafbf786def8d884a"; + revision = "8"; + editedCabalFile = "0j3ps7ngrzgxvkbr5gf8zkfkd1ci4dnfh425ndbr2xp9ipy00nkd"; + libraryHaskellDepends = [ + aeson base bifunctors binary containers data-default-class deepseq + hashable keys mtl profunctors QuickCheck semigroupoids transformers + transformers-compat unordered-containers vector vector-instances + ]; + doHaddock = false; + doCheck = false; + homepage = "https://github.com/isomorphism/these"; + description = "An either-or-both data type & a generalized 'zip with padding' typeclass"; + license = stdenv.lib.licenses.bsd3; + }) {}; + "thread-hierarchy" = callPackage + ({ mkDerivation, base, containers, stdenv, stm }: + mkDerivation { + pname = "thread-hierarchy"; + version = "0.3.0.0"; + sha256 = "e8879653bbe54b5134eed23186f98688c4e9819ce9ef4f2e2d01d0f1ae219a18"; + libraryHaskellDepends = [ base containers stm ]; + doHaddock = false; + doCheck = false; + homepage = "https://github.com/nshimaza/thread-hierarchy#readme"; + description = "Simple Haskel thread management in hierarchical manner"; + license = stdenv.lib.licenses.mit; + }) {}; + "thread-local-storage" = callPackage + ({ mkDerivation, base, containers, stdenv }: + mkDerivation { + pname = "thread-local-storage"; + version = "0.2"; + sha256 = "d648e01631189036a386d91de22f2b862e830ad0625b1f6096b347974f465294"; + libraryHaskellDepends = [ base containers ]; + doHaddock = false; + doCheck = false; + homepage = "https://github.com/rrnewton/thread-local-storage"; + description = "Several options for thread-local-storage (TLS) in Haskell"; + license = stdenv.lib.licenses.bsd3; + }) {}; + "threads" = callPackage + ({ mkDerivation, base, Cabal, stdenv, stm }: + mkDerivation { + pname = "threads"; + version = "0.5.1.6"; + sha256 = "139ac3c067fcbb392b5b9c2feaa98184b75ebe7f2e580726eea6ce812d94562e"; + setupHaskellDepends = [ base Cabal ]; + libraryHaskellDepends = [ base stm ]; + doHaddock = false; + doCheck = false; + homepage = "https://github.com/basvandijk/threads"; + description = "Fork threads and wait for their result"; + license = stdenv.lib.licenses.bsd3; + }) {}; + "threads-extras" = callPackage + ({ mkDerivation, base, stdenv, stm, threads }: + mkDerivation { + pname = "threads-extras"; + version = "0.1.0.2"; + sha256 = "4defab98b8a767b9580413d530e6823e53f6169671e53b6f8b6bfea89fde2575"; + libraryHaskellDepends = [ base stm threads ]; + doHaddock = false; + doCheck = false; + description = "Extends the threads package with a bounded thread group"; + license = stdenv.lib.licenses.bsd3; + }) {}; + "threepenny-gui" = callPackage + ({ mkDerivation, aeson, async, base, bytestring, containers + , data-default, deepseq, exceptions, file-embed, filepath, hashable + , safe, snap-core, snap-server, stdenv, stm, template-haskell, text + , transformers, unordered-containers, vault, vector, websockets + , websockets-snap + }: + mkDerivation { + pname = "threepenny-gui"; + version = "0.8.2.4"; + sha256 = "cb1ba01dea20537ec85b924e998adceae432514cec4533033c0c1d481eafc83b"; + isLibrary = true; + isExecutable = true; + enableSeparateDataOutput = true; + libraryHaskellDepends = [ + aeson async base bytestring containers data-default deepseq + exceptions file-embed filepath hashable safe snap-core snap-server + stm template-haskell text transformers unordered-containers vault + vector websockets websockets-snap + ]; + doHaddock = false; + doCheck = false; + homepage = "http://wiki.haskell.org/Threepenny-gui"; + description = "GUI framework that uses the web browser as a display"; + license = stdenv.lib.licenses.bsd3; + }) {}; + "throttle-io-stream" = callPackage + ({ mkDerivation, async, base, clock, stdenv, stm, stm-chans }: + mkDerivation { + pname = "throttle-io-stream"; + version = "0.2.0.1"; + sha256 = "e897a869062bcb4bcef372cfcf2a1e86699647fab8c721cfb22dbe6c47cf2c8e"; + libraryHaskellDepends = [ async base clock stm stm-chans ]; + doHaddock = false; + doCheck = false; + homepage = "https://github.com/mtesseract/throttle-io-stream#readme"; + description = "Throttler between arbitrary IO producer and consumer functions"; + license = stdenv.lib.licenses.bsd3; + }) {}; + "through-text" = callPackage + ({ mkDerivation, base, bytestring, case-insensitive, stdenv, text + }: + mkDerivation { + pname = "through-text"; + version = "0.1.0.0"; + sha256 = "933225da128906e61865ccd1da73463781b890d742cbb38f52524d94ac19b4cd"; + revision = "3"; + editedCabalFile = "1gia9j7zq3g74kqvkzwp68d690nhddix1kpmj23d5a3zns3rxasn"; + libraryHaskellDepends = [ base bytestring case-insensitive text ]; + doHaddock = false; + doCheck = false; + homepage = "https://www.github.com/bergmark/through-text"; + description = "Convert textual types through Text without needing O(n^2) instances"; + license = stdenv.lib.licenses.bsd3; + }) {}; + "throwable-exceptions" = callPackage + ({ mkDerivation, base, safe-exceptions, stdenv, template-haskell }: + mkDerivation { + pname = "throwable-exceptions"; + version = "0.1.0.9"; + sha256 = "3ab23c1dd24036a5d1229bed2b140ef50259e365e74c97face9d837c50c769a9"; + libraryHaskellDepends = [ base safe-exceptions template-haskell ]; + doHaddock = false; + doCheck = false; + homepage = "https://github.com/aiya000/hs-throwable-exceptions#README.md"; + description = "throwable-exceptions gives the easy way to throw exceptions"; + license = stdenv.lib.licenses.mit; + }) {}; + "tibetan-utils" = callPackage + ({ mkDerivation, base, composition-prelude, either, megaparsec + , stdenv, text, text-show + }: + mkDerivation { + pname = "tibetan-utils"; + version = "0.1.1.5"; + sha256 = "38007ff5e5ae38bbd68ff2ee6fd850bedb0da2e81891736146494ba1448f7825"; + revision = "2"; + editedCabalFile = "17zyhdxwnq85kr60bnxirmyvw3b1679j5mhm3i30ri65896pjdwf"; + libraryHaskellDepends = [ + base composition-prelude either megaparsec text text-show + ]; + doHaddock = false; + doCheck = false; + homepage = "https://github.com/vmchale/tibetan-utils#readme"; + description = "Parse and display tibetan numerals"; + license = stdenv.lib.licenses.bsd3; + }) {}; + "tile" = callPackage + ({ mkDerivation, base, stdenv }: + mkDerivation { + pname = "tile"; + version = "0.3.0.0"; + sha256 = "15ed186360bea0bfc64dd4e6fc27b4e4aed9ba2cc344f1d8ea69687933cc65f0"; + libraryHaskellDepends = [ base ]; + doHaddock = false; + doCheck = false; + homepage = "https://github.com/caneroj1/tile#readme"; + description = "Slippy map tile functionality"; + license = stdenv.lib.licenses.bsd3; + }) {}; + "time-compat" = callPackage + ({ mkDerivation, base, old-time, stdenv, time }: + mkDerivation { + pname = "time-compat"; + version = "0.1.0.3"; + sha256 = "590711214510c0d2d09780c7fe3b21748bc4802e9053f78ccd6658e951fe0f7f"; + libraryHaskellDepends = [ base old-time time ]; + doHaddock = false; + doCheck = false; + homepage = "http://hub.darcs.net/dag/time-compat"; + description = "Compatibility with old-time for the time package"; + license = stdenv.lib.licenses.bsd3; + }) {}; + "time-lens" = callPackage + ({ mkDerivation, base, data-lens-light, stdenv, time }: + mkDerivation { + pname = "time-lens"; + version = "0.4.0.2"; + sha256 = "d8cbb8fcb79867d4a5fe6bc024d0badd68fad8986f6cdc1161b0f41afa49d01e"; + libraryHaskellDepends = [ base data-lens-light time ]; + doHaddock = false; + doCheck = false; + homepage = "https://github.com/feuerbach/time-lens"; + description = "Lens-based interface to Data.Time data structures"; + license = stdenv.lib.licenses.bsd3; + }) {}; + "time-locale-compat" = callPackage + ({ mkDerivation, base, old-locale, stdenv, time }: + mkDerivation { + pname = "time-locale-compat"; + version = "0.1.1.4"; + sha256 = "f2d165557e2bbd014a4d6615b3e6c177adb034179a307a775e06836f91ebbe62"; + libraryHaskellDepends = [ base old-locale time ]; + doHaddock = false; + doCheck = false; + homepage = "https://github.com/khibino/haskell-time-locale-compat"; + description = "Compatibile module for time-format locale"; + license = stdenv.lib.licenses.bsd3; + }) {}; + "time-locale-vietnamese" = callPackage + ({ mkDerivation, base, stdenv, time }: + mkDerivation { + pname = "time-locale-vietnamese"; + version = "1.0.0.0"; + sha256 = "96062db31c2a858c20c8e3eb10aaff93e87f6514f335c14d0243429a7f730b76"; + libraryHaskellDepends = [ base time ]; + doHaddock = false; + doCheck = false; + homepage = "https://github.com/tungd/time-locale-vietnamese#readme"; + description = "Vietnamese locale for date and time format"; + license = stdenv.lib.licenses.asl20; + }) {}; + "time-parsers" = callPackage + ({ mkDerivation, base, parsers, stdenv, template-haskell, time }: + mkDerivation { + pname = "time-parsers"; + version = "0.1.2.0"; + sha256 = "4e50d40f13f8e6c5175be22b91586f909607ecb631f8209ff45bce2031bb3c24"; + revision = "3"; + editedCabalFile = "0im963wjcmwf6ii9a00mbi8lhmx5cy7cs6rmp0qi2j2jddba78j2"; + libraryHaskellDepends = [ base parsers template-haskell time ]; + doHaddock = false; + doCheck = false; + homepage = "https://github.com/phadej/time-parsers#readme"; + description = "Parsers for types in `time`"; + license = stdenv.lib.licenses.bsd3; + }) {}; + "timeit" = callPackage + ({ mkDerivation, base, stdenv }: + mkDerivation { + pname = "timeit"; + version = "2.0"; + sha256 = "a14df4e578db371e5c609f0784209144545f9cae90026d24a3398042f7c591ea"; + libraryHaskellDepends = [ base ]; + doHaddock = false; + doCheck = false; + homepage = "https://github.com/merijn/timeit"; + description = "Time monadic computations with an IO base"; + license = stdenv.lib.licenses.bsd3; + }) {}; + "timelens" = callPackage + ({ mkDerivation, base, lens, stdenv, time }: + mkDerivation { + pname = "timelens"; + version = "0.2.0.2"; + sha256 = "f4e6fa016ec37f79c96a62cff174929f04152831c308ab1f9a797f5b5674a764"; + libraryHaskellDepends = [ base lens time ]; + doHaddock = false; + doCheck = false; + homepage = "http://www.github.com/massysett/timelens"; + description = "Lenses for the time package"; + license = stdenv.lib.licenses.bsd3; + }) {}; + "timerep" = callPackage + ({ mkDerivation, attoparsec, base, monoid-subclasses, stdenv, text + , time + }: + mkDerivation { + pname = "timerep"; + version = "2.0.0.2"; + sha256 = "1d4e417f3ca08921941c16791680e13b66fb1844d94759068846ede78c965339"; + libraryHaskellDepends = [ + attoparsec base monoid-subclasses text time + ]; + doHaddock = false; + doCheck = false; + homepage = "https://github.com/HugoDaniel/timerep"; + description = "Parse and display time according to some RFCs (RFC3339, RFC2822, RFC822)"; + license = stdenv.lib.licenses.bsd3; + }) {}; + "timezone-olson" = callPackage + ({ mkDerivation, base, binary, bytestring, extensible-exceptions + , stdenv, time, timezone-series + }: + mkDerivation { + pname = "timezone-olson"; + version = "0.1.9"; + sha256 = "32230509029bcf9e1bd95b5ad7ee69b8b0250cffc4bb8f2df88a651b3af74b15"; + libraryHaskellDepends = [ + base binary bytestring extensible-exceptions time timezone-series + ]; + doHaddock = false; + doCheck = false; + homepage = "http://projects.haskell.org/time-ng/"; + description = "A pure Haskell parser and renderer for binary Olson timezone files"; + license = stdenv.lib.licenses.bsd3; + }) {}; + "timezone-series" = callPackage + ({ mkDerivation, base, deepseq, stdenv, time }: + mkDerivation { + pname = "timezone-series"; + version = "0.1.9"; + sha256 = "e5d35df5dc2408803120602b0a66ed63439e36b38dd0895f3e2159fcbd7d9cae"; + libraryHaskellDepends = [ base deepseq time ]; + doHaddock = false; + doCheck = false; + homepage = "http://projects.haskell.org/time-ng/"; + description = "Enhanced timezone handling for Data.Time"; + license = stdenv.lib.licenses.bsd3; + }) {}; + "tintin" = callPackage + ({ mkDerivation, base, clay, containers, data-has, directory + , frontmatter, inliterate, lucid, optparse-generic, process + , require, stdenv, temporary, text, universum, yaml + }: + mkDerivation { + pname = "tintin"; + version = "1.9.1"; + sha256 = "6b0a55f94c51d6bc52aae2a54c3816725885af373367a6a256acefb413a98444"; + isLibrary = true; + isExecutable = true; + libraryHaskellDepends = [ + base clay containers data-has directory frontmatter inliterate + lucid process require temporary text universum yaml + ]; + libraryToolDepends = [ require ]; + executableHaskellDepends = [ + base optparse-generic require universum + ]; + executableToolDepends = [ require ]; + doHaddock = false; + doCheck = false; + homepage = "https://github.com/theam/tintin#readme"; + description = "A softer alternative to Haddock"; + license = stdenv.lib.licenses.asl20; + }) {}; + "tinylog" = callPackage + ({ mkDerivation, base, bytestring, containers, double-conversion + , fast-logger, stdenv, text, transformers, unix-time + }: + mkDerivation { + pname = "tinylog"; + version = "0.14.1"; + sha256 = "d13e96117dfcedc861185bee5d1d130a92bce7876cc1ffd041ace2426820df07"; + libraryHaskellDepends = [ + base bytestring containers double-conversion fast-logger text + transformers unix-time + ]; + doHaddock = false; + doCheck = false; + homepage = "https://gitlab.com/twittner/tinylog/"; + description = "Simplistic logging using fast-logger"; + license = stdenv.lib.licenses.mpl20; + }) {}; + "titlecase" = callPackage + ({ mkDerivation, base, stdenv }: + mkDerivation { + pname = "titlecase"; + version = "1.0.1"; + sha256 = "e7731c29509d2b41b1d94b89484edffa10b86689a755c4019617a6c9485e49cc"; + isLibrary = true; + isExecutable = true; + libraryHaskellDepends = [ base ]; + executableHaskellDepends = [ base ]; + doHaddock = false; + doCheck = false; + homepage = "https://github.com/peti/titlecase#readme"; + description = "Convert English Words to Title Case"; + license = stdenv.lib.licenses.bsd3; + }) {}; + "tls" = callPackage + ({ mkDerivation, asn1-encoding, asn1-types, async, base, bytestring + , cereal, cryptonite, data-default-class, memory, mtl, network + , stdenv, transformers, x509, x509-store, x509-validation + }: + mkDerivation { + pname = "tls"; + version = "1.4.1"; + sha256 = "bbead1afc0b808bd5cff7bddaeae84ade37f18bbe72bd78d45a2fa4ac41908f8"; + libraryHaskellDepends = [ + asn1-encoding asn1-types async base bytestring cereal cryptonite + data-default-class memory mtl network transformers x509 x509-store + x509-validation + ]; + doHaddock = false; + doCheck = false; + homepage = "http://github.com/vincenthz/hs-tls"; + description = "TLS/SSL protocol native implementation (Server and Client)"; + license = stdenv.lib.licenses.bsd3; + }) {}; + "tls-debug" = callPackage + ({ mkDerivation, base, bytestring, cryptonite, data-default-class + , network, pem, stdenv, time, tls, x509, x509-store, x509-system + , x509-validation + }: + mkDerivation { + pname = "tls-debug"; + version = "0.4.5"; + sha256 = "a345c4863bf923829d73abb8e2b706dab8058b12cdf73859d3860eaf7223eb9b"; + isLibrary = false; + isExecutable = true; + executableHaskellDepends = [ + base bytestring cryptonite data-default-class network pem time tls + x509 x509-store x509-system x509-validation + ]; + doHaddock = false; + doCheck = false; + homepage = "http://github.com/vincenthz/hs-tls"; + description = "Set of programs for TLS testing and debugging"; + license = stdenv.lib.licenses.bsd3; + }) {}; + "tls-session-manager" = callPackage + ({ mkDerivation, auto-update, base, clock, psqueues, stdenv, tls }: + mkDerivation { + pname = "tls-session-manager"; + version = "0.0.0.2"; + sha256 = "c586ccfd8da578ed2174352bea1952f55fe38023e476f851d7f0ed428aa57567"; + libraryHaskellDepends = [ auto-update base clock psqueues tls ]; + doHaddock = false; + doCheck = false; + description = "In-memory TLS session manager"; + license = stdenv.lib.licenses.bsd3; + }) {}; + "tmapchan" = callPackage + ({ mkDerivation, base, containers, hashable, stdenv, stm + , unordered-containers + }: + mkDerivation { + pname = "tmapchan"; + version = "0.0.3"; + sha256 = "e86db4c2e6cdd373b0cbe91e01d2a223c95d5d36930f5a6c484c1586ae5011e0"; + libraryHaskellDepends = [ + base containers hashable stm unordered-containers + ]; + doHaddock = false; + doCheck = false; + homepage = "https://github.com/athanclark/tmapchan#readme"; + description = "An insert-ordered multimap (indexed FIFO) which consumes values as you lookup"; + license = stdenv.lib.licenses.bsd3; + }) {}; + "tmapmvar" = callPackage + ({ mkDerivation, base, containers, hashable, stdenv, stm + , unordered-containers + }: + mkDerivation { + pname = "tmapmvar"; + version = "0.0.4"; + sha256 = "a6e58cfd8bed77c9ec6122d26db79b3d16f139c977a255bd336fe3c53822b4e3"; + libraryHaskellDepends = [ + base containers hashable stm unordered-containers + ]; + doHaddock = false; + doCheck = false; + description = "A single-entity stateful Map in STM, similar to tmapchan"; + license = stdenv.lib.licenses.bsd3; + }) {}; + "tmp-postgres" = callPackage + ({ mkDerivation, base, bytestring, directory, network + , postgresql-simple, process, stdenv, temporary, unix + }: + mkDerivation { + pname = "tmp-postgres"; + version = "0.1.1.1"; + sha256 = "2c5d557c53f60179d5e5e8c7fb6e393ff703e45b55c126359b308ab7a82be863"; + libraryHaskellDepends = [ + base bytestring directory network postgresql-simple process + temporary unix + ]; + doHaddock = false; + doCheck = false; + homepage = "https://github.com/jfischoff/tmp-postgres#readme"; + description = "Start and stop a temporary postgres for testing"; + license = stdenv.lib.licenses.bsd3; + }) {}; + "tomland" = callPackage + ({ mkDerivation, base, hashable, megaparsec, mtl + , parser-combinators, stdenv, text, time, unordered-containers + }: + mkDerivation { + pname = "tomland"; + version = "0.3"; + sha256 = "90d34136d8bb4a38f276116484b60c8e90cd6edf42c0ba405946b4e9f7553c33"; + revision = "1"; + editedCabalFile = "1bnibs69aar32w7c4gz3hrcycfsjqsc5kavzislzgs69g0hd981z"; + isLibrary = true; + isExecutable = true; + libraryHaskellDepends = [ + base hashable megaparsec mtl parser-combinators text time + unordered-containers + ]; + executableHaskellDepends = [ base text time unordered-containers ]; + doHaddock = false; + doCheck = false; + homepage = "https://github.com/kowainik/tomland"; + description = "TOML parser"; + license = stdenv.lib.licenses.mpl20; + }) {}; + "tostring" = callPackage + ({ mkDerivation, base, case-insensitive, stdenv, text, utf8-string + }: + mkDerivation { + pname = "tostring"; + version = "0.2.1.1"; + sha256 = "efa700d44aec57c82be60c0eabd610f62f2df0d9b06cf41b5fc35a2b77502531"; + libraryHaskellDepends = [ base case-insensitive text utf8-string ]; + doHaddock = false; + doCheck = false; + description = "The ToString class"; + license = stdenv.lib.licenses.bsd3; + }) {}; + "transaction" = callPackage + ({ mkDerivation, base, mono-traversable, stdenv }: + mkDerivation { + pname = "transaction"; + version = "0.1.1.3"; + sha256 = "d264b1324726e70aceafdc2fa7eef1c863c527c69486a967116dee29aa23c0c5"; + libraryHaskellDepends = [ base mono-traversable ]; + doHaddock = false; + doCheck = false; + homepage = "https://github.com/arowM/haskell-transaction#readme"; + description = "Monadic representation of transactions"; + license = stdenv.lib.licenses.mit; + }) {}; + "transformers-base" = callPackage + ({ mkDerivation, base, base-orphans, stdenv, stm, transformers + , transformers-compat + }: + mkDerivation { + pname = "transformers-base"; + version = "0.4.5.2"; + sha256 = "d0c80c63fdce6a077dd8eda4f1ff289b85578703a3f1272e141d400fe23245e8"; + libraryHaskellDepends = [ + base base-orphans stm transformers transformers-compat + ]; + doHaddock = false; + doCheck = false; + homepage = "https://github.com/mvv/transformers-base"; + description = "Lift computations from the bottom of a transformer stack"; + license = stdenv.lib.licenses.bsd3; + }) {}; + "transformers-bifunctors" = callPackage + ({ mkDerivation, base, mmorph, stdenv, transformers }: + mkDerivation { + pname = "transformers-bifunctors"; + version = "0.1"; + sha256 = "3c25d3d76361f62b4c7c37d4bc4b7497af691d000fcd8e5fe9cbb3544d284807"; + libraryHaskellDepends = [ base mmorph transformers ]; + doHaddock = false; + doCheck = false; + homepage = "https://github.com/jystic/transformers-bifunctors"; + description = "Bifunctors over monad transformers"; + license = stdenv.lib.licenses.bsd3; + }) {}; + "transformers-compat" = callPackage + ({ mkDerivation, base, ghc-prim, stdenv, transformers }: + mkDerivation { + pname = "transformers-compat"; + version = "0.6.2"; + sha256 = "dc06228b7b8a546f9d257b4fe2b369fc2cb279240bbe4312aa8f47bb2752e4be"; + libraryHaskellDepends = [ base ghc-prim transformers ]; + doHaddock = false; + doCheck = false; + homepage = "http://github.com/ekmett/transformers-compat/"; + description = "A small compatibility shim for the transformers library"; + license = stdenv.lib.licenses.bsd3; + }) {}; + "transformers-fix" = callPackage + ({ mkDerivation, base, stdenv, transformers }: + mkDerivation { + pname = "transformers-fix"; + version = "1.0"; + sha256 = "65d1fff36b844d8ac22d47eb47e2c7e9d7ece54fafeeca4d4e38a08910be4a09"; + revision = "1"; + editedCabalFile = "126gyjr8jp42md6nblx7c0kan97jgsakvsf2vzv2pj828ax1icrs"; + libraryHaskellDepends = [ base transformers ]; + doHaddock = false; + doCheck = false; + homepage = "https://github.com/thumphries/transformers-fix"; + description = "Monad transformer for evaluating to a fixpoint"; + license = stdenv.lib.licenses.bsd3; + }) {}; + "transformers-lift" = callPackage + ({ mkDerivation, base, stdenv, transformers + , writer-cps-transformers + }: + mkDerivation { + pname = "transformers-lift"; + version = "0.2.0.1"; + sha256 = "0bd8bf23fb29874daf9ff990bf25035e21208cfa292f9f18e8cfdb0b4b1ee09d"; + revision = "2"; + editedCabalFile = "16gpca2wfa7w2b5kzfvqsjjyd61pkv0wyi2mk5b34367p4chnsc5"; + libraryHaskellDepends = [ + base transformers writer-cps-transformers + ]; + doHaddock = false; + doCheck = false; + description = "Ad-hoc type classes for lifting"; + license = stdenv.lib.licenses.bsd3; + }) {}; + "traverse-with-class" = callPackage + ({ mkDerivation, base, stdenv, template-haskell, transformers }: + mkDerivation { + pname = "traverse-with-class"; + version = "1.0.0.0"; + sha256 = "65a220f1652b68269dfe8cc283a6e9292941eb12bdbd79344e073ba766191fbb"; + libraryHaskellDepends = [ base template-haskell transformers ]; + doHaddock = false; + doCheck = false; + description = "Generic applicative traversals"; + license = stdenv.lib.licenses.mit; + }) {}; + "tree-diff" = callPackage + ({ mkDerivation, aeson, ansi-terminal, ansi-wl-pprint, base + , base-compat, bytestring, containers, generics-sop, hashable + , MemoTrie, parsec, parsers, pretty, QuickCheck, scientific, stdenv + , tagged, text, time, unordered-containers, uuid-types, vector + }: + mkDerivation { + pname = "tree-diff"; + version = "0.0.1"; + sha256 = "bfe23e4c17c0cdbffa9f159b7adaaeb20e48575b3b5bda591c5e025118213b11"; + revision = "6"; + editedCabalFile = "1wyhygrpqphxzzwlrk6nl4h5xbyx6zi0y34i1nxvsy726fl5idai"; + libraryHaskellDepends = [ + aeson ansi-terminal ansi-wl-pprint base base-compat bytestring + containers generics-sop hashable MemoTrie parsec parsers pretty + QuickCheck scientific tagged text time unordered-containers + uuid-types vector + ]; + doHaddock = false; + doCheck = false; + homepage = "https://github.com/phadej/tree-diff"; + description = "Diffing of (expression) trees"; + license = stdenv.lib.licenses.bsd3; + }) {}; + "tree-fun" = callPackage + ({ mkDerivation, base, containers, mtl, stdenv }: + mkDerivation { + pname = "tree-fun"; + version = "0.8.1.0"; + sha256 = "2ae925f198e9700dedbf809c2b77086fef32f58b4a4adb6c398dca49f4d56f1f"; + libraryHaskellDepends = [ base containers mtl ]; + doHaddock = false; + doCheck = false; + description = "Library for functions pertaining to tree exploration and manipulation"; + license = stdenv.lib.licenses.gpl3; + }) {}; + "trifecta" = callPackage + ({ mkDerivation, ansi-terminal, ansi-wl-pprint, array, base + , blaze-builder, blaze-html, blaze-markup, bytestring, Cabal + , cabal-doctest, charset, comonad, containers, deepseq, fingertree + , ghc-prim, hashable, lens, mtl, parsers, profunctors, reducers + , semigroups, stdenv, transformers, unordered-containers + , utf8-string + }: + mkDerivation { + pname = "trifecta"; + version = "2"; + sha256 = "53972fe9d206eab6ae1a654fe8c57274f01b373b0c8b3882ef01e962226af643"; + setupHaskellDepends = [ base Cabal cabal-doctest ]; + libraryHaskellDepends = [ + ansi-terminal ansi-wl-pprint array base blaze-builder blaze-html + blaze-markup bytestring charset comonad containers deepseq + fingertree ghc-prim hashable lens mtl parsers profunctors reducers + semigroups transformers unordered-containers utf8-string + ]; + doHaddock = false; + doCheck = false; + homepage = "http://github.com/ekmett/trifecta/"; + description = "A modern parser combinator library with convenient diagnostics"; + license = stdenv.lib.licenses.bsd3; + }) {}; + "triplesec" = callPackage + ({ mkDerivation, base, cryptonite, memory, mtl, stdenv + , transformers + }: + mkDerivation { + pname = "triplesec"; + version = "0.1.2.0"; + sha256 = "86b8749e708fd288a874d23ebeb9ff5e3a584ada13bc22c3a9b596418bd57063"; + libraryHaskellDepends = [ + base cryptonite memory mtl transformers + ]; + doHaddock = false; + doCheck = false; + homepage = "https://github.com/SamProtas/hs-triplesec"; + description = "TripleSec is a simple, triple-paranoid, symmetric encryption library"; + license = stdenv.lib.licenses.bsd3; + }) {}; + "tsv2csv" = callPackage + ({ mkDerivation, base, HUnit, split, stdenv }: + mkDerivation { + pname = "tsv2csv"; + version = "0.1.0.2"; + sha256 = "2c082f8bac93a5d47e312148493d0b8f078e2e0d0e919caa0fa24cab63dd3397"; + isLibrary = true; + isExecutable = true; + libraryHaskellDepends = [ base HUnit split ]; + executableHaskellDepends = [ base ]; + doHaddock = false; + doCheck = false; + description = "Convert tsv to csv"; + license = stdenv.lib.licenses.bsd3; + }) {}; + "ttrie" = callPackage + ({ mkDerivation, atomic-primops, base, hashable, primitive, stdenv + , stm + }: + mkDerivation { + pname = "ttrie"; + version = "0.1.2.1"; + sha256 = "50444fe989559a0b16120df72765321ffd9de2fd97c943104513d894f21f4a68"; + libraryHaskellDepends = [ + atomic-primops base hashable primitive stm + ]; + doHaddock = false; + doCheck = false; + homepage = "http://github.com/mcschroeder/ttrie"; + description = "Contention-free STM hash map"; + license = stdenv.lib.licenses.mit; + }) {}; + "tuple" = callPackage + ({ mkDerivation, base, OneTuple, stdenv }: + mkDerivation { + pname = "tuple"; + version = "0.3.0.2"; + sha256 = "2fcb068ffafbe64170e02094a363f83d1725f44f8af963d9dad943a592e89624"; + libraryHaskellDepends = [ base OneTuple ]; + doHaddock = false; + doCheck = false; + description = "Various functions on tuples"; + license = stdenv.lib.licenses.bsd3; + }) {}; + "tuple-sop" = callPackage + ({ mkDerivation, base, generics-sop, stdenv }: + mkDerivation { + pname = "tuple-sop"; + version = "0.3.1.0"; + sha256 = "f6e18d0f444993c959eaa7d1aca87993c779b929260b1c6dd823715d3e736043"; + libraryHaskellDepends = [ base generics-sop ]; + doHaddock = false; + doCheck = false; + homepage = "https://github.com/Ferdinand-vW/tuple-sop#readme"; + description = "functions on n-ary tuples using generics-sop"; + license = stdenv.lib.licenses.gpl3; + }) {}; + "tuple-th" = callPackage + ({ mkDerivation, base, containers, stdenv, template-haskell }: + mkDerivation { + pname = "tuple-th"; + version = "0.2.5"; + sha256 = "56ea37dcede07b5cf5385108540ae626db163f9df0387583d3c7afdaf72634d7"; + libraryHaskellDepends = [ base containers template-haskell ]; + doHaddock = false; + doCheck = false; + description = "Generate (non-recursive) utility functions for tuples of statically known size"; + license = stdenv.lib.licenses.bsd3; + }) {}; + "tuples-homogenous-h98" = callPackage + ({ mkDerivation, base, stdenv }: + mkDerivation { + pname = "tuples-homogenous-h98"; + version = "0.1.1.0"; + sha256 = "025afc8f0fe9c92fb43cebedfa6a764f744d3dc3a3d52935d0a01bc80d111f3a"; + libraryHaskellDepends = [ base ]; + doHaddock = false; + doCheck = false; + homepage = "https://github.com/ppetr/tuples-homogenous-h98"; + description = "Wrappers for n-ary tuples with Traversable and Applicative/Monad instances"; + license = stdenv.lib.licenses.bsd3; + }) {}; + "turtle" = callPackage + ({ mkDerivation, ansi-wl-pprint, async, base, bytestring, clock + , containers, directory, exceptions, foldl, hostname, managed + , optional-args, optparse-applicative, process, semigroups, stdenv + , stm, system-fileio, system-filepath, temporary, text, time + , transformers, unix, unix-compat + }: + mkDerivation { + pname = "turtle"; + version = "1.5.10"; + sha256 = "3a93a9aa84e7c04f57d1398b7b1d4ff21a13cc7869922c27d1c3dd201d774b30"; + libraryHaskellDepends = [ + ansi-wl-pprint async base bytestring clock containers directory + exceptions foldl hostname managed optional-args + optparse-applicative process semigroups stm system-fileio + system-filepath temporary text time transformers unix unix-compat + ]; + doHaddock = false; + doCheck = false; + description = "Shell programming, Haskell-style"; + license = stdenv.lib.licenses.bsd3; + }) {}; + "type-fun" = callPackage + ({ mkDerivation, base, stdenv }: + mkDerivation { + pname = "type-fun"; + version = "0.1.1"; + sha256 = "df5ec7428a101235df46c0b819a9ab3562d1d27991cc3b04303643952c555da1"; + libraryHaskellDepends = [ base ]; + doHaddock = false; + doCheck = false; + homepage = "https://github.com/s9gf4ult/type-fun"; + description = "Collection of widely reimplemented type families"; + license = stdenv.lib.licenses.bsd3; + }) {}; + "type-hint" = callPackage + ({ mkDerivation, base, stdenv }: + mkDerivation { + pname = "type-hint"; + version = "0.1"; + sha256 = "1161cdbf4b4b43c2953ee60438e948737604193e1bfe2c880ff178538faa99b9"; + libraryHaskellDepends = [ base ]; + doHaddock = false; + doCheck = false; + homepage = "https://github.com/mvv/type-hint"; + description = "Guide type inference with proxy values"; + license = stdenv.lib.licenses.bsd3; + }) {}; + "type-level-integers" = callPackage + ({ mkDerivation, base, stdenv }: + mkDerivation { + pname = "type-level-integers"; + version = "0.0.1"; + sha256 = "118be3a4b3ab65bb1d31220738079013bd14fc77db674a9a1577f5582ffcc7ba"; + libraryHaskellDepends = [ base ]; + doHaddock = false; + doCheck = false; + homepage = "https://github.com/mtesseract/type-level-integers"; + description = "Provides integers lifted to the type level"; + license = stdenv.lib.licenses.bsd3; + }) {}; + "type-level-kv-list" = callPackage + ({ mkDerivation, base, stdenv }: + mkDerivation { + pname = "type-level-kv-list"; + version = "1.1.0"; + sha256 = "4ff032e59108edc7dd27309ac0ee8987cc41ffba695d9699700bd37c6e7f7d73"; + libraryHaskellDepends = [ base ]; + doHaddock = false; + doCheck = false; + homepage = "https://github.com/arowM/type-level-kv-list#readme"; + description = "A module for hash map like object with type level keys"; + license = stdenv.lib.licenses.mit; + }) {}; + "type-level-numbers" = callPackage + ({ mkDerivation, base, stdenv, template-haskell }: + mkDerivation { + pname = "type-level-numbers"; + version = "0.1.1.1"; + sha256 = "5b56ef5f6e0b6476b9aba46055c3919e67823cbc1b87ed8e6ed70113b1f2318a"; + libraryHaskellDepends = [ base template-haskell ]; + doHaddock = false; + doCheck = false; + description = "Type level numbers implemented using type families"; + license = stdenv.lib.licenses.bsd3; + }) {}; + "type-of-html" = callPackage + ({ mkDerivation, base, bytestring, double-conversion, ghc-prim + , stdenv, text + }: + mkDerivation { + pname = "type-of-html"; + version = "1.4.0.1"; + sha256 = "e3992f60601f8624a13cb686d400f9be843e33c20223a2ce7af51e85f3bc92ad"; + libraryHaskellDepends = [ + base bytestring double-conversion ghc-prim text + ]; + doHaddock = false; + doCheck = false; + homepage = "https://github.com/knupfer/type-of-html"; + description = "High performance type driven html generation"; + license = stdenv.lib.licenses.bsd3; + }) {}; + "type-of-html-static" = callPackage + ({ mkDerivation, base, stdenv, template-haskell, type-of-html }: + mkDerivation { + pname = "type-of-html-static"; + version = "0.1.0.2"; + sha256 = "29b3d951eed5498e8011db25996660a5aa0895e1e25fc12da7522fdae74f6200"; + libraryHaskellDepends = [ base template-haskell type-of-html ]; + doHaddock = false; + doCheck = false; + homepage = "https://github.com/knupfer/type-of-html-static"; + description = "Optimize static parts of type-of-html"; + license = stdenv.lib.licenses.bsd3; + }) {}; + "type-operators" = callPackage + ({ mkDerivation, base, ghc-prim, stdenv }: + mkDerivation { + pname = "type-operators"; + version = "0.1.0.4"; + sha256 = "dbbcedf368c23c46abac04f157cb4f2c812099a4f75d606b24f1ac1116d40b74"; + libraryHaskellDepends = [ base ghc-prim ]; + doHaddock = false; + doCheck = false; + homepage = "https://github.com/Shou/type-operators#readme"; + description = "Various type-level operators"; + license = stdenv.lib.licenses.bsd3; + }) {}; + "type-spec" = callPackage + ({ mkDerivation, base, pretty, stdenv }: + mkDerivation { + pname = "type-spec"; + version = "0.3.0.1"; + sha256 = "aecd1a319efc13eb42b73b489cf374f94bf126f19fdc28b2f5cd6f73dda3a241"; + libraryHaskellDepends = [ base pretty ]; + doHaddock = false; + doCheck = false; + homepage = "https://github.com/sheyll/type-spec#readme"; + description = "Type Level Specification by Example"; + license = stdenv.lib.licenses.bsd3; + }) {}; + "typed-process" = callPackage + ({ mkDerivation, async, base, bytestring, process, stdenv, stm + , transformers + }: + mkDerivation { + pname = "typed-process"; + version = "0.2.2.0"; + sha256 = "42ed06889c15aa07577a0e8e3632659e343be95b77afa252b48b592ff7dbcf30"; + libraryHaskellDepends = [ + async base bytestring process stm transformers + ]; + doHaddock = false; + doCheck = false; + homepage = "https://haskell-lang.org/library/typed-process"; + description = "Run external processes, with strong typing of streams"; + license = stdenv.lib.licenses.mit; + }) {}; + "typelits-witnesses" = callPackage + ({ mkDerivation, base, base-compat, constraints, reflection, stdenv + , transformers + }: + mkDerivation { + pname = "typelits-witnesses"; + version = "0.3.0.2"; + sha256 = "6e26c69ff347d138568e6c7e3fc5b256fc3fa3d54c563c2423443dc3428ee64c"; + libraryHaskellDepends = [ + base base-compat constraints reflection transformers + ]; + doHaddock = false; + doCheck = false; + homepage = "https://github.com/mstksg/typelits-witnesses"; + description = "Existential witnesses, singletons, and classes for operations on GHC TypeLits"; + license = stdenv.lib.licenses.mit; + }) {}; + "typenums" = callPackage + ({ mkDerivation, base, stdenv }: + mkDerivation { + pname = "typenums"; + version = "0.1.1.1"; + sha256 = "9b80a0f187a34df8d1d8bbac3c0064b427405a40f55b60a8ae04f2c62108757e"; + libraryHaskellDepends = [ base ]; + doHaddock = false; + doCheck = false; + homepage = "https://github.com/adituv/typenums#readme"; + description = "Type level numbers using existing Nat functionality"; + license = stdenv.lib.licenses.bsd3; + }) {}; + "typography-geometry" = callPackage + ({ mkDerivation, base, containers, parallel, polynomials-bernstein + , stdenv, vector + }: + mkDerivation { + pname = "typography-geometry"; + version = "1.0.0.1"; + sha256 = "edaeafb60126be19f0e4fdda54be89b92317dd03b59e9d8b6f119064c1642ad7"; + libraryHaskellDepends = [ + base containers parallel polynomials-bernstein vector + ]; + doHaddock = false; + doCheck = false; + description = "Drawings for printed text documents"; + license = "GPL"; + }) {}; + "tz" = callPackage + ({ mkDerivation, base, binary, bytestring, containers, data-default + , deepseq, stdenv, template-haskell, time, tzdata, vector + }: + mkDerivation { + pname = "tz"; + version = "0.1.3.1"; + sha256 = "0b54729c7b60e90e00ee8e78190d4e86b3fb02d24ef4e393383df800faccfff9"; + libraryHaskellDepends = [ + base binary bytestring containers data-default deepseq + template-haskell time tzdata vector + ]; + doHaddock = false; + doCheck = false; + preConfigure = "export TZDIR=${pkgs.tzdata}/share/zoneinfo"; + homepage = "https://github.com/nilcons/haskell-tz"; + description = "Efficient time zone handling"; + license = stdenv.lib.licenses.asl20; + }) {}; + "tzdata" = callPackage + ({ mkDerivation, base, bytestring, containers, deepseq, stdenv + , vector + }: + mkDerivation { + pname = "tzdata"; + version = "0.1.20180122.0"; + sha256 = "a31bd845e94fd50d0e97d6d23a0ae39511cdf144075f4978579ede55b714db9d"; + revision = "1"; + editedCabalFile = "1a2jlinwj0m0ilc50wxgil1xr2an5byywipd55sf9pqvnj5ap0qi"; + enableSeparateDataOutput = true; + libraryHaskellDepends = [ + base bytestring containers deepseq vector + ]; + doHaddock = false; + doCheck = false; + homepage = "https://github.com/nilcons/haskell-tzdata"; + description = "Time zone database (as files and as a module)"; + license = stdenv.lib.licenses.asl20; + }) {}; + "uglymemo" = callPackage + ({ mkDerivation, base, containers, stdenv }: + mkDerivation { + pname = "uglymemo"; + version = "0.1.0.1"; + sha256 = "fe89ef49c0cb15867c58815b050b33f17d394d4c48a9b7240a39780a5a79b847"; + libraryHaskellDepends = [ base containers ]; + doHaddock = false; + doCheck = false; + description = "A simple (but internally ugly) memoization function"; + license = stdenv.lib.licenses.publicDomain; + }) {}; + "unbound-generics" = callPackage + ({ mkDerivation, ansi-wl-pprint, base, containers, contravariant + , deepseq, exceptions, mtl, profunctors, stdenv, template-haskell + , transformers, transformers-compat + }: + mkDerivation { + pname = "unbound-generics"; + version = "0.3.3"; + sha256 = "7fedc5b19dfb4a20d280a4ae538d89cf3482ad30ac77ee1bd2aaa35a6519ad1a"; + libraryHaskellDepends = [ + ansi-wl-pprint base containers contravariant deepseq exceptions mtl + profunctors template-haskell transformers transformers-compat + ]; + doHaddock = false; + doCheck = false; + homepage = "http://github.com/lambdageek/unbound-generics"; + description = "Support for programming with names and binders using GHC Generics"; + license = stdenv.lib.licenses.bsd3; + }) {}; + "unbounded-delays" = callPackage + ({ mkDerivation, base, stdenv }: + mkDerivation { + pname = "unbounded-delays"; + version = "0.1.1.0"; + sha256 = "8aa7f7d10a8d0073518804db76c3ef4c313359994ef175122341b0bce07329c7"; + libraryHaskellDepends = [ base ]; + doHaddock = false; + doCheck = false; + homepage = "https://github.com/basvandijk/unbounded-delays"; + description = "Unbounded thread delays and timeouts"; + license = stdenv.lib.licenses.bsd3; + }) {}; + "unboxed-ref" = callPackage + ({ mkDerivation, base, ghc-prim, primitive, stdenv }: + mkDerivation { + pname = "unboxed-ref"; + version = "0.4.0.0"; + sha256 = "64eba8d550035a3a90cf9179e52f79877b426f0a6337cc216fdef45fcbb8773f"; + libraryHaskellDepends = [ base ghc-prim primitive ]; + doHaddock = false; + doCheck = false; + homepage = "https://github.com/winterland1989/unboxed-ref"; + description = "Fast unboxed references for ST and IO monad"; + license = stdenv.lib.licenses.bsd3; + }) {}; + "uncertain" = callPackage + ({ mkDerivation, ad, base, base-compat, containers, free + , mwc-random, primitive, stdenv, transformers + }: + mkDerivation { + pname = "uncertain"; + version = "0.3.1.0"; + sha256 = "6f67855ed4799e0c3465dfaef062b637efc61fbea40ebc44ced163028a996ff2"; + libraryHaskellDepends = [ + ad base base-compat containers free mwc-random primitive + transformers + ]; + doHaddock = false; + doCheck = false; + homepage = "https://github.com/mstksg/uncertain"; + description = "Manipulating numbers with inherent experimental/measurement uncertainty"; + license = stdenv.lib.licenses.bsd3; + }) {}; + "unconstrained" = callPackage + ({ mkDerivation, stdenv }: + mkDerivation { + pname = "unconstrained"; + version = "0.1.0.2"; + sha256 = "d2717a66a0232ce454740f45c74645af5ef052e23ba81195ce6c3a06a10e010d"; + doHaddock = false; + doCheck = false; + description = "Null constraint"; + license = stdenv.lib.licenses.bsd3; + }) {}; + "unfoldable" = callPackage + ({ mkDerivation, base, containers, ghc-prim, one-liner, QuickCheck + , random, stdenv, transformers + }: + mkDerivation { + pname = "unfoldable"; + version = "0.9.6"; + sha256 = "cd90eae9ba258cfaf2554b4946c9b60def83c92548bbeb7269fec97a8657eaa1"; + revision = "2"; + editedCabalFile = "08rx8ci2jpa77q1dl4lghlyhd27if990ic9kaz30hczsazlzi44b"; + libraryHaskellDepends = [ + base containers ghc-prim one-liner QuickCheck random transformers + ]; + doHaddock = false; + doCheck = false; + homepage = "https://github.com/sjoerdvisscher/unfoldable"; + description = "Class of data structures that can be unfolded"; + license = stdenv.lib.licenses.bsd3; + }) {}; + "unfoldable-restricted" = callPackage + ({ mkDerivation, base, constraints, containers, hashable, stdenv + , transformers, unfoldable, unit-constraint, unordered-containers + }: + mkDerivation { + pname = "unfoldable-restricted"; + version = "0.0.3"; + sha256 = "0b19287719453617f3883863f32be75ba62aad68151cb79aea3a5fa90dc7836e"; + libraryHaskellDepends = [ + base constraints containers hashable transformers unfoldable + unit-constraint unordered-containers + ]; + doHaddock = false; + doCheck = false; + description = "An alternative to the Unfoldable typeclass"; + license = stdenv.lib.licenses.bsd3; + }) {}; + "unicode" = callPackage + ({ mkDerivation, base, containers, semigroups, stdenv }: + mkDerivation { + pname = "unicode"; + version = "0.0.1"; + sha256 = "49bde95d4df4ebed755b10860aeb92f9cf0a3be8127d39a95f480036e6449b81"; + isLibrary = true; + isExecutable = true; + libraryHaskellDepends = [ base containers semigroups ]; + doHaddock = false; + doCheck = false; + homepage = "http://hub.darcs.net/thielema/unicode/"; + description = "Construct and transform unicode characters"; + license = stdenv.lib.licenses.bsd3; + }) {}; + "unicode-show" = callPackage + ({ mkDerivation, base, stdenv }: + mkDerivation { + pname = "unicode-show"; + version = "0.1.0.2"; + sha256 = "7ee394879b345ee397aef87ca058628cd79d59cbfc1cec81aeda7fea65f53943"; + libraryHaskellDepends = [ base ]; + doHaddock = false; + doCheck = false; + homepage = "http://github.com/nushio3/unicode-show#readme"; + description = "print and show in unicode"; + license = stdenv.lib.licenses.bsd3; + }) {}; + "unicode-transforms" = callPackage + ({ mkDerivation, base, bitarray, bytestring, stdenv, text }: + mkDerivation { + pname = "unicode-transforms"; + version = "0.3.4"; + sha256 = "829eaccba7d2e3d642d0cf60bbab403a6a5673db64284c02abf3ee3e8d5c0852"; + libraryHaskellDepends = [ base bitarray bytestring text ]; + doHaddock = false; + doCheck = false; + homepage = "http://github.com/harendra-kumar/unicode-transforms"; + description = "Unicode normalization"; + license = stdenv.lib.licenses.bsd3; + }) {}; + "unification-fd" = callPackage + ({ mkDerivation, base, containers, logict, mtl, stdenv }: + mkDerivation { + pname = "unification-fd"; + version = "0.10.0.1"; + sha256 = "5bf46760e6db104c57f915322b32744f7604323281f5c7dd20185f905fb51996"; + libraryHaskellDepends = [ base containers logict mtl ]; + doHaddock = false; + doCheck = false; + homepage = "http://code.haskell.org/~wren/"; + description = "Simple generic unification algorithms"; + license = stdenv.lib.licenses.bsd3; + }) {}; + "union" = callPackage + ({ mkDerivation, base, deepseq, profunctors, stdenv, tagged, vinyl + }: + mkDerivation { + pname = "union"; + version = "0.1.1.2"; + sha256 = "7ce28e082940e184a255459b29356b7d39e3421cb37b01ee1ed067437165d382"; + revision = "5"; + editedCabalFile = "0mphzzvvr8lh1x8mb6n9nzzskx32cmr6ycihdy68qw35ybrqb0aj"; + libraryHaskellDepends = [ base deepseq profunctors tagged vinyl ]; + doHaddock = false; + doCheck = false; + description = "Extensible type-safe unions"; + license = stdenv.lib.licenses.bsd3; + }) {}; + "union-find" = callPackage + ({ mkDerivation, base, containers, stdenv, transformers }: + mkDerivation { + pname = "union-find"; + version = "0.2"; + sha256 = "e6c2682bb8c06e8c43e360f45658d0eea17209cce84953e2a7d2f0240591f0ec"; + revision = "1"; + editedCabalFile = "13cwjh03n82sgshbk4fdlvhc0pb3v979sdcdrpvnpjdqmvcprs92"; + libraryHaskellDepends = [ base containers transformers ]; + doHaddock = false; + doCheck = false; + homepage = "http://github.com/nominolo/union-find"; + description = "Efficient union and equivalence testing of sets"; + license = stdenv.lib.licenses.bsd3; + }) {}; + "uniplate" = callPackage + ({ mkDerivation, base, containers, hashable, stdenv, syb + , unordered-containers + }: + mkDerivation { + pname = "uniplate"; + version = "1.6.12"; + sha256 = "fcc60bc6b3f6e925f611646db90e6db9f05286a9363405f844df1dc15572a8b7"; + libraryHaskellDepends = [ + base containers hashable syb unordered-containers + ]; + doHaddock = false; + doCheck = false; + homepage = "http://community.haskell.org/~ndm/uniplate/"; + description = "Help writing simple, concise and fast generic operations"; + license = stdenv.lib.licenses.bsd3; + }) {}; + "uniprot-kb" = callPackage + ({ mkDerivation, attoparsec, base, stdenv, text }: + mkDerivation { + pname = "uniprot-kb"; + version = "0.1.2.0"; + sha256 = "d40c80522f9e70e6fe97234f362e503736ae9f520f1e10e9ab249a5cad750642"; + revision = "1"; + editedCabalFile = "0kvw9mzgjz6m1sslywn09n4axkjnwqpi4c5p00p9c81mr9fpbild"; + libraryHaskellDepends = [ attoparsec base text ]; + doHaddock = false; + doCheck = false; + homepage = "https://github.com/biocad/uniprot-kb#readme"; + description = "UniProt-KB format parser"; + license = stdenv.lib.licenses.bsd3; + }) {}; + "uniq-deep" = callPackage + ({ mkDerivation, base, bytestring, containers, stdenv }: + mkDerivation { + pname = "uniq-deep"; + version = "1.1.0.0"; + sha256 = "f8953f91cbf90c5073ca90d4e9235dbe0a399ff811709d051b037a8a7db0d38e"; + isLibrary = false; + isExecutable = true; + executableHaskellDepends = [ base bytestring containers ]; + doHaddock = false; + doCheck = false; + homepage = "https://github.com/ncaq/uniq-deep"; + description = "uniq-deep"; + license = stdenv.lib.licenses.publicDomain; + }) {}; + "unique" = callPackage + ({ mkDerivation, base, ghc-prim, hashable, stdenv }: + mkDerivation { + pname = "unique"; + version = "0"; + sha256 = "e3fb171b7b1787683863934df0fc082fb47c0da6972bb1839c2ee8ceb64a0a90"; + revision = "1"; + editedCabalFile = "0pq3a5y8ddgd37x21vafwxpyi079ir7k9g96y99pygmxwibkg4v8"; + libraryHaskellDepends = [ base ghc-prim hashable ]; + doHaddock = false; + doCheck = false; + homepage = "http://github.com/ekmett/unique/"; + description = "Fully concurrent unique identifiers"; + license = stdenv.lib.licenses.bsd3; + }) {}; + "unit-constraint" = callPackage + ({ mkDerivation, base, constraints, stdenv }: + mkDerivation { + pname = "unit-constraint"; + version = "0.0.0"; + sha256 = "446de8480016c9db75676445477b5ce1ff5c6d486d6708c55b06de7cbd845e59"; + libraryHaskellDepends = [ base constraints ]; + doHaddock = false; + doCheck = false; + description = "Extremely simple typeclass"; + license = stdenv.lib.licenses.bsd3; + }) {}; + "universe" = callPackage + ({ mkDerivation, stdenv, universe-instances-base + , universe-instances-extended, universe-instances-trans + , universe-reverse-instances + }: + mkDerivation { + pname = "universe"; + version = "1.0"; + sha256 = "1f80e4788d348d53e39a32c8514940418a71c49c5423eb70b94e1786d94ff9a7"; + libraryHaskellDepends = [ + universe-instances-base universe-instances-extended + universe-instances-trans universe-reverse-instances + ]; + doHaddock = false; + doCheck = false; + homepage = "https://github.com/dmwit/universe"; + description = "Classes for types where we know all the values"; + license = stdenv.lib.licenses.bsd3; + }) {}; + "universe-base" = callPackage + ({ mkDerivation, base, stdenv }: + mkDerivation { + pname = "universe-base"; + version = "1.0.2.1"; + sha256 = "07c48350afacdc0b5569f72e3d6a27a8ff3c208b7a6f22d00e149a201798bb51"; + libraryHaskellDepends = [ base ]; + doHaddock = false; + doCheck = false; + homepage = "https://github.com/dmwit/universe"; + description = "A class for finite and recursively enumerable types and some helper functions for enumerating them"; + license = stdenv.lib.licenses.bsd3; + }) {}; + "universe-instances-base" = callPackage + ({ mkDerivation, base, containers, stdenv, universe-base }: + mkDerivation { + pname = "universe-instances-base"; + version = "1.0"; + sha256 = "a21150ee3bb71283522a573bf092c8d96b2e28a95336a95505aa4c2a067dd212"; + revision = "2"; + editedCabalFile = "0c9zxmifhy2qjvsikgm168n8k8ka8ia88ldy8qjqkz5pqknlr9sj"; + libraryHaskellDepends = [ base containers universe-base ]; + doHaddock = false; + doCheck = false; + homepage = "https://github.com/dmwit/universe"; + description = "Universe instances for types from the base package"; + license = stdenv.lib.licenses.bsd3; + }) {}; + "universe-instances-extended" = callPackage + ({ mkDerivation, adjunctions, base, comonad, stdenv + , universe-instances-base, void + }: + mkDerivation { + pname = "universe-instances-extended"; + version = "1.0.0.1"; + sha256 = "665b272701b16a6bb8d40a5396aa1dcb038f002452ebdc29d353e3be2070c997"; + revision = "2"; + editedCabalFile = "1di3jk3ciikjrxzr76i0mqqza26mclnbxxak7ybkk4l06yqanj38"; + libraryHaskellDepends = [ + adjunctions base comonad universe-instances-base void + ]; + doHaddock = false; + doCheck = false; + homepage = "https://github.com/dmwit/universe"; + description = "Universe instances for types from select extra packages"; + license = stdenv.lib.licenses.bsd3; + }) {}; + "universe-instances-trans" = callPackage + ({ mkDerivation, base, mtl, stdenv, transformers, universe-base + , universe-instances-base + }: + mkDerivation { + pname = "universe-instances-trans"; + version = "1.0.0.1"; + sha256 = "0d047cf1eb4af9f2052f44f487e7d2d44c86f51b54a3cc1fc5243ad816e8310e"; + revision = "1"; + editedCabalFile = "0dcwgbgmbkjwzbxlncpl1b5hgjrmkl73djknjkhbnh02pysbwv69"; + libraryHaskellDepends = [ + base mtl transformers universe-base universe-instances-base + ]; + doHaddock = false; + doCheck = false; + homepage = "https://github.com/dmwit/universe"; + description = "Universe instances for types from the transformers and mtl packages"; + license = stdenv.lib.licenses.bsd3; + }) {}; + "universe-reverse-instances" = callPackage + ({ mkDerivation, base, containers, stdenv, universe-instances-base + }: + mkDerivation { + pname = "universe-reverse-instances"; + version = "1.0"; + sha256 = "e9d41cbf26eabd77587fddf69493d7ad23028303d1c1d1d2ee1de1bf3d3e8d49"; + revision = "2"; + editedCabalFile = "0cpnsip1iakwkgnwnd21gwrc8qbifzpff6agjwm34jgkq9j646k8"; + libraryHaskellDepends = [ + base containers universe-instances-base + ]; + doHaddock = false; + doCheck = false; + homepage = "https://github.com/dmwit/universe"; + description = "instances of standard classes that are made possible by enumerations"; + license = stdenv.lib.licenses.bsd3; + }) {}; + "universum" = callPackage + ({ mkDerivation, base, bytestring, containers, deepseq, ghc-prim + , hashable, microlens, microlens-mtl, mtl, safe-exceptions, stdenv + , stm, text, transformers, type-operators, unordered-containers + , utf8-string, vector + }: + mkDerivation { + pname = "universum"; + version = "1.2.0"; + sha256 = "37a10c85d0b4812a9687846cdfe20a61eb102839318149ad036d8c1be47e8518"; + libraryHaskellDepends = [ + base bytestring containers deepseq ghc-prim hashable microlens + microlens-mtl mtl safe-exceptions stm text transformers + type-operators unordered-containers utf8-string vector + ]; + doHaddock = false; + doCheck = false; + homepage = "https://github.com/serokell/universum"; + description = "Custom prelude used in Serokell"; + license = stdenv.lib.licenses.mit; + }) {}; + "unix-bytestring" = callPackage + ({ mkDerivation, base, bytestring, stdenv }: + mkDerivation { + pname = "unix-bytestring"; + version = "0.3.7.3"; + sha256 = "a3ec273da411988b7d9eb7317f6d84ce47f4b7fd39bdc721acd5229e7cff808c"; + libraryHaskellDepends = [ base bytestring ]; + doHaddock = false; + doCheck = false; + homepage = "http://code.haskell.org/~wren/"; + description = "Unix/Posix-specific functions for ByteStrings"; + license = stdenv.lib.licenses.bsd3; + }) {}; + "unix-compat" = callPackage + ({ mkDerivation, base, stdenv, unix }: + mkDerivation { + pname = "unix-compat"; + version = "0.5.0.1"; + sha256 = "c2f299e0439c15d93d5700911c922fd2b35543c19ba053779cd52f3b051caebd"; + revision = "1"; + editedCabalFile = "0yrdy4dz0zskgpw7c4wgkwskgayqxvch37axwka5z4g5gmic4mnn"; + libraryHaskellDepends = [ base unix ]; + doHaddock = false; + doCheck = false; + homepage = "http://github.com/jystic/unix-compat"; + description = "Portable POSIX-compatibility layer"; + license = stdenv.lib.licenses.bsd3; + }) {}; + "unix-time" = callPackage + ({ mkDerivation, base, binary, bytestring, old-time, stdenv }: + mkDerivation { + pname = "unix-time"; + version = "0.3.8"; + sha256 = "dca1bd332f4690f667570868c91c1270083428067e0e20b88a9d9516efa33a14"; + libraryHaskellDepends = [ base binary bytestring old-time ]; + doHaddock = false; + doCheck = false; + description = "Unix time parser/formatter and utilities"; + license = stdenv.lib.licenses.bsd3; + }) {}; + "unliftio" = callPackage + ({ mkDerivation, async, base, deepseq, directory, filepath, process + , stdenv, stm, time, transformers, unix, unliftio-core + }: + mkDerivation { + pname = "unliftio"; + version = "0.2.7.0"; + sha256 = "5adaf4c623914ec027760259042059326c14831e8c9142287cf8f082e9481463"; + revision = "1"; + editedCabalFile = "0w86bp3kbym481jj667bndswq1y7rca4g30d2xx9n1a7xxsbllv6"; + libraryHaskellDepends = [ + async base deepseq directory filepath process stm time transformers + unix unliftio-core + ]; + doHaddock = false; + doCheck = false; + homepage = "https://github.com/fpco/unliftio/tree/master/unliftio#readme"; + description = "The MonadUnliftIO typeclass for unlifting monads to IO (batteries included)"; + license = stdenv.lib.licenses.mit; + }) {}; + "unliftio-core" = callPackage + ({ mkDerivation, base, stdenv, transformers }: + mkDerivation { + pname = "unliftio-core"; + version = "0.1.1.0"; + sha256 = "7550b017d87af53ae3e0d3b8524e24a77faf739073f35e40663454a9e9752385"; + revision = "1"; + editedCabalFile = "16bjwcsaghqqmyi69rq65dn3ydifyfaabq3ns37apdm00mwqbcj2"; + libraryHaskellDepends = [ base transformers ]; + doHaddock = false; + doCheck = false; + homepage = "https://github.com/fpco/unliftio/tree/master/unliftio-core#readme"; + description = "The MonadUnliftIO typeclass for unlifting monads to IO"; + license = stdenv.lib.licenses.mit; + }) {}; + "unlit" = callPackage + ({ mkDerivation, base, directory, stdenv, text }: + mkDerivation { + pname = "unlit"; + version = "0.4.0.0"; + sha256 = "489ecde4843f1911ebdaac3099241d703bb1161f3d386e2b5143f2fd6c355515"; + isLibrary = true; + isExecutable = true; + libraryHaskellDepends = [ base directory text ]; + executableHaskellDepends = [ base directory text ]; + doHaddock = false; + doCheck = false; + description = "Tool to convert literate code between styles or to code"; + license = stdenv.lib.licenses.bsd3; + }) {}; + "unordered-containers" = callPackage + ({ mkDerivation, base, deepseq, hashable, stdenv }: + mkDerivation { + pname = "unordered-containers"; + version = "0.2.9.0"; + sha256 = "6730cb5c4a3e953e2c199d6425be08fd088ff0089a3e140d63226c052e318250"; + libraryHaskellDepends = [ base deepseq hashable ]; + doHaddock = false; + doCheck = false; + homepage = "https://github.com/tibbe/unordered-containers"; + description = "Efficient hashing-based container types"; + license = stdenv.lib.licenses.bsd3; + }) {}; + "unordered-intmap" = callPackage + ({ mkDerivation, base, deepseq, primitive, stdenv }: + mkDerivation { + pname = "unordered-intmap"; + version = "0.1.1"; + sha256 = "d8faaf0c23ed143942ba7948616c73134c78e02aa4cf252605c73fb2412876ef"; + libraryHaskellDepends = [ base deepseq primitive ]; + doHaddock = false; + doCheck = false; + homepage = "https://github.com/ethercrow/unordered-intmap"; + description = "A specialization of `HashMap Int v`"; + license = stdenv.lib.licenses.bsd3; + }) {}; + "unsafe" = callPackage + ({ mkDerivation, base, stdenv }: + mkDerivation { + pname = "unsafe"; + version = "0.0"; + sha256 = "df0a74ccf7b43956c1b5decd5580e235317d1f96a1bbd75e117fc21143ee8641"; + enableSeparateDataOutput = true; + libraryHaskellDepends = [ base ]; + doHaddock = false; + doCheck = false; + homepage = "http://code.haskell.org/~thielema/unsafe/"; + description = "Unified interface to unsafe functions"; + license = stdenv.lib.licenses.bsd3; + }) {}; + "uri-bytestring" = callPackage + ({ mkDerivation, attoparsec, base, blaze-builder, bytestring + , containers, stdenv, template-haskell, th-lift-instances + }: + mkDerivation { + pname = "uri-bytestring"; + version = "0.3.2.0"; + sha256 = "acecd68b9d3128d6b6de99580664ab1e7cbaa0e7722e50c5fc67ccbd7c9104e0"; + libraryHaskellDepends = [ + attoparsec base blaze-builder bytestring containers + template-haskell th-lift-instances + ]; + doHaddock = false; + doCheck = false; + homepage = "https://github.com/Soostone/uri-bytestring"; + description = "Haskell URI parsing as ByteStrings"; + license = stdenv.lib.licenses.bsd3; + }) {}; + "uri-encode" = callPackage + ({ mkDerivation, base, bytestring, network-uri, stdenv, text + , utf8-string + }: + mkDerivation { + pname = "uri-encode"; + version = "1.5.0.5"; + sha256 = "e82b588aad63112d34f6bad6f1ef72489b9edebfe14f2f523dc1dabdcbe2b186"; + isLibrary = true; + isExecutable = true; + libraryHaskellDepends = [ + base bytestring network-uri text utf8-string + ]; + doHaddock = false; + doCheck = false; + description = "Unicode aware uri-encoding"; + license = stdenv.lib.licenses.bsd3; + }) {}; + "uri-templater" = callPackage + ({ mkDerivation, ansi-wl-pprint, base, bytestring, charset + , containers, dlist, HTTP, mtl, parsers, stdenv, template-haskell + , text, time, trifecta, unordered-containers, uuid-types, vector + }: + mkDerivation { + pname = "uri-templater"; + version = "0.3.1.0"; + sha256 = "21e665ff2600b3de42b6ad01ef342b6165859dc6e66897f84a9075649f1c49c2"; + revision = "1"; + editedCabalFile = "0vl1nv40yzns9fnaz6h34x72vpfaaws8f0zm8qlr82333pxg2scw"; + libraryHaskellDepends = [ + ansi-wl-pprint base bytestring charset containers dlist HTTP mtl + parsers template-haskell text time trifecta unordered-containers + uuid-types vector + ]; + doHaddock = false; + doCheck = false; + homepage = "https://github.com/iand675/uri-templater"; + description = "Parsing & Quasiquoting for RFC 6570 URI Templates"; + license = stdenv.lib.licenses.mit; + }) {}; + "urlpath" = callPackage + ({ mkDerivation, attoparsec-uri, base, exceptions, mmorph + , monad-control, monad-control-aligned, monad-logger, mtl, path + , path-extra, resourcet, split, stdenv, strict, text, transformers + , transformers-base, vector + }: + mkDerivation { + pname = "urlpath"; + version = "9.0.0"; + sha256 = "90bf89265f5ae94d55e395e199a1b9205d4c56720f1edf9390644c2dc88252fb"; + libraryHaskellDepends = [ + attoparsec-uri base exceptions mmorph monad-control + monad-control-aligned monad-logger mtl path path-extra resourcet + split strict text transformers transformers-base vector + ]; + doHaddock = false; + doCheck = false; + homepage = "https://github.com/athanclark/urlpath#readme"; + description = "Painfully simple URL deployment"; + license = stdenv.lib.licenses.bsd3; + }) {}; + "users" = callPackage + ({ mkDerivation, aeson, base, bcrypt, path-pieces, stdenv, text + , time + }: + mkDerivation { + pname = "users"; + version = "0.5.0.0"; + sha256 = "6761ac937b0d4c13c5158239a0c51199c394facb72cc734ada90a391f01e53d4"; + revision = "1"; + editedCabalFile = "1x26g7k6kmq2vng9y5qkz82z06rs322s2y8bs9y6r4vayvg07q9v"; + libraryHaskellDepends = [ + aeson base bcrypt path-pieces text time + ]; + doHaddock = false; + doCheck = false; + homepage = "https://github.com/agrafix/users"; + description = "A library simplifying user management for web applications"; + license = stdenv.lib.licenses.mit; + }) {}; + "users-postgresql-simple" = callPackage + ({ mkDerivation, base, bytestring, mtl, postgresql-simple, stdenv + , text, time, users, uuid + }: + mkDerivation { + pname = "users-postgresql-simple"; + version = "0.5.0.2"; + sha256 = "051b5d2c9c6cdeaacb6271a50ee4084cc1473de8d873825dc6d98023e96ec100"; + libraryHaskellDepends = [ + base bytestring mtl postgresql-simple text time users uuid + ]; + doHaddock = false; + doCheck = false; + homepage = "https://github.com/agrafix/users"; + description = "A PostgreSQL backend for the users package"; + license = stdenv.lib.licenses.mit; + }) {}; + "users-test" = callPackage + ({ mkDerivation, base, hspec, stdenv, text, users }: + mkDerivation { + pname = "users-test"; + version = "0.5.0.1"; + sha256 = "f68549fa0cc002b16dc55f23a73b1a423aa2e64ab584c4041252a3bb6a5cac3e"; + libraryHaskellDepends = [ base hspec text users ]; + doHaddock = false; + doCheck = false; + homepage = "https://github.com/agrafix/users"; + description = "Library to test backends for the users library"; + license = stdenv.lib.licenses.mit; + }) {}; + "utf8-light" = callPackage + ({ mkDerivation, base, bytestring, ghc-prim, stdenv }: + mkDerivation { + pname = "utf8-light"; + version = "0.4.2"; + sha256 = "184c428ce7896d702da46f6f107e6873ff100dbc1af40b49b5ce87317e619e67"; + libraryHaskellDepends = [ base bytestring ghc-prim ]; + doHaddock = false; + doCheck = false; + description = "Unicode"; + license = stdenv.lib.licenses.bsd3; + }) {}; + "utf8-string" = callPackage + ({ mkDerivation, base, bytestring, stdenv }: + mkDerivation { + pname = "utf8-string"; + version = "1.0.1.1"; + sha256 = "fb0b9e3acbe0605bcd1c63e51f290a7bbbe6628dfa3294ff453e4235fbaef140"; + revision = "3"; + editedCabalFile = "02vhj5gykkqa2dyn7s6gn8is1b5fdn9xcqqvlls268g7cpv6rk38"; + libraryHaskellDepends = [ base bytestring ]; + doHaddock = false; + doCheck = false; + homepage = "http://github.com/glguy/utf8-string/"; + description = "Support for reading and writing UTF8 Strings"; + license = stdenv.lib.licenses.bsd3; + }) {}; + "util" = callPackage + ({ mkDerivation, base, stdenv }: + mkDerivation { + pname = "util"; + version = "0.1.10.1"; + sha256 = "04056d473579dff21aebb40db9947eebf27b1aead8b6c447b91286ab4c3773fc"; + libraryHaskellDepends = [ base ]; + doHaddock = false; + doCheck = false; + description = "Utilities"; + license = stdenv.lib.licenses.bsd3; + }) {}; + "utility-ht" = callPackage + ({ mkDerivation, base, stdenv }: + mkDerivation { + pname = "utility-ht"; + version = "0.0.14"; + sha256 = "69c2eee1330839cdff40fad4f68f8c7ce41ae3b46a9e1d575f589fcdcf7ceba8"; + libraryHaskellDepends = [ base ]; + doHaddock = false; + doCheck = false; + description = "Various small helper functions for Lists, Maybes, Tuples, Functions"; + license = stdenv.lib.licenses.bsd3; + }) {}; + "uuid" = callPackage + ({ mkDerivation, base, binary, bytestring, cryptohash-md5 + , cryptohash-sha1, entropy, network-info, random, stdenv, text + , time, uuid-types + }: + mkDerivation { + pname = "uuid"; + version = "1.3.13"; + sha256 = "dfac808a7026217d018b408eab18facc6a85c6183be308d4ac7877e80599b027"; + revision = "2"; + editedCabalFile = "0m185q62jkfb5jsv358nxbnrkv8y8hd0qqvgvh22wvc5g9ipz0r9"; + libraryHaskellDepends = [ + base binary bytestring cryptohash-md5 cryptohash-sha1 entropy + network-info random text time uuid-types + ]; + doHaddock = false; + doCheck = false; + homepage = "https://github.com/hvr/uuid"; + description = "For creating, comparing, parsing and printing Universally Unique Identifiers"; + license = stdenv.lib.licenses.bsd3; + }) {}; + "uuid-types" = callPackage + ({ mkDerivation, base, binary, bytestring, deepseq, hashable + , random, stdenv, text + }: + mkDerivation { + pname = "uuid-types"; + version = "1.0.3"; + sha256 = "9276517ab24a9b06f39d6e3c33c6c2b4ace1fc2126dbc1cd9806866a6551b3fd"; + revision = "1"; + editedCabalFile = "0iwwj07gp28g357hv76k4h8pvlzamvchnw003cv3qk778pcpx201"; + libraryHaskellDepends = [ + base binary bytestring deepseq hashable random text + ]; + doHaddock = false; + doCheck = false; + homepage = "https://github.com/aslatter/uuid"; + description = "Type definitions for Universally Unique Identifiers"; + license = stdenv.lib.licenses.bsd3; + }) {}; + "validation" = callPackage + ({ mkDerivation, base, bifunctors, deepseq, lens, semigroupoids + , semigroups, stdenv + }: + mkDerivation { + pname = "validation"; + version = "1"; + sha256 = "70455a22637983dbcf7a688ff80c05bb8bf2690d9e4523d6ca4ebcef77abb921"; + revision = "1"; + editedCabalFile = "1x1g4nannz81j1h64l1m3ancc96zc57d1bjhj1wk7bwn1xxbi5h3"; + libraryHaskellDepends = [ + base bifunctors deepseq lens semigroupoids semigroups + ]; + doHaddock = false; + doCheck = false; + homepage = "https://github.com/qfpl/validation"; + description = "A data-type like Either but with an accumulating Applicative"; + license = stdenv.lib.licenses.bsd3; + }) {}; + "validity" = callPackage + ({ mkDerivation, base, stdenv }: + mkDerivation { + pname = "validity"; + version = "0.7.0.0"; + sha256 = "ae2409c221d5c9839fb4991ab1123f3747bacd94aab583388c4e5585125f3177"; + libraryHaskellDepends = [ base ]; + doHaddock = false; + doCheck = false; + homepage = "https://github.com/NorfairKing/validity#readme"; + description = "Validity typeclass"; + license = stdenv.lib.licenses.mit; + }) {}; + "validity-aeson" = callPackage + ({ mkDerivation, aeson, base, stdenv, validity, validity-scientific + , validity-text, validity-unordered-containers, validity-vector + }: + mkDerivation { + pname = "validity-aeson"; + version = "0.2.0.2"; + sha256 = "fac03d29cf3d6f72c288111b68feb3c656574a1ac616b49f40426a9daf0e1d04"; + libraryHaskellDepends = [ + aeson base validity validity-scientific validity-text + validity-unordered-containers validity-vector + ]; + doHaddock = false; + doCheck = false; + homepage = "https://github.com/NorfairKing/validity#readme"; + description = "Validity instances for aeson"; + license = stdenv.lib.licenses.mit; + }) {}; + "validity-bytestring" = callPackage + ({ mkDerivation, base, bytestring, stdenv, validity }: + mkDerivation { + pname = "validity-bytestring"; + version = "0.3.0.2"; + sha256 = "62e1a00e9cc12af6451d4484f392d593a628687a7ff78996f1982ee6d2ed912f"; + libraryHaskellDepends = [ base bytestring validity ]; + doHaddock = false; + doCheck = false; + homepage = "https://github.com/NorfairKing/validity#readme"; + description = "Validity instances for bytestring"; + license = stdenv.lib.licenses.mit; + }) {}; + "validity-containers" = callPackage + ({ mkDerivation, base, containers, stdenv, validity }: + mkDerivation { + pname = "validity-containers"; + version = "0.3.1.0"; + sha256 = "39096c06200f3ce670c89d557def5dbdd0ba3f608bdc7587b057c2344b3f20b2"; + libraryHaskellDepends = [ base containers validity ]; + doHaddock = false; + doCheck = false; + homepage = "https://github.com/NorfairKing/validity#readme"; + description = "Validity instances for containers"; + license = stdenv.lib.licenses.mit; + }) {}; + "validity-path" = callPackage + ({ mkDerivation, base, filepath, path, stdenv, validity }: + mkDerivation { + pname = "validity-path"; + version = "0.3.0.1"; + sha256 = "7e06ff1aab574b7b2b03e69dc41ca59ea6138ecc0628f22d1e06f2748501cdd5"; + libraryHaskellDepends = [ base filepath path validity ]; + doHaddock = false; + doCheck = false; + homepage = "https://github.com/NorfairKing/validity#readme"; + description = "Validity instances for Path"; + license = stdenv.lib.licenses.mit; + }) {}; + "validity-scientific" = callPackage + ({ mkDerivation, base, scientific, stdenv, validity }: + mkDerivation { + pname = "validity-scientific"; + version = "0.2.0.1"; + sha256 = "5ce509c4a3ce6b4d098ad4b0c6561af5337cdf797af41a6a0c45e19d60fbf0c6"; + libraryHaskellDepends = [ base scientific validity ]; + doHaddock = false; + doCheck = false; + homepage = "https://github.com/NorfairKing/validity#readme"; + description = "Validity instances for scientific"; + license = stdenv.lib.licenses.mit; + }) {}; + "validity-text" = callPackage + ({ mkDerivation, base, bytestring, stdenv, text, validity }: + mkDerivation { + pname = "validity-text"; + version = "0.3.0.1"; + sha256 = "aeb10cb317e198a002cf5b30e2ad81bc2b90c38dad552670baf8751ac4329e31"; + libraryHaskellDepends = [ base bytestring text validity ]; + doHaddock = false; + doCheck = false; + homepage = "https://github.com/NorfairKing/validity#readme"; + description = "Validity instances for text"; + license = stdenv.lib.licenses.mit; + }) {}; + "validity-time" = callPackage + ({ mkDerivation, base, stdenv, time, validity }: + mkDerivation { + pname = "validity-time"; + version = "0.2.0.1"; + sha256 = "6e113bd05c43416c325e98f2173f4b13047051ae4be38142579c1d7d52d51cd5"; + libraryHaskellDepends = [ base time validity ]; + doHaddock = false; + doCheck = false; + homepage = "https://github.com/NorfairKing/validity#readme"; + description = "Validity instances for time"; + license = stdenv.lib.licenses.mit; + }) {}; + "validity-unordered-containers" = callPackage + ({ mkDerivation, base, hashable, stdenv, unordered-containers + , validity + }: + mkDerivation { + pname = "validity-unordered-containers"; + version = "0.2.0.1"; + sha256 = "821cc8d4c7514ffe57b1d9f2003c79b9efffeeebdf604c0377aef52543cbfc86"; + libraryHaskellDepends = [ + base hashable unordered-containers validity + ]; + doHaddock = false; + doCheck = false; + homepage = "https://github.com/NorfairKing/validity#readme"; + description = "Validity instances for unordered-containers"; + license = stdenv.lib.licenses.mit; + }) {}; + "validity-uuid" = callPackage + ({ mkDerivation, base, stdenv, uuid, validity }: + mkDerivation { + pname = "validity-uuid"; + version = "0.1.0.1"; + sha256 = "362d8cc2dbfbd54bc14061f1c7ecce1472e7f7e550d4b3c287dd48f022249396"; + libraryHaskellDepends = [ base uuid validity ]; + doHaddock = false; + doCheck = false; + homepage = "https://github.com/NorfairKing/validity#readme"; + description = "Validity instances for uuid"; + license = stdenv.lib.licenses.mit; + }) {}; + "validity-vector" = callPackage + ({ mkDerivation, base, hashable, stdenv, validity, vector }: + mkDerivation { + pname = "validity-vector"; + version = "0.2.0.1"; + sha256 = "640e25f047b83becc8ebafa9f383eec08135dc8b3c0d070961a2ac86cd845152"; + libraryHaskellDepends = [ base hashable validity vector ]; + doHaddock = false; + doCheck = false; + homepage = "https://github.com/NorfairKing/validity#readme"; + description = "Validity instances for vector"; + license = stdenv.lib.licenses.mit; + }) {}; + "valor" = callPackage + ({ mkDerivation, base, stdenv, transformers }: + mkDerivation { + pname = "valor"; + version = "0.1.0.0"; + sha256 = "04ce514f40ef954cdd4b45acb6b2bf6228a30e905fdce0b671df3bf789d6bae6"; + libraryHaskellDepends = [ base transformers ]; + doHaddock = false; + doCheck = false; + homepage = "https://github.com/reygoch/valor#readme"; + description = "Simple general structured validation library"; + license = stdenv.lib.licenses.mit; + }) {}; + "vault" = callPackage + ({ mkDerivation, base, containers, hashable, semigroups, stdenv + , unordered-containers + }: + mkDerivation { + pname = "vault"; + version = "0.3.1.1"; + sha256 = "b2a4150699db8a45d189cc93c34c36c3bfc1082b4ca94612e242aefd4e8e2e28"; + libraryHaskellDepends = [ + base containers hashable semigroups unordered-containers + ]; + doHaddock = false; + doCheck = false; + homepage = "https://github.com/HeinrichApfelmus/vault"; + description = "a persistent store for values of arbitrary types"; + license = stdenv.lib.licenses.bsd3; + }) {}; + "vec" = callPackage + ({ mkDerivation, adjunctions, base, base-compat, deepseq + , distributive, fin, hashable, lens, semigroupoids, stdenv + }: + mkDerivation { + pname = "vec"; + version = "0.1"; + sha256 = "be54ef0a53ff4f27a7a0f14b249d1fd47ede63c085d4c68962db24bf4ba3e054"; + revision = "3"; + editedCabalFile = "093q5qlhlia12ckhvax322lyy3sb554pg46ghabvsvx8znixw2hh"; + libraryHaskellDepends = [ + adjunctions base base-compat deepseq distributive fin hashable lens + semigroupoids + ]; + doHaddock = false; + doCheck = false; + homepage = "https://github.com/phadej/vec"; + description = "Vec: length-indexed (sized) list"; + license = stdenv.lib.licenses.bsd3; + }) {}; + "vector" = callPackage + ({ mkDerivation, base, deepseq, ghc-prim, primitive, stdenv }: + mkDerivation { + pname = "vector"; + version = "0.12.0.1"; + sha256 = "b100ee79b9da2651276278cd3e0f08a3c152505cc52982beda507515af173d7b"; + revision = "3"; + editedCabalFile = "0y5rh8k710i2a3p1h2rghvr5cfg78p5h0kbfi7ifxqqf6pzlyr1x"; + libraryHaskellDepends = [ base deepseq ghc-prim primitive ]; + doHaddock = false; + doCheck = false; + homepage = "https://github.com/haskell/vector"; + description = "Efficient Arrays"; + license = stdenv.lib.licenses.bsd3; + }) {}; + "vector-algorithms" = callPackage + ({ mkDerivation, base, bytestring, primitive, stdenv, vector }: + mkDerivation { + pname = "vector-algorithms"; + version = "0.7.0.1"; + sha256 = "ed460a41ca068f568bc2027579ab14185fbb72c7ac469b5179ae5f8a52719070"; + revision = "2"; + editedCabalFile = "186nxwg02m16v68gi186f0z99cafp4g87flhfccnzlrvshlfb83m"; + isLibrary = true; + isExecutable = true; + libraryHaskellDepends = [ base bytestring primitive vector ]; + doHaddock = false; + doCheck = false; + homepage = "http://code.haskell.org/~dolio/"; + description = "Efficient algorithms for vector arrays"; + license = stdenv.lib.licenses.bsd3; + }) {}; + "vector-binary-instances" = callPackage + ({ mkDerivation, base, binary, stdenv, vector }: + mkDerivation { + pname = "vector-binary-instances"; + version = "0.2.4"; + sha256 = "2b2f783e414dcf2e7dc34ad14264e5af83e5cd4784d5a0a64e4b4571963443f8"; + revision = "1"; + editedCabalFile = "196frl4akhfk7xf1nxzn8lmq99dxhzhsimanswn9yy7ym8zhki4i"; + libraryHaskellDepends = [ base binary vector ]; + doHaddock = false; + doCheck = false; + homepage = "https://github.com/bos/vector-binary-instances"; + description = "Instances of Data.Binary and Data.Serialize for vector"; + license = stdenv.lib.licenses.bsd3; + }) {}; + "vector-buffer" = callPackage + ({ mkDerivation, base, deepseq, stdenv, vector }: + mkDerivation { + pname = "vector-buffer"; + version = "0.4.1"; + sha256 = "9b5a9b57488267a765d9e7a8f2aa387ee0d3153989c169952da1e1229a60fd9b"; + libraryHaskellDepends = [ base deepseq vector ]; + doHaddock = false; + doCheck = false; + description = "A buffer compatible with Data.Vector.*"; + license = stdenv.lib.licenses.bsd3; + }) {}; + "vector-builder" = callPackage + ({ mkDerivation, base, base-prelude, semigroups, stdenv, vector }: + mkDerivation { + pname = "vector-builder"; + version = "0.3.4.1"; + sha256 = "d1649096abdcc96894031292a63dfc0b36be4ab004a00f91f08aa5bc4c65ebb7"; + libraryHaskellDepends = [ base base-prelude semigroups vector ]; + doHaddock = false; + doCheck = false; + homepage = "https://github.com/nikita-volkov/vector-builder"; + description = "Vector builder"; + license = stdenv.lib.licenses.mit; + }) {}; + "vector-bytes-instances" = callPackage + ({ mkDerivation, base, bytes, stdenv, vector }: + mkDerivation { + pname = "vector-bytes-instances"; + version = "0.1.1"; + sha256 = "7666e6ff4553a97727625178a6902f8d23d8e94af5f4701b2d1a1394eaeb8c44"; + libraryHaskellDepends = [ base bytes vector ]; + doHaddock = false; + doCheck = false; + homepage = "https://github.com/k0001/vector-bytes-instances"; + description = "Serial (from the bytes package) for Vector (from the vector package)"; + license = stdenv.lib.licenses.bsd3; + }) {}; + "vector-instances" = callPackage + ({ mkDerivation, base, comonad, hashable, keys, pointed + , semigroupoids, semigroups, stdenv, vector + }: + mkDerivation { + pname = "vector-instances"; + version = "3.4"; + sha256 = "1b0246ef0cf8372d61d5c7840d857f49299af2304b5107510377255ed4dd5381"; + libraryHaskellDepends = [ + base comonad hashable keys pointed semigroupoids semigroups vector + ]; + doHaddock = false; + doCheck = false; + homepage = "http://github.com/ekmett/vector-instances"; + description = "Orphan Instances for 'Data.Vector'"; + license = stdenv.lib.licenses.bsd3; + }) {}; + "vector-mmap" = callPackage + ({ mkDerivation, base, mmap, primitive, stdenv, vector }: + mkDerivation { + pname = "vector-mmap"; + version = "0.0.3"; + sha256 = "e539ddb02190ab5d04ba2605ac24317360919f99c332af470aafd0b78d9a868a"; + libraryHaskellDepends = [ base mmap primitive vector ]; + doHaddock = false; + doCheck = false; + homepage = "http://github.com/pumpkin/vector-mmap"; + description = "Memory map immutable and mutable vectors"; + license = stdenv.lib.licenses.bsd3; + }) {}; + "vector-sized" = callPackage + ({ mkDerivation, adjunctions, base, deepseq, distributive + , finite-typelits, indexed-list-literals, primitive, stdenv, vector + }: + mkDerivation { + pname = "vector-sized"; + version = "1.0.4.0"; + sha256 = "64be9a8eb50a7ee912b2f7429fc1eb9184283a2b09a9d19fbc6de3e90bf3b9e5"; + libraryHaskellDepends = [ + adjunctions base deepseq distributive finite-typelits + indexed-list-literals primitive vector + ]; + doHaddock = false; + doCheck = false; + homepage = "http://github.com/expipiplus1/vector-sized#readme"; + description = "Size tagged vectors"; + license = stdenv.lib.licenses.bsd3; + }) {}; + "vector-space" = callPackage + ({ mkDerivation, base, Boolean, MemoTrie, NumInstances, stdenv }: + mkDerivation { + pname = "vector-space"; + version = "0.13"; + sha256 = "0291d5778378acbbb1d6709ba57238f3d6ad551b8b2c6ca2b8177e68f748d617"; + revision = "2"; + editedCabalFile = "1p9vibym0ggr1rjyak0wphswdl4vik2b2w85afgvyj9zn32w28bw"; + libraryHaskellDepends = [ base Boolean MemoTrie NumInstances ]; + doHaddock = false; + doCheck = false; + description = "Vector & affine spaces, linear maps, and derivatives"; + license = stdenv.lib.licenses.bsd3; + }) {}; + "vector-split" = callPackage + ({ mkDerivation, base, stdenv, vector }: + mkDerivation { + pname = "vector-split"; + version = "1.0.0.2"; + sha256 = "b4aeeea50fec52e594b2d3c05aca3a112b2095d1e5238ced065cecf2d89bbd16"; + libraryHaskellDepends = [ base vector ]; + doHaddock = false; + doCheck = false; + homepage = "https://github.com/fhaust/vector-split"; + description = "Combinator library for splitting vectors"; + license = stdenv.lib.licenses.mit; + }) {}; + "vector-th-unbox" = callPackage + ({ mkDerivation, base, stdenv, template-haskell, vector }: + mkDerivation { + pname = "vector-th-unbox"; + version = "0.2.1.6"; + sha256 = "be87d4a6f1005ee2d0de6adf521e05c9e83c441568a8a8b60c79efe24ae90235"; + libraryHaskellDepends = [ base template-haskell vector ]; + doHaddock = false; + doCheck = false; + description = "Deriver for Data.Vector.Unboxed using Template Haskell"; + license = stdenv.lib.licenses.bsd3; + }) {}; + "vectortiles" = callPackage + ({ mkDerivation, base, bytestring, containers, deepseq, hashable + , mtl, protocol-buffers, protocol-buffers-descriptor, stdenv, text + , transformers, unordered-containers, vector + }: + mkDerivation { + pname = "vectortiles"; + version = "1.4.0"; + sha256 = "393cc4f3d0f16c8cbf3c1fda99a6823463d4a855b77babae41249d4175e915c0"; + revision = "1"; + editedCabalFile = "1nlkhmfcvlzi96nzq8cpbqw5akrjahnrhl460q07vq6iyhibvf87"; + libraryHaskellDepends = [ + base bytestring containers deepseq hashable mtl protocol-buffers + protocol-buffers-descriptor text transformers unordered-containers + vector + ]; + doHaddock = false; + doCheck = false; + homepage = "https://github.com/fosskers/vectortiles"; + description = "GIS Vector Tiles, as defined by Mapbox"; + license = stdenv.lib.licenses.bsd3; + }) {}; + "verbosity" = callPackage + ({ mkDerivation, base, binary, data-default-class, deepseq, stdenv + }: + mkDerivation { + pname = "verbosity"; + version = "0.2.3.0"; + sha256 = "8b4ce5ab48aab17b6752dec4efba259964b7084ce10330198ae3ff7ea090f264"; + libraryHaskellDepends = [ base binary data-default-class deepseq ]; + doHaddock = false; + doCheck = false; + homepage = "https://github.com/trskop/verbosity"; + description = "Simple enum that encodes application verbosity"; + license = stdenv.lib.licenses.bsd3; + }) {}; + "versions" = callPackage + ({ mkDerivation, base, deepseq, hashable, megaparsec, stdenv, text + }: + mkDerivation { + pname = "versions"; + version = "3.4.0.1"; + sha256 = "af46d833929f36757e0a50a733b06aa7fce72663c73d3a944f3752faadccec64"; + libraryHaskellDepends = [ base deepseq hashable megaparsec text ]; + doHaddock = false; + doCheck = false; + homepage = "https://gitlab.com/fosskers/versions"; + description = "Types and parsers for software version numbers"; + license = stdenv.lib.licenses.bsd3; + }) {}; + "viewprof" = callPackage + ({ mkDerivation, base, brick, containers, directory, ghc-prof, lens + , scientific, stdenv, text, vector, vector-algorithms, vty + }: + mkDerivation { + pname = "viewprof"; + version = "0.0.0.19"; + sha256 = "8cd64535b7cd95353b0b3739618e587f1707497f9f0c4533b79f4e6507b314ed"; + isLibrary = false; + isExecutable = true; + executableHaskellDepends = [ + base brick containers directory ghc-prof lens scientific text + vector vector-algorithms vty + ]; + doHaddock = false; + doCheck = false; + homepage = "https://github.com/maoe/viewprof"; + description = "Text-based interactive GHC .prof viewer"; + license = stdenv.lib.licenses.bsd3; + }) {}; + "vinyl" = callPackage + ({ mkDerivation, array, base, ghc-prim, stdenv }: + mkDerivation { + pname = "vinyl"; + version = "0.8.1.1"; + sha256 = "d03a3c53026b91160b30f4f65db1e29bed157ca67f676674488218d7cfd48f3f"; + revision = "1"; + editedCabalFile = "0mb694y03r185r0p473zh6bl4j0l4na9km0r3x8czjil7x9yb0vr"; + libraryHaskellDepends = [ array base ghc-prim ]; + doHaddock = false; + doCheck = false; + description = "Extensible Records"; + license = stdenv.lib.licenses.mit; + }) {}; + "vivid" = callPackage + ({ mkDerivation, base, bytestring, containers, directory, filepath + , hashable, MonadRandom, mtl, network, process, random + , random-shuffle, split, stdenv, stm, time, transformers + , utf8-string, vivid-osc, vivid-supercollider + }: + mkDerivation { + pname = "vivid"; + version = "0.3.0.2"; + sha256 = "00e0941c018fc467424d10a94ed568b48bf1fd226cd81a00ced319817d79bb99"; + libraryHaskellDepends = [ + base bytestring containers directory filepath hashable MonadRandom + mtl network process random random-shuffle split stm time + transformers utf8-string vivid-osc vivid-supercollider + ]; + doHaddock = false; + doCheck = false; + description = "Sound synthesis with SuperCollider"; + license = "GPL"; + }) {}; + "vivid-osc" = callPackage + ({ mkDerivation, base, binary, bytestring, cereal, stdenv, time }: + mkDerivation { + pname = "vivid-osc"; + version = "0.3.0.0"; + sha256 = "a728f85c60f6b8361d6b973f45c854485a2b061431869934df72c172a4884a94"; + libraryHaskellDepends = [ base binary bytestring cereal time ]; + doHaddock = false; + doCheck = false; + description = "Open Sound Control encode/decode"; + license = "GPL"; + }) {}; + "vivid-supercollider" = callPackage + ({ mkDerivation, base, binary, bytestring, cereal, split, stdenv + , utf8-string, vivid-osc + }: + mkDerivation { + pname = "vivid-supercollider"; + version = "0.3.0.0"; + sha256 = "83b79ebc06b4e6db34c91c850191e11488e108b4bf64aa85110c3a389cc4d395"; + libraryHaskellDepends = [ + base binary bytestring cereal split utf8-string vivid-osc + ]; + doHaddock = false; + doCheck = false; + description = "Implementation of SuperCollider server specifications"; + license = "GPL"; + }) {}; + "void" = callPackage + ({ mkDerivation, base, stdenv }: + mkDerivation { + pname = "void"; + version = "0.7.2"; + sha256 = "d3fffe66a03e4b53db1e459edf75ad8402385a817cae415d857ec0b03ce0cf2b"; + libraryHaskellDepends = [ base ]; + doHaddock = false; + doCheck = false; + homepage = "http://github.com/ekmett/void"; + description = "A Haskell 98 logically uninhabited data type"; + license = stdenv.lib.licenses.bsd3; + }) {}; + "vty" = callPackage + ({ mkDerivation, base, blaze-builder, bytestring, containers + , deepseq, directory, filepath, hashable, microlens, microlens-mtl + , microlens-th, mtl, parallel, parsec, stdenv, stm, terminfo, text + , transformers, unix, utf8-string, vector + }: + mkDerivation { + pname = "vty"; + version = "5.21"; + sha256 = "5a79b8b5f3a2ead0db01cfbc34e145cfa8ff36315f0bb075e6d364ae0a937a5b"; + isLibrary = true; + isExecutable = true; + libraryHaskellDepends = [ + base blaze-builder bytestring containers deepseq directory filepath + hashable microlens microlens-mtl microlens-th mtl parallel parsec + stm terminfo text transformers unix utf8-string vector + ]; + executableHaskellDepends = [ + base containers microlens microlens-mtl mtl + ]; + doHaddock = false; + doCheck = false; + homepage = "https://github.com/jtdaugherty/vty"; + description = "A simple terminal UI library"; + license = stdenv.lib.licenses.bsd3; + }) {}; + "wai" = callPackage + ({ mkDerivation, base, bytestring, http-types, network, stdenv + , text, transformers, vault + }: + mkDerivation { + pname = "wai"; + version = "3.2.1.2"; + sha256 = "282351461f19fbac26aa0a7896d7ab583b4abef522fcd9aba944f1848e58234b"; + libraryHaskellDepends = [ + base bytestring http-types network text transformers vault + ]; + doHaddock = false; + doCheck = false; + homepage = "https://github.com/yesodweb/wai"; + description = "Web Application Interface"; + license = stdenv.lib.licenses.mit; + }) {}; + "wai-app-static" = callPackage + ({ mkDerivation, base, blaze-html, blaze-markup, bytestring + , containers, cryptonite, directory, file-embed, filepath + , http-date, http-types, memory, mime-types, old-locale + , optparse-applicative, stdenv, template-haskell, text, time + , transformers, unix-compat, unordered-containers, wai, wai-extra + , warp, zlib + }: + mkDerivation { + pname = "wai-app-static"; + version = "3.1.6.2"; + sha256 = "d0b0a566be61ef4c8f800922a71dbc4de64287f8f73782b1461cd5d294c1dc3e"; + isLibrary = true; + isExecutable = true; + libraryHaskellDepends = [ + base blaze-html blaze-markup bytestring containers cryptonite + directory file-embed filepath http-date http-types memory + mime-types old-locale optparse-applicative template-haskell text + time transformers unix-compat unordered-containers wai wai-extra + warp zlib + ]; + executableHaskellDepends = [ + base bytestring containers directory mime-types text + ]; + doHaddock = false; + doCheck = false; + homepage = "http://www.yesodweb.com/book/web-application-interface"; + description = "WAI application for static serving"; + license = stdenv.lib.licenses.mit; + }) {}; + "wai-cli" = callPackage + ({ mkDerivation, ansi-terminal, base, http-types, monads-tf + , network, options, socket-activation, stdenv, stm + , streaming-commons, unix, wai, wai-extra, warp, warp-tls + }: + mkDerivation { + pname = "wai-cli"; + version = "0.1.1"; + sha256 = "0643ebd8cbd4fcedd2076450b635d020aa2101b26e80f69ade10acd2c3252862"; + libraryHaskellDepends = [ + ansi-terminal base http-types monads-tf network options + socket-activation stm streaming-commons unix wai wai-extra warp + warp-tls + ]; + doHaddock = false; + doCheck = false; + homepage = "https://github.com/myfreeweb/wai-cli"; + description = "Command line runner for Wai apps (using Warp) with TLS, CGI, socket activation & graceful shutdown"; + license = stdenv.lib.licenses.publicDomain; + }) {}; + "wai-conduit" = callPackage + ({ mkDerivation, base, bytestring, conduit, http-types, stdenv + , transformers, wai + }: + mkDerivation { + pname = "wai-conduit"; + version = "3.0.0.4"; + sha256 = "2790093bd52892b8087c295044573c720773144f4061ccc72d6d6a617320d61f"; + libraryHaskellDepends = [ + base bytestring conduit http-types transformers wai + ]; + doHaddock = false; + doCheck = false; + homepage = "https://github.com/yesodweb/wai"; + description = "conduit wrappers for WAI"; + license = stdenv.lib.licenses.mit; + }) {}; + "wai-cors" = callPackage + ({ mkDerivation, attoparsec, base, base-unicode-symbols, bytestring + , case-insensitive, http-types, mtl, stdenv, transformers, wai + }: + mkDerivation { + pname = "wai-cors"; + version = "0.2.6"; + sha256 = "cac61023184404ba5abf8d3739e51c4862561ba56f829f6f5e69dd64216aa986"; + enableSeparateDataOutput = true; + libraryHaskellDepends = [ + attoparsec base base-unicode-symbols bytestring case-insensitive + http-types mtl transformers wai + ]; + doHaddock = false; + doCheck = false; + homepage = "https://github.com/larskuhtz/wai-cors"; + description = "CORS for WAI"; + license = stdenv.lib.licenses.mit; + }) {}; + "wai-eventsource" = callPackage + ({ mkDerivation, stdenv, wai }: + mkDerivation { + pname = "wai-eventsource"; + version = "3.0.0"; + sha256 = "785005f23bf9bf4e1dfaae0705472c0e3ea4c3843ff6a8625db8d1e327a6bfc0"; + libraryHaskellDepends = [ wai ]; + doHaddock = false; + doCheck = false; + homepage = "http://www.yesodweb.com/book/web-application-interface"; + description = "WAI support for server-sent events (deprecated)"; + license = stdenv.lib.licenses.mit; + }) {}; + "wai-extra" = callPackage + ({ mkDerivation, aeson, ansi-terminal, base, base64-bytestring + , bytestring, case-insensitive, containers, cookie + , data-default-class, deepseq, directory, fast-logger, http-types + , iproute, lifted-base, network, old-locale, resourcet, stdenv + , streaming-commons, stringsearch, text, time, transformers, unix + , unix-compat, vault, void, wai, wai-logger, word8, zlib + }: + mkDerivation { + pname = "wai-extra"; + version = "3.0.23.0"; + sha256 = "88cf1fa003d4e85070185f461c534ccecd82a55975f94f58c0a7002f8b8c9081"; + isLibrary = true; + isExecutable = true; + libraryHaskellDepends = [ + aeson ansi-terminal base base64-bytestring bytestring + case-insensitive containers cookie data-default-class deepseq + directory fast-logger http-types iproute lifted-base network + old-locale resourcet streaming-commons stringsearch text time + transformers unix unix-compat vault void wai wai-logger word8 zlib + ]; + doHaddock = false; + doCheck = false; + homepage = "http://github.com/yesodweb/wai"; + description = "Provides some basic WAI handlers and middleware"; + license = stdenv.lib.licenses.mit; + }) {}; + "wai-handler-launch" = callPackage + ({ mkDerivation, async, base, bytestring, http-types, process + , stdenv, streaming-commons, transformers, wai, warp + }: + mkDerivation { + pname = "wai-handler-launch"; + version = "3.0.2.4"; + sha256 = "0e9d9c61310890380dc87807ba1285bc1ab185914be6367ea4bb0a05d3df2900"; + libraryHaskellDepends = [ + async base bytestring http-types process streaming-commons + transformers wai warp + ]; + doHaddock = false; + doCheck = false; + description = "Launch a web app in the default browser"; + license = stdenv.lib.licenses.mit; + }) {}; + "wai-logger" = callPackage + ({ mkDerivation, base, byteorder, bytestring, case-insensitive + , fast-logger, http-types, network, stdenv, unix, unix-time, wai + }: + mkDerivation { + pname = "wai-logger"; + version = "2.3.2"; + sha256 = "8dd4ff875d9ac2c115f5d45cc4375635a6c3e55a75c632ff3781d1fb086eb470"; + libraryHaskellDepends = [ + base byteorder bytestring case-insensitive fast-logger http-types + network unix unix-time wai + ]; + doHaddock = false; + doCheck = false; + description = "A logging system for WAI"; + license = stdenv.lib.licenses.bsd3; + }) {}; + "wai-middleware-caching" = callPackage + ({ mkDerivation, base, blaze-builder, bytestring, http-types + , stdenv, wai + }: + mkDerivation { + pname = "wai-middleware-caching"; + version = "0.1.0.2"; + sha256 = "15b5fb9c92599d5ecb6a70ba40bad024488f9eca7139abe23b961ba21602d78d"; + libraryHaskellDepends = [ + base blaze-builder bytestring http-types wai + ]; + doHaddock = false; + doCheck = false; + homepage = "http://github.com/yogsototh/wai-middleware-caching/tree/master/wai-middleware-caching#readme"; + description = "WAI Middleware to cache things"; + license = stdenv.lib.licenses.bsd3; + }) {}; + "wai-middleware-caching-lru" = callPackage + ({ mkDerivation, base, blaze-builder, bytestring, http-types + , lrucache, stdenv, text, wai, wai-middleware-caching + }: + mkDerivation { + pname = "wai-middleware-caching-lru"; + version = "0.1.0.0"; + sha256 = "377dc842f5ad77b98e8a817e092c891ccfd0da978fb9f69a380f001a95da28d3"; + libraryHaskellDepends = [ + base blaze-builder bytestring http-types lrucache text wai + wai-middleware-caching + ]; + doHaddock = false; + doCheck = false; + homepage = "http://github.com/yogsototh/wai-middleware-caching/tree/master/wai-middleware-caching-lru#readme"; + description = "Initial project template from stack"; + license = stdenv.lib.licenses.bsd3; + }) {}; + "wai-middleware-consul" = callPackage + ({ mkDerivation, async, base, base-prelude, bytestring, conduit + , conduit-extra, consul-haskell, enclosed-exceptions, http-client + , http-types, monad-control, monad-logger, network, process + , resourcet, stdenv, text, transformers, void, wai, wai-conduit + }: + mkDerivation { + pname = "wai-middleware-consul"; + version = "0.1.0.2"; + sha256 = "d89d5a5bf0b08cf4fcd300d9e16c351a146119c34a9f31949498a874699c0763"; + isLibrary = true; + isExecutable = true; + libraryHaskellDepends = [ + async base base-prelude bytestring conduit conduit-extra + consul-haskell enclosed-exceptions http-client http-types + monad-control monad-logger network process resourcet text + transformers void wai wai-conduit + ]; + doHaddock = false; + doCheck = false; + homepage = "https://github.com/fpco/wai-middleware-consul"; + description = "Wai Middleware for Consul"; + license = stdenv.lib.licenses.mit; + }) {}; + "wai-middleware-crowd" = callPackage + ({ mkDerivation, authenticate, base, base64-bytestring, binary + , blaze-builder, bytestring, case-insensitive, clientsession + , containers, cookie, gitrev, http-client, http-client-tls + , http-reverse-proxy, http-types, optparse-applicative, resourcet + , stdenv, template-haskell, text, time, transformers, unix-compat + , vault, wai, wai-app-static, wai-extra, warp + }: + mkDerivation { + pname = "wai-middleware-crowd"; + version = "0.1.4.2"; + sha256 = "1136b61a6ce7729093664b63a4ab70de73e356d34b0c7a8114b639b18626b058"; + revision = "1"; + editedCabalFile = "0qvh92p9s80kmzg5w7rga54kfqbwcrkkv5p03pd92px04j2h5lbm"; + isLibrary = true; + isExecutable = true; + libraryHaskellDepends = [ + authenticate base base64-bytestring binary blaze-builder bytestring + case-insensitive clientsession containers cookie http-client + http-client-tls http-types resourcet text time unix-compat vault + wai + ]; + executableHaskellDepends = [ + base bytestring clientsession gitrev http-client http-client-tls + http-reverse-proxy http-types optparse-applicative template-haskell + text transformers wai wai-app-static wai-extra warp + ]; + doHaddock = false; + doCheck = false; + description = "Middleware and utilities for using Atlassian Crowd authentication"; + license = stdenv.lib.licenses.mit; + }) {}; + "wai-middleware-metrics" = callPackage + ({ mkDerivation, base, ekg-core, http-types, stdenv, text, time + , wai + }: + mkDerivation { + pname = "wai-middleware-metrics"; + version = "0.2.4"; + sha256 = "e73685a748f0ba6d16956b500cdc23f3802f794f5259a3d6b8a5b885e928ec74"; + libraryHaskellDepends = [ base ekg-core http-types text time wai ]; + doHaddock = false; + doCheck = false; + homepage = "https://github.com/Helkafen/wai-middleware-metrics"; + description = "A WAI middleware to collect EKG request metrics"; + license = stdenv.lib.licenses.bsd3; + }) {}; + "wai-middleware-static" = callPackage + ({ mkDerivation, base, bytestring, containers, cryptonite + , directory, expiring-cache-map, filepath, http-types, memory + , mime-types, mtl, old-locale, semigroups, stdenv, text, time, wai + }: + mkDerivation { + pname = "wai-middleware-static"; + version = "0.8.2"; + sha256 = "0be4e9fd5252d526334e4e5885a2a75269aaaad560282b5c383c49e4d855befc"; + revision = "1"; + editedCabalFile = "0n7i81jrjsrav8bpg31avrd18vh95l5z6bfj4fqkrdj4h1v6armi"; + libraryHaskellDepends = [ + base bytestring containers cryptonite directory expiring-cache-map + filepath http-types memory mime-types mtl old-locale semigroups + text time wai + ]; + doHaddock = false; + doCheck = false; + homepage = "https://github.com/scotty-web/wai-middleware-static"; + description = "WAI middleware that serves requests to static files"; + license = stdenv.lib.licenses.bsd3; + }) {}; + "wai-middleware-travisci" = callPackage + ({ mkDerivation, aeson, base, base64-bytestring, bytestring + , cryptonite, http-types, stdenv, text, transformers, vault, wai + }: + mkDerivation { + pname = "wai-middleware-travisci"; + version = "0.1.0"; + sha256 = "bbc9f2fea4c0ee3d9a73fd13dd1a2a7ef85fc294bd311ed519c1e41a1fada828"; + revision = "1"; + editedCabalFile = "0fd99j9lyb562p3rsdb8d7swg31bwahzhgjm6afijc5f6i5awcw3"; + libraryHaskellDepends = [ + aeson base base64-bytestring bytestring cryptonite http-types text + transformers vault wai + ]; + doHaddock = false; + doCheck = false; + homepage = "https://github.com/mitchellwrosen/wai-middleware-travisci"; + description = "WAI middleware for authenticating webhook payloads from Travis CI"; + license = stdenv.lib.licenses.bsd3; + }) {}; + "wai-predicates" = callPackage + ({ mkDerivation, attoparsec, base, bytestring + , bytestring-conversion, case-insensitive, cookie, http-types + , singletons, stdenv, text, transformers, vault, vector, wai + }: + mkDerivation { + pname = "wai-predicates"; + version = "0.10.0"; + sha256 = "b7b3f6d147bbbf7a959c84235d0533763eda8fc4973b42f131fd47fe8ffbd7c2"; + libraryHaskellDepends = [ + attoparsec base bytestring bytestring-conversion case-insensitive + cookie http-types singletons text transformers vault vector wai + ]; + doHaddock = false; + doCheck = false; + homepage = "https://gitlab.com/twittner/wai-predicates/"; + description = "WAI request predicates"; + license = "unknown"; + }) {}; + "wai-session" = callPackage + ({ mkDerivation, base, blaze-builder, bytestring + , bytestring-builder, containers, cookie, entropy, http-types + , StateVar, stdenv, time, transformers, vault, wai + }: + mkDerivation { + pname = "wai-session"; + version = "0.3.3"; + sha256 = "d2392702446b9af8d45b83b2ce1bbb9937024c2d65fcf943ab51a7d52c7e0053"; + libraryHaskellDepends = [ + base blaze-builder bytestring bytestring-builder containers cookie + entropy http-types StateVar time transformers vault wai + ]; + doHaddock = false; + doCheck = false; + homepage = "https://github.com/singpolyma/wai-session"; + description = "Flexible session middleware for WAI"; + license = "unknown"; + }) {}; + "wai-session-postgresql" = callPackage + ({ mkDerivation, base, bytestring, cereal, cookie, data-default + , entropy, postgresql-simple, resource-pool, stdenv, text, time + , transformers, wai, wai-session + }: + mkDerivation { + pname = "wai-session-postgresql"; + version = "0.2.1.2"; + sha256 = "39d570dd99b4dc38e7803b60b4da4bc804244ed83b3fb250a6e2191a1419ac83"; + libraryHaskellDepends = [ + base bytestring cereal cookie data-default entropy + postgresql-simple resource-pool text time transformers wai + wai-session + ]; + doHaddock = false; + doCheck = false; + homepage = "https://github.com/hce/postgresql-session#readme"; + description = "PostgreSQL backed Wai session store"; + license = stdenv.lib.licenses.bsd3; + }) {}; + "wai-slack-middleware" = callPackage + ({ mkDerivation, aeson, base, http-client, http-types, stdenv, wai + }: + mkDerivation { + pname = "wai-slack-middleware"; + version = "0.2.0"; + sha256 = "d14482f43147e16f05c7282f5b478e76a803dc7398d73dbf6cd2d9be83695750"; + libraryHaskellDepends = [ aeson base http-client http-types wai ]; + doHaddock = false; + doCheck = false; + homepage = "https://github.com/psibi/wai-slack-middleware#readme"; + description = "A Slack middleware for WAI"; + license = stdenv.lib.licenses.bsd3; + }) {}; + "wai-transformers" = callPackage + ({ mkDerivation, base, exceptions, extractable-singleton + , monad-control-aligned, stdenv, transformers, wai, wai-websockets + , websockets + }: + mkDerivation { + pname = "wai-transformers"; + version = "0.1.0"; + sha256 = "17a330c80bad8a95add5d6efb0a12c774c197a2d19f83e6b9dc08ab73d8c8592"; + libraryHaskellDepends = [ + base exceptions extractable-singleton monad-control-aligned + transformers wai wai-websockets websockets + ]; + doHaddock = false; + doCheck = false; + homepage = "https://github.com/athanclark/wai-transformers#readme"; + license = stdenv.lib.licenses.bsd3; + }) {}; + "wai-websockets" = callPackage + ({ mkDerivation, base, bytestring, case-insensitive, file-embed + , http-types, network, stdenv, text, transformers, wai + , wai-app-static, warp, websockets + }: + mkDerivation { + pname = "wai-websockets"; + version = "3.0.1.2"; + sha256 = "917cceb08f296d7dc6b6cafb66133ae53888b2c98b8fb2a2d7fa629d75ab5d2c"; + isLibrary = true; + isExecutable = true; + libraryHaskellDepends = [ + base bytestring case-insensitive http-types network transformers + wai websockets + ]; + executableHaskellDepends = [ + base bytestring case-insensitive file-embed http-types network text + transformers wai wai-app-static warp websockets + ]; + doHaddock = false; + doCheck = false; + homepage = "http://github.com/yesodweb/wai"; + description = "Provide a bridge between WAI and the websockets package"; + license = stdenv.lib.licenses.mit; + }) {}; + "warp" = callPackage + ({ mkDerivation, array, async, auto-update, base, bsb-http-chunked + , bytestring, case-insensitive, containers, ghc-prim, hashable + , http-date, http-types, http2, iproute, network, simple-sendfile + , stdenv, stm, streaming-commons, text, unix, unix-compat, vault + , wai, word8 + }: + mkDerivation { + pname = "warp"; + version = "3.2.23"; + sha256 = "a0aaff3afbda9675b61ec5725ced21fd48694257ba350fd2d2e07a4822c4698b"; + libraryHaskellDepends = [ + array async auto-update base bsb-http-chunked bytestring + case-insensitive containers ghc-prim hashable http-date http-types + http2 iproute network simple-sendfile stm streaming-commons text + unix unix-compat vault wai word8 + ]; + doHaddock = false; + doCheck = false; + homepage = "http://github.com/yesodweb/wai"; + description = "A fast, light-weight web server for WAI applications"; + license = stdenv.lib.licenses.mit; + }) {}; + "warp-tls" = callPackage + ({ mkDerivation, base, bytestring, cryptonite, data-default-class + , network, stdenv, streaming-commons, tls, tls-session-manager, wai + , warp + }: + mkDerivation { + pname = "warp-tls"; + version = "3.2.4.3"; + sha256 = "84cd511e32019ba5bef07b0e8a3550b2da06d534bf3df1673d14a5ec4a12f29d"; + libraryHaskellDepends = [ + base bytestring cryptonite data-default-class network + streaming-commons tls tls-session-manager wai warp + ]; + doHaddock = false; + doCheck = false; + homepage = "http://github.com/yesodweb/wai"; + description = "HTTP over TLS support for Warp via the TLS package"; + license = stdenv.lib.licenses.mit; + }) {}; + "warp-tls-uid" = callPackage + ({ mkDerivation, base, bytestring, network, stdenv + , streaming-commons, unix, wai, warp, warp-tls + }: + mkDerivation { + pname = "warp-tls-uid"; + version = "0.2.0.5"; + sha256 = "b856932108364220abbba3cdebc86740a9b7436684f39936c6dda6a8d6ed73ac"; + libraryHaskellDepends = [ + base bytestring network streaming-commons unix wai warp warp-tls + ]; + doHaddock = false; + doCheck = false; + homepage = "https://github.com/YoshikuniJujo/warp-tls-uid#readme"; + description = "set group and user id before running server"; + license = stdenv.lib.licenses.bsd3; + }) {}; + "wave" = callPackage + ({ mkDerivation, base, bytestring, cereal, containers + , data-default-class, stdenv, transformers + }: + mkDerivation { + pname = "wave"; + version = "0.1.5"; + sha256 = "250a08b0c36870fb7fd0de7714818784eed0c4ff74377746dc1842967965fe0f"; + revision = "2"; + editedCabalFile = "0zs0mw42z9xzs1r935pd5dssf0x10qbkhxlpfknv0x75n2k0azzj"; + enableSeparateDataOutput = true; + libraryHaskellDepends = [ + base bytestring cereal containers data-default-class transformers + ]; + doHaddock = false; + doCheck = false; + homepage = "https://github.com/mrkkrp/wave"; + description = "Work with WAVE and RF64 files"; + license = stdenv.lib.licenses.bsd3; + }) {}; + "wcwidth" = callPackage + ({ mkDerivation, base, containers, stdenv }: + mkDerivation { + pname = "wcwidth"; + version = "0.0.2"; + sha256 = "ffc68736a3bbde3e8157710f29f4a99c0ca593c41194579c54a92c62f6c12ed8"; + isLibrary = true; + isExecutable = true; + libraryHaskellDepends = [ base containers ]; + doHaddock = false; + doCheck = false; + homepage = "http://github.com/solidsnack/wcwidth/"; + description = "Native wcwidth"; + license = stdenv.lib.licenses.bsd3; + }) {}; + "web-plugins" = callPackage + ({ mkDerivation, base, containers, mtl, stdenv, stm, text }: + mkDerivation { + pname = "web-plugins"; + version = "0.2.9"; + sha256 = "e63bfd7f666b40c7ff962a070c64dc5bef4a5c490af745fa7ee8f964284a7a50"; + libraryHaskellDepends = [ base containers mtl stm text ]; + doHaddock = false; + doCheck = false; + homepage = "https://github.com/clckwrks/web-plugins"; + description = "dynamic plugin system for web applications"; + license = stdenv.lib.licenses.bsd3; + }) {}; + "web-routes" = callPackage + ({ mkDerivation, base, blaze-builder, bytestring, exceptions + , ghc-prim, http-types, mtl, parsec, split, stdenv, text + , utf8-string + }: + mkDerivation { + pname = "web-routes"; + version = "0.27.14.2"; + sha256 = "af8b349c5d17de1d1accc30ab0a21537414a66e9d9515852098443e1d5d1f74a"; + libraryHaskellDepends = [ + base blaze-builder bytestring exceptions ghc-prim http-types mtl + parsec split text utf8-string + ]; + doHaddock = false; + doCheck = false; + homepage = "http://www.happstack.com/docs/crashcourse/index.html#web-routes"; + description = "portable, type-safe URL routing"; + license = stdenv.lib.licenses.bsd3; + }) {}; + "web-routes-hsp" = callPackage + ({ mkDerivation, base, hsp, stdenv, text, web-routes }: + mkDerivation { + pname = "web-routes-hsp"; + version = "0.24.6.1"; + sha256 = "ca7cf5bf026c52fee5b6af3ca173c7341cd991dcd38508d07589cc7ea8102cab"; + libraryHaskellDepends = [ base hsp text web-routes ]; + doHaddock = false; + doCheck = false; + description = "Adds XMLGenerator instance for RouteT monad"; + license = stdenv.lib.licenses.bsd3; + }) {}; + "web-routes-wai" = callPackage + ({ mkDerivation, base, bytestring, http-types, stdenv, text, wai + , web-routes + }: + mkDerivation { + pname = "web-routes-wai"; + version = "0.24.3.1"; + sha256 = "8e1fd187686452af39929bc6b6a31319001859930744e22e2eee1fa9ad103049"; + libraryHaskellDepends = [ + base bytestring http-types text wai web-routes + ]; + doHaddock = false; + doCheck = false; + description = "Library for maintaining correctness of URLs within an application"; + license = stdenv.lib.licenses.bsd3; + }) {}; + "web3" = callPackage + ({ mkDerivation, aeson, async, base, basement, bytestring, cereal + , cryptonite, data-default, exceptions, generics-sop, http-client + , machines, memory, mtl, parsec, stdenv, tagged, template-haskell + , text, transformers + }: + mkDerivation { + pname = "web3"; + version = "0.7.3.0"; + sha256 = "af821da95766fcfc74a2dd3cfac867e651443011c2c8251dfad46f63f314c5b9"; + libraryHaskellDepends = [ + aeson async base basement bytestring cereal cryptonite data-default + exceptions generics-sop http-client machines memory mtl parsec + tagged template-haskell text transformers + ]; + doHaddock = false; + doCheck = false; + homepage = "https://github.com/airalab/hs-web3#readme"; + description = "Ethereum API for Haskell"; + license = stdenv.lib.licenses.bsd3; + }) {}; + "webdriver" = callPackage + ({ mkDerivation, aeson, attoparsec, base, base64-bytestring + , bytestring, data-default-class, directory, directory-tree + , exceptions, filepath, http-client, http-types, lifted-base + , monad-control, network, network-uri, scientific, stdenv + , temporary, text, time, transformers, transformers-base + , unordered-containers, vector, zip-archive + }: + mkDerivation { + pname = "webdriver"; + version = "0.8.5"; + sha256 = "a8167a8b147411a929e81727a77bc31fcd7d93424442268913fb522e1932c1be"; + libraryHaskellDepends = [ + aeson attoparsec base base64-bytestring bytestring + data-default-class directory directory-tree exceptions filepath + http-client http-types lifted-base monad-control network + network-uri scientific temporary text time transformers + transformers-base unordered-containers vector zip-archive + ]; + doHaddock = false; + doCheck = false; + homepage = "https://github.com/kallisti-dev/hs-webdriver"; + description = "a Haskell client for the Selenium WebDriver protocol"; + license = stdenv.lib.licenses.bsd3; + }) {}; + "webex-teams-api" = callPackage + ({ mkDerivation, aeson, attoparsec, base, bitset-word8, bytestring + , conduit, data-default, http-conduit, network-uri + , optparse-applicative, stdenv, text, utf8-string + }: + mkDerivation { + pname = "webex-teams-api"; + version = "0.2.0.0"; + sha256 = "7756e38bd54d4dae1f70e7343259438f98bf58ff484ebc1c798166904178a40b"; + isLibrary = true; + isExecutable = true; + libraryHaskellDepends = [ + aeson attoparsec base bitset-word8 bytestring conduit data-default + http-conduit network-uri text + ]; + executableHaskellDepends = [ + aeson base bytestring data-default http-conduit + optparse-applicative text utf8-string + ]; + doHaddock = false; + doCheck = false; + homepage = "https://github.com/nshimaza/webex-teams-api#readme"; + description = "A Haskell bindings for Webex Teams API"; + license = stdenv.lib.licenses.mit; + }) {}; + "webex-teams-conduit" = callPackage + ({ mkDerivation, base, bytestring, conduit, data-default + , http-client, optparse-applicative, stdenv, text, utf8-string + , webex-teams-api + }: + mkDerivation { + pname = "webex-teams-conduit"; + version = "0.2.0.0"; + sha256 = "0d7c7db689092656653d687adadeb92669b647b1d7adc2493d8ca08a87742e5d"; + isLibrary = true; + isExecutable = true; + libraryHaskellDepends = [ base conduit webex-teams-api ]; + executableHaskellDepends = [ + base bytestring conduit data-default http-client + optparse-applicative text utf8-string webex-teams-api + ]; + doHaddock = false; + doCheck = false; + homepage = "https://github.com/nshimaza/webex-teams-api#readme"; + description = "Conduit wrapper of Webex Teams List API"; + license = stdenv.lib.licenses.mit; + }) {}; + "webex-teams-pipes" = callPackage + ({ mkDerivation, base, bytestring, data-default, http-client + , optparse-applicative, pipes, stdenv, text, utf8-string + , webex-teams-api + }: + mkDerivation { + pname = "webex-teams-pipes"; + version = "0.2.0.0"; + sha256 = "77fad574346613e4989997852ca5972185a6321290caa718ce081be985a33100"; + isLibrary = true; + isExecutable = true; + libraryHaskellDepends = [ base pipes webex-teams-api ]; + executableHaskellDepends = [ + base bytestring data-default http-client optparse-applicative pipes + text utf8-string webex-teams-api + ]; + doHaddock = false; + doCheck = false; + homepage = "https://github.com/nshimaza/webex-teams-api#readme"; + description = "Pipes wrapper of Webex Teams List API"; + license = stdenv.lib.licenses.mit; + }) {}; + "webrtc-vad" = callPackage + ({ mkDerivation, base, primitive, stdenv, vector }: + mkDerivation { + pname = "webrtc-vad"; + version = "0.1.0.3"; + sha256 = "89cc6691d314c8c2ae7801bf56e1cca0252617536af4ac94acb92ad6d560d453"; + libraryHaskellDepends = [ base primitive vector ]; + doHaddock = false; + doCheck = false; + description = "Easy voice activity detection"; + license = stdenv.lib.licenses.mit; + }) {}; + "websockets" = callPackage + ({ mkDerivation, attoparsec, base, base64-bytestring, binary + , bytestring, bytestring-builder, case-insensitive, containers + , entropy, network, random, SHA, stdenv, streaming-commons, text + }: + mkDerivation { + pname = "websockets"; + version = "0.12.5.1"; + sha256 = "3fb7c1d0a60f647d3e509bb6846f93a5853b77b0c4396905f000d64546ab3fed"; + isLibrary = true; + isExecutable = true; + libraryHaskellDepends = [ + attoparsec base base64-bytestring binary bytestring + bytestring-builder case-insensitive containers entropy network + random SHA streaming-commons text + ]; + doHaddock = false; + doCheck = false; + homepage = "http://jaspervdj.be/websockets"; + description = "A sensible and clean way to write WebSocket-capable servers in Haskell"; + license = stdenv.lib.licenses.bsd3; + }) {}; + "websockets-snap" = callPackage + ({ mkDerivation, base, bytestring, bytestring-builder, io-streams + , mtl, snap-core, snap-server, stdenv, websockets + }: + mkDerivation { + pname = "websockets-snap"; + version = "0.10.3.0"; + sha256 = "b34a40583a2111bb44233b728095fac38b8de1ab74c027fc4ee92a65af373be4"; + libraryHaskellDepends = [ + base bytestring bytestring-builder io-streams mtl snap-core + snap-server websockets + ]; + doHaddock = false; + doCheck = false; + description = "Snap integration for the websockets library"; + license = stdenv.lib.licenses.bsd3; + }) {}; + "weeder" = callPackage + ({ mkDerivation, aeson, base, bytestring, cmdargs, deepseq + , directory, extra, filepath, foundation, hashable, process, stdenv + , text, unordered-containers, vector, yaml + }: + mkDerivation { + pname = "weeder"; + version = "1.0.6"; + sha256 = "326e943c5c49e298856d95d6255aafd40ccaa29e4af8b299b33858b0ae27281e"; + isLibrary = true; + isExecutable = true; + libraryHaskellDepends = [ + aeson base bytestring cmdargs deepseq directory extra filepath + foundation hashable process text unordered-containers vector yaml + ]; + executableHaskellDepends = [ base ]; + doHaddock = false; + doCheck = false; + homepage = "https://github.com/ndmitchell/weeder#readme"; + description = "Detect dead code"; + license = stdenv.lib.licenses.bsd3; + }) {}; + "weigh" = callPackage + ({ mkDerivation, base, deepseq, mtl, process, split, stdenv + , temporary + }: + mkDerivation { + pname = "weigh"; + version = "0.0.12"; + sha256 = "fdc8b86edac17d57a56a04f149f796f55bfffa04e3c8d32afeedf5775252827f"; + libraryHaskellDepends = [ + base deepseq mtl process split temporary + ]; + doHaddock = false; + doCheck = false; + homepage = "https://github.com/fpco/weigh#readme"; + description = "Measure allocations of a Haskell functions/values"; + license = stdenv.lib.licenses.bsd3; + }) {}; + "wide-word" = callPackage + ({ mkDerivation, base, deepseq, ghc-prim, stdenv }: + mkDerivation { + pname = "wide-word"; + version = "0.1.0.6"; + sha256 = "1d8c0998b70af7b850a9d22642a50c6334ec47acdb8a31a90de7533d4b6b7c78"; + libraryHaskellDepends = [ base deepseq ghc-prim ]; + doHaddock = false; + doCheck = false; + homepage = "https://github.com/erikd/wide-word"; + description = "Data types for large but fixed width signed and unsigned integers"; + license = stdenv.lib.licenses.bsd2; + }) {}; + "wikicfp-scraper" = callPackage + ({ mkDerivation, attoparsec, base, bytestring, scalpel-core, stdenv + , text, time + }: + mkDerivation { + pname = "wikicfp-scraper"; + version = "0.1.0.9"; + sha256 = "9e3cfd6dae669c34c8037cfc0996f371799297f4d08588702399413d8a4242e2"; + libraryHaskellDepends = [ + attoparsec base bytestring scalpel-core text time + ]; + doHaddock = false; + doCheck = false; + homepage = "https://github.com/debug-ito/wikicfp-scraper"; + description = "Scrape WikiCFP web site"; + license = stdenv.lib.licenses.bsd3; + }) {}; + "wild-bind" = callPackage + ({ mkDerivation, base, containers, semigroups, stdenv, text + , transformers + }: + mkDerivation { + pname = "wild-bind"; + version = "0.1.2.1"; + sha256 = "ae76ece570252bfd9b1fdc86f998f95d935bdce7e77c96f5ef22a6fd9c7274ca"; + libraryHaskellDepends = [ + base containers semigroups text transformers + ]; + doHaddock = false; + doCheck = false; + homepage = "https://github.com/debug-ito/wild-bind"; + description = "Dynamic key binding framework"; + license = stdenv.lib.licenses.bsd3; + }) {}; + "wild-bind-x11" = callPackage + ({ mkDerivation, base, containers, fold-debounce, mtl, semigroups + , stdenv, stm, text, transformers, wild-bind, X11 + }: + mkDerivation { + pname = "wild-bind-x11"; + version = "0.2.0.4"; + sha256 = "bfc09fcf7e0c3c4c48250bc2049e8ee0894ecfad1b3e42ad71d3cbd987dad071"; + libraryHaskellDepends = [ + base containers fold-debounce mtl semigroups stm text transformers + wild-bind X11 + ]; + doHaddock = false; + doCheck = false; + homepage = "https://github.com/debug-ito/wild-bind"; + description = "X11-specific implementation for WildBind"; + license = stdenv.lib.licenses.bsd3; + }) {}; + "wire-streams" = callPackage + ({ mkDerivation, base, binary, binary-parsers, bytestring + , io-streams, stdenv + }: + mkDerivation { + pname = "wire-streams"; + version = "0.1.1.0"; + sha256 = "96dffb70c08c89589881c96f199d271b55e4a5b3cc5be0f3e24e101858e2fb27"; + revision = "1"; + editedCabalFile = "1j7gpk3k82h0kxnhpv40jmnqxpnr0v0m4lj6bhpga81vlmznr088"; + libraryHaskellDepends = [ + base binary binary-parsers bytestring io-streams + ]; + doHaddock = false; + doCheck = false; + homepage = "https://github.com/winterland1989/wire-streams"; + description = "Fast binary io-streams adapter"; + license = stdenv.lib.licenses.bsd3; + }) {}; + "with-location" = callPackage + ({ mkDerivation, base, stdenv }: + mkDerivation { + pname = "with-location"; + version = "0.1.0"; + sha256 = "2c91d70cb28d39d6d5fbb37800c7d984aed4254cdcbf03ffa0787404bddefde7"; + libraryHaskellDepends = [ base ]; + doHaddock = false; + doCheck = false; + homepage = "https://github.com/sol/with-location#readme"; + description = "Use ImplicitParams-based source locations in a backward compatible way"; + license = stdenv.lib.licenses.mit; + }) {}; + "withdependencies" = callPackage + ({ mkDerivation, base, conduit, containers, mtl, profunctors + , stdenv + }: + mkDerivation { + pname = "withdependencies"; + version = "0.2.4.2"; + sha256 = "ff51ed5d94ec0051d61458ef38264e0c21119606377d27cc0d9a5a8ae32bf312"; + libraryHaskellDepends = [ + base conduit containers mtl profunctors + ]; + doHaddock = false; + doCheck = false; + homepage = "https://github.com/bartavelle/withdependencies"; + description = "Run computations that depend on one or more elements in a stream"; + license = stdenv.lib.licenses.gpl3; + }) {}; + "witherable" = callPackage + ({ mkDerivation, base, base-orphans, containers, hashable, stdenv + , transformers, unordered-containers, vector + }: + mkDerivation { + pname = "witherable"; + version = "0.2"; + sha256 = "9ddb5a2b02fe0f7950742461dfabc9fc4aba245eddeec6afa9e1cd35fa16ea2d"; + libraryHaskellDepends = [ + base base-orphans containers hashable transformers + unordered-containers vector + ]; + doHaddock = false; + doCheck = false; + homepage = "https://github.com/fumieval/witherable"; + description = "filterable traversable"; + license = stdenv.lib.licenses.bsd3; + }) {}; + "witness" = callPackage + ({ mkDerivation, base, constraints, semigroupoids, stdenv + , transformers + }: + mkDerivation { + pname = "witness"; + version = "0.4"; + sha256 = "93c6c83681a3ab94f53e49c07d0d1474e21169f779c917a896c9d6ed1bf01ea0"; + libraryHaskellDepends = [ + base constraints semigroupoids transformers + ]; + doHaddock = false; + doCheck = false; + homepage = "https://github.com/AshleyYakeley/witness"; + description = "values that witness types"; + license = stdenv.lib.licenses.bsd3; + }) {}; + "wizards" = callPackage + ({ mkDerivation, base, containers, control-monad-free, haskeline + , mtl, stdenv, transformers + }: + mkDerivation { + pname = "wizards"; + version = "1.0.2"; + sha256 = "4ba12c726d60688b8173db3891aa1dce7f57c6364c40ba2f1c2c8d16404bd30b"; + revision = "1"; + editedCabalFile = "15vwynd5v6xm92dxkxf125grd8sv599n5bnj92qqmhlc89psxhxk"; + libraryHaskellDepends = [ + base containers control-monad-free haskeline mtl transformers + ]; + doHaddock = false; + doCheck = false; + description = "High level, generic library for interrogative user interfaces"; + license = stdenv.lib.licenses.bsd3; + }) {}; + "wl-pprint-annotated" = callPackage + ({ mkDerivation, base, containers, deepseq, stdenv, text }: + mkDerivation { + pname = "wl-pprint-annotated"; + version = "0.1.0.0"; + sha256 = "b7ce310688626b25c19e2c93c3546ce5f6a3a6c5943b0a687031b757ba494930"; + libraryHaskellDepends = [ base containers deepseq text ]; + doHaddock = false; + doCheck = false; + homepage = "https://github.com/minad/wl-pprint-annotated#readme"; + description = "Wadler/Leijen pretty printer with annotations and slightly modernized API"; + license = stdenv.lib.licenses.bsd3; + }) {}; + "wl-pprint-console" = callPackage + ({ mkDerivation, base, bytestring, colorful-monoids, stdenv, text + , wl-pprint-annotated + }: + mkDerivation { + pname = "wl-pprint-console"; + version = "0.1.0.1"; + sha256 = "a7c7f6aa14f78bf6a8aae1a629433872f8bfb377b1392f08047520cdcb3b70fc"; + revision = "1"; + editedCabalFile = "1mlbjjk5mhv3jxzqvfspm07di09pns0xfalhx68k2r39z4lj1fa5"; + libraryHaskellDepends = [ + base bytestring colorful-monoids text wl-pprint-annotated + ]; + doHaddock = false; + doCheck = false; + homepage = "https://github.com/minad/wl-pprint-console#readme"; + description = "Wadler/Leijen pretty printer supporting colorful console output"; + license = stdenv.lib.licenses.mit; + }) {}; + "wl-pprint-extras" = callPackage + ({ mkDerivation, base, containers, nats, semigroupoids, semigroups + , stdenv, text, utf8-string + }: + mkDerivation { + pname = "wl-pprint-extras"; + version = "3.5.0.5"; + sha256 = "a9c21a85a729191fc422938a1f785d61be52f3a2923d8d79dade9b21e8e98d8f"; + libraryHaskellDepends = [ + base containers nats semigroupoids semigroups text utf8-string + ]; + doHaddock = false; + doCheck = false; + homepage = "http://github.com/ekmett/wl-pprint-extras/"; + description = "A free monad based on the Wadler/Leijen pretty printer"; + license = stdenv.lib.licenses.bsd3; + }) {}; + "wl-pprint-terminfo" = callPackage + ({ mkDerivation, base, bytestring, containers, nats, semigroups + , stdenv, terminfo, text, transformers, wl-pprint-extras + }: + mkDerivation { + pname = "wl-pprint-terminfo"; + version = "3.7.1.4"; + sha256 = "3cdaba571fc3f8c51e39d14773b23f0f8237bb2d33dbaf9230a98d4b2f388d20"; + enableSeparateDataOutput = true; + libraryHaskellDepends = [ + base bytestring containers nats semigroups terminfo text + transformers wl-pprint-extras + ]; + doHaddock = false; + doCheck = false; + homepage = "http://github.com/ekmett/wl-pprint-terminfo/"; + description = "A color pretty printer with terminfo support"; + license = stdenv.lib.licenses.bsd3; + }) {}; + "wl-pprint-text" = callPackage + ({ mkDerivation, base, base-compat, stdenv, text }: + mkDerivation { + pname = "wl-pprint-text"; + version = "1.2.0.0"; + sha256 = "40dd4c2d2b8a2884616f3a240f01143d0aadd85f5988e5ee55a59ba6b2487c3c"; + libraryHaskellDepends = [ base base-compat text ]; + doHaddock = false; + doCheck = false; + description = "A Wadler/Leijen Pretty Printer for Text values"; + license = stdenv.lib.licenses.bsd3; + }) {}; + "word-trie" = callPackage + ({ mkDerivation, base, binary, containers, stdenv }: + mkDerivation { + pname = "word-trie"; + version = "0.3.0"; + sha256 = "a3f3c2c088c64219ae35f7383a5dc1a368217183ba603e98785c110ac3f29282"; + revision = "1"; + editedCabalFile = "01aanzslm69z94lqy43hgyxj1ys7sqfqwn72l0snw3h2n3pjwn45"; + libraryHaskellDepends = [ base binary containers ]; + doHaddock = false; + doCheck = false; + homepage = "https://github.com/yi-editor/word-trie"; + description = "Implementation of a finite trie over words"; + license = stdenv.lib.licenses.gpl2; + }) {}; + "word-wrap" = callPackage + ({ mkDerivation, base, stdenv, text }: + mkDerivation { + pname = "word-wrap"; + version = "0.4.1"; + sha256 = "eb72f91947c0c62cb862feb33cad9efdc5e720f456fa9ca68ef8ac9d1ec42c97"; + revision = "1"; + editedCabalFile = "1k4w4g053vhmpp08542hrqaw81p3p35i567xgdarqmpghfrk68pp"; + libraryHaskellDepends = [ base text ]; + doHaddock = false; + doCheck = false; + homepage = "https://github.com/jtdaugherty/word-wrap/"; + description = "A library for word-wrapping"; + license = stdenv.lib.licenses.bsd3; + }) {}; + "word24" = callPackage + ({ mkDerivation, base, deepseq, stdenv }: + mkDerivation { + pname = "word24"; + version = "2.0.1"; + sha256 = "c34ba17cc88df314151ef27dea192102ed73d5f0678f1359a5fe59799dc3a086"; + libraryHaskellDepends = [ base deepseq ]; + doHaddock = false; + doCheck = false; + homepage = "https://github.com/winterland1989/word24"; + description = "24-bit word and int types for GHC"; + license = stdenv.lib.licenses.bsd3; + }) {}; + "word8" = callPackage + ({ mkDerivation, base, stdenv }: + mkDerivation { + pname = "word8"; + version = "0.1.3"; + sha256 = "2630934c75728bfbf390c1f0206b225507b354f68d4047b06c018a36823b5d8a"; + libraryHaskellDepends = [ base ]; + doHaddock = false; + doCheck = false; + description = "Word8 library"; + license = stdenv.lib.licenses.bsd3; + }) {}; + "world-peace" = callPackage + ({ mkDerivation, aeson, base, deepseq, profunctors, stdenv, tagged + }: + mkDerivation { + pname = "world-peace"; + version = "0.1.0.0"; + sha256 = "737685799cdd97c2178c749a60906d15548b040570b90f1bbb4f259ba0e756a5"; + libraryHaskellDepends = [ aeson base deepseq profunctors tagged ]; + doHaddock = false; + doCheck = false; + homepage = "https://github.com/cdepillabout/world-peace"; + description = "Open Union and Open Product Types"; + license = stdenv.lib.licenses.bsd3; + }) {}; + "wrap" = callPackage + ({ mkDerivation, base, stdenv }: + mkDerivation { + pname = "wrap"; + version = "0.0.0"; + sha256 = "f8bbc4b417b2291532784d0c7940c0f1a24d054e6012963f7d727ad13977f50e"; + libraryHaskellDepends = [ base ]; + doHaddock = false; + doCheck = false; + description = "Wrap a function's return value with another function"; + license = stdenv.lib.licenses.bsd3; + }) {}; + "wreq" = callPackage + ({ mkDerivation, aeson, attoparsec, authenticate-oauth, base + , base16-bytestring, bytestring, Cabal, cabal-doctest + , case-insensitive, containers, cryptonite, exceptions, ghc-prim + , hashable, http-client, http-client-tls, http-types, lens + , lens-aeson, memory, mime-types, psqueues, stdenv + , template-haskell, text, time, time-locale-compat + , unordered-containers + }: + mkDerivation { + pname = "wreq"; + version = "0.5.2.1"; + sha256 = "b3d069b38d709becdd5ebc75859ff46833419d25f6168367e672243f29491237"; + isLibrary = true; + isExecutable = true; + setupHaskellDepends = [ base Cabal cabal-doctest ]; + libraryHaskellDepends = [ + aeson attoparsec authenticate-oauth base base16-bytestring + bytestring case-insensitive containers cryptonite exceptions + ghc-prim hashable http-client http-client-tls http-types lens + lens-aeson memory mime-types psqueues template-haskell text time + time-locale-compat unordered-containers + ]; + doHaddock = false; + doCheck = false; + homepage = "http://www.serpentine.com/wreq"; + description = "An easy-to-use HTTP client library"; + license = stdenv.lib.licenses.bsd3; + }) {}; + "wreq-stringless" = callPackage + ({ mkDerivation, base, bytestring, stdenv, text, utf8-string, wreq + }: + mkDerivation { + pname = "wreq-stringless"; + version = "0.5.9.1"; + sha256 = "502cd16163ff3356f5477ed7ab1b67147aa6bb445238055450df12b69697f235"; + libraryHaskellDepends = [ base bytestring text utf8-string wreq ]; + doHaddock = false; + doCheck = false; + homepage = "https://github.com/j-keck/wreq-stringless#readme"; + description = "Simple wrapper to use wreq without Strings"; + license = stdenv.lib.licenses.mit; + }) {}; + "writer-cps-full" = callPackage + ({ mkDerivation, base, stdenv, writer-cps-lens, writer-cps-morph + , writer-cps-mtl, writer-cps-transformers + }: + mkDerivation { + pname = "writer-cps-full"; + version = "0.1.0.0"; + sha256 = "ba51df5149470be6d70fd179f2af4cae30824a3a63528f1549a97f57610a5e95"; + libraryHaskellDepends = [ + base writer-cps-lens writer-cps-morph writer-cps-mtl + writer-cps-transformers + ]; + doHaddock = false; + doCheck = false; + homepage = "https://github.com/minad/writer-cps-full#readme"; + description = "WriteT and RWST monad transformers (Reexport with all dependencies)"; + license = stdenv.lib.licenses.bsd3; + }) {}; + "writer-cps-lens" = callPackage + ({ mkDerivation, base, lens, profunctors, stdenv, transformers + , writer-cps-mtl, writer-cps-transformers + }: + mkDerivation { + pname = "writer-cps-lens"; + version = "0.1.0.1"; + sha256 = "2d6b8b6f4f86dcb3cc75bdd25d4ab186d09c2859023f3a6ef2171576b0d306ef"; + libraryHaskellDepends = [ + base lens profunctors transformers writer-cps-mtl + writer-cps-transformers + ]; + doHaddock = false; + doCheck = false; + homepage = "https://github.com/louispan/writer-cps-lens#readme"; + description = "Lens instances for the stricter CPS WriterT and RWST"; + license = stdenv.lib.licenses.bsd3; + }) {}; + "writer-cps-morph" = callPackage + ({ mkDerivation, base, mmorph, stdenv, writer-cps-transformers }: + mkDerivation { + pname = "writer-cps-morph"; + version = "0.1.0.2"; + sha256 = "e91d07b7dce83973c8ad8f489e161ea8092bd3c7d161f4e57cddeedd2f3fd5d8"; + revision = "1"; + editedCabalFile = "0dqpbpaidwa7ahk0n7pv397mv7ncr26p3vcrjh1xzl6vk26bdah5"; + libraryHaskellDepends = [ base mmorph writer-cps-transformers ]; + doHaddock = false; + doCheck = false; + homepage = "https://github.com/louispan/writer-cps-morph#readme"; + description = "MFunctor instance for CPS style WriterT and RWST"; + license = stdenv.lib.licenses.bsd3; + }) {}; + "writer-cps-mtl" = callPackage + ({ mkDerivation, base, mtl, stdenv, transformers + , writer-cps-transformers + }: + mkDerivation { + pname = "writer-cps-mtl"; + version = "0.1.1.4"; + sha256 = "62a3b3b76a5dc0dc6e8b9837afc8c5fc83fb334a034f89fab6a4a544fe204870"; + libraryHaskellDepends = [ + base mtl transformers writer-cps-transformers + ]; + doHaddock = false; + doCheck = false; + homepage = "https://github.com/minad/writer-cps-mtl#readme"; + description = "MonadWriter orphan instances for writer-cps-transformers"; + license = stdenv.lib.licenses.bsd3; + }) {}; + "writer-cps-transformers" = callPackage + ({ mkDerivation, base, stdenv, transformers }: + mkDerivation { + pname = "writer-cps-transformers"; + version = "0.1.1.3"; + sha256 = "8aa22832fdb413c706a6862b83ad4a4ef8dd61ae8658aca6e5076cf2a5cd4aae"; + libraryHaskellDepends = [ base transformers ]; + doHaddock = false; + doCheck = false; + homepage = "https://github.com/minad/writer-cps-transformers#readme"; + description = "WriteT and RWST monad transformers"; + license = stdenv.lib.licenses.bsd3; + }) {}; + "ws" = callPackage + ({ mkDerivation, async, attoparsec, attoparsec-uri, base + , bytestring, exceptions, haskeline, mtl, network + , optparse-applicative, stdenv, strict, text, vector, websockets + , wuss + }: + mkDerivation { + pname = "ws"; + version = "0.0.4"; + sha256 = "d88080c45551cccb8e8de012795852d9ca3c98b97519f2b2e81118d18f3a5f02"; + isLibrary = true; + isExecutable = true; + libraryHaskellDepends = [ + async attoparsec-uri base bytestring exceptions haskeline mtl + network text websockets wuss + ]; + executableHaskellDepends = [ + async attoparsec attoparsec-uri base bytestring exceptions + haskeline mtl network optparse-applicative strict text vector + websockets wuss + ]; + doHaddock = false; + doCheck = false; + homepage = "https://github.com/athanclark/ws#readme"; + description = "A simple CLI utility for interacting with a websocket"; + license = stdenv.lib.licenses.bsd3; + }) {}; + "wuss" = callPackage + ({ mkDerivation, base, bytestring, connection, network, stdenv + , websockets + }: + mkDerivation { + pname = "wuss"; + version = "1.1.10"; + sha256 = "097c1186006e8a4168a7ba868d6bffb0cbbb80052e8f552de9cda23572a59550"; + libraryHaskellDepends = [ + base bytestring connection network websockets + ]; + doHaddock = false; + doCheck = false; + homepage = "https://github.com/tfausak/wuss#readme"; + description = "Secure WebSocket (WSS) clients"; + license = stdenv.lib.licenses.mit; + }) {}; + "x11-xim" = callPackage + ({ mkDerivation, base, stdenv, utf8-string, X11 }: + mkDerivation { + pname = "x11-xim"; + version = "0.0.9.0"; + sha256 = "3ccb05847f7eacd607db095e4f655984607f46313d6b70130d09fd096442c76a"; + revision = "1"; + editedCabalFile = "1c561z9xvfcd7ddbiw3r0frhjvsrklachd38s66fzwjdgw1sl124"; + libraryHaskellDepends = [ base utf8-string X11 ]; + doHaddock = false; + doCheck = false; + homepage = "https://github.com/YoshikuniJujo/x11-xim_haskell/wiki/"; + description = "A binding to the xim of X11 graphics library"; + license = stdenv.lib.licenses.bsd3; + }) {}; + "x509" = callPackage + ({ mkDerivation, asn1-encoding, asn1-parse, asn1-types, base + , bytestring, containers, cryptonite, hourglass, memory, mtl, pem + , stdenv + }: + mkDerivation { + pname = "x509"; + version = "1.7.3"; + sha256 = "41740f949bb773dc721d342a85587a512658c81ee8cd38f102473b315e127356"; + revision = "1"; + editedCabalFile = "06zzirygvzp0ssdg9blipdwmd0b41p4gxh3ldai7ngjyjsdclwsx"; + libraryHaskellDepends = [ + asn1-encoding asn1-parse asn1-types base bytestring containers + cryptonite hourglass memory mtl pem + ]; + doHaddock = false; + doCheck = false; + homepage = "http://github.com/vincenthz/hs-certificate"; + description = "X509 reader and writer"; + license = stdenv.lib.licenses.bsd3; + }) {}; + "x509-store" = callPackage + ({ mkDerivation, asn1-encoding, asn1-types, base, bytestring + , containers, cryptonite, directory, filepath, mtl, pem, stdenv + , x509 + }: + mkDerivation { + pname = "x509-store"; + version = "1.6.6"; + sha256 = "6a276f595cf91c9688129cad4c9c6be9c349ffc0de22300eeb3dfa6a2b6e7635"; + libraryHaskellDepends = [ + asn1-encoding asn1-types base bytestring containers cryptonite + directory filepath mtl pem x509 + ]; + doHaddock = false; + doCheck = false; + homepage = "http://github.com/vincenthz/hs-certificate"; + description = "X.509 collection accessing and storing methods"; + license = stdenv.lib.licenses.bsd3; + }) {}; + "x509-system" = callPackage + ({ mkDerivation, base, bytestring, containers, directory, filepath + , mtl, pem, process, stdenv, x509, x509-store + }: + mkDerivation { + pname = "x509-system"; + version = "1.6.6"; + sha256 = "40dcdaae3ec67f38c08d96d4365b901eb8ac0c590bd7972eb429d37d58aa4419"; + libraryHaskellDepends = [ + base bytestring containers directory filepath mtl pem process x509 + x509-store + ]; + doHaddock = false; + doCheck = false; + homepage = "http://github.com/vincenthz/hs-certificate"; + description = "Handle per-operating-system X.509 accessors and storage"; + license = stdenv.lib.licenses.bsd3; + }) {}; + "x509-validation" = callPackage + ({ mkDerivation, asn1-encoding, asn1-types, base, bytestring + , containers, cryptonite, data-default-class, hourglass, memory + , mtl, pem, stdenv, x509, x509-store + }: + mkDerivation { + pname = "x509-validation"; + version = "1.6.10"; + sha256 = "761c9d77322528259b690508e829cb360feb1fc542951a99f3af51ae980e45d7"; + revision = "1"; + editedCabalFile = "1isap8v1gh31q4pj3gn155ya8nd1da0a5a3cryqh4yhf0ivbwl0w"; + libraryHaskellDepends = [ + asn1-encoding asn1-types base bytestring containers cryptonite + data-default-class hourglass memory mtl pem x509 x509-store + ]; + doHaddock = false; + doCheck = false; + homepage = "http://github.com/vincenthz/hs-certificate"; + description = "X.509 Certificate and CRL validation"; + license = stdenv.lib.licenses.bsd3; + }) {}; + "xdg-basedir" = callPackage + ({ mkDerivation, base, directory, filepath, stdenv }: + mkDerivation { + pname = "xdg-basedir"; + version = "0.2.2"; + sha256 = "e461c3a5c6007c55ceaea03be3be0ef3a92aa0ea1aea936da0c43671bbfaf42b"; + libraryHaskellDepends = [ base directory filepath ]; + doHaddock = false; + doCheck = false; + homepage = "http://github.com/willdonnelly/xdg-basedir"; + description = "A basic implementation of the XDG Base Directory specification"; + license = stdenv.lib.licenses.bsd3; + }) {}; + "xeno" = callPackage + ({ mkDerivation, array, base, bytestring, deepseq, hspec, mtl + , mutable-containers, stdenv, vector + }: + mkDerivation { + pname = "xeno"; + version = "0.3.4"; + sha256 = "5a2a56d969a6410b65150bc4254f343c6bbe585e60eb4890d2bc0ac6c1f334eb"; + libraryHaskellDepends = [ + array base bytestring deepseq hspec mtl mutable-containers vector + ]; + doHaddock = false; + doCheck = false; + homepage = "https://github.com/ocramz/xeno"; + description = "A fast event-based XML parser in pure Haskell"; + license = stdenv.lib.licenses.bsd3; + }) {}; + "xenstore" = callPackage + ({ mkDerivation, base, bytestring, cereal, mtl, network, stdenv }: + mkDerivation { + pname = "xenstore"; + version = "0.1.1"; + sha256 = "c2b538c9ce6716f4a1b4c0cb63ed5c6e5ee3e69e80dbb7826ee7f5392f45e874"; + isLibrary = true; + isExecutable = true; + libraryHaskellDepends = [ base bytestring cereal mtl network ]; + doHaddock = false; + doCheck = false; + description = "Xenstore client access"; + license = stdenv.lib.licenses.bsd3; + }) {}; + "xhtml" = callPackage + ({ mkDerivation, base, stdenv }: + mkDerivation { + pname = "xhtml"; + version = "3000.2.2.1"; + sha256 = "5cc869013ecc07ff68b3f873c0ab7f03b943fd7fa16d6f8725d4601b2f9f6924"; + libraryHaskellDepends = [ base ]; + doHaddock = false; + doCheck = false; + homepage = "https://github.com/haskell/xhtml"; + description = "An XHTML combinator library"; + license = stdenv.lib.licenses.bsd3; + }) {}; + "xls" = callPackage + ({ mkDerivation, base, conduit, filepath, getopt-generics + , resourcet, stdenv, transformers + }: + mkDerivation { + pname = "xls"; + version = "0.1.1"; + sha256 = "097711246a78389bdde19484d422ffb2248d46ab62248e4ca653c50e12ff0928"; + isLibrary = true; + isExecutable = true; + libraryHaskellDepends = [ + base conduit filepath resourcet transformers + ]; + executableHaskellDepends = [ + base conduit getopt-generics resourcet transformers + ]; + doHaddock = false; + doCheck = false; + homepage = "http://github.com/harendra-kumar/xls"; + description = "Parse Microsoft Excel xls files (BIFF/Excel 97-2004)"; + license = stdenv.lib.licenses.bsd3; + }) {}; + "xlsx" = callPackage + ({ mkDerivation, attoparsec, base, base64-bytestring, binary-search + , bytestring, conduit, containers, data-default, deepseq, errors + , extra, filepath, lens, mtl, network-uri, old-locale, safe, stdenv + , text, time, transformers, vector, xeno, xml-conduit, zip-archive + , zlib + }: + mkDerivation { + pname = "xlsx"; + version = "0.7.2"; + sha256 = "b2560467ea5639d7bbd97ecf492f2e2cc9fa34e0b05fc5d55243304bbe7f1103"; + libraryHaskellDepends = [ + attoparsec base base64-bytestring binary-search bytestring conduit + containers data-default deepseq errors extra filepath lens mtl + network-uri old-locale safe text time transformers vector xeno + xml-conduit zip-archive zlib + ]; + doHaddock = false; + doCheck = false; + homepage = "https://github.com/qrilka/xlsx"; + description = "Simple and incomplete Excel file parser/writer"; + license = stdenv.lib.licenses.mit; + }) {}; + "xml" = callPackage + ({ mkDerivation, base, bytestring, stdenv, text }: + mkDerivation { + pname = "xml"; + version = "1.3.14"; + sha256 = "32d1a1a9f21a59176d84697f96ae3a13a0198420e3e4f1c48abbab7d2425013d"; + libraryHaskellDepends = [ base bytestring text ]; + doHaddock = false; + doCheck = false; + homepage = "http://code.galois.com"; + description = "A simple XML library"; + license = stdenv.lib.licenses.bsd3; + }) {}; + "xml-basic" = callPackage + ({ mkDerivation, base, containers, data-accessor + , explicit-exception, semigroups, stdenv, utility-ht + }: + mkDerivation { + pname = "xml-basic"; + version = "0.1.3"; + sha256 = "98d8d1263462c7880afefff15957affe969d202bd3716f5bb553c6ada55c4355"; + libraryHaskellDepends = [ + base containers data-accessor explicit-exception semigroups + utility-ht + ]; + doHaddock = false; + doCheck = false; + description = "Basics for XML/HTML representation and processing"; + license = stdenv.lib.licenses.bsd3; + }) {}; + "xml-conduit" = callPackage + ({ mkDerivation, attoparsec, base, blaze-html, blaze-markup + , bytestring, conduit, conduit-extra, containers + , data-default-class, deepseq, monad-control, resourcet, stdenv + , text, transformers, xml-types + }: + mkDerivation { + pname = "xml-conduit"; + version = "1.8.0"; + sha256 = "0382bfd3627be4970b11228948274faef51ca9a2590a7723b5787a7205a52036"; + libraryHaskellDepends = [ + attoparsec base blaze-html blaze-markup bytestring conduit + conduit-extra containers data-default-class deepseq monad-control + resourcet text transformers xml-types + ]; + doHaddock = false; + doCheck = false; + homepage = "http://github.com/snoyberg/xml"; + description = "Pure-Haskell utilities for dealing with XML with the conduit package"; + license = stdenv.lib.licenses.mit; + }) {}; + "xml-conduit-parse" = callPackage + ({ mkDerivation, base, conduit, conduit-parse, containers + , exceptions, parsers, stdenv, text, xml-conduit, xml-types + }: + mkDerivation { + pname = "xml-conduit-parse"; + version = "0.3.1.2"; + sha256 = "c1aae117720128195dbbf2ce196271e4ca2973163c6a03a1b0ead3b32f936308"; + revision = "1"; + editedCabalFile = "0jnnr4z3c6rq2dz0ldiic5zwkrp36igf6gip11qrm9ss2pk9khbl"; + libraryHaskellDepends = [ + base conduit conduit-parse containers exceptions parsers text + xml-conduit xml-types + ]; + doHaddock = false; + doCheck = false; + homepage = "https://github.com/k0ral/xml-conduit-parse"; + description = "Streaming XML parser based on conduits"; + license = "unknown"; + }) {}; + "xml-conduit-writer" = callPackage + ({ mkDerivation, base, containers, data-default, dlist, mtl, stdenv + , text, xml-conduit, xml-types + }: + mkDerivation { + pname = "xml-conduit-writer"; + version = "0.1.1.2"; + sha256 = "0891c05ad2a2de68183868de8f66230d02f209446ee91bca772cbf22b599ae58"; + libraryHaskellDepends = [ + base containers data-default dlist mtl text xml-conduit xml-types + ]; + doHaddock = false; + doCheck = false; + homepage = "https://bitbucket.org/dpwiz/xml-conduit-writer"; + description = "Warm and fuzzy creation of XML documents"; + license = stdenv.lib.licenses.mit; + }) {}; + "xml-hamlet" = callPackage + ({ mkDerivation, base, containers, parsec, shakespeare, stdenv + , template-haskell, text, xml-conduit + }: + mkDerivation { + pname = "xml-hamlet"; + version = "0.5.0"; + sha256 = "7bcec0aad83e72c2870efd3327553b3d78f6332cf01c12ad4b67c02f499015a3"; + libraryHaskellDepends = [ + base containers parsec shakespeare template-haskell text + xml-conduit + ]; + doHaddock = false; + doCheck = false; + homepage = "http://www.yesodweb.com/"; + description = "Hamlet-style quasiquoter for XML content"; + license = stdenv.lib.licenses.bsd3; + }) {}; + "xml-html-qq" = callPackage + ({ mkDerivation, base, blaze-markup, conduit, data-default + , from-sum, heterocephalus, html-conduit, resourcet, stdenv + , template-haskell, text, th-lift, th-lift-instances, xml-conduit + }: + mkDerivation { + pname = "xml-html-qq"; + version = "0.1.0.1"; + sha256 = "1a2ebb1f4ca58a4f442c470db6d3271e6b1069d41860f8683b5da9082329235a"; + libraryHaskellDepends = [ + base blaze-markup conduit data-default from-sum heterocephalus + html-conduit resourcet template-haskell text th-lift + th-lift-instances xml-conduit + ]; + doHaddock = false; + doCheck = false; + homepage = "https://github.com/cdepillabout/xml-html-qq"; + description = "Quasi-quoters for XML and HTML Documents"; + license = stdenv.lib.licenses.bsd3; + }) {}; + "xml-indexed-cursor" = callPackage + ({ mkDerivation, base, bytestring, containers, data-default, stdenv + , text, xml-conduit + }: + mkDerivation { + pname = "xml-indexed-cursor"; + version = "0.1.1.0"; + sha256 = "46d622fc738e8cc1513f598207ee5e6cda790c79e0697fe02d2da6ad02a6da74"; + libraryHaskellDepends = [ + base bytestring containers data-default text xml-conduit + ]; + doHaddock = false; + doCheck = false; + homepage = "https://github.com/cdepillabout/xml-indexed-cursor"; + description = "Indexed XML cursors similar to 'Text.XML.Cursor' from xml-conduit"; + license = stdenv.lib.licenses.bsd3; + }) {}; + "xml-isogen" = callPackage + ({ mkDerivation, base, deepseq, dom-parser, lens, mtl, QuickCheck + , semigroups, stdenv, template-haskell, text, xml-conduit + , xml-conduit-writer + }: + mkDerivation { + pname = "xml-isogen"; + version = "0.3.0"; + sha256 = "9f812d7bb5dd280e62f5013fd77af27e3710fb1a76dcf7a12f0abbfae5400a17"; + libraryHaskellDepends = [ + base deepseq dom-parser lens mtl QuickCheck semigroups + template-haskell text xml-conduit xml-conduit-writer + ]; + doHaddock = false; + doCheck = false; + homepage = "https://github.com/typeable/xml-isogen"; + description = "Generate XML-isomorphic types"; + license = stdenv.lib.licenses.mit; + }) {}; + "xml-lens" = callPackage + ({ mkDerivation, base, case-insensitive, containers, lens, stdenv + , text, xml-conduit + }: + mkDerivation { + pname = "xml-lens"; + version = "0.1.6.3"; + sha256 = "4dd7f1a91fbb12ae52d5a14badd9f38c0f0d7556f08ee77d79a67cc546dcb1e8"; + revision = "1"; + editedCabalFile = "1fbk4wv7zr10wsh8a0svd799im64fybnlb09rjpfl2pvb6i6h1qs"; + libraryHaskellDepends = [ + base case-insensitive containers lens text xml-conduit + ]; + doHaddock = false; + doCheck = false; + homepage = "https://github.com/fumieval/xml-lens"; + description = "Lenses, traversals, and prisms for xml-conduit"; + license = stdenv.lib.licenses.bsd3; + }) {}; + "xml-picklers" = callPackage + ({ mkDerivation, base, containers, stdenv, text, xml-types }: + mkDerivation { + pname = "xml-picklers"; + version = "0.3.6"; + sha256 = "d1b802cd9543a228c6699928e6695539c28f6cbd8e7859a65ca874543ef1d1a4"; + libraryHaskellDepends = [ base containers text xml-types ]; + doHaddock = false; + doCheck = false; + description = "XML picklers based on xml-types, ported from hexpat-pickle"; + license = stdenv.lib.licenses.bsd3; + }) {}; + "xml-to-json" = callPackage + ({ mkDerivation, aeson, base, bytestring, containers, curl + , hashable, hxt, hxt-curl, hxt-expat, hxt-tagsoup, regex-posix + , stdenv, tagsoup, text, unordered-containers, vector + }: + mkDerivation { + pname = "xml-to-json"; + version = "2.0.1"; + sha256 = "ad1a2501828052a1798178c309638a9b8e4fe66ad24dae9c76de939c156d2e2f"; + isLibrary = true; + isExecutable = true; + libraryHaskellDepends = [ + aeson base bytestring containers curl hashable hxt hxt-curl + hxt-expat hxt-tagsoup regex-posix tagsoup text unordered-containers + vector + ]; + executableHaskellDepends = [ base ]; + doHaddock = false; + doCheck = false; + homepage = "https://github.com/sinelaw/xml-to-json"; + description = "Library and command line tool for converting XML files to json"; + license = stdenv.lib.licenses.mit; + }) {}; + "xml-to-json-fast" = callPackage + ({ mkDerivation, base, directory, process, stdenv, tagsoup, text }: + mkDerivation { + pname = "xml-to-json-fast"; + version = "2.0.0"; + sha256 = "dd852fe1aa54db3c6d87a2e74b5345b0f14effdd49bad5b73d79571e1b47563f"; + isLibrary = true; + isExecutable = true; + libraryHaskellDepends = [ base tagsoup text ]; + executableHaskellDepends = [ base directory process ]; + doHaddock = false; + doCheck = false; + homepage = "https://github.com/sinelaw/xml-to-json-fast"; + description = "Fast, light converter of xml to json capable of handling huge xml files"; + license = stdenv.lib.licenses.mit; + }) {}; + "xml-types" = callPackage + ({ mkDerivation, base, deepseq, stdenv, text }: + mkDerivation { + pname = "xml-types"; + version = "0.3.6"; + sha256 = "9937d440072552c03c6d8ad79f61e61467dc28dcd5adeaad81038b9b94eef8c9"; + libraryHaskellDepends = [ base deepseq text ]; + doHaddock = false; + doCheck = false; + homepage = "https://john-millikin.com/software/haskell-xml/"; + description = "Basic types for representing XML"; + license = stdenv.lib.licenses.mit; + }) {}; + "xmlbf" = callPackage + ({ mkDerivation, base, bytestring, containers, stdenv, text + , transformers, unordered-containers + }: + mkDerivation { + pname = "xmlbf"; + version = "0.4.1"; + sha256 = "189a02e8b54c3576c3a919799def7b83c0e602b222264901c644c941c34fdc75"; + libraryHaskellDepends = [ + base bytestring containers text transformers unordered-containers + ]; + doHaddock = false; + doCheck = false; + homepage = "https://gitlab.com/k0001/xmlbf"; + description = "XML back and forth! Parser, renderer, ToXml, FromXml, fixpoints"; + license = stdenv.lib.licenses.asl20; + }) {}; + "xmlbf-xeno" = callPackage + ({ mkDerivation, base, bytestring, html-entities, stdenv, text + , unordered-containers, xeno, xmlbf + }: + mkDerivation { + pname = "xmlbf-xeno"; + version = "0.1.1"; + sha256 = "6c1c4e419240c1e480d5543e89883cd2a356c1bb470a452f935424a80367dd32"; + libraryHaskellDepends = [ + base bytestring html-entities text unordered-containers xeno xmlbf + ]; + doHaddock = false; + doCheck = false; + homepage = "https://gitlab.com/k0001/xmlbf"; + description = "xeno backend support for the xmlbf library"; + license = stdenv.lib.licenses.asl20; + }) {}; + "xmlgen" = callPackage + ({ mkDerivation, base, blaze-builder, bytestring, containers, mtl + , stdenv, text + }: + mkDerivation { + pname = "xmlgen"; + version = "0.6.2.2"; + sha256 = "926fa98c77525f5046274758fcebd190e86de3f53a4583179e8ce328f25a34d6"; + libraryHaskellDepends = [ + base blaze-builder bytestring containers mtl text + ]; + doHaddock = false; + doCheck = false; + description = "Fast XML generation library"; + license = stdenv.lib.licenses.bsd3; + }) {}; + "xss-sanitize" = callPackage + ({ mkDerivation, attoparsec, base, containers, css-text + , network-uri, stdenv, tagsoup, text, utf8-string + }: + mkDerivation { + pname = "xss-sanitize"; + version = "0.3.6"; + sha256 = "b385eea5652c798b701c627dce8b327c3d6cbfd8c92e1e18e7118862d4d0e2b4"; + libraryHaskellDepends = [ + attoparsec base containers css-text network-uri tagsoup text + utf8-string + ]; + doHaddock = false; + doCheck = false; + homepage = "https://github.com/yesodweb/haskell-xss-sanitize#readme"; + description = "sanitize untrusted HTML to prevent XSS attacks"; + license = stdenv.lib.licenses.bsd2; + }) {}; + "xxhash-ffi" = callPackage + ({ mkDerivation, base, bytestring, stdenv }: + mkDerivation { + pname = "xxhash-ffi"; + version = "0.2.0.0"; + sha256 = "fc2e63ea54531e2888a9ddd6816cb113bd5fd0e01192156e9f1459d88af92e6b"; + libraryHaskellDepends = [ base bytestring ]; + doHaddock = false; + doCheck = false; + homepage = "https://github.com/haskell-haskey/xxhash-ffi#readme"; + description = "Bindings to the C implementation the xxHash algorithm"; + license = stdenv.lib.licenses.bsd3; + }) {}; + "yaml" = callPackage + ({ mkDerivation, aeson, attoparsec, base, bytestring, conduit + , containers, directory, filepath, resourcet, scientific + , semigroups, stdenv, template-haskell, text, transformers + , unordered-containers, vector + }: + mkDerivation { + pname = "yaml"; + version = "0.8.32"; + sha256 = "dc20f863deb4ee75395bf1f78268781db76be6209af67b70c05f6e1a09f47a31"; + configureFlags = [ "-f-system-libyaml" ]; + isLibrary = true; + isExecutable = true; + libraryHaskellDepends = [ + aeson attoparsec base bytestring conduit containers directory + filepath resourcet scientific semigroups template-haskell text + transformers unordered-containers vector + ]; + doHaddock = false; + doCheck = false; + homepage = "https://github.com/snoyberg/yaml#readme"; + description = "Support for parsing and rendering YAML documents"; + license = stdenv.lib.licenses.bsd3; + }) {}; + "yes-precure5-command" = callPackage + ({ mkDerivation, base, Cabal, containers, mtl, parsec, random + , stdenv + }: + mkDerivation { + pname = "yes-precure5-command"; + version = "5.5.3"; + sha256 = "27f2f2dcd81923a18450cda21a31585d0d3887afde504190667cb7dbf0a0af7e"; + isLibrary = true; + isExecutable = true; + libraryHaskellDepends = [ + base Cabal containers mtl parsec random + ]; + executableHaskellDepends = [ + base Cabal containers mtl parsec random + ]; + doHaddock = false; + doCheck = false; + homepage = "https://github.com/igrep/yes-precure5-command/"; + description = "Extended yes command to reproduce phrases in Yes! Precure 5"; + license = stdenv.lib.licenses.mit; + }) {}; + "yeshql" = callPackage + ({ mkDerivation, base, stdenv, yeshql-core, yeshql-hdbc }: + mkDerivation { + pname = "yeshql"; + version = "4.1.0.0"; + sha256 = "d89fe3285de21f3ba1b40c701ea4a0b2535ae4897d772abb34b089ad52157113"; + libraryHaskellDepends = [ base yeshql-core yeshql-hdbc ]; + doHaddock = false; + doCheck = false; + homepage = "https://github.com/tdammers/yeshql"; + description = "YesQL-style SQL database abstraction (legacy compatibility wrapper)"; + license = stdenv.lib.licenses.mit; + }) {}; + "yeshql-core" = callPackage + ({ mkDerivation, base, containers, convertible, filepath, parsec + , stdenv, template-haskell + }: + mkDerivation { + pname = "yeshql-core"; + version = "4.1.0.0"; + sha256 = "fc8c01606c55a00a4628839a11b6e9145b92f887e556e9cb0f85d46d52d4c2ff"; + libraryHaskellDepends = [ + base containers convertible filepath parsec template-haskell + ]; + doHaddock = false; + doCheck = false; + homepage = "https://github.com/tdammers/yeshql"; + description = "YesQL-style SQL database abstraction (core)"; + license = stdenv.lib.licenses.mit; + }) {}; + "yeshql-hdbc" = callPackage + ({ mkDerivation, base, containers, convertible, filepath, HDBC + , parsec, stdenv, template-haskell, yeshql-core + }: + mkDerivation { + pname = "yeshql-hdbc"; + version = "4.1.0.0"; + sha256 = "6482254c550bbd7a17c444760ab5a99af22723873c52ccfd406a4a7338154a94"; + libraryHaskellDepends = [ + base containers convertible filepath HDBC parsec template-haskell + yeshql-core + ]; + doHaddock = false; + doCheck = false; + homepage = "https://github.com/tdammers/yeshql"; + description = "YesQL-style SQL database abstraction (HDBC backend)"; + license = stdenv.lib.licenses.mit; + }) {}; + "yesod" = callPackage + ({ mkDerivation, aeson, base, blaze-html, blaze-markup, bytestring + , conduit, data-default-class, directory, fast-logger, monad-logger + , resourcet, semigroups, shakespeare, stdenv, streaming-commons + , template-haskell, text, transformers, unix, unordered-containers + , wai, wai-extra, wai-logger, warp, yaml, yesod-core, yesod-form + , yesod-persistent + }: + mkDerivation { + pname = "yesod"; + version = "1.6.0"; + sha256 = "8a242ffe1df10bc2c5dffb6e255ad21b11e96a9c4794bac20504b67f973da773"; + libraryHaskellDepends = [ + aeson base blaze-html blaze-markup bytestring conduit + data-default-class directory fast-logger monad-logger resourcet + semigroups shakespeare streaming-commons template-haskell text + transformers unix unordered-containers wai wai-extra wai-logger + warp yaml yesod-core yesod-form yesod-persistent + ]; + doHaddock = false; + doCheck = false; + homepage = "http://www.yesodweb.com/"; + description = "Creation of type-safe, RESTful web applications"; + license = stdenv.lib.licenses.mit; + }) {}; + "yesod-alerts" = callPackage + ({ mkDerivation, alerts, base, blaze-html, blaze-markup, safe + , stdenv, text, yesod-core + }: + mkDerivation { + pname = "yesod-alerts"; + version = "0.1.2.0"; + sha256 = "8e52c8a7ec9cdbe7cdc06f39ea4e27b852be0391cf78652e349f0f2c169b146f"; + libraryHaskellDepends = [ + alerts base blaze-html blaze-markup safe text yesod-core + ]; + doHaddock = false; + doCheck = false; + homepage = "https://github.com/alx741/yesod-alerts#readme"; + description = "Alert messages for the Yesod framework"; + license = stdenv.lib.licenses.bsd3; + }) {}; + "yesod-auth" = callPackage + ({ mkDerivation, aeson, authenticate, base, base16-bytestring + , base64-bytestring, binary, blaze-builder, blaze-html + , blaze-markup, bytestring, conduit, conduit-extra, containers + , cryptonite, data-default, email-validate, file-embed, http-client + , http-client-tls, http-conduit, http-types, memory, network-uri + , nonce, persistent, random, safe, shakespeare, stdenv + , template-haskell, text, time, transformers, unliftio + , unliftio-core, unordered-containers, wai, yesod-core, yesod-form + , yesod-persistent + }: + mkDerivation { + pname = "yesod-auth"; + version = "1.6.4.1"; + sha256 = "f2d493f4fb9f52c958757ca98056011e980857a111f012fc3de56a76641a3fe8"; + libraryHaskellDepends = [ + aeson authenticate base base16-bytestring base64-bytestring binary + blaze-builder blaze-html blaze-markup bytestring conduit + conduit-extra containers cryptonite data-default email-validate + file-embed http-client http-client-tls http-conduit http-types + memory network-uri nonce persistent random safe shakespeare + template-haskell text time transformers unliftio unliftio-core + unordered-containers wai yesod-core yesod-form yesod-persistent + ]; + doHaddock = false; + doCheck = false; + homepage = "http://www.yesodweb.com/"; + description = "Authentication for Yesod"; + license = stdenv.lib.licenses.mit; + }) {}; + "yesod-auth-fb" = callPackage + ({ mkDerivation, aeson, base, bytestring, conduit, fb, http-conduit + , resourcet, shakespeare, stdenv, text, time, transformers + , unliftio, wai, yesod-auth, yesod-core, yesod-fb + }: + mkDerivation { + pname = "yesod-auth-fb"; + version = "1.9.0"; + sha256 = "e8751b7703b2bc73eb37ec3ed03f3afec552cbc3933dff25fa0d899dcfea46c2"; + libraryHaskellDepends = [ + aeson base bytestring conduit fb http-conduit resourcet shakespeare + text time transformers unliftio wai yesod-auth yesod-core yesod-fb + ]; + doHaddock = false; + doCheck = false; + homepage = "https://github.com/psibi/yesod-auth-fb"; + description = "Authentication backend for Yesod using Facebook"; + license = stdenv.lib.licenses.bsd3; + }) {}; + "yesod-auth-hashdb" = callPackage + ({ mkDerivation, aeson, base, bytestring, persistent, stdenv, text + , yesod-auth, yesod-core, yesod-form, yesod-persistent + }: + mkDerivation { + pname = "yesod-auth-hashdb"; + version = "1.7"; + sha256 = "65b9a941a9eb87421dfc57f817a7e4dd46bb204b0f27438084f7417805434f1c"; + libraryHaskellDepends = [ + aeson base bytestring persistent text yesod-auth yesod-core + yesod-form yesod-persistent + ]; + doHaddock = false; + doCheck = false; + homepage = "https://github.com/paul-rouse/yesod-auth-hashdb"; + description = "Authentication plugin for Yesod"; + license = stdenv.lib.licenses.mit; + }) {}; + "yesod-bin" = callPackage + ({ mkDerivation, attoparsec, base, base64-bytestring, blaze-builder + , bytestring, Cabal, conduit, conduit-extra, containers + , data-default-class, directory, file-embed, filepath, fsnotify + , http-client, http-client-tls, http-reverse-proxy, http-types + , network, optparse-applicative, parsec, process, project-template + , resourcet, say, shakespeare, split, stdenv, stm + , streaming-commons, tar, template-haskell, text, time + , transformers, transformers-compat, unix-compat, unliftio + , unordered-containers, wai, wai-extra, warp, warp-tls, yaml, zlib + }: + mkDerivation { + pname = "yesod-bin"; + version = "1.6.0.3"; + sha256 = "e4db295b4c651c205a1730df38501c217d9b600f3dbc1eea21d5fa47e832aedc"; + revision = "3"; + editedCabalFile = "0v3bwg26ghxa1wdvwyvrffd8wwxhv1qk9g8f64ax1n8gz53k6an7"; + isLibrary = false; + isExecutable = true; + executableHaskellDepends = [ + attoparsec base base64-bytestring blaze-builder bytestring Cabal + conduit conduit-extra containers data-default-class directory + file-embed filepath fsnotify http-client http-client-tls + http-reverse-proxy http-types network optparse-applicative parsec + process project-template resourcet say shakespeare split stm + streaming-commons tar template-haskell text time transformers + transformers-compat unix-compat unliftio unordered-containers wai + wai-extra warp warp-tls yaml zlib + ]; + doHaddock = false; + doCheck = false; + homepage = "http://www.yesodweb.com/"; + description = "The yesod helper executable"; + license = stdenv.lib.licenses.mit; + }) {}; + "yesod-core" = callPackage + ({ mkDerivation, aeson, auto-update, base, blaze-html, blaze-markup + , byteable, bytestring, case-insensitive, cereal, clientsession + , conduit, conduit-extra, containers, cookie, deepseq, fast-logger + , http-types, monad-logger, mtl, parsec, path-pieces, random + , resourcet, rio, shakespeare, stdenv, template-haskell, text, time + , transformers, unix-compat, unliftio, unordered-containers, vector + , wai, wai-extra, wai-logger, warp, word8 + }: + mkDerivation { + pname = "yesod-core"; + version = "1.6.6"; + sha256 = "6b8ac48c3178b913caac9d7391201d9af0b238f1353e70c9a1b31e56aa715075"; + libraryHaskellDepends = [ + aeson auto-update base blaze-html blaze-markup byteable bytestring + case-insensitive cereal clientsession conduit conduit-extra + containers cookie deepseq fast-logger http-types monad-logger mtl + parsec path-pieces random resourcet rio shakespeare + template-haskell text time transformers unix-compat unliftio + unordered-containers vector wai wai-extra wai-logger warp word8 + ]; + doHaddock = false; + doCheck = false; + homepage = "http://www.yesodweb.com/"; + description = "Creation of type-safe, RESTful web applications"; + license = stdenv.lib.licenses.mit; + }) {}; + "yesod-csp" = callPackage + ({ mkDerivation, attoparsec, base, case-insensitive + , mono-traversable, network-uri, semigroups, stdenv, syb + , template-haskell, text, wai, yesod, yesod-core + }: + mkDerivation { + pname = "yesod-csp"; + version = "0.2.4.0"; + sha256 = "e05d31857d6d0e8aececdd83b6a896267ecab2c29426d559e3dafb259eac92a5"; + libraryHaskellDepends = [ + attoparsec base case-insensitive mono-traversable network-uri + semigroups syb template-haskell text wai yesod yesod-core + ]; + doHaddock = false; + doCheck = false; + description = "Add CSP headers to Yesod apps"; + license = stdenv.lib.licenses.mit; + }) {}; + "yesod-eventsource" = callPackage + ({ mkDerivation, base, blaze-builder, conduit, stdenv, transformers + , wai, wai-eventsource, wai-extra, yesod-core + }: + mkDerivation { + pname = "yesod-eventsource"; + version = "1.6.0"; + sha256 = "6fceeca34d5e80c8a0d65ab95fab3c53807d1f18eb506abdef67a8f70d0e418b"; + libraryHaskellDepends = [ + base blaze-builder conduit transformers wai wai-eventsource + wai-extra yesod-core + ]; + doHaddock = false; + doCheck = false; + homepage = "http://www.yesodweb.com/"; + description = "Server-sent events support for Yesod apps"; + license = stdenv.lib.licenses.mit; + }) {}; + "yesod-fb" = callPackage + ({ mkDerivation, aeson, base, bytestring, conduit, crypto-api, fb + , http-client-tls, http-conduit, stdenv, text, wai, yesod-core + }: + mkDerivation { + pname = "yesod-fb"; + version = "0.5.0"; + sha256 = "de375004c12e89eec47738d60465c7c63b5f0c7bfc3591c70a35522fdc0841db"; + libraryHaskellDepends = [ + aeson base bytestring conduit crypto-api fb http-client-tls + http-conduit text wai yesod-core + ]; + doHaddock = false; + doCheck = false; + homepage = "https://github.com/psibi/yesod-fb"; + description = "Useful glue functions between the fb library and Yesod"; + license = stdenv.lib.licenses.bsd3; + }) {}; + "yesod-form" = callPackage + ({ mkDerivation, aeson, attoparsec, base, blaze-builder, blaze-html + , blaze-markup, byteable, bytestring, containers, data-default + , email-validate, network-uri, persistent, resourcet, semigroups + , shakespeare, stdenv, text, time, transformers, wai, xss-sanitize + , yesod-core, yesod-persistent + }: + mkDerivation { + pname = "yesod-form"; + version = "1.6.2"; + sha256 = "a780ce27d19d59e8eeef7ba1e3f0c33a966b6a3eb34d2f10a337abed1c0c3ddc"; + libraryHaskellDepends = [ + aeson attoparsec base blaze-builder blaze-html blaze-markup + byteable bytestring containers data-default email-validate + network-uri persistent resourcet semigroups shakespeare text time + transformers wai xss-sanitize yesod-core yesod-persistent + ]; + doHaddock = false; + doCheck = false; + homepage = "http://www.yesodweb.com/"; + description = "Form handling support for Yesod Web Framework"; + license = stdenv.lib.licenses.mit; + }) {}; + "yesod-form-bootstrap4" = callPackage + ({ mkDerivation, base, stdenv, text, yesod-core, yesod-form }: + mkDerivation { + pname = "yesod-form-bootstrap4"; + version = "1.0.2"; + sha256 = "98695338541fab09f27c4df2083ed15f257307d315b0c084e227a265bb99c878"; + libraryHaskellDepends = [ base text yesod-core yesod-form ]; + doHaddock = false; + doCheck = false; + homepage = "https://github.com/ncaq/yesod-form-bootstrap4#readme"; + description = "renderBootstrap4"; + license = stdenv.lib.licenses.mit; + }) {}; + "yesod-gitrepo" = callPackage + ({ mkDerivation, base, directory, http-types, process, stdenv + , temporary, text, unliftio, wai, yesod-core + }: + mkDerivation { + pname = "yesod-gitrepo"; + version = "0.3.0"; + sha256 = "b03c67c506bc3fc402cb41759d69f2c3159af47959cbd964cb6531996084981e"; + libraryHaskellDepends = [ + base directory http-types process temporary text unliftio wai + yesod-core + ]; + doHaddock = false; + doCheck = false; + homepage = "https://github.com/snoyberg/yesod-gitrepo#readme"; + description = "Host content provided by a Git repo"; + license = stdenv.lib.licenses.mit; + }) {}; + "yesod-gitrev" = callPackage + ({ mkDerivation, aeson, base, gitrev, stdenv, template-haskell + , yesod-core + }: + mkDerivation { + pname = "yesod-gitrev"; + version = "0.2.0.0"; + sha256 = "df9f374e6099e55eb62cc273451605ce8746785a293e76115d25002355fee052"; + revision = "1"; + editedCabalFile = "1b0df34lz569gnwbbz0p20dml6bi2nbva9wfdsxyvva0dhvxjaz5"; + libraryHaskellDepends = [ + aeson base gitrev template-haskell yesod-core + ]; + doHaddock = false; + doCheck = false; + homepage = "https://github.com/DanBurton/yesod-gitrev"; + description = "A subsite for displaying git information"; + license = stdenv.lib.licenses.bsd3; + }) {}; + "yesod-newsfeed" = callPackage + ({ mkDerivation, base, blaze-html, blaze-markup, bytestring + , containers, shakespeare, stdenv, text, time, xml-conduit + , yesod-core + }: + mkDerivation { + pname = "yesod-newsfeed"; + version = "1.6.1.0"; + sha256 = "6d0b97592d74ca45e204f1876fb113a4830c5f35612b876175169af3d2f79615"; + libraryHaskellDepends = [ + base blaze-html blaze-markup bytestring containers shakespeare text + time xml-conduit yesod-core + ]; + doHaddock = false; + doCheck = false; + homepage = "http://www.yesodweb.com/"; + description = "Helper functions and data types for producing News feeds"; + license = stdenv.lib.licenses.mit; + }) {}; + "yesod-paginator" = callPackage + ({ mkDerivation, base, blaze-markup, path-pieces, persistent, safe + , stdenv, text, transformers, uri-encode, yesod-core + , yesod-persistent + }: + mkDerivation { + pname = "yesod-paginator"; + version = "1.1.0.0"; + sha256 = "1640cc7e7cbe708ba0de02731ccd84cbd53a4734a332e01aa38b3e4deffd090e"; + isLibrary = true; + isExecutable = true; + libraryHaskellDepends = [ + base blaze-markup path-pieces persistent safe text transformers + uri-encode yesod-core yesod-persistent + ]; + doHaddock = false; + doCheck = false; + homepage = "http://github.com/pbrisbin/yesod-paginator"; + description = "A pagination approach for yesod"; + license = stdenv.lib.licenses.bsd3; + }) {}; + "yesod-persistent" = callPackage + ({ mkDerivation, base, blaze-builder, conduit, persistent + , persistent-template, resource-pool, resourcet, stdenv + , transformers, yesod-core + }: + mkDerivation { + pname = "yesod-persistent"; + version = "1.6.0"; + sha256 = "42be2b4277fb265e18273503f3592259feb69ce5bfa2d2a862639b755c4fa5bd"; + libraryHaskellDepends = [ + base blaze-builder conduit persistent persistent-template + resource-pool resourcet transformers yesod-core + ]; + doHaddock = false; + doCheck = false; + homepage = "http://www.yesodweb.com/"; + description = "Some helpers for using Persistent from Yesod"; + license = stdenv.lib.licenses.mit; + }) {}; + "yesod-recaptcha2" = callPackage + ({ mkDerivation, base, classy-prelude-yesod, http-conduit, stdenv + , yesod-auth + }: + mkDerivation { + pname = "yesod-recaptcha2"; + version = "0.2.4"; + sha256 = "2848ecd3fd581cb3beba406640417add2def248c1fc7f20b6ba6a62d220181ab"; + libraryHaskellDepends = [ + base classy-prelude-yesod http-conduit yesod-auth + ]; + doHaddock = false; + doCheck = false; + homepage = "https://github.com/ncaq/yesod-recaptcha2#readme"; + description = "yesod recaptcha2"; + license = stdenv.lib.licenses.mit; + }) {}; + "yesod-sitemap" = callPackage + ({ mkDerivation, base, conduit, containers, data-default, stdenv + , text, time, xml-conduit, xml-types, yesod-core + }: + mkDerivation { + pname = "yesod-sitemap"; + version = "1.6.0"; + sha256 = "e5fa06abdcd57772fc74707ae663c63b45b172bce48117b70a4a9af15131dbd6"; + libraryHaskellDepends = [ + base conduit containers data-default text time xml-conduit + xml-types yesod-core + ]; + doHaddock = false; + doCheck = false; + homepage = "http://www.yesodweb.com/"; + description = "Generate XML sitemaps"; + license = stdenv.lib.licenses.mit; + }) {}; + "yesod-static" = callPackage + ({ mkDerivation, async, attoparsec, base, base64-bytestring + , blaze-builder, byteable, bytestring, conduit, containers + , cryptonite, cryptonite-conduit, css-text, data-default, directory + , exceptions, file-embed, filepath, hashable, hjsmin, http-types + , memory, mime-types, old-time, process, resourcet, stdenv + , template-haskell, text, transformers, unix-compat + , unordered-containers, wai, wai-app-static, yesod-core + }: + mkDerivation { + pname = "yesod-static"; + version = "1.6.0"; + sha256 = "bd0bf5924bb9c27fe24047816018158e92fc687053c190221af2f03bac94880e"; + libraryHaskellDepends = [ + async attoparsec base base64-bytestring blaze-builder byteable + bytestring conduit containers cryptonite cryptonite-conduit + css-text data-default directory exceptions file-embed filepath + hashable hjsmin http-types memory mime-types old-time process + resourcet template-haskell text transformers unix-compat + unordered-containers wai wai-app-static yesod-core + ]; + doHaddock = false; + doCheck = false; + homepage = "http://www.yesodweb.com/"; + description = "Static file serving subsite for Yesod Web Framework"; + license = stdenv.lib.licenses.mit; + }) {}; + "yesod-test" = callPackage + ({ mkDerivation, attoparsec, base, blaze-builder, blaze-html + , bytestring, case-insensitive, conduit, containers, cookie + , hspec-core, html-conduit, http-types, HUnit, network, pretty-show + , semigroups, stdenv, text, time, transformers, wai, wai-extra + , xml-conduit, xml-types, yesod-core + }: + mkDerivation { + pname = "yesod-test"; + version = "1.6.5"; + sha256 = "be0246f7f7a003b280c8744675d1bbd38df3c23ad9ea881cddafc7d4f38103d8"; + libraryHaskellDepends = [ + attoparsec base blaze-builder blaze-html bytestring + case-insensitive conduit containers cookie hspec-core html-conduit + http-types HUnit network pretty-show semigroups text time + transformers wai wai-extra xml-conduit xml-types yesod-core + ]; + doHaddock = false; + doCheck = false; + homepage = "http://www.yesodweb.com"; + description = "integration testing for WAI/Yesod Applications"; + license = stdenv.lib.licenses.mit; + }) {}; + "yesod-text-markdown" = callPackage + ({ mkDerivation, aeson, base, markdown, persistent, shakespeare + , stdenv, text, yesod-core, yesod-form, yesod-persistent + }: + mkDerivation { + pname = "yesod-text-markdown"; + version = "0.1.10"; + sha256 = "3cee8b3d8d84f30e8b825076d650afb05e79ebd22f34a21fc7ad7f45e1637ddc"; + libraryHaskellDepends = [ + aeson base markdown persistent shakespeare text yesod-core + yesod-form yesod-persistent + ]; + doHaddock = false; + doCheck = false; + description = "Yesod support for Text.Markdown."; + license = stdenv.lib.licenses.bsd3; + }) {}; + "yesod-websockets" = callPackage + ({ mkDerivation, base, conduit, mtl, stdenv, transformers, unliftio + , wai, wai-websockets, websockets, yesod-core + }: + mkDerivation { + pname = "yesod-websockets"; + version = "0.3.0"; + sha256 = "4a642982209e27e3b1dac0f29c2c86c4ac39e5109483fa8274e97cd8a574e446"; + libraryHaskellDepends = [ + base conduit mtl transformers unliftio wai wai-websockets + websockets yesod-core + ]; + doHaddock = false; + doCheck = false; + homepage = "https://github.com/yesodweb/yesod"; + description = "WebSockets support for Yesod"; + license = stdenv.lib.licenses.mit; + }) {}; + "yi-language" = callPackage + ({ mkDerivation, alex, array, base, binary, containers + , data-default, hashable, microlens-platform, oo-prototypes + , pointedlist, regex-base, regex-tdfa, stdenv, template-haskell + , transformers-base, unordered-containers + }: + mkDerivation { + pname = "yi-language"; + version = "0.17.1"; + sha256 = "4aee628b278e9d6b2b2e92a8974696ce6de10c30ef137ababb709bdca193b69e"; + libraryHaskellDepends = [ + array base binary containers data-default hashable + microlens-platform oo-prototypes pointedlist regex-base regex-tdfa + template-haskell transformers-base unordered-containers + ]; + libraryToolDepends = [ alex ]; + doHaddock = false; + doCheck = false; + homepage = "https://github.com/yi-editor/yi#readme"; + description = "Collection of language-related Yi libraries"; + license = stdenv.lib.licenses.gpl2; + }) {}; + "yi-rope" = callPackage + ({ mkDerivation, base, binary, bytestring, deepseq, fingertree + , stdenv, text + }: + mkDerivation { + pname = "yi-rope"; + version = "0.11"; + sha256 = "9a9318693501bdbb3e8f3c19b0acd6c3cbd607a6e9d966201b613c41a1b71008"; + libraryHaskellDepends = [ + base binary bytestring deepseq fingertree text + ]; + doHaddock = false; + doCheck = false; + description = "A rope data structure used by Yi"; + license = stdenv.lib.licenses.gpl2; + }) {}; + "yjtools" = callPackage + ({ mkDerivation, base, stdenv }: + mkDerivation { + pname = "yjtools"; + version = "0.9.18"; + sha256 = "9b121c6fcece8241d87aec737458d49c0b76313e9e5e1e70f72b5f71cfc0eb8f"; + libraryHaskellDepends = [ base ]; + doHaddock = false; + doCheck = false; + homepage = "http://homepage3.nifty.com/salamander/second/projects/yjtools/index.xhtml"; + description = "some tools for Monad, List, Tuple and so on"; + license = "LGPL"; + }) {}; + "yoga" = callPackage + ({ mkDerivation, base, bindings-DSL, ieee754, stdenv }: + mkDerivation { + pname = "yoga"; + version = "0.0.0.2"; + sha256 = "2ce82bd1e87ea37cd8ad1e1bb3886bb3535ce583aea2841d07f0b47658a278be"; + isLibrary = true; + isExecutable = true; + libraryHaskellDepends = [ base bindings-DSL ieee754 ]; + doHaddock = false; + doCheck = false; + description = "Bindings to Facebook's Yoga layout library"; + license = stdenv.lib.licenses.bsd3; + }) {}; + "youtube" = callPackage + ({ mkDerivation, base, bytestring, process, stdenv, utility-ht }: + mkDerivation { + pname = "youtube"; + version = "0.2.1.1"; + sha256 = "2e396a785f3d8f504f0e39ed8c87d0a748111ed40b26b950595d83c3fd840e25"; + isLibrary = false; + isExecutable = true; + enableSeparateDataOutput = true; + executableHaskellDepends = [ base bytestring process utility-ht ]; + doHaddock = false; + doCheck = false; + description = "Upload video to YouTube via YouTube API"; + license = stdenv.lib.licenses.bsd3; + }) {}; + "zero" = callPackage + ({ mkDerivation, base, semigroups, stdenv }: + mkDerivation { + pname = "zero"; + version = "0.1.4"; + sha256 = "38cdc62d9673b8b40999de69da2ec60dab7a65fb1c22133ecd54e0a2ec61d5d5"; + libraryHaskellDepends = [ base semigroups ]; + doHaddock = false; + doCheck = false; + homepage = "https://github.com/phaazon/zero"; + description = "Semigroups with absorption"; + license = stdenv.lib.licenses.bsd3; + }) {}; + "zeromq4-haskell" = callPackage + ({ mkDerivation, async, base, bytestring, containers, exceptions + , monad-control, semigroups, stdenv, transformers + , transformers-base, zeromq + }: + mkDerivation { + pname = "zeromq4-haskell"; + version = "0.7.0"; + sha256 = "58d4504ee607cb681fc3da2474ed92afaefdb2dc34752b145aa9f746ab29079f"; + libraryHaskellDepends = [ + async base bytestring containers exceptions monad-control + semigroups transformers transformers-base + ]; + libraryPkgconfigDepends = [ zeromq ]; + doHaddock = false; + doCheck = false; + homepage = "https://gitlab.com/twittner/zeromq-haskell/"; + description = "Bindings to ZeroMQ 4.x"; + license = stdenv.lib.licenses.mit; + }) {inherit (pkgs) zeromq;}; + "zeromq4-patterns" = callPackage + ({ mkDerivation, async, base, binary, bytestring, exceptions + , stdenv, stm, zeromq4-haskell + }: + mkDerivation { + pname = "zeromq4-patterns"; + version = "0.3.1.0"; + sha256 = "74f3a82a72a22684449103c0786e290be2c14de9d48a3ea9d64a7cc063b33ed9"; + isLibrary = true; + isExecutable = true; + libraryHaskellDepends = [ + async base binary bytestring exceptions stm zeromq4-haskell + ]; + executableHaskellDepends = [ base ]; + doHaddock = false; + doCheck = false; + homepage = "https://github.com/hverr/zeromq4-patterns#readme"; + description = "Haskell implementation of several ZeroMQ patterns"; + license = stdenv.lib.licenses.bsd3; + }) {}; + "zim-parser" = callPackage + ({ mkDerivation, array, base, base-compat, binary, binary-conduit + , bytestring, conduit, conduit-extra, lzma, stdenv + }: + mkDerivation { + pname = "zim-parser"; + version = "0.2.1.0"; + sha256 = "b27f6a395c54e0dac6926a5ea18b582aa21c5d91e31b53f8749f063947a15789"; + libraryHaskellDepends = [ + array base base-compat binary binary-conduit bytestring conduit + conduit-extra lzma + ]; + doHaddock = false; + doCheck = false; + homepage = "https://github.com/robbinch/zim-parser#readme"; + description = "Read and parse ZIM files"; + license = stdenv.lib.licenses.gpl3; + }) {}; + "zip" = callPackage + ({ mkDerivation, base, bytestring, bzlib-conduit, case-insensitive + , cereal, conduit, conduit-extra, containers, digest, directory + , dlist, exceptions, filepath, monad-control, mtl, resourcet + , stdenv, text, time, transformers, transformers-base + }: + mkDerivation { + pname = "zip"; + version = "1.1.0"; + sha256 = "65942d6a2ccef6d2b78183f250a6d8b6c04d081ab3df1f39215de0a76a26d9dc"; + libraryHaskellDepends = [ + base bytestring bzlib-conduit case-insensitive cereal conduit + conduit-extra containers digest directory dlist exceptions filepath + monad-control mtl resourcet text time transformers + transformers-base + ]; + doHaddock = false; + doCheck = false; + homepage = "https://github.com/mrkkrp/zip"; + description = "Operations on zip archives"; + license = stdenv.lib.licenses.bsd3; + }) {}; + "zip-archive" = callPackage + ({ mkDerivation, array, base, binary, bytestring, Cabal, containers + , digest, directory, filepath, mtl, pretty, stdenv, text, time + , unix, zlib + }: + mkDerivation { + pname = "zip-archive"; + version = "0.3.3"; + sha256 = "988adee77c806e0b497929b24d5526ea68bd3297427da0d0b30b99c094efc84d"; + isLibrary = true; + isExecutable = true; + setupHaskellDepends = [ base Cabal ]; + libraryHaskellDepends = [ + array base binary bytestring containers digest directory filepath + mtl pretty text time unix zlib + ]; + doHaddock = false; + doCheck = false; + homepage = "http://github.com/jgm/zip-archive"; + description = "Library for creating and modifying zip archives"; + license = stdenv.lib.licenses.bsd3; + }) {}; + "zip-stream" = callPackage + ({ mkDerivation, base, binary, binary-conduit, bytestring, conduit + , conduit-extra, digest, directory, exceptions, filepath, mtl + , primitive, resourcet, stdenv, time, transformers + , transformers-base, zlib + }: + mkDerivation { + pname = "zip-stream"; + version = "0.1.1"; + sha256 = "b88ce2ad46b218a7f0f31ffe02f61105c0ad2b35bf3a171a8e44f8727590d2f2"; + isLibrary = true; + isExecutable = true; + libraryHaskellDepends = [ + base binary binary-conduit bytestring conduit conduit-extra digest + exceptions mtl primitive resourcet time transformers-base zlib + ]; + executableHaskellDepends = [ + base bytestring conduit conduit-extra directory filepath resourcet + time transformers + ]; + doHaddock = false; + doCheck = false; + description = "ZIP archive streaming using conduits"; + license = stdenv.lib.licenses.bsd3; + }) {}; + "zippers" = callPackage + ({ mkDerivation, base, Cabal, cabal-doctest, lens, profunctors + , semigroupoids, semigroups, stdenv + }: + mkDerivation { + pname = "zippers"; + version = "0.2.5"; + sha256 = "2d127772564655df0cb99d5191b91a555797e66e535d0b8b4f5ed4d54097c085"; + revision = "3"; + editedCabalFile = "0y0klc2jaj611cjvmqi95dyj9yvribf9xhibn1andrz5rs6ysz3p"; + setupHaskellDepends = [ base Cabal cabal-doctest ]; + libraryHaskellDepends = [ + base lens profunctors semigroupoids semigroups + ]; + doHaddock = false; + doCheck = false; + homepage = "http://github.com/ekmett/zippers/"; + description = "Traversal based zippers"; + license = stdenv.lib.licenses.bsd3; + }) {}; + "zlib" = callPackage + ({ mkDerivation, base, bytestring, stdenv, zlib }: + mkDerivation { + pname = "zlib"; + version = "0.6.2"; + sha256 = "0dcc7d925769bdbeb323f83b66884101084167501f11d74d21eb9bc515707fed"; + libraryHaskellDepends = [ base bytestring ]; + librarySystemDepends = [ zlib ]; + doHaddock = false; + doCheck = false; + description = "Compression and decompression in the gzip and zlib formats"; + license = stdenv.lib.licenses.bsd3; + }) {inherit (pkgs) zlib;}; + "zlib-bindings" = callPackage + ({ mkDerivation, base, bytestring, stdenv, zlib }: + mkDerivation { + pname = "zlib-bindings"; + version = "0.1.1.5"; + sha256 = "c83bb438f9b6c5fe860982731eb8ac7eff993e8b56cbc15ef5b471f229f79109"; + revision = "2"; + editedCabalFile = "0fq49694gqkab8m0vq4i879blswczwd66n7xh4r4gwiahf0ryvqc"; + libraryHaskellDepends = [ base bytestring zlib ]; + doHaddock = false; + doCheck = false; + homepage = "http://github.com/snapframework/zlib-bindings"; + description = "Low-level bindings to the zlib package"; + license = stdenv.lib.licenses.bsd3; + }) {}; + "zlib-lens" = callPackage + ({ mkDerivation, base, bytestring, profunctors, stdenv, zlib }: + mkDerivation { + pname = "zlib-lens"; + version = "0.1.2.1"; + sha256 = "e5a563453899e0896cfa3aed22a2fbfc67012990ace6d14631f31b704ff766eb"; + libraryHaskellDepends = [ base bytestring profunctors zlib ]; + doHaddock = false; + doCheck = false; + homepage = "http://lens.github.io/"; + description = "Lenses for zlib"; + license = stdenv.lib.licenses.bsd3; + }) {}; + "zot" = callPackage + ({ mkDerivation, base, monads-tf, stdenv }: + mkDerivation { + pname = "zot"; + version = "0.0.3"; + sha256 = "c8a9091b939e3f74aca6be3007a0066c8a1de69da4b62e22891bed543f8a2b32"; + revision = "1"; + editedCabalFile = "04gsbs6fvwpjjg1f6g1j17dxlfzsci9vmirk7mwqwmm9ha0a4hxm"; + isLibrary = false; + isExecutable = true; + enableSeparateDataOutput = true; + executableHaskellDepends = [ base monads-tf ]; + doHaddock = false; + doCheck = false; + description = "Zot language"; + license = stdenv.lib.licenses.bsd3; + }) {}; + "zstd" = callPackage + ({ mkDerivation, base, bytestring, deepseq, ghc-prim, stdenv }: + mkDerivation { + pname = "zstd"; + version = "0.1.0.0"; + sha256 = "0875840799d987cf8f8dd5e0a7686978084b3088c07123e66f6f88561f474bff"; + libraryHaskellDepends = [ base bytestring deepseq ghc-prim ]; + doHaddock = false; + doCheck = false; + homepage = "https://github.com/facebookexperimental/hs-zstd"; + description = "Haskell bindings to the Zstandard compression algorithm"; + license = stdenv.lib.licenses.bsd3; + }) {}; + "ztail" = callPackage + ({ mkDerivation, array, base, bytestring, filepath, hinotify + , process, regex-posix, stdenv, time, unix, unordered-containers + }: + mkDerivation { + pname = "ztail"; + version = "1.2.0.2"; + sha256 = "a14341d51da6dbef9f0edcdefe185dbd7726880ec4e230855fb9871de7c07717"; + revision = "1"; + editedCabalFile = "0d0cpgb0v849zxl12c2gkm3x4nmyfycka1pcfix43lawx62rky8s"; + isLibrary = false; + isExecutable = true; + executableHaskellDepends = [ + array base bytestring filepath hinotify process regex-posix time + unix unordered-containers + ]; + doHaddock = false; + doCheck = false; + description = "Multi-file, colored, filtered log tailer"; + license = stdenv.lib.licenses.bsd3; + }) {}; + }; +in compiler.override { + initialPackages = stackPackages; + configurationCommon = { ... }: self: super: {}; + compilerConfig = self: super: {}; +}