hackage-packages.nix: update to https://github.com/commercialhaskell/all-cabal-files/commit/1f18eb65463817b88fed29ee1560a3ec95a562a4 with hackage2nix revision v20150807-5-g2b9cf46

pkgs/development/haskell-modules/hackage-packages.nix

···
     ({ mkDerivation, allocated-processor, base, opencv, vector-space }:
      mkDerivation {
        pname = "HOpenCV";
-       version = "0.1.2.4";
-       sha256 = "1q32rcrzv79z125sbjlzhd4sl1pl8if01vrwd7y18s3acs3aqr4b";
+       version = "0.3.0.1";
+       sha256 = "0v9pcbbfj254n6mryb16rplh6mgjizdm4c8qqdsb41gdpx1h59n6";
        isLibrary = true;
        isExecutable = true;
        libraryHaskellDepends = [ allocated-processor base vector-space ];
···
        executableHaskellDepends = [ base ];
        executablePkgconfigDepends = [ opencv ];
        description = "A binding for the OpenCV computer vision library";
-       license = stdenv.lib.licenses.bsd3;
+       license = stdenv.lib.licenses.gpl2;
      }) { inherit (pkgs) opencv;};
 
   "HPDF" = callPackage
···
      }:
      mkDerivation {
        pname = "cabal-helper";
-       version = "0.3.7.0";
-       sha256 = "1lq8i45wvk8rqilay7j9i9iv5irhqvdg3bp96mj2xxaxrpfi7l20";
+       version = "0.3.8.0";
+       sha256 = "1l2ign8q4kdsnypqvjl8x152lkb0s1zfn08vshirz2qf4v5wxs3n";
        isLibrary = true;
        isExecutable = true;
        libraryHaskellDepends = [
···
        description = "the Computer Algebra SHell";
        license = stdenv.lib.licenses.bsd3;
        hydraPlatforms = stdenv.lib.platforms.none;
+     }) {};
+
+  "casing" = callPackage
+    ({ mkDerivation, base, split }:
+     mkDerivation {
+       pname = "casing";
+       version = "0.1.0.0";
+       sha256 = "0d7frpz512gig2crpx3kxsnfwf3kbcklkann158wrzg8q02jhjhi";
+       libraryHaskellDepends = [ base split ];
+       description = "Convert between various source code casing conventions";
+       license = stdenv.lib.licenses.mit;
      }) {};
 
   "cassandra-cql" = callPackage
···
     ({ mkDerivation, base, tagged, void }:
      mkDerivation {
        pname = "constrained-categories";
-       version = "0.2.0.0";
-       sha256 = "1mh61gfydh068qws3r52rbnw30ihi9k88wklx8p18j43c7jngamx";
+       version = "0.2.1.1";
+       sha256 = "0m4c2kva0djxhiqnbxbnlrkq10wvzpbjbbvjv3mz9b550sxr6azy";
        libraryHaskellDepends = [ base tagged void ];
        homepage = "https://github.com/leftaroundabout/constrained-categories";
        description = "Constrained clones of the category-theory type classes, using ConstraintKinds";
···
      }) {};
 
   "cv-combinators" = callPackage
-    ({ mkDerivation, allocated-processor, base
-     , graphics-drawingcombinators, HOpenCV, SDL, vector-space
+    ({ mkDerivation, allocated-processor, base, HOpenCV, vector-space
      }:
      mkDerivation {
        pname = "cv-combinators";
-       version = "0.1.2.3";
-       sha256 = "1bdhs4dy9yfgc9j281rxiiy9md3s27yy44scz86s29vbm7prccvp";
+       version = "0.1.3";
+       sha256 = "1lak96kr1fpsrqcvgv9k0igd5w2f42hv20f2mw8cvr0q0xwzc9zb";
        isLibrary = true;
        isExecutable = true;
        libraryHaskellDepends = [
          allocated-processor base HOpenCV vector-space
        ];
        executableHaskellDepends = [
-         allocated-processor base graphics-drawingcombinators HOpenCV SDL
-         vector-space
+         allocated-processor base HOpenCV vector-space
        ];
        description = "Functional Combinators for Computer Vision";
-       license = stdenv.lib.licenses.bsd3;
+       license = stdenv.lib.licenses.gpl2;
      }) {};
 
   "cyclotomic" = callPackage
···
          network network-multicast network-transport network-transport-tcp
          transformers
        ];
+       jailbreak = true;
        homepage = "http://haskell-distributed.github.com";
        description = "Simple zero-configuration backend for Cloud Haskell";
        license = stdenv.lib.licenses.bsd3;
···
        hydraPlatforms = stdenv.lib.platforms.none;
      }) {};
 
+  "formattable" = callPackage
+    ({ mkDerivation, base, bytestring, data-default-class
+     , double-conversion, hspec, HUnit, lens, old-locale, QuickCheck
+     , text, time
+     }:
+     mkDerivation {
+       pname = "formattable";
+       version = "0.1.1";
+       sha256 = "0brp1j21ll6g266zyzknqc20k5nf3na97fjbh66hjbsw6yxah5x7";
+       libraryHaskellDepends = [
+         base bytestring data-default-class old-locale text time
+       ];
+       testHaskellDepends = [
+         base bytestring data-default-class double-conversion hspec HUnit
+         lens old-locale QuickCheck text time
+       ];
+       homepage = "https://github.com/Soostone/formattable";
+       description = "Business-quality formatting of numbers, dates, and other things";
+       license = stdenv.lib.licenses.bsd3;
+     }) {};
+
   "formatting" = callPackage
     ({ mkDerivation, base, clock, old-locale, scientific, text
      , text-format, time
···
      }:
      mkDerivation {
        pname = "github-backup";
-       version = "1.20150618";
-       sha256 = "110nivss9436ls2mr5bl0m6fzg6ds5m0ams803zq60b8dya96wic";
+       version = "1.20150807";
+       sha256 = "19x8716wdhrj3nv4pgz4ncmnfnids8wjirkp3jkw5sd6fnx6q8sj";
        isLibrary = false;
        isExecutable = true;
        executableHaskellDepends = [
···
        pname = "hadoop-formats";
        version = "0.2.1.1";
        sha256 = "1w3869jz3mxhzdik5fwaha7dn9rhjg5w8g0qnznd4x45cnzxv5ga";
+       revision = "1";
+       editedCabalFile = "59248cb9b3f28b9f003d694ee356a13ff1313c8edd3bf2963c154ce7e1de0553";
        libraryHaskellDepends = [ attoparsec base bytestring text vector ];
        librarySystemDepends = [ snappy ];
        testHaskellDepends = [ base bytestring filepath text vector ];
-       jailbreak = true;
        homepage = "http://github.com/jystic/hadoop-formats";
        description = "Read/write file formats commonly used by Hadoop";
        license = stdenv.lib.licenses.asl20;
···
      }:
      mkDerivation {
        pname = "hasql-postgres";
-       version = "0.10.3.3";
-       sha256 = "0xwc1r7jirscsn1f11s7hkhc5knzzhb5l6if7c5w4skfx0vla7rh";
+       version = "0.10.4.0";
+       sha256 = "0s2ng84m7mals3wm3lzmhfd9xlh8fm231gklzjyh6q7z5yw4yszf";
        libraryHaskellDepends = [
          aeson attoparsec base-prelude bytestring either free hashable
          hashtables hasql-backend list-t loch-th mmorph placeholders
···
      }:
      mkDerivation {
        pname = "haste-compiler";
-       version = "0.5.0";
-       sha256 = "18n9sl9m2fpzshpj3gqvd7wlmvz5mrgsz8awcd3imcb7136qa9s9";
+       version = "0.5.0.1";
+       sha256 = "14kqrkjhfxzg0gv4v2kzxh938085bmzg426vp2jrhzvf5dzypkh0";
        configureFlags = [ "-fportable" ];
        isLibrary = true;
        isExecutable = true;
···
     ({ mkDerivation, base, containers, directory, unix }:
      mkDerivation {
        pname = "hinotify";
-       version = "0.3.7";
-       sha256 = "0i7mxg9ilzcgijda6j3ya5xnpbxa3wm9xswdfif95jim9w82sw0b";
+       version = "0.3.8";
+       sha256 = "13xjhbx3b6icqf7451dzknxz41lb874a9s3zs0h0c19p902ii9ff";
        libraryHaskellDepends = [ base containers directory unix ];
+       testHaskellDepends = [ base directory ];
        homepage = "https://github.com/kolmodin/hinotify.git";
        description = "Haskell binding to inotify";
        license = stdenv.lib.licenses.bsd3;
···
        testHaskellDepends = [ base process ];
        description = "Low-level bindings to libgit2";
        license = stdenv.lib.licenses.mit;
-       hydraPlatforms = stdenv.lib.platforms.none;
      }) { inherit (pkgs) openssl;};
 
   "hlibsass" = callPackage
···
     ({ mkDerivation, aeson, aeson-pretty, array, attoparsec, base
      , bin-package-db, bytestring, Cabal, containers, deepseq, directory
      , exceptions, filepath, fsnotify, ghc, ghc-mod, ghc-paths
-     , haddock-api, haskell-src-exts, hdocs, hlint, HTTP, lens
-     , lifted-base, monad-control, monad-loops
+     , ghc-syb-utils, haddock-api, haskell-src-exts, hdocs, hlint, HTTP
+     , lens, lifted-base, monad-control, monad-loops
      , MonadCatchIO-transformers, mtl, network, process
-     , regex-pcre-builtin, scientific, simple-log, system-filepath
-     , template-haskell, text, time, transformers, transformers-base
-     , uniplate, unix, unordered-containers, vector
+     , regex-pcre-builtin, scientific, simple-log, syb, template-haskell
+     , text, time, transformers, transformers-base, uniplate, unix
+     , unordered-containers, vector
      }:
      mkDerivation {
        pname = "hsdev";
-       version = "0.1.4.1";
-       sha256 = "180xrxamas2fg2366k3cpy7al8mq82d1hgjrs7i1r2s3gr877xz8";
+       version = "0.1.4.2";
+       sha256 = "1l2pm2p0k2m8aln6an3kxswcalc7w72v7mxs5fzq0nfy60iphcys";
        isLibrary = true;
        isExecutable = true;
        libraryHaskellDepends = [
          aeson aeson-pretty array attoparsec base bin-package-db bytestring
          Cabal containers deepseq directory exceptions filepath fsnotify ghc
-         ghc-mod ghc-paths haddock-api haskell-src-exts hdocs hlint HTTP
-         lens lifted-base monad-control monad-loops
+         ghc-mod ghc-paths ghc-syb-utils haddock-api haskell-src-exts hdocs
+         hlint HTTP lens lifted-base monad-control monad-loops
          MonadCatchIO-transformers mtl network process regex-pcre-builtin
-         scientific simple-log system-filepath template-haskell text time
-         transformers transformers-base uniplate unix unordered-containers
-         vector
+         scientific simple-log syb template-haskell text time transformers
+         transformers-base uniplate unix unordered-containers vector
        ];
        executableHaskellDepends = [
          aeson aeson-pretty base bytestring containers deepseq directory
···
      }:
      mkDerivation {
        pname = "html-tokenizer";
-       version = "0.3.0.3";
-       sha256 = "0xdjjmpp1wh17cb4lnziglwhv7frr0y5v216s5ycy9lkby9r9fyv";
+       version = "0.4.0.0";
+       sha256 = "0a44jxw90hk1i3h8j1vk8rjz3z91z9gdszyjbkngnpnfwrdhfrw7";
        libraryHaskellDepends = [
          attoparsec base-prelude case-insensitive conversion
          conversion-case-insensitive conversion-text text
···
        testHaskellDepends = [
          base base-prelude directory doctest filepath
        ];
-       jailbreak = true;
        homepage = "https://github.com/nikita-volkov/html-tokenizer";
        description = "An \"attoparsec\"-based HTML tokenizer";
        license = stdenv.lib.licenses.mit;
···
        license = stdenv.lib.licenses.publicDomain;
      }) {};
 
+  "http-listen" = callPackage
+    ({ mkDerivation, base, bytestring, exceptions, HTTP, network
+     , transformers
+     }:
+     mkDerivation {
+       pname = "http-listen";
+       version = "0.1.0.0";
+       sha256 = "1ccm4lzlngcw7hp4rvk2d85zg5725pj01mzavl3zx140i6w0psz0";
+       revision = "1";
+       editedCabalFile = "3fcb0a5c155c41513cf81c4cd5058be331d56aed083a3f42892feef452a0cd8b";
+       libraryHaskellDepends = [
+         base bytestring exceptions HTTP network transformers
+       ];
+       homepage = "http://rel4tion.org/projects/http-listen/";
+       description = "Listen to HTTP requests and handle them in arbitrary ways";
+       license = stdenv.lib.licenses.publicDomain;
+     }) {};
+
   "http-media" = callPackage
     ({ mkDerivation, base, bytestring, case-insensitive, containers
      , QuickCheck, test-framework, test-framework-quickcheck2
···
      , bytestring-trie, Cabal-ide-backend, containers, crypto-api
      , data-accessor, data-accessor-mtl, deepseq, directory
      , executable-path, filemanip, filepath, fingertree, ghc-prim, HUnit
-     , ide-backend-common, mtl, pretty-show, process, pureMD5, random
-     , regex-compat, stm, tagged, tasty, template-haskell, temporary
-     , test-framework, test-framework-hunit, text, time, transformers
-     , unix, unordered-containers, utf8-string
+     , ide-backend-common, monads-tf, mtl, parallel, pretty-show
+     , process, pureMD5, random, regex-compat, stm, tagged, tasty
+     , template-haskell, temporary, test-framework, test-framework-hunit
+     , text, time, transformers, unix, unordered-containers, utf8-string
      }:
      mkDerivation {
        pname = "ide-backend";
-       version = "0.9.0.11";
-       sha256 = "06ip0yq8vb8i0qcz2l7z4s1myxm6ix3l44gmjpvspj9vwlsrfxpp";
+       version = "0.10.0";
+       sha256 = "18p079m9hfi4mbhyp8fhlhzlvhdpr9v82ih49s1630rxaf15z8r6";
        isLibrary = true;
        isExecutable = true;
        libraryHaskellDepends = [
···
        testHaskellDepends = [
          aeson async base binary bytestring Cabal-ide-backend containers
          deepseq directory executable-path filemanip filepath HUnit
-         ide-backend-common process random regex-compat stm tagged tasty
-         template-haskell temporary test-framework test-framework-hunit text
-         unix utf8-string
+         ide-backend-common monads-tf parallel process random regex-compat
+         stm tagged tasty template-haskell temporary test-framework
+         test-framework-hunit text unix utf8-string
        ];
        description = "An IDE backend library";
        license = stdenv.lib.licenses.mit;
···
   "ide-backend-common" = callPackage
     ({ mkDerivation, aeson, async, attoparsec, base, binary, bytestring
      , bytestring-trie, containers, crypto-api, data-accessor, directory
-     , filepath, fingertree, mtl, pretty-show, pureMD5, tagged
-     , template-haskell, temporary, text, transformers, unix
+     , filepath, fingertree, monad-logger, mtl, pretty-show, pureMD5
+     , tagged, template-haskell, temporary, text, transformers, unix
      }:
      mkDerivation {
        pname = "ide-backend-common";
-       version = "0.9.1.3";
-       sha256 = "11dnm1ibgibrjkxigzh9l442npb2br5rchahm6gza88imy3xcd96";
+       version = "0.10.0";
+       sha256 = "1x230hvxr5n8d04q9cdjryalrp47q9vsamgd0qafw1x25ar1fxwl";
        libraryHaskellDepends = [
          aeson async attoparsec base binary bytestring bytestring-trie
          containers crypto-api data-accessor directory filepath fingertree
-         mtl pretty-show pureMD5 tagged template-haskell temporary text
-         transformers unix
+         monad-logger mtl pretty-show pureMD5 tagged template-haskell
+         temporary text transformers unix
        ];
        description = "Shared library used be ide-backend and ide-backend-server";
        license = stdenv.lib.licenses.mit;
···
 
   "ide-backend-server" = callPackage
     ({ mkDerivation, array, async, base, bytestring, Cabal, containers
-     , data-accessor, data-accessor-mtl, directory, filemanip, filepath
-     , ghc, haddock-api, ide-backend-common, mtl, process, temporary
-     , text, time, transformers, unix, unordered-containers
+     , data-accessor, data-accessor-mtl, directory, file-embed
+     , filemanip, filepath, ghc, haddock-api, ide-backend-common, mtl
+     , process, tar, temporary, text, time, transformers, unix
+     , unordered-containers, zlib
      }:
      mkDerivation {
        pname = "ide-backend-server";
-       version = "0.9.0";
-       sha256 = "0kljg5dpcxhk4dr8mi5ywb0ykygqm9p89rinyk1i2fqdcvza89rm";
+       version = "0.10.0";
+       sha256 = "1kahc57f5jrz7869phzlbk6y3apwyh3j6k8b7xbyfcc4qwq6jgry";
        isLibrary = false;
        isExecutable = true;
        executableHaskellDepends = [
          array async base bytestring Cabal containers data-accessor
-         data-accessor-mtl directory filemanip filepath ghc haddock-api
-         ide-backend-common mtl process temporary text time transformers
-         unix unordered-containers
+         data-accessor-mtl directory file-embed filemanip filepath ghc
+         haddock-api ide-backend-common mtl process tar temporary text time
+         transformers unix unordered-containers zlib
        ];
        description = "An IDE backend server";
        license = stdenv.lib.licenses.mit;
···
      }) {};
 
   "json-rpc" = callPackage
-    ({ mkDerivation, aeson, async, attoparsec, base, bytestring
-     , conduit, conduit-extra, deepseq, hashable, mtl, QuickCheck, stm
-     , stm-conduit, test-framework, test-framework-quickcheck2, text
-     , transformers, unordered-containers
+    ({ mkDerivation, aeson, attoparsec, base, bytestring, conduit
+     , conduit-extra, deepseq, hashable, lifted-async, monad-control
+     , monad-logger, mtl, QuickCheck, stm, stm-conduit, test-framework
+     , test-framework-quickcheck2, text, transformers
+     , unordered-containers
      }:
      mkDerivation {
        pname = "json-rpc";
-       version = "0.2.1.6";
-       sha256 = "1y9c95qbvkg0r75y4dd0fvcy5r0bj08pklf7hl052ncwm87l9hln";
+       version = "0.6.0.0";
+       sha256 = "0ld8r5zln9a18vzgpiylifzbpiivv8icalqg1l1863kgirgsz2hg";
        libraryHaskellDepends = [
-         aeson async attoparsec base bytestring conduit conduit-extra
-         deepseq hashable mtl stm stm-conduit text transformers
-         unordered-containers
+         aeson attoparsec base bytestring conduit conduit-extra deepseq
+         hashable lifted-async monad-control monad-logger mtl QuickCheck stm
+         stm-conduit text transformers unordered-containers
        ];
        testHaskellDepends = [
-         aeson async base bytestring conduit conduit-extra deepseq hashable
-         mtl QuickCheck stm stm-conduit test-framework
+         aeson base bytestring conduit lifted-async monad-logger mtl
+         QuickCheck stm stm-conduit test-framework
          test-framework-quickcheck2 text unordered-containers
        ];
-       jailbreak = true;
        homepage = "https://github.com/xenog/json-rpc";
        description = "Fully-featured JSON-RPC 2.0 library";
        license = stdenv.lib.licenses.publicDomain;
···
      }:
      mkDerivation {
        pname = "json-schema";
-       version = "0.7.3.7";
-       sha256 = "0lrr5zhydb2g36xlpr3mhn0m6bz138gbm0zih3f3qamnsm21mjk5";
-       revision = "1";
-       editedCabalFile = "94b50ebb4b1aa921270db172dbef2ed18c85846d147d1526ec9c85ea0be1705a";
+       version = "0.7.4.0";
+       sha256 = "073hs9wmpmv7b07s7by9r6hjcwn7bjhwyf256f2xiz4y355zljf5";
        libraryHaskellDepends = [
          aeson base containers generic-aeson generic-deriving mtl scientific
          text time unordered-containers vector
···
          keera-hails-reactivevalues MissingK mtl network process SDL
          SDL-mixer setlocale time utf8-string
        ];
+       jailbreak = true;
        homepage = "http://keera.co.uk/projects/keera-posture";
        description = "Get notifications when your sitting posture is inappropriate";
        license = "unknown";
···
      }:
      mkDerivation {
        pname = "llvm-general";
-       version = "3.4.5.3";
-       sha256 = "03rps9ga20cdqfh2khqnahwrkljs714ac7yx9x7krb3dngf83zsm";
+       version = "3.4.5.4";
+       sha256 = "1zfixhvwagvznrvnxzrb9fzkswa43mj1nmbpmx87888q8z9m31j0";
        libraryHaskellDepends = [
          array base bytestring containers llvm-general-pure mtl parsec
          setenv template-haskell transformers transformers-compat
···
      }:
      mkDerivation {
        pname = "llvm-general-pure";
-       version = "3.4.5.3";
-       sha256 = "1b3zh2y3b3jj5sg6421wv2qsrhyjs23qdzrk693r7mpj10rd258k";
+       version = "3.4.5.4";
+       sha256 = "0kc4f431j65qfsa54a17y3m82a8xf3dmd3hzr8mj514jz4wv6jn5";
        libraryHaskellDepends = [
          base containers mtl parsec setenv template-haskell transformers
          transformers-compat
···
     ({ mkDerivation, array, base }:
      mkDerivation {
        pname = "logfloat";
-       version = "0.13.3.1";
-       sha256 = "0rqnp2zkp247sb3parn3ywsk9clasy4l906a1wyrrybc3p72126s";
+       version = "0.13.3.2";
+       sha256 = "092c9xviq9gsr3q25q254x9kdl80lfssbwjyvi8rrv1300nw7h4c";
        libraryHaskellDepends = [ array base ];
        homepage = "http://code.haskell.org/~wren/";
        description = "Log-domain floating point numbers";
···
     ({ mkDerivation, base, hspec, template-haskell, transformers }:
      mkDerivation {
        pname = "logging-facade";
-       version = "0.0.0";
-       sha256 = "0i7m4dpj7b556bfiahisvxcvdb1lv352zggjyrcr69iqnrac30z8";
-       revision = "1";
-       editedCabalFile = "18d32076d981102462c3f24c95c6d9dc2470be80f5f36f99759cb23cc3db2d24";
+       version = "0.1.0";
+       sha256 = "0zhdbjyj0j9by19rma9alxysrxnnl3s4kks4zk4bx0dg5xa0264y";
        libraryHaskellDepends = [ base template-haskell transformers ];
        testHaskellDepends = [ base hspec ];
-       description = "Simple logging abstraction that allows multiple backends";
+       description = "Simple logging abstraction that allows multiple back-ends";
        license = stdenv.lib.licenses.mit;
      }) {};
 
···
 
   "manifolds" = callPackage
     ({ mkDerivation, base, comonad, constrained-categories, containers
-     , MemoTrie, MonadRandom, random, semigroups, tagged, transformers
+     , deepseq, hmatrix, MemoTrie, semigroups, tagged, transformers
      , vector, vector-algorithms, vector-space, void
      }:
      mkDerivation {
        pname = "manifolds";
-       version = "0.1.0.2";
-       sha256 = "05ysr2rmjc0rqgy409qcga8j748l0w322vxbjdw9yyhcp2kbrv14";
+       version = "0.1.3.0";
+       sha256 = "17i77nhp65ikgyz0yif6i1pnj65da38mnx87yy96wkcdlad3zivj";
+       revision = "1";
+       editedCabalFile = "2495967b40c73a494475058072f59fc2c730c655bfb6861c5d0c2f51531a0060";
        libraryHaskellDepends = [
-         base comonad constrained-categories containers MemoTrie MonadRandom
-         random semigroups tagged transformers vector vector-algorithms
+         base comonad constrained-categories containers deepseq hmatrix
+         MemoTrie semigroups tagged transformers vector vector-algorithms
          vector-space void
        ];
+       jailbreak = true;
+       homepage = "https://github.com/leftaroundabout/manifolds";
        description = "Working with manifolds in a direct, embedding-free way";
        license = stdenv.lib.licenses.gpl3;
        hydraPlatforms = stdenv.lib.platforms.none;
···
     ({ mkDerivation, base }:
      mkDerivation {
        pname = "microlens";
-       version = "0.1.3.0";
-       sha256 = "1ryjxc3qa583ryp9sig3rjjr3dpv9sx2ybag4qrlkwja1dz8r2dm";
+       version = "0.2.0.0";
+       sha256 = "08m0qcsazq690w1k6hd2h3z8w47bqc01s53j6qbf3jbfin28axbg";
        libraryHaskellDepends = [ base ];
        homepage = "http://github.com/aelve/microlens";
        description = "A tiny part of the lens library which you can depend upon";
···
        version = "0.1.0.0";
        sha256 = "00bk2vriwh8aj2c6n5g2w84pfq0nssfa62iw97dm9c3zkp558wxj";
        libraryHaskellDepends = [ base microlens ];
+       jailbreak = true;
        homepage = "http://github.com/aelve/microlens";
        description = "'each' for microlens";
        license = stdenv.lib.licenses.bsd3;
      }) {};
 
+  "microlens-ghc" = callPackage
+    ({ mkDerivation, array, base, bytestring, containers, microlens }:
+     mkDerivation {
+       pname = "microlens-ghc";
+       version = "0.1.0.1";
+       sha256 = "17kkh6dnxhr2j1a9nll5ia0y5rd68icxjjk4kqs0wml1whmhhg55";
+       libraryHaskellDepends = [
+         array base bytestring containers microlens
+       ];
+       homepage = "http://github.com/aelve/microlens";
+       description = "Orphan instances of microlens classes for packages coming with GHC (array, bytestring, containers)";
+       license = stdenv.lib.licenses.bsd3;
+     }) {};
+
   "microlens-mtl" = callPackage
     ({ mkDerivation, base, microlens, mtl, transformers
      , transformers-compat
      }:
      mkDerivation {
        pname = "microlens-mtl";
-       version = "0.1.2.0";
-       sha256 = "1jvw9pspnr24rh7bvl6q7hv7x0g6vwy2a5xl19pxf36rl8wlfm9v";
+       version = "0.1.3.1";
+       sha256 = "118ym5n1c6b2lg815hikzbwc4bnz8kz3j4flfxwq3m50dbn29vzc";
        libraryHaskellDepends = [
          base microlens mtl transformers transformers-compat
        ];
···
     ({ mkDerivation, base, containers, microlens, template-haskell }:
      mkDerivation {
        pname = "microlens-th";
-       version = "0.2.0.0";
-       sha256 = "048q6ridxvg7zi272q01k6ds0f411kg27p5whgj63qgg3k9w72sp";
+       version = "0.2.1.0";
+       sha256 = "1l4hxkq8z8h6pvld54bjlnzy5g30wr0akv1xjrjyk552mfi9gwvl";
        libraryHaskellDepends = [
          base containers microlens template-haskell
        ];
···
      }) {};
 
   "moesocks" = callPackage
-    ({ mkDerivation, aeson, attoparsec, base, binary, bytestring
+    ({ mkDerivation, aeson, async, attoparsec, base, binary, bytestring
      , containers, cryptohash, hslogger, HsOpenSSL, lens, mtl, network
-     , optparse-applicative, random, safe, text, transformers, unix
+     , optparse-applicative, random, safe, stm, text, transformers, unix
      , unordered-containers
      }:
      mkDerivation {
        pname = "moesocks";
-       version = "0.1.0.8";
-       sha256 = "1f09sf41kbza3mci2yps0b38xi2j5gakjqx9hmi7lfzga4dkqgg0";
+       version = "0.1.0.10";
+       sha256 = "0cv741gcbjcd4gvqbiys40dh8y553cy6rxhpz0bvdv8xv4qfsz47";
        isLibrary = false;
        isExecutable = true;
        executableHaskellDepends = [
-         aeson attoparsec base binary bytestring containers cryptohash
+         aeson async attoparsec base binary bytestring containers cryptohash
          hslogger HsOpenSSL lens mtl network optparse-applicative random
-         safe text transformers unix unordered-containers
+         safe stm text transformers unix unordered-containers
        ];
        homepage = "https://github.com/nfjinjing/moesocks";
        description = "moe for all";
···
     ({ mkDerivation, base, mmorph, mtl, transformers }:
      mkDerivation {
        pname = "monad-resumption";
-       version = "0.1.1.5";
-       sha256 = "08h750qbvzvlw5hyp1d44rkhiqlhgnsfy8sya2ya7p62l80w96sf";
+       version = "0.1.2.0";
+       sha256 = "09yz5cbvjlmqdlr25adxggpdz52jxyryyyrzix1pkdjr6aqpidkr";
        libraryHaskellDepends = [ base mmorph mtl transformers ];
        homepage = "https://github.com/igraves/resumption_monads";
        description = "Resumption and reactive resumption monads for Haskell";
···
      }) {};
 
   "mtl-unleashed" = callPackage
-    ({ mkDerivation, base, mtl }:
+    ({ mkDerivation, base, contravariant, hspec, hspec-core, lens, mtl
+     , profunctors
+     }:
      mkDerivation {
        pname = "mtl-unleashed";
-       version = "0.2.2";
-       sha256 = "0ih03zznq8mf8c76ic43j3vana6127bh6hxfz549g5kv9h54y83h";
-       libraryHaskellDepends = [ base mtl ];
+       version = "0.3";
+       sha256 = "1rirgbs4b7q7yjnvdw1j2y6nmym47adm8lcl0xysxi2hhhvs8r9c";
+       libraryHaskellDepends = [
+         base contravariant lens mtl profunctors
+       ];
+       testHaskellDepends = [
+         base contravariant hspec hspec-core lens mtl profunctors
+       ];
        homepage = "https://github.com/seereason/mtl-unleashed";
        description = "MTL classes without the functional dependency";
        license = stdenv.lib.licenses.bsd3;
···
        homepage = "http://github.com/jsnajder/multex-east-msd";
        description = "MULTEXT-East morphosyntactic descriptors";
        license = stdenv.lib.licenses.bsd3;
+     }) {};
+
+  "multi-cabal" = callPackage
+    ({ mkDerivation, AAI, aeson, base, bytestring, directory, filepath
+     , HUnit, mtl, process, strict, test-framework, test-framework-hunit
+     }:
+     mkDerivation {
+       pname = "multi-cabal";
+       version = "0.1.0.0";
+       sha256 = "0qzphh4pmrdqanv9sjy0ipf3z775xvrvdyagd0291vv1mqkbbz3g";
+       isLibrary = true;
+       isExecutable = true;
+       libraryHaskellDepends = [ aeson base filepath mtl ];
+       executableHaskellDepends = [
+         AAI aeson base bytestring directory filepath process strict
+       ];
+       testHaskellDepends = [
+         base HUnit test-framework test-framework-hunit
+       ];
+       homepage = "https://github.com/aka-bash0r/multi-cabal";
+       description = "A tool supporting multi cabal project builds";
+       license = stdenv.lib.licenses.mit;
      }) {};
 
   "multiarg" = callPackage
···
     ({ mkDerivation, base, network }:
      mkDerivation {
        pname = "network-multicast";
-       version = "0.0.11";
-       sha256 = "0fgscv9crk2lx99rh234ipgl5psbrjili95inxj23drvwmsj3135";
+       version = "0.1.0";
+       sha256 = "12kswjqg4xv7gdjqabbyr7wvqkkzsyga3fjxnv9z9fdmil7xphhq";
        libraryHaskellDepends = [ base network ];
        description = "Simple multicast library";
        license = stdenv.lib.licenses.publicDomain;
···
        license = stdenv.lib.licenses.bsd3;
      }) {};
 
+  "nurbs" = callPackage
+    ({ mkDerivation, base, base-unicode-symbols, hspec, lens, linear
+     , mtl
+     }:
+     mkDerivation {
+       pname = "nurbs";
+       version = "0.1.0.0";
+       sha256 = "1rxg0d8j6srhw5mq0i6ma9dyqrx3h1c15pv3gj8brh8ghjw9z1wi";
+       libraryHaskellDepends = [
+         base base-unicode-symbols lens linear mtl
+       ];
+       testHaskellDepends = [
+         base base-unicode-symbols hspec lens linear
+       ];
+       homepage = "https://github.com/mvoidex/nurbs";
+       description = "NURBS";
+       license = stdenv.lib.licenses.bsd3;
+     }) {};
+
   "nvim-hs" = callPackage
     ({ mkDerivation, base, bytestring, cereal, cereal-conduit, conduit
      , conduit-extra, containers, data-default, directory, dyre
···
      }:
      mkDerivation {
        pname = "rei";
-       version = "0.2.0.0";
-       sha256 = "17ldmx351b54fxmiw3z89v7cs6p33x09k2aav7jphqgv2520phyv";
+       version = "0.3.0.0";
+       sha256 = "03dd4miy0r2mkh603f1p7f93mgxqhfkz8gfk6b4macqcw5pvi3vf";
        isLibrary = false;
        isExecutable = true;
        executableHaskellDepends = [
···
     ({ mkDerivation, array, base, ghc, ghc-paths, json, network }:
      mkDerivation {
        pname = "remote-debugger";
-       version = "0.2.1";
-       sha256 = "0mgq2n92d4xk6yqzrbghlp0h18nmkyhxnv5zynrqykfw5h9xl0f8";
+       version = "0.2.2";
+       sha256 = "1c6xh390963hk7q2qvhqb6yma5ma7hk39nxjikizwh7s2h9vi9k4";
        isLibrary = false;
        isExecutable = true;
        executableHaskellDepends = [
          array base ghc ghc-paths json network
        ];
-       jailbreak = true;
        homepage = "https://github.com/octomarat/HaskellDebugger";
        description = "Interface to ghci debugger";
        license = stdenv.lib.licenses.bsd3;
···
      }:
      mkDerivation {
        pname = "smallcheck-series";
-       version = "0.3";
-       sha256 = "1vdwafwdv38n1bvjf1rybfhh42a0q0g0g4wmw0v4fgxh73qndfdv";
+       version = "0.4";
+       sha256 = "05iixqnq9mfqc2gbwxnhx640apbppck8zb8akkwz1linlypvym60";
        libraryHaskellDepends = [
          base bytestring containers logict smallcheck text transformers
        ];
···
        sha256 = "0i1b4lgwv98pp7251fm3h4cdb1d868fqwm6175rk7zg699g2v61y";
      mkDerivation {
        sha256 = "0i1b4lgwv98pp7251fm3h4cdb1d868fqwm6175rk7zg699g2v61y";
-       sha256 = "0i1b4lgwv98pp7251fm3h4cdb1d868fqwm6175rk7zg699g2v61y";
-       sha256 = "0i1b4lgwv98pp7251fm3h4cdb1d868fqwm6175rk7zg699g2v61y";
+       version = "0.1.6.5";
+       sha256 = "0yi3fagwqkgr8pf6wnl360qikyvfb649qs2y6gp0n7jjw0zc27c2";
        sha256 = "0i1b4lgwv98pp7251fm3h4cdb1d868fqwm6175rk7zg699g2v61y";
-       jailbreak = true;
        sha256 = "0i1b4lgwv98pp7251fm3h4cdb1d868fqwm6175rk7zg699g2v61y";
        sha256 = "0i1b4lgwv98pp7251fm3h4cdb1d868fqwm6175rk7zg699g2v61y";
        license = stdenv.lib.licenses.bsd3;
···
      }:
      mkDerivation {
        pname = "th-typegraph";
-       version = "0.27";
-       sha256 = "1v7vic9kfig9flcnqcpzazd1s4wgqiz3mj9gcyc1ijkrd4y83cdr";
+       version = "0.28";
+       sha256 = "0dwkhrrcb5n3n06dr0ck613yr3j6f05sldnvrkb654xm69pw1qfc";
        libraryHaskellDepends = [
          base base-compat containers data-default haskell-src-exts lens mtl
          mtl-unleashed set-extra syb template-haskell th-desugar th-orphans
···
 
   "thyme" = callPackage
     ({ mkDerivation, aeson, attoparsec, base, bytestring, Cabal
-     , containers, deepseq, directory, filepath, mtl, old-locale
+     , containers, cpphs, deepseq, directory, filepath, mtl, old-locale
      , profunctors, QuickCheck, random, system-posix-redirect, text
      , time, vector, vector-space, vector-th-unbox
      }:
···
          profunctors QuickCheck random text time vector vector-space
          vector-th-unbox
        ];
+       libraryToolDepends = [ cpphs ];
        testHaskellDepends = [
          attoparsec base bytestring Cabal containers directory filepath mtl
          old-locale profunctors QuickCheck random system-posix-redirect text
···
        homepage = "https://github.com/liyang/thyme";
        description = "A faster time library";
        license = stdenv.lib.licenses.bsd3;
-       hydraPlatforms = stdenv.lib.platforms.none;
      }) {};
 
   "tianbar" = callPackage
···
      }:
      mkDerivation {
        pname = "tidal-midi";
-       version = "0.0.2";
-       sha256 = "0q3g4qgzpd8p4z3l1npcs0gy14967l3yn4xqingdbcq22xasim6q";
+       version = "0.1";
+       sha256 = "04d5xfr57rw22jq62iil6sa9drya6z545hcm1fx98jrkcyglb10c";
        libraryHaskellDepends = [
          base bytestring containers hashable hosc PortMidi process tidal
          time
···
      }:
      mkDerivation {
        pname = "uhc-util";
-       version = "0.1.5.6";
-       sha256 = "1axg2apkvg3xk1cq78shbnc68i0h6fqcpjg8z3l4nc49kl5dywwz";
+       version = "0.1.6.0";
+       sha256 = "1ndnmk8rfa8hwp72hgh6xx043lf59a8k50cqjm8bibfpd7fl31hj";
        libraryHaskellDepends = [
          array base binary bytestring containers directory fclabels fgl
          hashable ListLike mtl process syb time time-compat uulib
···
     ({ mkDerivation, base, QtWebKit, wai, warp }:
      mkDerivation {
        pname = "wai-handler-webkit";
-       version = "3.0.0.1";
-       sha256 = "1fm985jq1sa8v3vj850cpcjl6kcyq2kgq6xwpb1rmzi8zmb80kpc";
+       sha256 = "0i1b4lgwv98pp7251fm3h4cdb1d868fqwm6175rk7zg699g2v61y";
+       sha256 = "0y7di5pnrri4dkqi8lx4gfksfpbqfwax1wjp1ijc5cw6p34mmzcs";
        libraryHaskellDepends = [ base wai warp ];
        libraryPkgconfigDepends = [ QtWebKit ];
-       jailbreak = true;
        homepage = "https://github.com/yesodweb/wai/tree/master/wai-handler-webkit";
        description = "Turn WAI applications into standalone GUIs using QtWebkit";
        license = stdenv.lib.licenses.mit;
···
        pname = "xmonad-contrib";
        version = "0.11.4";
        sha256 = "1g5cw9vvnfbiyi599fngk02zlmdhrf82x0bndhypkn6kybab6yd3";
+       revision = "1";
+       editedCabalFile = "0280216420efaa06de7080d5998a24e27166e8b2c3d8a012846d004799c5edf2";
        libraryHaskellDepends = [
          base containers directory extensible-exceptions mtl old-locale
          old-time process random unix utf8-string X11 X11-xft xmonad