diff --git a/doc/languages-frameworks/haskell.section.md b/doc/languages-frameworks/haskell.section.md index c2838c733c7..67318a5b746 100644 --- a/doc/languages-frameworks/haskell.section.md +++ b/doc/languages-frameworks/haskell.section.md @@ -3,1125 +3,11 @@ title: User's Guide for Haskell in Nixpkgs author: Peter Simons date: 2015-06-01 --- + # Haskell - -## How to install Haskell packages - -Nixpkgs distributes build instructions for all Haskell packages registered on -[Hackage](http://hackage.haskell.org/), but strangely enough normal Nix package -lookups don't seem to discover any of them, except for the default version of ghc, cabal-install, and stack: -``` -$ nix-env -i alex -error: selector ‘alex’ matches no derivations -$ nix-env -qa ghc -ghc-7.10.2 -``` - -The Haskell package set is not registered in the top-level namespace because it -is *huge*. If all Haskell packages were visible to these commands, then -name-based search/install operations would be much slower than they are now. We -avoided that by keeping all Haskell-related packages in a separate attribute -set called `haskellPackages`, which the following command will list: -``` -$ nix-env -f "" -qaP -A haskellPackages -haskellPackages.a50 a50-0.5 -haskellPackages.AAI AAI-0.2.0.1 -haskellPackages.abacate abacate-0.0.0.0 -haskellPackages.abc-puzzle abc-puzzle-0.2.1 -haskellPackages.abcBridge abcBridge-0.15 -haskellPackages.abcnotation abcnotation-1.9.0 -haskellPackages.abeson abeson-0.1.0.1 -[... some 14000 entries omitted ...] -``` - -To install any of those packages into your profile, refer to them by their -attribute path (first column): -```shell -nix-env -f "" -iA haskellPackages.Allure ... -``` - -The attribute path of any Haskell packages corresponds to the name of that -particular package on Hackage: the package `cabal-install` has the attribute -`haskellPackages.cabal-install`, and so on. (Actually, this convention causes -trouble with packages like `3dmodels` and `4Blocks`, because these names are -invalid identifiers in the Nix language. The issue of how to deal with these -rare corner cases is currently unresolved.) - -Haskell packages whose Nix name (second column) begins with a `haskell-` prefix -are packages that provide a library whereas packages without that prefix -provide just executables. Libraries may provide executables too, though: the -package `haskell-pandoc`, for example, installs both a library and an -application. You can install and use Haskell executables just like any other -program in Nixpkgs, but using Haskell libraries for development is a bit -trickier and we'll address that subject in great detail in section [How to -create a development environment](#how-to-create-a-development-environment). - -Attribute paths are deterministic inside of Nixpkgs, but the path necessary to -reach Nixpkgs varies from system to system. We dodged that problem by giving -`nix-env` an explicit `-f ""` parameter, but if you call `nix-env` -without that flag, then chances are the invocation fails: -``` -$ nix-env -iA haskellPackages.cabal-install -error: attribute ‘haskellPackages’ in selection path - ‘haskellPackages.cabal-install’ not found -``` - -On NixOS, for example, Nixpkgs does *not* exist in the top-level namespace by -default. To figure out the proper attribute path, it's easiest to query for the -path of a well-known Nixpkgs package, i.e.: -``` -$ nix-env -qaP coreutils -nixos.coreutils coreutils-8.23 -``` - -If your system responds like that (most NixOS installations will), then the -attribute path to `haskellPackages` is `nixos.haskellPackages`. Thus, if you -want to use `nix-env` without giving an explicit `-f` flag, then that's the way -to do it: -```shell -nix-env -qaP -A nixos.haskellPackages -nix-env -iA nixos.haskellPackages.cabal-install -``` - -Our current default compiler is GHC 8.8.x and the `haskellPackages` set -contains packages built with that particular version. Nixpkgs contains the last -three major releases of GHC and there is a whole family of package sets -available that defines Hackage packages built with each of those compilers, -too: -```shell -nix-env -f "" -qaP -A haskell.packages.ghc865 -nix-env -f "" -qaP -A haskell.packages.ghc8101 -``` - -The name `haskellPackages` is really just a synonym for -`haskell.packages.ghc882`, because we prefer that package set internally and -recommend it to our users as their default choice, but ultimately you are free -to compile your Haskell packages with any GHC version you please. The following -command displays the complete list of available compilers: -``` -$ nix-env -f "" -qaP -A haskell.compiler -haskell.compiler.ghc8101 ghc-8.10.1 -haskell.compiler.integer-simple.ghc8101 ghc-8.10.1 -haskell.compiler.ghcHEAD ghc-8.11.20200505 -haskell.compiler.integer-simple.ghcHEAD ghc-8.11.20200505 -haskell.compiler.ghc822Binary ghc-8.2.2-binary -haskell.compiler.ghc844 ghc-8.4.4 -haskell.compiler.ghc863Binary ghc-8.6.3-binary -haskell.compiler.ghc865 ghc-8.6.5 -haskell.compiler.integer-simple.ghc865 ghc-8.6.5 -haskell.compiler.ghc882 ghc-8.8.2 -haskell.compiler.integer-simple.ghc882 ghc-8.8.2 -haskell.compiler.ghc883 ghc-8.8.3 -haskell.compiler.integer-simple.ghc883 ghc-8.8.3 -haskell.compiler.ghcjs ghcjs-8.6.0.1 -``` - -We have no package sets for `jhc` or `uhc` yet, unfortunately, but for every -version of GHC listed above, there exists a package set based on that compiler. -Also, the attributes `haskell.compiler.ghcXYC` and -`haskell.packages.ghcXYC.ghc` are synonymous for the sake of convenience. - -## How to create a development environment - -### How to install a compiler - -A simple development environment consists of a Haskell compiler and one or both -of the tools `cabal-install` and `stack`. We saw in section -[How to install Haskell packages](#how-to-install-haskell-packages) how you can install those programs into your -user profile: -```shell -nix-env -f "" -iA haskellPackages.ghc haskellPackages.cabal-install -``` - -Instead of the default package set `haskellPackages`, you can also use the more -precise name `haskell.compiler.ghc7102`, which has the advantage that it refers -to the same GHC version regardless of what Nixpkgs considers "default" at any -given time. - -Once you've made those tools available in `$PATH`, it's possible to build -Hackage packages the same way people without access to Nix do it all the time: -```shell -cabal get lens-4.11 && cd lens-4.11 -cabal install -j --dependencies-only -cabal configure -cabal build -``` - -If you enjoy working with Cabal sandboxes, then that's entirely possible too: -just execute the command -```shell -cabal sandbox init -``` -before installing the required dependencies. - -The `nix-shell` utility makes it easy to switch to a different compiler -version; just enter the Nix shell environment with the command -```shell -nix-shell -p haskell.compiler.ghc784 -``` -to bring GHC 7.8.4 into `$PATH`. Alternatively, you can use Stack instead of -`nix-shell` directly to select compiler versions and other build tools -per-project. It uses `nix-shell` under the hood when Nix support is turned on. -See [How to build a Haskell project using Stack](#how-to-build-a-haskell-project-using-stack). - -If you're using `cabal-install`, re-running `cabal configure` inside the spawned -shell switches your build to use that compiler instead. If you're working on -a project that doesn't depend on any additional system libraries outside of GHC, -then it's even sufficient to just run the `cabal configure` command inside of -the shell: -```shell -nix-shell -p haskell.compiler.ghc784 --command "cabal configure" -``` - -Afterwards, all other commands like `cabal build` work just fine in any shell -environment, because the configure phase recorded the absolute paths to all -required tools like GHC in its build configuration inside of the `dist/` -directory. Please note, however, that `nix-collect-garbage` can break such an -environment because the Nix store paths created by `nix-shell` aren't "alive" -anymore once `nix-shell` has terminated. If you find that your Haskell builds -no longer work after garbage collection, then you'll have to re-run `cabal -configure` inside of a new `nix-shell` environment. - -### How to install a compiler with libraries - -GHC expects to find all installed libraries inside of its own `lib` directory. -This approach works fine on traditional Unix systems, but it doesn't work for -Nix, because GHC's store path is immutable once it's built. We cannot install -additional libraries into that location. As a consequence, our copies of GHC -don't know any packages except their own core libraries, like `base`, -`containers`, `Cabal`, etc. - -We can register additional libraries to GHC, however, using a special build -function called `ghcWithPackages`. That function expects one argument: a -function that maps from an attribute set of Haskell packages to a list of -packages, which determines the libraries known to that particular version of -GHC. For example, the Nix expression `ghcWithPackages (pkgs: [pkgs.mtl])` -generates a copy of GHC that has the `mtl` library registered in addition to -its normal core packages: -``` -$ nix-shell -p "haskellPackages.ghcWithPackages (pkgs: [pkgs.mtl])" - -[nix-shell:~]$ ghc-pkg list mtl -/nix/store/zy79...-ghc-7.10.2/lib/ghc-7.10.2/package.conf.d: - mtl-2.2.1 -``` - -This function allows users to define their own development environment by means -of an override. After adding the following snippet to `~/.config/nixpkgs/config.nix`, -```nix -{ - packageOverrides = super: let self = super.pkgs; in - { - myHaskellEnv = self.haskell.packages.ghc7102.ghcWithPackages - (haskellPackages: with haskellPackages; [ - # libraries - arrows async cgi criterion - # tools - cabal-install haskintex - ]); - }; -} -``` -it's possible to install that compiler with `nix-env -f "" -iA -myHaskellEnv`. If you'd like to switch that development environment to a -different version of GHC, just replace the `ghc7102` bit in the previous -definition with the appropriate name. Of course, it's also possible to define -any number of these development environments! (You can't install two of them -into the same profile at the same time, though, because that would result in -file conflicts.) - -The generated `ghc` program is a wrapper script that re-directs the real -GHC executable to use a new `lib` directory --- one that we specifically -constructed to contain all those packages the user requested: -``` -$ cat $(type -p ghc) -#! /nix/store/xlxj...-bash-4.3-p33/bin/bash -e -export NIX_GHC=/nix/store/19sm...-ghc-7.10.2/bin/ghc -export NIX_GHCPKG=/nix/store/19sm...-ghc-7.10.2/bin/ghc-pkg -export NIX_GHC_DOCDIR=/nix/store/19sm...-ghc-7.10.2/share/doc/ghc/html -export NIX_GHC_LIBDIR=/nix/store/19sm...-ghc-7.10.2/lib/ghc-7.10.2 -exec /nix/store/j50p...-ghc-7.10.2/bin/ghc "-B$NIX_GHC_LIBDIR" "$@" -``` - -The variables `$NIX_GHC`, `$NIX_GHCPKG`, etc. point to the *new* store path -`ghcWithPackages` constructed specifically for this environment. The last line -of the wrapper script then executes the real `ghc`, but passes the path to the -new `lib` directory using GHC's `-B` flag. - -The purpose of those environment variables is to work around an impurity in the -popular [ghc-paths](http://hackage.haskell.org/package/ghc-paths) library. That -library promises to give its users access to GHC's installation paths. Only, -the library can't possible know that path when it's compiled, because the path -GHC considers its own is determined only much later, when the user configures -it through `ghcWithPackages`. So we [patched -ghc-paths](https://github.com/NixOS/nixpkgs/blob/master/pkgs/development/haskell-modules/patches/ghc-paths-nix.patch) -to return the paths found in those environment variables at run-time rather -than trying to guess them at compile-time. - -To make sure that mechanism works properly all the time, we recommend that you -set those variables to meaningful values in your shell environment, too, i.e. -by adding the following code to your `~/.bashrc`: -```bash -if type >/dev/null 2>&1 -p ghc; then - eval "$(egrep ^export "$(type -p ghc)")" -fi -``` - -If you are certain that you'll use only one GHC environment which is located in -your user profile, then you can use the following code, too, which has the -advantage that it doesn't contain any paths from the Nix store, i.e. those -settings always remain valid even if a `nix-env -u` operation updates the GHC -environment in your profile: -```bash -if [ -e ~/.nix-profile/bin/ghc ]; then - export NIX_GHC="$HOME/.nix-profile/bin/ghc" - export NIX_GHCPKG="$HOME/.nix-profile/bin/ghc-pkg" - export NIX_GHC_DOCDIR="$HOME/.nix-profile/share/doc/ghc/html" - export NIX_GHC_LIBDIR="$HOME/.nix-profile/lib/ghc-$($NIX_GHC --numeric-version)" -fi -``` - -### How to install a compiler with libraries, hoogle and documentation indexes - -If you plan to use your environment for interactive programming, not just -compiling random Haskell code, you might want to replace `ghcWithPackages` in -all the listings above with `ghcWithHoogle`. - -This environment generator not only produces an environment with GHC and all -the specified libraries, but also generates a `hoogle` and `haddock` indexes -for all the packages, and provides a wrapper script around `hoogle` binary that -uses all those things. A precise name for this thing would be -"`ghcWithPackagesAndHoogleAndDocumentationIndexes`", which is, regrettably, too -long and scary. - -For example, installing the following environment -```nix -{ - packageOverrides = super: let self = super.pkgs; in - { - myHaskellEnv = self.haskellPackages.ghcWithHoogle - (haskellPackages: with haskellPackages; [ - # libraries - arrows async cgi criterion - # tools - cabal-install haskintex - ]); - }; -} -``` -allows one to browse module documentation index [not too dissimilar to -this](https://downloads.haskell.org/~ghc/latest/docs/html/libraries/index.html) -for all the specified packages and their dependencies by directing a browser of -choice to `~/.nix-profile/share/doc/hoogle/index.html` (or -`/run/current-system/sw/share/doc/hoogle/index.html` in case you put it in -`environment.systemPackages` in NixOS). - -After you've marveled enough at that try adding the following to your -`~/.ghc/ghci.conf` -``` -:def hoogle \s -> return $ ":! hoogle search -cl --count=15 \"" ++ s ++ "\"" -:def doc \s -> return $ ":! hoogle search -cl --info \"" ++ s ++ "\"" -``` -and test it by typing into `ghci`: -``` -:hoogle a -> a -:doc a -> a -``` - -Be sure to note the links to `haddock` files in the output. With any modern and -properly configured terminal emulator you can just click those links to -navigate there. - -Finally, you can run -```shell -hoogle server --local -p 8080 -``` -and navigate to http://localhost:8080/ for your own local -[Hoogle](https://www.haskell.org/hoogle/). The `--local` flag makes the hoogle -server serve files from your nix store over http, without the flag it will use -`file://` URIs. Note, however, that Firefox and possibly other browsers -disallow navigation from `http://` to `file://` URIs for security reasons, -which might be quite an inconvenience. Versions before v5 did not have this -flag. See -[this page](http://kb.mozillazine.org/Links_to_local_pages_do_not_work) for -workarounds. - -For NixOS users there's a service which runs this exact command for you. -Specify the `packages` you want documentation for and the `haskellPackages` set -you want them to come from. Add the following to `configuration.nix`. - -```nix -services.hoogle = { - enable = true; - packages = (hpkgs: with hpkgs; [text cryptonite]); - haskellPackages = pkgs.haskellPackages; -}; -``` - -### How to install haskell-language-server - -In short: Install `pkgs.haskell-language-server` and use the -`haskell-language-server-wrapper` command to run it. See the [hls -README](https://github.com/haskell/haskell-language-server) on how to configure -your text editor to use hls and how to test your setup. - -Hls needs to be compiled with the ghc version of the project you use it on. - -`pkgs.haskell-language-server` provides `haskell-language-server-wrapper`, -`haskell-language-server`, `haskell-language-server-x.x` and -`haskell-language-server-x.x.x` binaries, where `x.x.x` is the ghc version for -which it is compiled. By default it includes binaries for all ghc versions -that are provided in the binary caches. You can override that list with e.g. - -```nix -pkgs.haskell-language-server.override { supportedGhcVersions = [ "884" "901" ]; } -``` - -When you run `haskell-language-server-wrapper` it will detect the ghc version -used by the project you are working on (by asking e.g. cabal or stack) and pick -the appropriate above mentioned binary from your path. - -Be careful when installing hls globally and using a pinned nixpkgs for a Haskell -project in a nix-shell. If the nixpkgs versions deviate to much (e.g. use -different `glibc` versions) hls might fail. It is recommended to then install hls -in the nix-shell from the nixpkgs version pinned in there. - -If you know, that you only use one ghc version, e.g. in a project specific -nix-shell You can either use an override as given above or simply install -`pkgs.haskellPackages.haskell-language-server` instead of the top-level -attribute `pkgs.haskell-language-server`. - -### How to build a Haskell project using Stack - -[Stack](http://haskellstack.org) is a popular build tool for Haskell projects. -It has first-class support for Nix. Stack can optionally use Nix to -automatically select the right version of GHC and other build tools to build, -test and execute apps in an existing project downloaded from somewhere on the -Internet. Pass the `--nix` flag to any `stack` command to do so, e.g. -```shell -git clone --recurse-submodules https://github.com/yesodweb/wai.git -cd wai -stack --nix build -``` - -If you want `stack` to use Nix by default, you can add a `nix` section to the -`stack.yaml` file, as explained in the [Stack documentation][stack-nix-doc]. For -example: -```yaml -nix: - enable: true - packages: [pkgconfig zeromq zlib] -``` - -The example configuration snippet above tells Stack to create an ad hoc -environment for `nix-shell` as in the below section, in which the `pkgconfig`, -`zeromq` and `zlib` packages from Nixpkgs are available. All `stack` commands -will implicitly be executed inside this ad hoc environment. - -Some projects have more sophisticated needs. For examples, some ad hoc -environments might need to expose Nixpkgs packages compiled in a certain way, or -with extra environment variables. In these cases, you'll need a `shell` field -instead of `packages`: -```yaml -nix: - enable: true - shell-file: shell.nix -``` - -For more on how to write a `shell.nix` file see the below section. You'll need -to express a derivation. Note that Nixpkgs ships with a convenience wrapper -function around `mkDerivation` called `haskell.lib.buildStackProject` to help you -create this derivation in exactly the way Stack expects. However for this to work -you need to disable the sandbox, which you can do by using `--option sandbox relaxed` -or `--option sandbox false` to the Nix command. All of the same inputs -as `mkDerivation` can be provided. For example, to build a Stack project that -including packages that link against a version of the R library compiled with -special options turned on: -```nix -with (import { }); - -let R = pkgs.R.override { enableStrictBarrier = true; }; -in -haskell.lib.buildStackProject { - name = "HaskellR"; - buildInputs = [ R zeromq zlib ]; -} -``` - -You can select a particular GHC version to compile with by setting the -`ghc` attribute as an argument to `buildStackProject`. Better yet, let -Stack choose what GHC version it wants based on the snapshot specified -in `stack.yaml` (only works with Stack >= 1.1.3): -```nix -{nixpkgs ? import { }, ghc ? nixpkgs.ghc}: - -with nixpkgs; - -let R = pkgs.R.override { enableStrictBarrier = true; }; -in -haskell.lib.buildStackProject { - name = "HaskellR"; - buildInputs = [ R zeromq zlib ]; - inherit ghc; -} -``` - -[stack-nix-doc]: http://docs.haskellstack.org/en/stable/nix_integration.html - -### How to create ad hoc environments for `nix-shell` - -The easiest way to create an ad hoc development environment is to run -`nix-shell` with the appropriate GHC environment given on the command-line: -```shell -nix-shell -p "haskellPackages.ghcWithPackages (pkgs: with pkgs; [mtl pandoc])" -``` - -For more sophisticated use-cases, however, it's more convenient to save the -desired configuration in a file called `shell.nix` that looks like this: -```nix -{ nixpkgs ? import {}, compiler ? "ghc7102" }: -let - inherit (nixpkgs) pkgs; - ghc = pkgs.haskell.packages.${compiler}.ghcWithPackages (ps: with ps; [ - monad-par mtl - ]); -in -pkgs.stdenv.mkDerivation { - name = "my-haskell-env-0"; - buildInputs = [ ghc ]; - shellHook = "eval $(egrep ^export ${ghc}/bin/ghc)"; -} -``` - -Now run `nix-shell` --- or even `nix-shell --pure` --- to enter a shell -environment that has the appropriate compiler in `$PATH`. If you use `--pure`, -then add all other packages that your development environment needs into the -`buildInputs` attribute. If you'd like to switch to a different compiler -version, then pass an appropriate `compiler` argument to the expression, i.e. -`nix-shell --argstr compiler ghc784`. - -If you need such an environment because you'd like to compile a Hackage package -outside of Nix --- i.e. because you're hacking on the latest version from Git ----, then the package set provides suitable nix-shell environments for you -already! Every Haskell package has an `env` attribute that provides a shell -environment suitable for compiling that particular package. If you'd like to -hack the `lens` library, for example, then you just have to check out the -source code and enter the appropriate environment: -``` -$ cabal get lens-4.11 && cd lens-4.11 -Downloading lens-4.11... -Unpacking to lens-4.11/ - -$ nix-shell "" -A haskellPackages.lens.env -[nix-shell:/tmp/lens-4.11]$ -``` - -At point, you can run `cabal configure`, `cabal build`, and all the other -development commands. Note that you need `cabal-install` installed in your -`$PATH` already to use it here --- the `nix-shell` environment does not provide -it. - -## How to create Nix builds for your own private Haskell packages - -If your own Haskell packages have build instructions for Cabal, then you can -convert those automatically into build instructions for Nix using the -`cabal2nix` utility, which you can install into your profile by running -`nix-env -i cabal2nix`. - -### How to build a stand-alone project - -For example, let's assume that you're working on a private project called -`foo`. To generate a Nix build expression for it, change into the project's -top-level directory and run the command: -```shell -cabal2nix . > foo.nix -``` -Then write the following snippet into a file called `default.nix`: -```nix -{ nixpkgs ? import {}, compiler ? "ghc7102" }: -nixpkgs.pkgs.haskell.packages.${compiler}.callPackage ./foo.nix { } -``` - -Finally, store the following code in a file called `shell.nix`: -```nix -{ nixpkgs ? import {}, compiler ? "ghc7102" }: -(import ./default.nix { inherit nixpkgs compiler; }).env -``` - -At this point, you can run `nix-build` to have Nix compile your project and -install it into a Nix store path. The local directory will contain a symlink -called `result` after `nix-build` returns that points into that location. Of -course, passing the flag `--argstr compiler ghc763` allows switching the build -to any version of GHC currently supported. - -Furthermore, you can call `nix-shell` to enter an interactive development -environment in which you can use `cabal configure` and `cabal build` to develop -your code. That environment will automatically contain a proper GHC derivation -with all the required libraries registered as well as all the system-level -libraries your package might need. - -If your package does not depend on any system-level libraries, then it's -sufficient to run -```shell -nix-shell --command "cabal configure" -``` -once to set up your build. `cabal-install` determines the absolute paths to all -resources required for the build and writes them into a config file in the -`dist/` directory. Once that's done, you can run `cabal build` and any other -command for that project even outside of the `nix-shell` environment. This -feature is particularly nice for those of us who like to edit their code with -an IDE, like Emacs' `haskell-mode`, because it's not necessary to start Emacs -inside of nix-shell just to make it find out the necessary settings for -building the project; `cabal-install` has already done that for us. - -If you want to do some quick-and-dirty hacking and don't want to bother setting -up a `default.nix` and `shell.nix` file manually, then you can use the -`--shell` flag offered by `cabal2nix` to have it generate a stand-alone -`nix-shell` environment for you. With that feature, running -```shell -cabal2nix --shell . > shell.nix -nix-shell --command "cabal configure" -``` -is usually enough to set up a build environment for any given Haskell package. -You can even use that generated file to run `nix-build`, too: -```shell -nix-build shell.nix -``` - -### How to build projects that depend on each other - -If you have multiple private Haskell packages that depend on each other, then -you'll have to register those packages in the Nixpkgs set to make them visible -for the dependency resolution performed by `callPackage`. First of all, change -into each of your projects top-level directories and generate a `default.nix` -file with `cabal2nix`: -```shell -cd ~/src/foo && cabal2nix . > default.nix -cd ~/src/bar && cabal2nix . > default.nix -``` -Then edit your `~/.config/nixpkgs/config.nix` file to register those builds in the -default Haskell package set: -```nix -{ - packageOverrides = super: let self = super.pkgs; in - { - haskellPackages = super.haskellPackages.override { - overrides = self: super: { - foo = self.callPackage ../src/foo {}; - bar = self.callPackage ../src/bar {}; - }; - }; - }; -} -``` -Once that's accomplished, `nix-env -f "" -qA haskellPackages` will -show your packages like any other package from Hackage, and you can build them -```shell -nix-build "" -A haskellPackages.foo -``` -or enter an interactive shell environment suitable for building them: -```shell -nix-shell "" -A haskellPackages.bar.env -``` - -## Miscellaneous Topics - -### How to build with profiling enabled - -Every Haskell package set takes a function called `overrides` that you can use -to manipulate the package as much as you please. One useful application of this -feature is to replace the default `mkDerivation` function with one that enables -library profiling for all packages. To accomplish that add the following -snippet to your `~/.config/nixpkgs/config.nix` file: -```nix -{ - packageOverrides = super: let self = super.pkgs; in - { - profiledHaskellPackages = self.haskellPackages.override { - overrides = self: super: { - mkDerivation = args: super.mkDerivation (args // { - enableLibraryProfiling = true; - }); - }; - }; - }; -} -``` -Then, replace instances of `haskellPackages` in the `cabal2nix`-generated -`default.nix` or `shell.nix` files with `profiledHaskellPackages`. - -### How to override package versions in a compiler-specific package set - -Nixpkgs provides the latest version of -[`ghc-events`](http://hackage.haskell.org/package/ghc-events), which is 0.4.4.0 -at the time of this writing. This is fine for users of GHC 7.10.x, but GHC -7.8.4 cannot compile that binary. Now, one way to solve that problem is to -register an older version of `ghc-events` in the 7.8.x-specific package set. -The first step is to generate Nix build instructions with `cabal2nix`: -```shell -cabal2nix cabal://ghc-events-0.4.3.0 > ~/.nixpkgs/ghc-events-0.4.3.0.nix -``` -Then add the override in `~/.config/nixpkgs/config.nix`: -```nix -{ - packageOverrides = super: let self = super.pkgs; in - { - haskell = super.haskell // { - packages = super.haskell.packages // { - ghc784 = super.haskell.packages.ghc784.override { - overrides = self: super: { - ghc-events = self.callPackage ./ghc-events-0.4.3.0.nix {}; - }; - }; - }; - }; - }; -} -``` - -This code is a little crazy, no doubt, but it's necessary because the intuitive -version -```nix -{ # ... - - haskell.packages.ghc784 = super.haskell.packages.ghc784.override { - overrides = self: super: { - ghc-events = self.callPackage ./ghc-events-0.4.3.0.nix {}; - }; - }; -} -``` -doesn't do what we want it to: that code replaces the `haskell` package set in -Nixpkgs with one that contains only one entry,`packages`, which contains only -one entry `ghc784`. This override loses the `haskell.compiler` set, and it -loses the `haskell.packages.ghcXYZ` sets for all compilers but GHC 7.8.4. To -avoid that problem, we have to perform the convoluted little dance from above, -iterating over each step in hierarchy. - -Once it's accomplished, however, we can install a variant of `ghc-events` -that's compiled with GHC 7.8.4: -```shell -nix-env -f "" -iA haskell.packages.ghc784.ghc-events -``` -Unfortunately, it turns out that this build fails again while executing the -test suite! Apparently, the release archive on Hackage is missing some data -files that the test suite requires, so we cannot run it. We accomplish that by -re-generating the Nix expression with the `--no-check` flag: -```shell -cabal2nix --no-check cabal://ghc-events-0.4.3.0 > ~/.nixpkgs/ghc-events-0.4.3.0.nix -``` -Now the builds succeeds. - -Of course, in the concrete example of `ghc-events` this whole exercise is not -an ideal solution, because `ghc-events` can analyze the output emitted by any -version of GHC later than 6.12 regardless of the compiler version that was used -to build the `ghc-events` executable, so strictly speaking there's no reason to -prefer one built with GHC 7.8.x in the first place. However, for users who -cannot use GHC 7.10.x at all for some reason, the approach of downgrading to an -older version might be useful. - -### How to override packages in all compiler-specific package sets - -In the previous section we learned how to override a package in a single -compiler-specific package set. You may have some overrides defined that you want -to use across multiple package sets. To accomplish this you could use the -technique that we learned in the previous section by repeating the overrides for -all the compiler-specific package sets. For example: - -```nix -{ - packageOverrides = super: let self = super.pkgs; in - { - haskell = super.haskell // { - packages = super.haskell.packages // { - ghc784 = super.haskell.packages.ghc784.override { - overrides = self: super: { - my-package = ...; - my-other-package = ...; - }; - }; - ghc822 = super.haskell.packages.ghc784.override { - overrides = self: super: { - my-package = ...; - my-other-package = ...; - }; - }; - ... - }; - }; - }; -} -``` - -However there's a more convenient way to override all compiler-specific package -sets at once: - -```nix -{ - packageOverrides = super: let self = super.pkgs; in - { - haskell = super.haskell // { - packageOverrides = self: super: { - my-package = ...; - my-other-package = ...; - }; - }; - }; -} -``` - -### How to specify source overrides for your Haskell package - -When starting a Haskell project you can use `developPackage` -to define a derivation for your package at the `root` path -as well as source override versions for Hackage packages, like so: - -```nix -# default.nix -{ compilerVersion ? "ghc842" }: -let - # pinning nixpkgs using new Nix 2.0 builtin `fetchGit` - pkgs = import (fetchGit (import ./version.nix)) { }; - compiler = pkgs.haskell.packages."${compilerVersion}"; - pkg = compiler.developPackage { - root = ./.; - source-overrides = { - # Let's say the GHC 8.4.2 haskellPackages uses 1.6.0.0 and your test suite is incompatible with >= 1.6.0.0 - HUnit = "1.5.0.0"; - }; - }; -in pkg -``` - -This could be used in place of a simplified `stack.yaml` defining a Nix -derivation for your Haskell package. - -As you can see this allows you to specify only the source version found on -Hackage and nixpkgs will take care of the rest. - -You can also specify `buildInputs` for your Haskell derivation for packages -that directly depend on external libraries like so: - -```nix -# default.nix -{ compilerVersion ? "ghc842" }: -let - # pinning nixpkgs using new Nix 2.0 builtin `fetchGit` - pkgs = import (fetchGit (import ./version.nix)) { }; - compiler = pkgs.haskell.packages."${compilerVersion}"; - pkg = compiler.developPackage { - root = ./.; - source-overrides = { - HUnit = "1.5.0.0"; # Let's say the GHC 8.4.2 haskellPackages uses 1.6.0.0 and your test suite is incompatible with >= 1.6.0.0 - }; - }; - # in case your package source depends on any libraries directly, not just transitively. - buildInputs = [ zlib ]; -in pkg.overrideAttrs(attrs: { - buildInputs = attrs.buildInputs ++ buildInputs; -}) -``` - -Notice that you will need to override (via `overrideAttrs` or similar) the -derivation returned by the `developPackage` Nix lambda as there is no `buildInputs` -named argument you can pass directly into the `developPackage` lambda. - -### How to recover from GHC's infamous non-deterministic library ID bug - -GHC and distributed build farms don't get along well: - - - https://ghc.haskell.org/trac/ghc/ticket/4012 - -When you see an error like this one -``` -package foo-0.7.1.0 is broken due to missing package -text-1.2.0.4-98506efb1b9ada233bb5c2b2db516d91 -``` -then you have to download and re-install `foo` and all its dependents from -scratch: -```shell -nix-store -q --referrers /nix/store/*-haskell-text-1.2.0.4 \ - | xargs -L 1 nix-store --repair-path -``` - -If you're using additional Hydra servers other than `hydra.nixos.org`, then it -might be necessary to purge the local caches that store data from those -machines to disable these binary channels for the duration of the previous -command, i.e. by running: -```shell -rm ~/.cache/nix/binary-cache*.sqlite -``` - -### Builds on Darwin fail with `math.h` not found - -Users of GHC on Darwin have occasionally reported that builds fail, because the -compiler complains about a missing include file: -``` -fatal error: 'math.h' file not found -``` -The issue has been discussed at length in [ticket -6390](https://github.com/NixOS/nixpkgs/issues/6390), and so far no good -solution has been proposed. As a work-around, users who run into this problem -can configure the environment variables -```shell -export NIX_CFLAGS_COMPILE="-idirafter /usr/include" -export NIX_CFLAGS_LINK="-L/usr/lib" -``` -in their `~/.bashrc` file to avoid the compiler error. - -### Builds using Stack complain about missing system libraries - -``` --- While building package zlib-0.5.4.2 using: - runhaskell -package=Cabal-1.22.4.0 -clear-package-db [... lots of flags ...] -Process exited with code: ExitFailure 1 -Logs have been written to: /home/foo/src/stack-ide/.stack-work/logs/zlib-0.5.4.2.log - -Configuring zlib-0.5.4.2... -Setup.hs: Missing dependency on a foreign library: -* Missing (or bad) header file: zlib.h -This problem can usually be solved by installing the system package that -provides this library (you may need the "-dev" version). If the library is -already installed but in a non-standard location then you can use the flags ---extra-include-dirs= and --extra-lib-dirs= to specify where it is. -If the header file does exist, it may contain errors that are caught by the C -compiler at the preprocessing stage. In this case you can re-run configure -with the verbosity flag -v3 to see the error messages. -``` - -When you run the build inside of the nix-shell environment, the system -is configured to find `libz.so` without any special flags -- the compiler -and linker "just know" how to find it. Consequently, Cabal won't record -any search paths for `libz.so` in the package description, which means -that the package works fine inside of nix-shell, but once you leave the -shell the shared object can no longer be found. That issue is by no -means specific to Stack: you'll have that problem with any other -Haskell package that's built inside of nix-shell but run outside of that -environment. - -You can remedy this issue in several ways. The easiest is to add a `nix` section -to the `stack.yaml` like the following: -```yaml -nix: - enable: true - packages: [ zlib ] -``` - -Stack's Nix support knows to add `${zlib.out}/lib` and `${zlib.dev}/include` -as an `--extra-lib-dirs` and `extra-include-dirs`, respectively. -Alternatively, you can achieve the same effect by hand. First of all, run -``` -$ nix-build --no-out-link "" -A zlib -/nix/store/alsvwzkiw4b7ip38l4nlfjijdvg3fvzn-zlib-1.2.8 -``` -to find out the store path of the system's zlib library. Now, you can - - 1. add that path (plus a "/lib" suffix) to your `$LD_LIBRARY_PATH` - environment variable to make sure your system linker finds `libz.so` - automatically. It's no pretty solution, but it will work. - - 2. As a variant of (1), you can also install any number of system - libraries into your user's profile (or some other profile) and point - `$LD_LIBRARY_PATH` to that profile instead, so that you don't have to - list dozens of those store paths all over the place. - - 3. The solution I prefer is to call stack with an appropriate - --extra-lib-dirs flag like so: - ```shell - stack --extra-lib-dirs=/nix/store/alsvwzkiw4b7ip38l4nlfjijdvg3fvzn-zlib-1.2.8/lib build - ``` - -Typically, you'll need `--extra-include-dirs` as well. It's possible -to add those flag to the project's `stack.yaml` or your user's -global `~/.stack/global/stack.yaml` file so that you don't have to -specify them manually every time. But again, you're likely better off -using Stack's Nix support instead. - -The same thing applies to `cabal configure`, of course, if you're -building with `cabal-install` instead of Stack. - -### Creating statically linked binaries - -There are two levels of static linking. The first option is to configure the -build with the Cabal flag `--disable-executable-dynamic`. In Nix expressions, -this can be achieved by setting the attribute: -``` -enableSharedExecutables = false; -``` -That gives you a binary with statically linked Haskell libraries and -dynamically linked system libraries. - -To link both Haskell libraries and system libraries statically, the additional -flags `--ghc-option=-optl=-static --ghc-option=-optl=-pthread` need to be used. -In Nix, this is accomplished with: -``` -configureFlags = [ "--ghc-option=-optl=-static" "--ghc-option=-optl=-pthread" ]; -``` - -It's important to realize, however, that most system libraries in Nix are -built as shared libraries only, i.e. there is just no static library -available that Cabal could link! - -### Building GHC with integer-simple - -By default GHC implements the Integer type using the -[GNU Multiple Precision Arithmetic (GMP) library](https://gmplib.org/). -The implementation can be found in the -[integer-gmp](http://hackage.haskell.org/package/integer-gmp) package. - -A potential problem with this is that GMP is licensed under the -[GNU Lesser General Public License (LGPL)](https://www.gnu.org/copyleft/lesser.html), -a kind of "copyleft" license. According to the terms of the LGPL, paragraph 5, -you may distribute a program that is designed to be compiled and dynamically -linked with the library under the terms of your choice (i.e., commercially) but -if your program incorporates portions of the library, if it is linked -statically, then your program is a "derivative"--a "work based on the -library"--and according to paragraph 2, section c, you "must cause the whole of -the work to be licensed" under the terms of the LGPL (including for free). - -The LGPL licensing for GMP is a problem for the overall licensing of binary -programs compiled with GHC because most distributions (and builds) of GHC use -static libraries. (Dynamic libraries are currently distributed only for macOS.) -The LGPL licensing situation may be worse: even though -[The Glasgow Haskell Compiler License](https://www.haskell.org/ghc/license) -is essentially a "free software" license (BSD3), according to -paragraph 2 of the LGPL, GHC must be distributed under the terms of the LGPL! - -To work around these problems GHC can be build with a slower but LGPL-free -alternative implementation for Integer called -[integer-simple](http://hackage.haskell.org/package/integer-simple). - -To get a GHC compiler build with `integer-simple` instead of `integer-gmp` use -the attribute: `haskell.compiler.integer-simple."${ghcVersion}"`. -For example: -``` -$ nix-build -E '(import {}).haskell.compiler.integer-simple.ghc802' -... -$ result/bin/ghc-pkg list | grep integer - integer-simple-0.1.1.1 -``` -The following command displays the complete list of GHC compilers build with `integer-simple`: -``` -$ nix-env -f "" -qaP -A haskell.compiler.integer-simple -haskell.compiler.integer-simple.ghc7102 ghc-7.10.2 -haskell.compiler.integer-simple.ghc7103 ghc-7.10.3 -haskell.compiler.integer-simple.ghc722 ghc-7.2.2 -haskell.compiler.integer-simple.ghc742 ghc-7.4.2 -haskell.compiler.integer-simple.ghc783 ghc-7.8.3 -haskell.compiler.integer-simple.ghc784 ghc-7.8.4 -haskell.compiler.integer-simple.ghc801 ghc-8.0.1 -haskell.compiler.integer-simple.ghc802 ghc-8.0.2 -haskell.compiler.integer-simple.ghcHEAD ghc-8.1.20170106 -``` - -To get a package set supporting `integer-simple` use the attribute: -`haskell.packages.integer-simple."${ghcVersion}"`. For example -use the following to get the `scientific` package build with `integer-simple`: -```shell -nix-build -A haskell.packages.integer-simple.ghc802.scientific -``` - -### Quality assurance - -The `haskell.lib` library includes a number of functions for checking for -various imperfections in Haskell packages. It's useful to apply these functions -to your own Haskell packages and integrate that in a Continuous Integration -server like [hydra](https://nixos.org/hydra/) to assure your packages maintain a -minimum level of quality. This section discusses some of these functions. - -#### failOnAllWarnings - -Applying `haskell.lib.failOnAllWarnings` to a Haskell package enables the -`-Wall` and `-Werror` GHC options to turn all warnings into build failures. - -#### buildStrictly - -Applying `haskell.lib.buildStrictly` to a Haskell package calls -`failOnAllWarnings` on the given package to turn all warnings into build -failures. Additionally the source of your package is gotten from first invoking -`cabal sdist` to ensure all needed files are listed in the Cabal file. - -#### checkUnusedPackages - -Applying `haskell.lib.checkUnusedPackages` to a Haskell package invokes -the [packunused](http://hackage.haskell.org/package/packunused) tool on the -package. `packunused` complains when it finds packages listed as build-depends -in the Cabal file which are redundant. For example: - -``` -$ nix-build -E 'let pkgs = import {}; in pkgs.haskell.lib.checkUnusedPackages {} pkgs.haskellPackages.scientific' -these derivations will be built: - /nix/store/3lc51cxj2j57y3zfpq5i69qbzjpvyci1-scientific-0.3.5.1.drv -... -detected package components -~~~~~~~~~~~~~~~~~~~~~~~~~~~ - - - library - - testsuite(s): test-scientific - - benchmark(s): bench-scientific* - -(component names suffixed with '*' are not configured to be built) - -library -~~~~~~~ - -The following package dependencies seem redundant: - - - ghc-prim-0.5.0.0 - -testsuite(test-scientific) -~~~~~~~~~~~~~~~~~~~~~~~~~~ - -no redundant packages dependencies found - -builder for ‘/nix/store/3lc51cxj2j57y3zfpq5i69qbzjpvyci1-scientific-0.3.5.1.drv’ failed with exit code 1 -error: build of ‘/nix/store/3lc51cxj2j57y3zfpq5i69qbzjpvyci1-scientific-0.3.5.1.drv’ failed -``` - -As you can see, `packunused` finds out that although the testsuite component has -no redundant dependencies the library component of `scientific-0.3.5.1` depends -on `ghc-prim` which is unused in the library. - -### Using hackage2nix with nixpkgs - -Hackage package derivations are found in the -[`hackage-packages.nix`](https://github.com/NixOS/nixpkgs/blob/master/pkgs/development/haskell-modules/hackage-packages.nix) -file within `nixpkgs` and are used as the initial package set for -`haskellPackages`. The `hackage-packages.nix` file is not meant to be edited -by hand, but rather autogenerated by [`hackage2nix`](https://github.com/NixOS/cabal2nix/tree/master/hackage2nix), -which by default uses the [`configuration-hackage2nix.yaml`](https://github.com/NixOS/nixpkgs/blob/master/pkgs/development/haskell-modules/configuration-hackage2nix.yaml) -file to generate all the derivations. - -To modify the contents `configuration-hackage2nix.yaml`, follow the -instructions on [`hackage2nix`](https://github.com/NixOS/cabal2nix/tree/master/hackage2nix). - -## Other resources - - - The Youtube video [Nix Loves Haskell](https://www.youtube.com/watch?v=BsBhi_r-OeE) - provides an introduction into Haskell NG aimed at beginners. The slides are - available at http://cryp.to/nixos-meetup-3-slides.pdf and also -- in a form - ready for cut & paste -- at - https://github.com/NixOS/cabal2nix/blob/master/doc/nixos-meetup-3-slides.md. - - - Another Youtube video is [Escaping Cabal Hell with Nix](https://www.youtube.com/watch?v=mQd3s57n_2Y), - which discusses the subject of Haskell development with Nix but also provides - a basic introduction to Nix as well, i.e. it's suitable for viewers with - almost no prior Nix experience. - - - Oliver Charles wrote a very nice [Tutorial how to develop Haskell packages with Nix](http://wiki.ocharles.org.uk/Nix). - - - The *Journey into the Haskell NG infrastructure* series of postings - describe the new Haskell infrastructure in great detail: - - - [Part 1](https://nixos.org/nix-dev/2015-January/015591.html) - explains the differences between the old and the new code and gives - instructions how to migrate to the new setup. - - - [Part 2](https://nixos.org/nix-dev/2015-January/015608.html) - looks in-depth at how to tweak and configure your setup by means of - overrides. - - - [Part 3](https://nixos.org/nix-dev/2015-April/016912.html) - describes the infrastructure that keeps the Haskell package set in Nixpkgs - up-to-date. +The documentation for the Haskell infrastructure is published at +. The source code for that +site lives in the `doc/` sub-directory of the +[`cabal2nix` Git repository](https://github.com/NixOS/cabal2nix) +and changes can be submitted there. diff --git a/pkgs/data/misc/hackage/default.nix b/pkgs/data/misc/hackage/default.nix index d390445f315..c9950d9fcd1 100644 --- a/pkgs/data/misc/hackage/default.nix +++ b/pkgs/data/misc/hackage/default.nix @@ -1,6 +1,6 @@ { fetchurl }: fetchurl { - url = "https://github.com/commercialhaskell/all-cabal-hashes/archive/cc32e957fbe01d248c9a0e99253fadb37fd3adfa.tar.gz"; - sha256 = "121n26r3sm55ycwh6m71n4823c5af3hfpc497g4prf1j2n4yh2dl"; + url = "https://github.com/commercialhaskell/all-cabal-hashes/archive/197a82b352062bfeeefd4b62bfec19dd51a3728d.tar.gz"; + sha256 = "11c9a67j421vf6a7vvh280gsmssf49rxqnamdp1n9iljkhlfh5z1"; } diff --git a/pkgs/development/haskell-modules/configuration-common.nix b/pkgs/development/haskell-modules/configuration-common.nix index 43753f147de..adf5694d270 100644 --- a/pkgs/development/haskell-modules/configuration-common.nix +++ b/pkgs/development/haskell-modules/configuration-common.nix @@ -940,7 +940,7 @@ self: super: { dhall-json = generateOptparseApplicativeCompletions ["dhall-to-json" "dhall-to-yaml"] super.dhall-json; dhall-nix = generateOptparseApplicativeCompletion "dhall-to-nix" ( super.dhall-nix.overrideScope (self: super: { - dhall = super.dhall_1_35_0; + dhall = super.dhall_1_36_0; repline = self.repline_0_4_0_0; haskeline = self.haskeline_0_8_1_0; })); @@ -1230,6 +1230,7 @@ self: super: { hie-bios = dontCheck super.hie-bios_0_7_1; lsp-test = dontCheck self.lsp-test_0_11_0_7; })); + implicit-hie-cradle = super.implicit-hie-cradle.override { hie-bios = dontCheck super.hie-bios_0_7_1; }; # hasn‘t bumped upper bounds # upstream: https://github.com/obsidiansystems/which/pull/6 @@ -1322,10 +1323,6 @@ self: super: { # Upstream issue: https://github.com/kowainik/trial/issues/62 trial = doJailbreak super.trial; - # 2020-06-24: Tests are broken in hackage distribution. - # See: https://github.com/kowainik/stan/issues/316 - stan = dontCheck super.stan; - # 2020-06-24: Tests are broken in hackage distribution. # See: https://github.com/robstewart57/rdf4h/issues/39 rdf4h = dontCheck super.rdf4h; @@ -1464,8 +1461,8 @@ self: super: { cryptonite = doDistribute self.cryptonite_0_27; # We want the latest version of Pandoc. - skylighting = doDistribute super.skylighting_0_10_0_2; - skylighting-core = doDistribute super.skylighting-core_0_10_0_2; + skylighting = doDistribute super.skylighting_0_10_0_3; + skylighting-core = doDistribute super.skylighting-core_0_10_0_3; hslua = doDistribute self.hslua_1_1_2; jira-wiki-markup = doDistribute self.jira-wiki-markup_1_3_2; pandoc = doDistribute self.pandoc_2_11_0_2; @@ -1481,6 +1478,9 @@ self: super: { # stack-2.5.1 needs a more current version of pantry to compile pantry = self.pantry_0_5_1_3; + # Too tight version bounds, see https://github.com/haskell-hvr/microaeson/pull/4 + microaeson = doJailbreak super.microaeson; + # haskell-language-server needs a more current version of pantry to compile } // (let inherit (self) hls-ghcide hls-brittany; diff --git a/pkgs/development/haskell-modules/configuration-ghc-8.10.x.nix b/pkgs/development/haskell-modules/configuration-ghc-8.10.x.nix index 71680074b74..047c5ba481f 100644 --- a/pkgs/development/haskell-modules/configuration-ghc-8.10.x.nix +++ b/pkgs/development/haskell-modules/configuration-ghc-8.10.x.nix @@ -66,7 +66,7 @@ self: super: { unliftio-core = doJailbreak super.unliftio-core; # Use the latest version to fix the build. - dhall = self.dhall_1_35_0; + dhall = self.dhall_1_36_0; lens = self.lens_4_19_2; optics = self.optics_0_3; optics-core = self.optics-core_0_3_0_1; diff --git a/pkgs/development/haskell-modules/configuration-ghc-9.0.x.nix b/pkgs/development/haskell-modules/configuration-ghc-9.0.x.nix index 2a3a0b3bc14..88f935c3b6d 100644 --- a/pkgs/development/haskell-modules/configuration-ghc-9.0.x.nix +++ b/pkgs/development/haskell-modules/configuration-ghc-9.0.x.nix @@ -43,4 +43,72 @@ self: super: { unix = null; xhtml = null; + # Take the 3.4.x release candidate. + cabal-install = assert super.cabal-install.version == "3.2.0.0"; + overrideCabal super.cabal-install (drv: { + postUnpack = "sourceRoot+=/cabal-install; echo source root reset to $sourceRoot"; + version = "cabal-install-3.4.0.0-rc4"; + editedCabalFile = null; + src = pkgs.fetchgit { + url = "git://github.com/haskell/cabal.git"; + rev = "cabal-install-3.4.0.0-rc4"; + sha256 = "049hllk1d8jid9yg70hmcsdgb0n7hm24p39vavllaahfb0qfimrk"; + }; + }); + + # Jailbreaks & Version Updates + async = doJailbreak super.async; + ChasingBottoms = markBrokenVersion "1.3.1.9" super.ChasingBottoms; + dec = doJailbreak super.dec; + ed25519 = doJailbreak super.ed25519; + hashable = overrideCabal (doJailbreak (dontCheck super.hashable)) (drv: { postPatch = "sed -i -e 's,integer-gmp .*<1.1,integer-gmp < 2,' hashable.cabal"; }); + hashable-time = doJailbreak super.hashable-time; + integer-logarithms = overrideCabal (doJailbreak super.integer-logarithms) (drv: { postPatch = "sed -i -e 's,integer-gmp <1.1,integer-gmp < 2,' integer-logarithms.cabal"; }); + lukko = doJailbreak super.lukko; + parallel = doJailbreak super.parallel; + primitive = doJailbreak super.primitive_0_7_1_0; + regex-posix = doJailbreak super.regex-posix; + resolv = doJailbreak super.resolv; + singleton-bool = doJailbreak super.singleton-bool; + split = doJailbreak super.split; + splitmix = self.splitmix_0_1_0_3; + tar = doJailbreak super.tar; + th-abstraction = self.th-abstraction_0_4_0_0; + time-compat = doJailbreak super.time-compat; + vector = doJailbreak (dontCheck super.vector); + zlib = doJailbreak super.zlib; + + # Apply patches from head.hackage. + alex = appendPatch (dontCheck super.alex) (pkgs.fetchpatch { + url = "https://gitlab.haskell.org/ghc/head.hackage/-/raw/master/patches/alex-3.2.5.patch"; + sha256 = "0q8x49k3jjwyspcmidwr6b84s4y43jbf4wqfxfm6wz8x2dxx6nwh"; + }); + doctest = appendPatch (dontCheck (doJailbreak super.doctest_0_17)) (pkgs.fetchpatch { + url = "https://gitlab.haskell.org/ghc/head.hackage/-/raw/master/patches/doctest-0.17.patch"; + sha256 = "16s2jcbk9hsww38i2wzxghbf0zpp5dc35hp6rd2n7d4z5xfavp62"; + }); + generic-deriving = appendPatch (doJailbreak super.generic-deriving) (pkgs.fetchpatch { + url = "https://gitlab.haskell.org/ghc/head.hackage/-/raw/master/patches/generic-deriving-1.13.1.patch"; + sha256 = "0z85kiwhi5p2wiqwyym0y8q8qrcifp125x5vm0n4482lz41kmqds"; + }); + language-haskell-extract = appendPatch (doJailbreak super.language-haskell-extract) (pkgs.fetchpatch { + url = "https://gitlab.haskell.org/ghc/head.hackage/-/raw/master/patches/language-haskell-extract-0.2.4.patch"; + sha256 = "0rgzrq0513nlc1vw7nw4km4bcwn4ivxcgi33jly4a7n3c1r32v1f"; + }); + QuickCheck = appendPatch super.QuickCheck_2_14_1 (pkgs.fetchpatch { + url = "https://gitlab.haskell.org/ghc/head.hackage/-/raw/master/patches/QuickCheck-2.14.1.patch"; + sha256 = "0n89nx95w353h4dzala57gb0y7hx4wbkv5igs89dza50p7ybq9an"; + }); + regex-base = appendPatch (doJailbreak super.regex-base) (pkgs.fetchpatch { + url = "https://gitlab.haskell.org/ghc/head.hackage/-/raw/master/patches/regex-base-0.94.0.0.patch"; + sha256 = "0k5fglbl7nnhn8400c4cpnflxcbj9p3xi5prl9jfmszr31jwdy5d"; + }); + syb = appendPatch (dontCheck super.syb) (pkgs.fetchpatch { + url = "https://gitlab.haskell.org/ghc/head.hackage/-/raw/master/patches/syb-0.7.1.patch"; + sha256 = "1407r8xv6bfnmpbw7glfh4smi76a2fc9pkq300c3d9f575708zqr"; + }); + + # The test suite depends on ChasingBottoms, which is broken with ghc-9.0.x. + unordered-containers = dontCheck super.unordered-containers; + } diff --git a/pkgs/development/haskell-modules/configuration-hackage2nix.yaml b/pkgs/development/haskell-modules/configuration-hackage2nix.yaml index 2082da20618..8a2e787038d 100644 --- a/pkgs/development/haskell-modules/configuration-hackage2nix.yaml +++ b/pkgs/development/haskell-modules/configuration-hackage2nix.yaml @@ -75,7 +75,7 @@ default-package-overrides: # haskell-language-server 0.5.0.0 doesn't accept newer versions - fourmolu ==0.2.* - refinery ==0.2.* - # LTS Haskell 16.18 + # LTS Haskell 16.19 - abstract-deque ==0.3 - abstract-par ==0.3.3 - AC-Angle ==1.0 @@ -83,7 +83,7 @@ default-package-overrides: - ace ==0.6 - action-permutations ==0.0.0.1 - active ==0.2.0.14 - - ad ==4.4 + - ad ==4.4.1 - adjunctions ==4.4 - adler32 ==0.1.2.0 - advent-of-code-api ==0.2.7.0 @@ -91,7 +91,7 @@ default-package-overrides: - aeson-attoparsec ==0.0.0 - aeson-better-errors ==0.9.1.0 - aeson-casing ==0.2.0.0 - - aeson-combinators ==0.0.2.1 + - aeson-combinators ==0.0.3.0 - aeson-compat ==0.3.9 - aeson-default ==0.9.1.0 - aeson-diff ==1.1.0.9 @@ -301,7 +301,7 @@ default-package-overrides: - bech32 ==1.0.2 - bech32-th ==1.0.2 - bench ==1.0.12 - - benchpress ==0.2.2.14 + - benchpress ==0.2.2.15 - between ==0.11.0.0 - bibtex ==0.1.0.6 - bifunctors ==5.5.7 @@ -492,7 +492,7 @@ default-package-overrides: - concurrent-split ==0.0.1.1 - concurrent-supply ==0.1.8 - cond ==0.4.1.1 - - conduit ==1.3.2.1 + - conduit ==1.3.3 - conduit-algorithms ==0.0.11.0 - conduit-combinators ==1.3.0 - conduit-concurrent-map ==0.1.1 @@ -522,7 +522,7 @@ default-package-overrides: - convertible ==1.1.1.0 - cookie ==0.4.5 - core-data ==0.2.1.8 - - core-program ==0.2.4.5 + - core-program ==0.2.5.0 - core-text ==0.2.3.6 - countable ==1.0 - cpio-conduit ==0.7.0 @@ -606,7 +606,7 @@ default-package-overrides: - data-or ==1.0.0.5 - data-ordlist ==0.4.7.0 - data-ref ==0.0.2 - - data-reify ==0.6.2 + - data-reify ==0.6.3 - data-serializer ==0.3.4.1 - data-textual ==0.3.0.3 - data-tree-print ==0.1.0.2 @@ -623,7 +623,7 @@ default-package-overrides: - declarative ==0.5.3 - deepseq-generics ==0.2.0.0 - deepseq-instances ==0.1.0.1 - - deferred-folds ==0.9.10.1 + - deferred-folds ==0.9.11 - dejafu ==2.3.0.1 - dense-linear-algebra ==0.1.0.0 - depq ==0.4.1.0 @@ -1030,10 +1030,10 @@ default-package-overrides: - hedgehog-fakedata ==0.0.1.3 - hedgehog-fn ==1.0 - hedgehog-quickcheck ==0.1.1 - - hedis ==0.12.14 + - hedis ==0.12.15 - here ==1.2.13 - heredoc ==0.2.0.0 - - heterocephalus ==1.0.5.3 + - heterocephalus ==1.0.5.4 - hexml ==0.3.4 - hexml-lens ==0.2.1 - hexpat ==0.20.13 @@ -1091,9 +1091,9 @@ default-package-overrides: - HSlippyMap ==3.0.1 - hslogger ==1.3.1.0 - hslua ==1.0.3.2 - - hslua-aeson ==1.0.3 + - hslua-aeson ==1.0.3.1 - hslua-module-doclayout ==0.1.0 - - hslua-module-system ==0.2.2 + - hslua-module-system ==0.2.2.1 - hslua-module-text ==0.2.1 - HsOpenSSL ==0.11.4.20 - hsp ==0.10.0 @@ -1212,7 +1212,7 @@ default-package-overrides: - influxdb ==1.7.1.6 - ini ==0.4.1 - inj ==1.0 - - inline-c ==0.9.1.2 + - inline-c ==0.9.1.3 - inline-c-cpp ==0.4.0.2 - inliterate ==0.1.0 - insert-ordered-containers ==0.2.3.1 @@ -1651,7 +1651,7 @@ default-package-overrides: - password-instances ==2.0.0.1 - path ==0.7.0 - path-extra ==0.2.0 - - path-io ==1.6.0 + - path-io ==1.6.1 - path-pieces ==0.2.1 - path-text-utf8 ==0.0.1.6 - pathtype ==0.8.1.1 @@ -1858,7 +1858,7 @@ default-package-overrides: - regex-compat ==0.95.2.0 - regex-compat-tdfa ==0.95.1.4 - regex-pcre ==0.95.0.0 - - regex-pcre-builtin ==0.95.1.2.8.43 + - regex-pcre-builtin ==0.95.1.3.8.43 - regex-posix ==0.96.0.0 - regex-tdfa ==1.3.1.0 - regex-with-pcre ==1.1.0.0 @@ -2099,7 +2099,7 @@ default-package-overrides: - storablevector ==0.2.13.1 - stratosphere ==0.53.0 - streaming ==0.2.3.0 - - streaming-bytestring ==0.1.6 + - streaming-bytestring ==0.1.7 - streaming-commons ==0.2.2.1 - streamly ==0.7.2 - streamly-bytestring ==0.1.2 @@ -2162,7 +2162,7 @@ default-package-overrides: - tar-conduit ==0.3.2 - tardis ==0.4.1.0 - tasty ==1.2.3 - - tasty-ant-xml ==1.1.6 + - tasty-ant-xml ==1.1.7 - tasty-dejafu ==2.0.0.6 - tasty-discover ==4.2.2 - tasty-expected-failure ==0.11.1.2 @@ -2172,7 +2172,7 @@ default-package-overrides: - tasty-hunit ==0.10.0.2 - tasty-kat ==0.0.3 - tasty-leancheck ==0.0.1 - - tasty-lua ==0.2.3 + - tasty-lua ==0.2.3.1 - tasty-program ==1.0.5 - tasty-quickcheck ==0.10.1.1 - tasty-rerun ==1.1.17 @@ -2303,7 +2303,7 @@ default-package-overrides: - type-equality ==1 - type-errors ==0.2.0.0 - type-errors-pretty ==0.0.1.1 - - type-fun ==0.1.1 + - type-fun ==0.1.2 - type-hint ==0.1 - type-level-integers ==0.0.1 - type-level-kv-list ==1.1.0 @@ -2330,7 +2330,7 @@ default-package-overrides: - unexceptionalio-trans ==0.5.1 - unicode ==0.0.1.1 - unicode-show ==0.1.0.4 - - unicode-transforms ==0.3.7 + - unicode-transforms ==0.3.7.1 - unification-fd ==0.10.0.1 - union-find ==0.2 - uniplate ==1.6.12 @@ -2361,7 +2361,7 @@ default-package-overrides: - urbit-hob ==0.3.3 - uri-bytestring ==0.3.2.2 - uri-bytestring-aeson ==0.1.0.8 - - uri-encode ==1.5.0.6 + - uri-encode ==1.5.0.7 - url ==2.1.3 - users ==0.5.0.0 - utf8-conversions ==0.1.0.4 @@ -2501,7 +2501,7 @@ default-package-overrides: - xturtle ==0.2.0.0 - xxhash-ffi ==0.2.0.0 - yaml ==0.11.5.0 - - yamlparse-applicative ==0.1.0.1 + - yamlparse-applicative ==0.1.0.2 - yesod ==1.6.1.0 - yesod-auth ==1.6.10 - yesod-auth-fb ==1.10.1 @@ -2877,6 +2877,7 @@ broken-packages: - AC-VanillaArray - AC-Vector - AC-Vector-Fancy + - acc - accelerate - accelerate-arithmetic - accelerate-fftw @@ -2946,6 +2947,7 @@ broken-packages: - aern2-mp - aern2-real - aeson-applicative + - aeson-commit - aeson-decode - aeson-diff-generic - aeson-filthy @@ -3052,6 +3054,9 @@ broken-packages: - aop-prelude - aosd - apart + - apecs-gloss + - apecs-physics + - apecs-physics-gloss - apecs-stm - apelsin - api-builder @@ -3094,6 +3099,7 @@ broken-packages: - arbor-monad-metric-datadog - arbor-postgres - arbtt + - arch-hs - archive-libarchive - archive-tar-bytestring - archiver @@ -3274,6 +3280,7 @@ broken-packages: - Bang - bank-holiday-usa - banwords + - barbies-th - barchart - barcodes-code128 - barecheck @@ -3281,6 +3288,7 @@ broken-packages: - barrie - barrier - barrier-monad + - base-compat-migrate - base-encoding - base-feature-macros - base-generics @@ -3507,6 +3515,7 @@ broken-packages: - blunt - bno055-haskell - bogre-banana + - boilerplate - bolt - boltzmann-brain - bond @@ -3553,6 +3562,7 @@ broken-packages: - brotli-conduit - brotli-streams - browscap + - bsd-sysctl - bson - bson-generic - bson-generics @@ -3567,6 +3577,7 @@ broken-packages: - BufferedSocket - buffet - buffon + - bugsnag-haskell - bugzilla - build - buildable @@ -3615,6 +3626,7 @@ broken-packages: - c10k - c2ats - cabal-audit + - cabal-auto-expose - cabal-bundle-clib - cabal-cache - cabal-cargs @@ -3631,6 +3643,7 @@ broken-packages: - cabal-install-bundle - cabal-install-ghc72 - cabal-install-ghc74 + - cabal-install-parsers - cabal-meta - cabal-mon - cabal-nirvana @@ -3655,6 +3668,7 @@ broken-packages: - cabin - cabocha - cached + - caching - cacophony - cafeteria-prelude - caffegraph @@ -3789,6 +3803,7 @@ broken-packages: - chessIO - chevalier-common - chiasma + - chiphunk - chitauri - Chitra - choose @@ -3854,6 +3869,7 @@ broken-packages: - clckwrks-plugin-mailinglist - clckwrks-plugin-media - clckwrks-plugin-page + - clckwrks-plugin-redirect - clckwrks-theme-bootstrap - clckwrks-theme-clckwrks - clckwrks-theme-geo-bootstrap @@ -4043,6 +4059,7 @@ broken-packages: - confide - config-parser - config-select + - config-value-getopt - ConfigFileTH - Configger - configifier @@ -4229,6 +4246,7 @@ broken-packages: - cuboid - cuckoo - cudd + - curl-runnings - currency-codes - currency-convert - curry-frontend @@ -4446,6 +4464,8 @@ broken-packages: - dhall-check - dhall-docs - dhall-fly + - dhall-nix + - dhall-nixpkgs - dhall-text - dhall-to-cabal - dhall-yaml @@ -4497,6 +4517,7 @@ broken-packages: - dingo-core - dingo-example - dingo-widgets + - diohsc - diophantine - diplomacy - diplomacy-server @@ -4508,6 +4529,7 @@ broken-packages: - directed-cubical - direm - dirfiles + - dirichlet - dirtree - discogs-haskell - discord-gateway @@ -4846,6 +4868,7 @@ broken-packages: - exference - exherbo-cabal - exif + - exiftool - exinst - exinst-aeson - exinst-bytes @@ -5042,6 +5065,7 @@ broken-packages: - flaccuraterip - flamethrower - flamingra + - flashblast - flat - flat-maybe - flatbuffers @@ -5050,6 +5074,7 @@ broken-packages: - flexiwrap - flexiwrap-smallcheck - flickr + - flink-statefulfun - Flippi - flite - float-binstring @@ -5208,6 +5233,7 @@ broken-packages: - funsat - funspection - fused-effects-exceptions + - fused-effects-mwc-random - fused-effects-optics - fused-effects-random - fused-effects-readline @@ -5215,6 +5241,7 @@ broken-packages: - fused-effects-th - fusion - fusion-plugin + - futhark - futun - future - fuzzy-time-gen @@ -5369,6 +5396,7 @@ broken-packages: - gi-gtk-declarative-app-simple - gi-gtk-hs - gi-gtkosxapplication + - gi-gtksheet - gi-handy - gi-poppler - gi-wnck @@ -5550,6 +5578,8 @@ broken-packages: - graphicstools - graphmod-plugin - graphql + - graphql-client + - graphql-engine - graphql-utils - graphql-w-persistent - graphted @@ -5620,6 +5650,7 @@ broken-packages: - haar - habit - hablo + - hablog - HABQT - Hach - hack-contrib @@ -5710,6 +5741,7 @@ broken-packages: - halma-gui - halma-telegram-bot - halves + - ham - HaMinitel - hampp - hamsql @@ -5819,6 +5851,7 @@ broken-packages: - haskell-bitmex-client - haskell-bitmex-rest - haskell-brainfuck + - haskell-ci - haskell-cnc - haskell-coffee - haskell-compression @@ -6054,6 +6087,7 @@ broken-packages: - hdph-closure - hdr-histogram - HDRUtils + - headed-megaparsec - headergen - heapsort - heart-app @@ -6615,7 +6649,9 @@ broken-packages: - http-client-request-modifiers - http-client-session - http-client-streams + - http-client-websockets - http-conduit-browser + - http-conduit-downloader - http-directory - http-dispatch - http-enumerator @@ -6860,6 +6896,7 @@ broken-packages: - instapaper-sender - instinct - int-multimap + - intcode - integer-pure - integreat - intel-aes @@ -6953,6 +6990,7 @@ broken-packages: - ixmonad - ixshader - iyql + - j - j2hs - jack-bindings - JackMiniMix @@ -7032,6 +7070,7 @@ broken-packages: - JSONb - jsonextfilter - JsonGrammar + - jsonifier - jsonresume - jsonrpc-conduit - jsons-to-schema @@ -7124,6 +7163,7 @@ broken-packages: - kit - kmeans-par - kmeans-vector + - kmonad - kmp-dfa - knead - knead-arithmetic @@ -7134,6 +7174,7 @@ broken-packages: - korfu - kqueue - kraken + - krank - krapsh - Kriens - krpc @@ -7336,6 +7377,7 @@ broken-packages: - libhbb - libinfluxdb - libjenkins + - libjwt-typed - liblastfm - liblawless - liblinear-enumerator @@ -7509,6 +7551,7 @@ broken-packages: - loopy - lord - lorem + - lorentz - loris - loshadka - lostcities @@ -7521,6 +7564,7 @@ broken-packages: - ls-usb - lscabal - LslPlus + - lsp - lsystem - ltext - lti13 @@ -7609,6 +7653,7 @@ broken-packages: - mangopay - manifold-random - manifolds + - Map - map-exts - mapalgebra - Mapping @@ -7729,7 +7774,6 @@ broken-packages: - Michelangelo - miconix-test - micro-recursion-schemes - - microaeson - microbase - microformats2-parser - microformats2-types @@ -7782,6 +7826,7 @@ broken-packages: - mlist - mltool - mm2 + - mmsyn4 - mmtf - mmtl - mmtl-base @@ -7883,6 +7928,7 @@ broken-packages: - moo - morfette - morfeusz + - morley - morpheus-graphql-cli - morpheus-graphql-client - morphisms-functors @@ -8029,6 +8075,9 @@ broken-packages: - nagios-plugin-ekg - nakadi-client - named-lock + - named-servant + - named-servant-client + - named-servant-server - namelist - nano-hmac - nano-md5 @@ -8186,7 +8235,9 @@ broken-packages: - NoSlow - not-gloss-examples - notcpp + - nothunks - notifications-tray-icon + - notmuch - notmuch-haskell - notmuch-web - NoTrace @@ -8210,6 +8261,7 @@ broken-packages: - numeric-ranges - numerical - numhask-array + - numhask-free - numhask-hedgehog - numhask-histogram - numhask-prelude @@ -8279,6 +8331,8 @@ broken-packages: - op - opaleye-classy - opaleye-sqlite + - open-adt + - open-adt-tutorial - open-haddock - open-pandoc - open-signals @@ -8314,6 +8368,7 @@ broken-packages: - Operads - operate-do - operational-extra + - oplang - opml-conduit - opn - optima @@ -8343,6 +8398,7 @@ broken-packages: - origami - orizentic - OrPatterns + - orthotope - osc - oscpacking - oset @@ -8523,6 +8579,9 @@ broken-packages: - perfecthash - perhaps - periodic + - periodic-client + - periodic-client-exe + - periodic-server - perm - permutation - permutations @@ -8840,6 +8899,7 @@ broken-packages: - proj4-hs-bindings - project-m36 - projectile + - prolens - prolog - prolog-graph - prolog-graph-lib @@ -8878,6 +8938,7 @@ broken-packages: - pseudo-trie - PTQ - ptr + - ptr-poker - publicsuffixlistcreate - publish - pubnub @@ -8915,6 +8976,7 @@ broken-packages: - puzzle-draw - puzzle-draw-cmdline - pvd + - PyF - pyffi - pyfi - python-pickle @@ -8923,6 +8985,7 @@ broken-packages: - qd - qd-vec - qed + - qhs - qhull-simple - qif - QIO @@ -9082,6 +9145,7 @@ broken-packages: - readpyc - readshp - really-simple-xml-parser + - reanimate - reasonable-lens - record - record-aeson @@ -9105,6 +9169,7 @@ broken-packages: - reenact - Ref - ref + - ref-extras - ref-mtl - refcount - Referees @@ -9295,10 +9360,12 @@ broken-packages: - rng-utils - rob - robin + - roboservant - robots-txt - roc-cluster - roc-cluster-demo - rock + - rocksdb-haskell - rocksdb-query - roku-api - rollbar @@ -9447,6 +9514,7 @@ broken-packages: - scotty-binding-play - scotty-blaze - scotty-fay + - scotty-form - scotty-format - scotty-hastache - scotty-haxl @@ -9524,6 +9592,7 @@ broken-packages: - serv-wai - servant-aeson-specs - servant-auth-cookie + - servant-auth-docs - servant-auth-hmac - servant-auth-token - servant-auth-token-acid @@ -9532,6 +9601,7 @@ broken-packages: - servant-auth-token-persistent - servant-auth-token-rocksdb - servant-avro + - servant-client-js - servant-client-namedargs - servant-csharp - servant-db @@ -9558,6 +9628,7 @@ broken-packages: - servant-matrix-param - servant-namedargs - servant-nix + - servant-openapi3 - servant-pandoc - servant-pool - servant-postgresql @@ -9624,6 +9695,7 @@ broken-packages: - shake-cabal-build - shake-dhall - shake-extras + - shake-futhark - shake-minify - shake-pack - shake-path @@ -9675,8 +9747,10 @@ broken-packages: - sifflet - sifflet-lib - sigma-ij + - signable - signals - signed-multiset + - silkscreen - silvi - simd - simgi @@ -10002,7 +10076,6 @@ broken-packages: - stackage-types - stackage-upload - stackage2nix - - stan - standalone-derive-topdown - standalone-haddock - starling @@ -10041,7 +10114,9 @@ broken-packages: - stgi - STL - STLinkUSB + - stm-actor - stm-chunked-queues + - stm-containers - stm-firehose - stm-promise - stm-stats @@ -10742,6 +10817,7 @@ broken-packages: - Updater - uploadcare - upskirt + - urbit-airlock - ureader - urembed - uri @@ -10794,6 +10870,7 @@ broken-packages: - uuid-aeson - uuid-bytes - uuid-crypto + - uusi - uvector - uvector-algorithms - uxadt @@ -10908,6 +10985,7 @@ broken-packages: - vty-menu - vty-ui - vty-ui-extras + - vulkan-utils - waargonaut - wacom-daemon - waddle @@ -10991,9 +11069,11 @@ broken-packages: - web3 - webapi - webapp + - webauthn - WebBits - WebBits-Html - WebBits-multiplate + - webby - webcloud - WebCont - webcrank @@ -11057,6 +11137,7 @@ broken-packages: - word2vec-model - WordAlignment - wordify + - wordn - WordNet - WordNet-ghc74 - wordpass @@ -11160,6 +11241,7 @@ broken-packages: - xmonad-bluetilebranch - xmonad-contrib-bluetilebranch - xmonad-contrib-gpl + - xmonad-dbus - xmonad-eval - xmonad-vanessa - xmonad-windownames @@ -11338,6 +11420,8 @@ broken-packages: - yu-utils - yuuko - yxdb-utils + - Z-Data + - Z-IO - z3-encoding - z85 - zabt diff --git a/pkgs/development/haskell-modules/configuration-nix.nix b/pkgs/development/haskell-modules/configuration-nix.nix index 2158386629a..a74b1eb05cd 100644 --- a/pkgs/development/haskell-modules/configuration-nix.nix +++ b/pkgs/development/haskell-modules/configuration-nix.nix @@ -542,6 +542,7 @@ self: super: builtins.intersectAttrs super { # Break infinite recursion cycle between QuickCheck and splitmix. splitmix = dontCheck super.splitmix; + splitmix_0_1_0_3 = dontCheck super.splitmix_0_1_0_3; # Break infinite recursion cycle between tasty and clock. clock = dontCheck super.clock; @@ -730,6 +731,7 @@ self: super: builtins.intersectAttrs super { # break infinite recursion with base-orphans primitive = dontCheck super.primitive; + primitive_0_7_1_0 = dontCheck super.primitive_0_7_1_0; cut-the-crap = let path = pkgs.stdenv.lib.makeBinPath [ pkgs.ffmpeg_3 pkgs.youtube-dl ]; diff --git a/pkgs/development/haskell-modules/generic-builder.nix b/pkgs/development/haskell-modules/generic-builder.nix index afb0087a028..a221ce38c8a 100644 --- a/pkgs/development/haskell-modules/generic-builder.nix +++ b/pkgs/development/haskell-modules/generic-builder.nix @@ -64,6 +64,7 @@ in , patches ? null, patchPhase ? null, prePatch ? "", postPatch ? "" , preConfigure ? null, postConfigure ? null , preBuild ? null, postBuild ? null +, preHaddock ? null, postHaddock ? null , installPhase ? null, preInstall ? null, postInstall ? null , checkPhase ? null, preCheck ? null, postCheck ? null , preFixup ? null, postFixup ? null @@ -658,6 +659,8 @@ stdenv.mkDerivation ({ // optionalAttrs (args ? checkPhase) { inherit checkPhase; } // optionalAttrs (args ? preCheck) { inherit preCheck; } // optionalAttrs (args ? postCheck) { inherit postCheck; } +// optionalAttrs (args ? preHaddock) { inherit preHaddock; } +// optionalAttrs (args ? postHaddock) { inherit postHaddock; } // optionalAttrs (args ? preInstall) { inherit preInstall; } // optionalAttrs (args ? installPhase) { inherit installPhase; } // optionalAttrs (args ? postInstall) { inherit postInstall; } diff --git a/pkgs/development/haskell-modules/hackage-packages.nix b/pkgs/development/haskell-modules/hackage-packages.nix index 74c6e3b92f9..f48e90b187b 100644 --- a/pkgs/development/haskell-modules/hackage-packages.nix +++ b/pkgs/development/haskell-modules/hackage-packages.nix @@ -6592,14 +6592,16 @@ self: { ({ mkDerivation, base, base-compat, GLUT, OpenGL, random }: mkDerivation { pname = "FunGEn"; - version = "1.0.1"; - sha256 = "1bal6v1ps8ha5hkz12i20vwypvbcb6s9ykr8yylh4w4ddnsdgh3r"; + version = "1.1.1"; + sha256 = "167bf5p4qcb9wj89x5i5zjjx1f7pmi6s5xbbh43ljhp1f25s9147"; + revision = "1"; + editedCabalFile = "0rgqkr95d2bssmnm4rrkrla7380vgr3isljs8jqglfjy660cynq3"; isLibrary = true; isExecutable = true; enableSeparateDataOutput = true; libraryHaskellDepends = [ base base-compat GLUT OpenGL random ]; executableHaskellDepends = [ base GLUT OpenGL random ]; - description = "A lightweight, cross-platform, OpenGL/GLUT-based game engine"; + description = "A lightweight, cross-platform, OpenGL-based game engine"; license = stdenv.lib.licenses.bsd3; hydraPlatforms = stdenv.lib.platforms.none; broken = true; @@ -8067,8 +8069,8 @@ self: { }: mkDerivation { pname = "HDBC-postgresql"; - version = "2.3.2.7"; - sha256 = "0mfx172lrhwxx6gbqfqji8m14llng76x0mxksm3s556kakvv1cgg"; + version = "2.3.2.8"; + sha256 = "0c76di7a134xhw5pmzdjasgyqxj6gkjkj45mr4mwfrchgdg4cvil"; isLibrary = true; isExecutable = true; setupHaskellDepends = [ base Cabal ]; @@ -13257,6 +13259,8 @@ self: { testHaskellDepends = [ base smallcheck tasty tasty-smallcheck ]; description = "Class of key-value maps"; license = stdenv.lib.licenses.bsd3; + hydraPlatforms = stdenv.lib.platforms.none; + broken = true; }) {}; "MapWith" = callPackage @@ -16332,6 +16336,8 @@ self: { ]; description = "Quasiquotations for a python like interpolated string formater"; license = stdenv.lib.licenses.bsd3; + hydraPlatforms = stdenv.lib.platforms.none; + broken = true; }) {}; "QIO" = callPackage @@ -21882,8 +21888,8 @@ self: { }: mkDerivation { pname = "Z-Data"; - version = "0.1.7.1"; - sha256 = "1yz2bh7mvhc8v4rjzx5wc89x10xnhp0hn40y8n9id982c256vfgm"; + version = "0.1.8.0"; + sha256 = "1yzavy7y8rdpazxmxfa0b9nw7ijrvafcwi5yv74kkj5m626hcizl"; libraryHaskellDepends = [ base case-insensitive deepseq ghc-prim hashable integer-gmp primitive QuickCheck scientific tagged template-haskell @@ -21896,19 +21902,22 @@ self: { ]; description = "Array, vector and text"; license = stdenv.lib.licenses.bsd3; + hydraPlatforms = stdenv.lib.platforms.none; + broken = true; }) {}; "Z-IO" = callPackage ({ mkDerivation, base, bytestring, exceptions, hashable, hspec , hspec-discover, HUnit, primitive, QuickCheck - , quickcheck-instances, scientific, stm, time, word8, Z-Data, zlib + , quickcheck-instances, scientific, stm, time, unix-time, word8 + , Z-Data, zlib }: mkDerivation { pname = "Z-IO"; - version = "0.1.5.2"; - sha256 = "05dkfbnj1kry6c32xdiv1fdlxd2a2z7ma4zk5gisnx5kmshyw75p"; + version = "0.1.6.1"; + sha256 = "1cd84n434i2l13xziys0rm7wx5iqw2xqydf96yj6fwkaysh3hrps"; libraryHaskellDepends = [ - base exceptions primitive stm time Z-Data + base exceptions primitive stm time unix-time Z-Data ]; libraryToolDepends = [ hspec-discover ]; testHaskellDepends = [ @@ -21917,6 +21926,8 @@ self: { ]; description = "Simple and high performance IO toolkit for Haskell"; license = stdenv.lib.licenses.bsd3; + hydraPlatforms = stdenv.lib.platforms.none; + broken = true; }) {}; "ZEBEDDE" = callPackage @@ -22284,6 +22295,8 @@ self: { benchmarkHaskellDepends = [ criterion rerebase ]; description = "Sequence optimized for monoidal construction and folding"; license = stdenv.lib.licenses.mit; + hydraPlatforms = stdenv.lib.platforms.none; + broken = true; }) {}; "accelerate" = callPackage @@ -23821,28 +23834,6 @@ self: { }) {}; "ad" = callPackage - ({ mkDerivation, array, base, Cabal, cabal-doctest, comonad - , containers, criterion, data-reify, directory, doctest, erf - , filepath, free, nats, reflection, semigroups, transformers - }: - mkDerivation { - pname = "ad"; - version = "4.4"; - sha256 = "1v7m5nk9aa0sfqfqmv15dq87s2nl7i3v1d5xx0xla9ydhlqizy4x"; - revision = "1"; - editedCabalFile = "1l9515avbn8hc1yc3x9mqxjrl6idjcf4a9wl4m3607n4anc62hlc"; - setupHaskellDepends = [ base Cabal cabal-doctest ]; - libraryHaskellDepends = [ - array base comonad containers data-reify erf free nats reflection - semigroups transformers - ]; - testHaskellDepends = [ base directory doctest filepath ]; - benchmarkHaskellDepends = [ base criterion erf ]; - description = "Automatic Differentiation"; - license = stdenv.lib.licenses.bsd3; - }) {}; - - "ad_4_4_1" = callPackage ({ mkDerivation, array, base, Cabal, cabal-doctest, comonad , containers, criterion, data-reify, directory, doctest, erf , filepath, free, nats, reflection, semigroups, transformers @@ -23860,7 +23851,6 @@ self: { benchmarkHaskellDepends = [ base criterion erf ]; description = "Automatic Differentiation"; license = stdenv.lib.licenses.bsd3; - hydraPlatforms = stdenv.lib.platforms.none; }) {}; "adaptive-containers" = callPackage @@ -24415,26 +24405,6 @@ self: { }) {}; "aeson-combinators" = callPackage - ({ mkDerivation, aeson, base, bytestring, containers, fail, hspec - , scientific, text, time, time-compat, unordered-containers - , utf8-string, uuid-types, vector, void - }: - mkDerivation { - pname = "aeson-combinators"; - version = "0.0.2.1"; - sha256 = "1a087940jpbnc2rc7cs4xj6kq1wv7b5ibhaimj7f6jglrn9xjgf0"; - libraryHaskellDepends = [ - aeson base bytestring containers fail scientific text time - time-compat unordered-containers uuid-types vector void - ]; - testHaskellDepends = [ - aeson base bytestring hspec text utf8-string - ]; - description = "Aeson combinators for dead simple JSON decoding"; - license = stdenv.lib.licenses.bsd3; - }) {}; - - "aeson-combinators_0_0_3_0" = callPackage ({ mkDerivation, aeson, base, bytestring, containers, doctest, fail , hspec, scientific, text, time, time-compat, unordered-containers , utf8-string, uuid-types, vector, void @@ -24452,7 +24422,6 @@ self: { ]; description = "Aeson combinators for dead simple JSON decoding"; license = stdenv.lib.licenses.bsd3; - hydraPlatforms = stdenv.lib.platforms.none; }) {}; "aeson-commit" = callPackage @@ -24470,6 +24439,8 @@ self: { ]; description = "Parse Aeson data with commitment"; license = stdenv.lib.licenses.bsd3; + hydraPlatforms = stdenv.lib.platforms.none; + broken = true; }) {}; "aeson-compat" = callPackage @@ -24704,8 +24675,8 @@ self: { }: mkDerivation { pname = "aeson-gadt-th"; - version = "0.2.2"; - sha256 = "1nk0897569cldp7fhzc51mj8f93dx3nwk0fxy2pr41wmrbqrxw1k"; + version = "0.2.4"; + sha256 = "0nl9p7q7bfggm7nk8jmqb53qzdr5qwgscpnxy4r7hjvmd4cx6nrm"; isLibrary = true; isExecutable = true; libraryHaskellDepends = [ @@ -26125,16 +26096,17 @@ self: { }) {}; "alfred-margaret" = callPackage - ({ mkDerivation, base, containers, deepseq, hashable, hspec + ({ mkDerivation, aeson, base, containers, deepseq, hashable, hspec , hspec-expectations, primitive, QuickCheck, quickcheck-instances - , text, vector + , text, unordered-containers, vector }: mkDerivation { pname = "alfred-margaret"; - version = "1.0.0.0"; - sha256 = "0dapvcxwwd6ylyqxfjf58jink2rh9i6k1lw1ii6j8jb28qfvy400"; + version = "1.1.1.0"; + sha256 = "1z3plc2a6qnlx1cpb3icw44h3lbspaq2n7djl4pljhb4dm5bflbq"; libraryHaskellDepends = [ - base containers deepseq hashable primitive text vector + aeson base containers deepseq hashable primitive text + unordered-containers vector ]; testHaskellDepends = [ base deepseq hspec hspec-expectations QuickCheck @@ -30296,8 +30268,8 @@ self: { }: mkDerivation { pname = "antiope-athena"; - version = "7.5.1"; - sha256 = "03yy4l5czchq9djxh0yg40vlnynly2wsl5rcj91231n575ndqbij"; + version = "7.5.3"; + sha256 = "0v8qk3v4i8f0bc8mw67km6bly37widk5v94d6paizpkn014c3y0m"; libraryHaskellDepends = [ amazonka amazonka-athena amazonka-core base lens resourcet text unliftio-core @@ -30315,8 +30287,8 @@ self: { ({ mkDerivation, aeson, antiope-s3, avro, base, bytestring, text }: mkDerivation { pname = "antiope-contract"; - version = "7.5.1"; - sha256 = "006i6z7hzz6kkss18wyk2pwmib9ip2z2qwc1r0y3ni1j6kaghbh0"; + version = "7.5.3"; + sha256 = "18ifdaq6z5x3x3fbfbaf86x9wcb4dlgdbdi652a7dyh5kap29a3j"; libraryHaskellDepends = [ aeson antiope-s3 avro base bytestring text ]; @@ -30350,6 +30322,33 @@ self: { license = stdenv.lib.licenses.mit; }) {}; + "antiope-core_7_5_3" = callPackage + ({ mkDerivation, aeson, aeson-lens, amazonka, amazonka-core, base + , bytestring, exceptions, generic-lens, hedgehog, hspec + , hspec-discover, http-client, http-types, hw-hspec-hedgehog, lens + , mtl, resourcet, scientific, text, transformers, unliftio-core + }: + mkDerivation { + pname = "antiope-core"; + version = "7.5.3"; + sha256 = "1bzyahw9i098riqlmhymbk0zjg4iz95r0c4mpsrc811wyqdi7f65"; + libraryHaskellDepends = [ + aeson amazonka amazonka-core base bytestring exceptions + generic-lens http-client http-types lens mtl resourcet text + transformers unliftio-core + ]; + testHaskellDepends = [ + aeson aeson-lens amazonka amazonka-core base bytestring exceptions + generic-lens hedgehog hspec http-client http-types + hw-hspec-hedgehog lens mtl resourcet scientific text transformers + unliftio-core + ]; + testToolDepends = [ hspec-discover ]; + description = "Please see the README on Github at "; + license = stdenv.lib.licenses.mit; + hydraPlatforms = stdenv.lib.platforms.none; + }) {}; + "antiope-dynamodb" = callPackage ({ mkDerivation, aeson, amazonka, amazonka-core, amazonka-dynamodb , antiope-core, base, generic-lens, hspec-discover, lens, text @@ -30374,6 +30373,30 @@ self: { broken = true; }) {}; + "antiope-dynamodb_7_5_3" = callPackage + ({ mkDerivation, aeson, amazonka, amazonka-core, amazonka-dynamodb + , antiope-core, base, generic-lens, hspec-discover, lens, text + , unliftio-core, unordered-containers + }: + mkDerivation { + pname = "antiope-dynamodb"; + version = "7.5.3"; + sha256 = "1j9g36c33virrnsqxrggnx2283nw9bp0i256vgq4z92h1z76kfz0"; + libraryHaskellDepends = [ + aeson amazonka amazonka-core amazonka-dynamodb antiope-core base + generic-lens lens text unliftio-core unordered-containers + ]; + testHaskellDepends = [ + amazonka amazonka-core amazonka-dynamodb antiope-core base + generic-lens lens text unliftio-core unordered-containers + ]; + testToolDepends = [ hspec-discover ]; + description = "Please see the README on Github at "; + license = stdenv.lib.licenses.mit; + hydraPlatforms = stdenv.lib.platforms.none; + broken = true; + }) {}; + "antiope-es" = callPackage ({ mkDerivation, aeson, amazonka, amazonka-core , amazonka-elasticsearch, base, bytestring, hspec, hspec-discover @@ -30381,8 +30404,8 @@ self: { }: mkDerivation { pname = "antiope-es"; - version = "7.5.1"; - sha256 = "1ww4bfwqbyrmzb84wy78yqzp3snbq3xlxvhs7vl3ik71bn99abyr"; + version = "7.5.3"; + sha256 = "0w6l22psj5q2p3chvxikywf5ix20sw7qlqgk24rm0ss6ybsfmk2k"; libraryHaskellDepends = [ aeson amazonka amazonka-core amazonka-elasticsearch base bytestring json-stream lens thyme unordered-containers vector @@ -30417,6 +30440,31 @@ self: { license = stdenv.lib.licenses.mit; }) {}; + "antiope-messages_7_5_3" = callPackage + ({ mkDerivation, aeson, amazonka, amazonka-core, base, bytestring + , generic-lens, hedgehog, hspec, hspec-discover, hw-hspec-hedgehog + , lens, lens-aeson, monad-loops, network-uri, scientific, text + , unliftio-core + }: + mkDerivation { + pname = "antiope-messages"; + version = "7.5.3"; + sha256 = "1kajbd0f81jamk7cg97zkm9z89m0zlsfklhbfarg3rgiaq28ss2v"; + libraryHaskellDepends = [ + aeson amazonka amazonka-core base bytestring generic-lens lens + lens-aeson monad-loops network-uri text unliftio-core + ]; + testHaskellDepends = [ + aeson amazonka amazonka-core base bytestring generic-lens hedgehog + hspec hw-hspec-hedgehog lens lens-aeson monad-loops network-uri + scientific text unliftio-core + ]; + testToolDepends = [ hspec-discover ]; + description = "Please see the README on Github at "; + license = stdenv.lib.licenses.mit; + hydraPlatforms = stdenv.lib.platforms.none; + }) {}; + "antiope-optparse-applicative" = callPackage ({ mkDerivation, aeson, amazonka, amazonka-core, amazonka-s3, base , hedgehog, hspec, hspec-discover, hw-hspec-hedgehog @@ -30424,8 +30472,8 @@ self: { }: mkDerivation { pname = "antiope-optparse-applicative"; - version = "7.5.1"; - sha256 = "0zmsb9ng46p0plch2q8lh5awbkx7vhg9xl3na1czdk0mdh2hdhxz"; + version = "7.5.3"; + sha256 = "1cmgzkfqszqrngfrpj064cpmkw97pxrmcni3352qyzzicnakww56"; libraryHaskellDepends = [ amazonka amazonka-core amazonka-s3 base optparse-applicative text ]; @@ -30466,6 +30514,35 @@ self: { license = stdenv.lib.licenses.mit; }) {}; + "antiope-s3_7_5_3" = callPackage + ({ mkDerivation, aeson, amazonka, amazonka-core, amazonka-s3 + , antiope-core, antiope-messages, attoparsec, base, bytestring + , conduit, conduit-extra, deepseq, dlist, exceptions, generic-lens + , hedgehog, hspec, hspec-discover, http-types, hw-hspec-hedgehog + , lens, mtl, network-uri, resourcet, text, time, unliftio-core + }: + mkDerivation { + pname = "antiope-s3"; + version = "7.5.3"; + sha256 = "1wwh17vzrbg20jmbgf9xdx8vn5qkx8azzczzlyb2s2k3ldlh8s0c"; + libraryHaskellDepends = [ + aeson amazonka amazonka-core amazonka-s3 antiope-core + antiope-messages attoparsec base bytestring conduit conduit-extra + deepseq dlist exceptions generic-lens http-types lens mtl + network-uri resourcet text time unliftio-core + ]; + testHaskellDepends = [ + aeson amazonka amazonka-core amazonka-s3 antiope-core attoparsec + base bytestring conduit conduit-extra exceptions generic-lens + hedgehog hspec http-types hw-hspec-hedgehog lens mtl network-uri + resourcet text time unliftio-core + ]; + testToolDepends = [ hspec-discover ]; + description = "Please see the README on Github at "; + license = stdenv.lib.licenses.mit; + hydraPlatforms = stdenv.lib.platforms.none; + }) {}; + "antiope-shell" = callPackage ({ mkDerivation, aeson, amazonka, amazonka-core, amazonka-s3 , antiope-core, antiope-messages, antiope-s3, attoparsec, base @@ -30476,8 +30553,8 @@ self: { }: mkDerivation { pname = "antiope-shell"; - version = "7.5.1"; - sha256 = "1c68d84ykdamzgybryr474xh826j9b5mh4gn6q3aiapzl5bhh7ym"; + version = "7.5.3"; + sha256 = "1cbvym7ip9vflwjas9fi8izbb6qdrjqq3c8pd7f0ab8a5i7qmbqh"; libraryHaskellDepends = [ aeson amazonka amazonka-core amazonka-s3 antiope-core antiope-messages antiope-s3 attoparsec base bytestring exceptions @@ -30518,6 +30595,30 @@ self: { license = stdenv.lib.licenses.mit; }) {}; + "antiope-sns_7_5_3" = callPackage + ({ mkDerivation, aeson, amazonka, amazonka-core, amazonka-sns, base + , bytestring, generic-lens, hedgehog, hspec, hspec-discover + , hw-hspec-hedgehog, lens, text, time, unliftio-core + }: + mkDerivation { + pname = "antiope-sns"; + version = "7.5.3"; + sha256 = "01saqspi2033y423nyw4k0km3ggmypp3zzhkr7ha51r717bj6sii"; + libraryHaskellDepends = [ + aeson amazonka amazonka-core amazonka-sns base bytestring + generic-lens lens text time unliftio-core + ]; + testHaskellDepends = [ + aeson amazonka amazonka-core amazonka-sns base bytestring + generic-lens hedgehog hspec hw-hspec-hedgehog lens text time + unliftio-core + ]; + testToolDepends = [ hspec-discover ]; + description = "Please see the README on Github at "; + license = stdenv.lib.licenses.mit; + hydraPlatforms = stdenv.lib.platforms.none; + }) {}; + "antiope-sqs" = callPackage ({ mkDerivation, aeson, amazonka, amazonka-core, amazonka-sqs, base , bytestring, conduit, generic-lens, hedgehog, hspec @@ -30544,6 +30645,33 @@ self: { license = stdenv.lib.licenses.mit; }) {}; + "antiope-sqs_7_5_3" = callPackage + ({ mkDerivation, aeson, amazonka, amazonka-core, amazonka-sqs, base + , bytestring, conduit, generic-lens, hedgehog, hspec + , hspec-discover, hw-hspec-hedgehog, lens, lens-aeson, monad-loops + , mtl, network-uri, split, text, time, unliftio-core + , unordered-containers + }: + mkDerivation { + pname = "antiope-sqs"; + version = "7.5.3"; + sha256 = "18wz0ajnh5hib7srwksbwsyqrnp4slzcd2i30p98gnh1plqgbx5p"; + libraryHaskellDepends = [ + aeson amazonka amazonka-core amazonka-sqs base bytestring conduit + generic-lens lens lens-aeson monad-loops mtl network-uri split text + unliftio-core unordered-containers + ]; + testHaskellDepends = [ + aeson amazonka amazonka-core amazonka-sqs base bytestring conduit + generic-lens hedgehog hspec hw-hspec-hedgehog lens lens-aeson + monad-loops mtl network-uri text time unliftio-core + ]; + testToolDepends = [ hspec-discover ]; + description = "Please see the README on Github at "; + license = stdenv.lib.licenses.mit; + hydraPlatforms = stdenv.lib.platforms.none; + }) {}; + "antiope-swf" = callPackage ({ mkDerivation, amazonka-swf, base, hedgehog, hspec , hspec-discover, hw-hspec-hedgehog, lens, text @@ -30825,6 +30953,8 @@ self: { ]; description = "Simple gloss renderer for apecs"; license = stdenv.lib.licenses.bsd3; + hydraPlatforms = stdenv.lib.platforms.none; + broken = true; }) {}; "apecs-physics" = callPackage @@ -30841,6 +30971,8 @@ self: { ]; description = "2D physics for apecs"; license = stdenv.lib.licenses.bsd3; + hydraPlatforms = stdenv.lib.platforms.none; + broken = true; }) {}; "apecs-physics-gloss" = callPackage @@ -30852,6 +30984,8 @@ self: { libraryHaskellDepends = [ apecs apecs-physics base gloss ]; description = "Gloss rendering for apecs-physics"; license = stdenv.lib.licenses.bsd3; + hydraPlatforms = stdenv.lib.platforms.none; + broken = true; }) {}; "apecs-stm" = callPackage @@ -32102,6 +32236,8 @@ self: { pname = "arbor-postgres"; version = "0.0.5"; sha256 = "0vn3jv60pphjjmhjwn1il3sh886dgdxs47gdiqfrii12hv8rsi21"; + revision = "1"; + editedCabalFile = "0954zfh8rnajywcjipd614axbpqq1r04v2nrrmgyjb3f6bk1y8k9"; libraryHaskellDepends = [ base bytestring generic-lens lens network-uri optparse-applicative postgresql-simple text @@ -32203,6 +32339,8 @@ self: { ]; description = "Distribute hackage packages to archlinux"; license = stdenv.lib.licenses.mit; + hydraPlatforms = stdenv.lib.platforms.none; + broken = true; }) {}; "archive" = callPackage @@ -33068,12 +33206,12 @@ self: { }) {}; "arrow-list" = callPackage - ({ mkDerivation, base, containers, mtl }: + ({ mkDerivation, base, containers, fail, mtl }: mkDerivation { pname = "arrow-list"; - version = "0.7"; - sha256 = "1n6m77hdkpjd12r0b8fwxiz3jz0j86cplgsk27m2raj86vr3dy1k"; - libraryHaskellDepends = [ base containers mtl ]; + version = "0.7.1"; + sha256 = "11rzpq8mml00amb0hd09bwwhpn199jr8mxp0454ljkpbgqc5jm9s"; + libraryHaskellDepends = [ base containers fail mtl ]; description = "List arrows for Haskell"; license = stdenv.lib.licenses.bsd3; hydraPlatforms = stdenv.lib.platforms.none; @@ -34923,8 +35061,8 @@ self: { }: mkDerivation { pname = "attoparsec-data"; - version = "1.0.5"; - sha256 = "0wis420lq3bynwjb86sphlhw50d1q9mpm2fnrvpd9a768m1qwiba"; + version = "1.0.5.1"; + sha256 = "1fn28rg79w5kkv3lrmqjcff8fhn1kc2b84vnblr0xqbfdjdbzgp6"; libraryHaskellDepends = [ attoparsec attoparsec-time base bytestring scientific text time uuid @@ -36374,8 +36512,8 @@ self: { }: mkDerivation { pname = "aws-lambda-haskell-runtime"; - version = "3.0.4"; - sha256 = "1rbgi7f1vymh8q6b074z64jlww5gssbzhpam8k8lcgp0zlvm13n1"; + version = "3.0.5"; + sha256 = "07p0lz2hj17n97f2ps59axb4c6416g45m6wcd3hk7jybd6ja8qpr"; libraryHaskellDepends = [ aeson base bytestring case-insensitive http-client http-types path path-io safe-exceptions-checked template-haskell text @@ -36969,13 +37107,13 @@ self: { , free, hashable, hspec, hspec-expectations, lens, monad-control , mtl, neat-interpolation, optparse-applicative, parallel, parsec , posix-pty, pretty, pretty-show, process, QuickCheck, random - , shake, syb, tagged, template, text, time, transformers, unix - , unordered-containers, vector, yaml + , shake, syb, tagged, template, temporary, text, time, transformers + , unix, unordered-containers, vector, yaml }: mkDerivation { pname = "b9"; - version = "3.1.0"; - sha256 = "1jggx5ph7js5r9jck6y2ghlb2il2winz0wg1y01vkp6dc1jpqjd7"; + version = "3.2.0"; + sha256 = "00zsrvqj46a9f7fa8g64xrlmzbwy8gca2bsgvnkv0chzbgn26pjk"; isLibrary = true; isExecutable = true; libraryHaskellDepends = [ @@ -36984,8 +37122,8 @@ self: { exceptions extensible-effects filepath free hashable hspec hspec-expectations lens monad-control mtl neat-interpolation optparse-applicative parallel parsec posix-pty pretty pretty-show - process QuickCheck random shake syb tagged template text time - transformers unix unordered-containers vector yaml + process QuickCheck random shake syb tagged template temporary text + time transformers unix unordered-containers vector yaml ]; executableHaskellDepends = [ aeson base binary bytestring containers directory @@ -37516,6 +37654,8 @@ self: { testHaskellDepends = [ barbies base ]; description = "Create strippable HKD via TH"; license = stdenv.lib.licenses.bsd3; + hydraPlatforms = stdenv.lib.platforms.none; + broken = true; }) {}; "barbly" = callPackage @@ -37717,6 +37857,8 @@ self: { doHaddock = false; description = "Helps migrating projects to base-compat(-batteries)"; license = stdenv.lib.licenses.bsd3; + hydraPlatforms = stdenv.lib.platforms.none; + broken = true; }) {}; "base-encoding" = callPackage @@ -38991,8 +39133,8 @@ self: { }: mkDerivation { pname = "beam-core"; - version = "0.8.0.0"; - sha256 = "1l71xvmny0nf6fdhsffvfj764h4d97icgc291kfqz25n511b74r8"; + version = "0.9.0.0"; + sha256 = "0ixaxjmgg162ff7srvwmkv5lp1kfb0b6wmrpaz97rsmlpa5vf6ji"; libraryHaskellDepends = [ aeson base bytestring containers dlist free ghc-prim hashable microlens mtl network-uri scientific tagged text time vector @@ -39015,8 +39157,8 @@ self: { }: mkDerivation { pname = "beam-migrate"; - version = "0.4.0.1"; - sha256 = "12c5yibargwrw9z806bik7rly9njq0qa60gsqlh8pbzaaji5fknf"; + version = "0.5.0.0"; + sha256 = "0xrmb5nmn5ffzgcpsjilagz5ppm283kfjvvbnsvpvnh6p6i0xc99"; libraryHaskellDepends = [ aeson base beam-core bytestring containers deepseq dependent-map dependent-sum free ghc-prim hashable haskell-src-exts microlens mtl @@ -39067,16 +39209,16 @@ self: { "beam-postgres" = callPackage ({ mkDerivation, aeson, attoparsec, base, beam-core, beam-migrate - , bytestring, case-insensitive, conduit, directory, filepath, free - , hashable, haskell-src-exts, hedgehog, lifted-base, monad-control - , mtl, network-uri, postgresql-libpq, postgresql-simple, process - , scientific, tagged, tasty, tasty-hunit, temporary, text, time + , bytestring, case-insensitive, conduit, free, hashable + , haskell-src-exts, hedgehog, lifted-base, monad-control, mtl + , network-uri, postgresql-libpq, postgresql-simple, scientific + , tagged, tasty, tasty-hunit, text, time, tmp-postgres , unordered-containers, uuid, uuid-types, vector }: mkDerivation { pname = "beam-postgres"; - version = "0.4.0.0"; - sha256 = "0dxnp6zsyy30vrlv15iw4qwyzwawg468zqqsjnzk9h3g9k9xzj3v"; + version = "0.5.0.0"; + sha256 = "03dd9qzw3b2rqva2pn4iaq5lswn8gb7lrlsa6nmc0bfn1w9i4a7k"; libraryHaskellDepends = [ aeson attoparsec base beam-core beam-migrate bytestring case-insensitive conduit free hashable haskell-src-exts lifted-base @@ -39084,8 +39226,8 @@ self: { scientific tagged text time unordered-containers uuid-types vector ]; testHaskellDepends = [ - base beam-core beam-migrate bytestring directory filepath hedgehog - postgresql-simple process tasty tasty-hunit temporary text uuid + aeson base beam-core beam-migrate bytestring hedgehog + postgresql-simple tasty tasty-hunit text tmp-postgres uuid vector ]; description = "Connection layer between beam and postgres"; license = stdenv.lib.licenses.mit; @@ -39096,16 +39238,21 @@ self: { "beam-sqlite" = callPackage ({ mkDerivation, aeson, attoparsec, base, beam-core, beam-migrate , bytestring, dlist, free, hashable, mtl, network-uri, scientific - , sqlite-simple, text, time, unix + , sqlite-simple, tasty, tasty-expected-failure, tasty-hunit, text + , time, unix }: mkDerivation { pname = "beam-sqlite"; - version = "0.4.0.0"; - sha256 = "09va580nv05xavcrqw9drh86xgqgzl98bvh707xjn1d6wh3miizw"; + version = "0.5.0.0"; + sha256 = "1ng67jspdwp4prfzp9lzhl1g26q9bfpmxpwv0q392y8wwrq6zxrj"; libraryHaskellDepends = [ aeson attoparsec base beam-core beam-migrate bytestring dlist free hashable mtl network-uri scientific sqlite-simple text time unix ]; + testHaskellDepends = [ + base beam-core beam-migrate sqlite-simple tasty + tasty-expected-failure tasty-hunit text time + ]; description = "Beam driver for SQLite"; license = stdenv.lib.licenses.mit; hydraPlatforms = stdenv.lib.platforms.none; @@ -39431,22 +39578,6 @@ self: { }) {}; "benchpress" = callPackage - ({ mkDerivation, base, bytestring, mtl, time }: - mkDerivation { - pname = "benchpress"; - version = "0.2.2.14"; - sha256 = "02d4ndwz0xyvfa5j1a4564sfn6fmpf4757dfxr6k20z5vgcdbqih"; - isLibrary = true; - isExecutable = true; - libraryHaskellDepends = [ base mtl time ]; - executableHaskellDepends = [ base bytestring time ]; - description = "Micro-benchmarking with detailed statistics"; - license = stdenv.lib.licenses.bsd3; - hydraPlatforms = stdenv.lib.platforms.none; - broken = true; - }) {}; - - "benchpress_0_2_2_15" = callPackage ({ mkDerivation, base, bytestring, mtl, time }: mkDerivation { pname = "benchpress"; @@ -40760,16 +40891,17 @@ self: { }) {}; "binaryen" = callPackage - ({ mkDerivation, base, binaryen }: + ({ mkDerivation, base }: mkDerivation { pname = "binaryen"; - version = "0.0.4.0"; - sha256 = "1kgvzn5m2pq7ncid27n68p9axrdganna08wlp8csg9c22jixg7rg"; + version = "0.0.5.0"; + sha256 = "0n3w222k1jbijqgjy1kngwx4hjny7qzw3w2gx82qxycbmm1sb1qg"; libraryHaskellDepends = [ base ]; - librarySystemDepends = [ binaryen ]; + testHaskellDepends = [ base ]; + doHaddock = false; description = "Haskell bindings to binaryen"; license = stdenv.lib.licenses.bsd3; - }) {inherit (pkgs) binaryen;}; + }) {}; "bind-marshal" = callPackage ({ mkDerivation, base, bytestring, containers, deepseq, ghc-prim @@ -44264,6 +44396,8 @@ self: { testToolDepends = [ tasty-discover ]; description = "Generate Haskell boilerplate"; license = stdenv.lib.licenses.gpl3Plus; + hydraPlatforms = stdenv.lib.platforms.none; + broken = true; }) {}; "bolt" = callPackage @@ -45973,6 +46107,8 @@ self: { libraryHaskellDepends = [ base ]; description = "Access to the BSD sysctl(3) interface"; license = stdenv.lib.licenses.bsd3; + hydraPlatforms = stdenv.lib.platforms.none; + broken = true; }) {}; "bson" = callPackage @@ -46278,19 +46414,21 @@ self: { "buffet" = callPackage ({ mkDerivation, aeson, aeson-pretty, base, bytestring, cassava , containers, directory, filepath, language-docker, mustache - , optparse-applicative, parsec, random, split, tasty, tasty-hunit - , text, typed-process, unordered-containers, vector, yaml + , optparse-applicative, parsec, prettyprinter, random, split, tasty + , tasty-hunit, text, typed-process, unordered-containers, vector + , yaml }: mkDerivation { pname = "buffet"; - version = "0.4.0"; - sha256 = "04q4k7bfbh41jg869w71wv4idlxbpf48cz2sg5m3ds66wknnhqwq"; + version = "0.5.0"; + sha256 = "0xi5hr51fwksc9983qzgji6p9lhxqfkhnczs6hamddj9glanf183"; isLibrary = false; isExecutable = true; libraryHaskellDepends = [ aeson aeson-pretty base bytestring cassava containers directory filepath language-docker mustache optparse-applicative parsec - random split text typed-process unordered-containers vector yaml + prettyprinter random split text typed-process unordered-containers + vector yaml ]; executableHaskellDepends = [ base ]; testHaskellDepends = [ @@ -46351,12 +46489,12 @@ self: { , case-insensitive, containers, doctest, Glob, hspec, http-client , http-client-tls, http-conduit, http-types, iproute, network , parsec, template-haskell, text, th-lift-instances, time - , ua-parser, unliftio, wai + , ua-parser, unliftio, wai, yaml }: mkDerivation { pname = "bugsnag-haskell"; - version = "0.0.3.1"; - sha256 = "0ka4sj415pn2r2f037hyxw3fwsjzad9g67llm4yx1d3b15zzdxx9"; + version = "0.0.4.0"; + sha256 = "1vmbyyya221f6nkk6j1wxscwcxmh10f0hwsy9ib460d59vf607ym"; isLibrary = true; isExecutable = true; libraryHaskellDepends = [ @@ -46365,10 +46503,12 @@ self: { template-haskell text th-lift-instances time ua-parser wai ]; testHaskellDepends = [ - aeson aeson-qq base doctest hspec text time unliftio + aeson aeson-qq base doctest hspec text time unliftio yaml ]; description = "Bugsnag error reporter for Haskell"; license = stdenv.lib.licenses.mit; + hydraPlatforms = stdenv.lib.platforms.none; + broken = true; }) {}; "bugsnag-hs" = callPackage @@ -48174,6 +48314,8 @@ self: { libraryHaskellDepends = [ base Cabal directory extra filepath ]; description = "Build time library that autodetects exposed modules"; license = stdenv.lib.licenses.mit; + hydraPlatforms = stdenv.lib.platforms.none; + broken = true; }) {}; "cabal-bounds" = callPackage @@ -48761,24 +48903,25 @@ self: { }: mkDerivation { pname = "cabal-install-parsers"; - version = "0.3.0.1"; - sha256 = "1skv3psqs26m68n5xqsw4jil2f3dz5yv8hmskl58sg0q22mjbspm"; - revision = "1"; - editedCabalFile = "1q89viamcwb49qi8as9pdscsi2a0pkjpfj275ch4rx0qj0vwkr67"; + version = "0.4"; + sha256 = "12z9gz1afra0fqd79j1r9fsdc7k8r6v1saw14l42kd2dqxdjqwcf"; libraryHaskellDepends = [ aeson base base16-bytestring binary binary-instances bytestring Cabal containers cryptohash-sha256 deepseq directory filepath lukko network-uri parsec pretty tar text time transformers ]; testHaskellDepends = [ - ansi-terminal base bytestring Cabal containers directory filepath - pretty tasty tasty-golden tasty-hunit tree-diff + ansi-terminal base base16-bytestring bytestring Cabal containers + directory filepath pretty tar tasty tasty-golden tasty-hunit + tree-diff ]; benchmarkHaskellDepends = [ base bytestring Cabal containers criterion directory filepath ]; description = "Utilities to work with cabal-install files"; license = "GPL-2.0-or-later AND BSD-3-Clause"; + hydraPlatforms = stdenv.lib.platforms.none; + broken = true; }) {}; "cabal-lenses" = callPackage @@ -48893,8 +49036,8 @@ self: { }: mkDerivation { pname = "cabal-plan"; - version = "0.7.1.0"; - sha256 = "01hd6wl80j6njlg3h4rxsf5izyx49bs6v1j5756g2pyxc9h4hrs4"; + version = "0.7.2.0"; + sha256 = "118g2ywzgjny57c2iysnj5f7rlriwic3f0k9c54f6bvkc0a3sfi3"; configureFlags = [ "-fexe" ]; isLibrary = true; isExecutable = true; @@ -49274,6 +49417,8 @@ self: { pname = "cabal2spec"; version = "2.6.2"; sha256 = "0x1r01fk5mch76zindalvmlkfaca4y1x89zw2dm0d46fncsfgdrv"; + revision = "1"; + editedCabalFile = "196j1fga9cqlc0nbxbgl0c3g0ic8sf618whps95zzp58lac9dqak"; isLibrary = true; isExecutable = true; libraryHaskellDepends = [ base Cabal filepath time ]; @@ -49541,6 +49686,8 @@ self: { ]; description = "Cache combinators"; license = stdenv.lib.licenses.bsd3; + hydraPlatforms = stdenv.lib.platforms.none; + broken = true; }) {}; "cachix" = callPackage @@ -50080,8 +50227,8 @@ self: { }: mkDerivation { pname = "call-alloy"; - version = "0.2.0.5"; - sha256 = "1qgvrvb9la7nsx04ql8qvlsavalyimbsc7j6pdc14pmyqnrh3y60"; + version = "0.2.1.0"; + sha256 = "0k75fcrn2r4yk59i8r7qwirg0b9vwga9gmibmj4lznqg44yy2bhi"; libraryHaskellDepends = [ base bytestring containers directory file-embed filepath hashable lens mtl process split trifecta unix @@ -50903,6 +51050,8 @@ self: { pname = "casa-types"; version = "0.0.1"; sha256 = "0f8c4a43rh6zr5cwingxyjfpisipy4x4xc0lpasfjaj4vhjgwqkp"; + revision = "1"; + editedCabalFile = "101hhpwc7nhg2laywv2jnqa3jsjkvbvc30i6cs4srvdv2n87jlcb"; libraryHaskellDepends = [ aeson attoparsec base base16-bytestring bytestring hashable path-pieces persistent text @@ -53473,8 +53622,8 @@ self: { }: mkDerivation { pname = "chessIO"; - version = "0.3.1.2"; - sha256 = "0x79cgngxbrk43f28pprqq85n54cg2i2chhpycdcnkx16iva5bbf"; + version = "0.4.0.0"; + sha256 = "0166hrzpw9hcbcgckyf966nvjyf6caa1h3sdi923m9y32924p65v"; isLibrary = true; isExecutable = true; libraryHaskellDepends = [ @@ -53593,6 +53742,8 @@ self: { libraryToolDepends = [ c2hs ]; description = "Haskell bindings for Chipmunk2D physics engine"; license = stdenv.lib.licenses.bsd3; + hydraPlatforms = stdenv.lib.platforms.none; + broken = true; }) {}; "chitauri" = callPackage @@ -54144,8 +54295,8 @@ self: { }: mkDerivation { pname = "churros"; - version = "0.1.2.0"; - sha256 = "0djfcvr81gl6lcz8pb3v0432jh49v8phwp513ca1fz1i75a2nx43"; + version = "0.1.5.0"; + sha256 = "05fb9vmx18dypfw6303y74cbag9vv187w6z402dv4vff35ya4bvh"; libraryHaskellDepends = [ async base containers random stm time unagi-chan ]; @@ -54582,8 +54733,8 @@ self: { }: mkDerivation { pname = "citeproc"; - version = "0.1.0.2"; - sha256 = "184d633d186sa9rshh8im6xxars0x26623sym9pw2h2h709xsg4n"; + version = "0.1.0.3"; + sha256 = "10zkkn00b2rm1lfnwdpmbxp82vmzbh69ivsda40kh0x2d8r1rzxp"; isLibrary = true; isExecutable = true; libraryHaskellDepends = [ @@ -55535,6 +55686,32 @@ self: { broken = true; }) {}; + "clckwrks-plugin-redirect" = callPackage + ({ mkDerivation, acid-state, aeson, attoparsec, base, clckwrks + , containers, filepath, happstack-hsp, happstack-server, hsp + , hsx2hs, ixset, mtl, old-locale, random, reform, reform-happstack + , reform-hsp, safecopy, template-haskell, text, uuid, uuid-orphans + , web-plugins, web-routes, web-routes-happstack, web-routes-th + }: + mkDerivation { + pname = "clckwrks-plugin-redirect"; + version = "0.0.1"; + sha256 = "1946m4fxdj8kr7n1q39j2q9j6srdz97srq0fifnk7mil23lw2vyj"; + isLibrary = true; + isExecutable = true; + libraryHaskellDepends = [ + acid-state aeson attoparsec base clckwrks containers filepath + happstack-hsp happstack-server hsp hsx2hs ixset mtl old-locale + random reform reform-happstack reform-hsp safecopy template-haskell + text uuid uuid-orphans web-plugins web-routes web-routes-happstack + web-routes-th + ]; + description = "support redirects for CMS/Blogging in clckwrks"; + license = stdenv.lib.licenses.bsd3; + hydraPlatforms = stdenv.lib.platforms.none; + broken = true; + }) {}; + "clckwrks-theme-bootstrap" = callPackage ({ mkDerivation, base, clckwrks, happstack-authenticate, hsp , hsx-jmacro, hsx2hs, jmacro, mtl, text, web-plugins @@ -57115,8 +57292,8 @@ self: { }: mkDerivation { pname = "cobot-io"; - version = "0.1.3.7"; - sha256 = "04861j2g4pa05p788inkyvgwqjn1c6jsalkrlmin8j3nd0gw2ggq"; + version = "0.1.3.8"; + sha256 = "1x3ikycb9v9hmn1j57sddnr50kb3kvnch6w09fsyqzzmbnfc6nys"; libraryHaskellDepends = [ array attoparsec base binary bytestring containers data-msgpack deepseq http-conduit hyraxAbif lens linear mtl split text vector @@ -60492,34 +60669,6 @@ self: { }) {}; "conduit" = callPackage - ({ mkDerivation, base, bytestring, containers, deepseq, directory - , exceptions, filepath, gauge, hspec, kan-extensions - , mono-traversable, mtl, mwc-random, primitive, QuickCheck - , resourcet, safe, silently, split, text, transformers, unix - , unliftio, unliftio-core, vector - }: - mkDerivation { - pname = "conduit"; - version = "1.3.2.1"; - sha256 = "0kyl1zspkp14vrgxgc2zpy9rd9h6aa7m9f385sgshysnhbc7hbg5"; - libraryHaskellDepends = [ - base bytestring directory exceptions filepath mono-traversable mtl - primitive resourcet text transformers unix unliftio-core vector - ]; - testHaskellDepends = [ - base bytestring containers directory exceptions filepath hspec - mono-traversable mtl QuickCheck resourcet safe silently split text - transformers unliftio vector - ]; - benchmarkHaskellDepends = [ - base containers deepseq gauge hspec kan-extensions mwc-random - transformers vector - ]; - description = "Streaming data processing library"; - license = stdenv.lib.licenses.mit; - }) {}; - - "conduit_1_3_3" = callPackage ({ mkDerivation, base, bytestring, containers, deepseq, directory , exceptions, filepath, gauge, hspec, kan-extensions , mono-traversable, mtl, mwc-random, primitive, QuickCheck @@ -60545,7 +60694,6 @@ self: { ]; description = "Streaming data processing library"; license = stdenv.lib.licenses.mit; - hydraPlatforms = stdenv.lib.platforms.none; }) {}; "conduit-algorithms" = callPackage @@ -61448,6 +61596,8 @@ self: { libraryHaskellDepends = [ base config-value text ]; description = "Interface between config-value and System.GetOpt"; license = stdenv.lib.licenses.mit; + hydraPlatforms = stdenv.lib.platforms.none; + broken = true; }) {}; "configifier" = callPackage @@ -63489,8 +63639,8 @@ self: { }: mkDerivation { pname = "core-program"; - version = "0.2.4.5"; - sha256 = "1a2zjdywmgniwcj649f43hri55bh30vz2s00r3yqj3gvhhighi86"; + version = "0.2.5.0"; + sha256 = "0bgzlyxcmnn7bscw04v9rljny9wjhcg066nbqk47aphdd6b716dj"; libraryHaskellDepends = [ async base bytestring chronologique core-data core-text directory exceptions filepath fsnotify hashable hourglass mtl prettyprinter @@ -66818,6 +66968,8 @@ self: { ]; description = "A framework for declaratively writing curl based API tests"; license = stdenv.lib.licenses.mit; + hydraPlatforms = stdenv.lib.platforms.none; + broken = true; }) {}; "curlhs" = callPackage @@ -67576,17 +67728,17 @@ self: { , filepath, FindBin, hashable, haskeline, html, http-conduit , http-types, HUnit, leancheck, memory, mmap, monad-control, mtl , network, network-uri, old-time, parsec, process, QuickCheck - , regex-applicative, regex-compat-tdfa, sandi, split, stm - , system-fileio, system-filepath, tar, temporary, terminfo - , test-framework, test-framework-hunit, test-framework-leancheck + , regex-applicative, regex-compat-tdfa, stm, system-fileio + , system-filepath, tar, temporary, terminfo, test-framework + , test-framework-hunit, test-framework-leancheck , test-framework-quickcheck2, text, time, transformers , transformers-base, unix, unix-compat, utf8-string, vector , zip-archive, zlib }: mkDerivation { pname = "darcs"; - version = "2.16.2"; - sha256 = "1nsmaai4l5zas4v1vk92nvh721dykcxrpd4c2v9bh3wi3n2m45qn"; + version = "2.16.3"; + sha256 = "1bf11ndz6k7fx9bb31l4l6dqfkrld3gxsrrqggcg7d57wa3yw9c9"; configureFlags = [ "-fforce-char8-encoding" "-flibrary" ]; isLibrary = true; isExecutable = true; @@ -67596,16 +67748,16 @@ self: { conduit constraints containers cryptonite data-ordlist directory fgl filepath hashable haskeline html http-conduit http-types memory mmap mtl network network-uri old-time parsec process - regex-applicative regex-compat-tdfa sandi stm tar temporary - terminfo text time transformers unix unix-compat utf8-string vector - zip-archive zlib + regex-applicative regex-compat-tdfa stm tar temporary terminfo text + time transformers unix unix-compat utf8-string vector zip-archive + zlib ]; executableHaskellDepends = [ base ]; testHaskellDepends = [ array async base bytestring cmdargs constraints containers directory exceptions filepath FindBin HUnit leancheck monad-control - mtl process QuickCheck split system-fileio system-filepath - test-framework test-framework-hunit test-framework-leancheck + mtl process QuickCheck system-fileio system-filepath test-framework + test-framework-hunit test-framework-leancheck test-framework-quickcheck2 text time transformers transformers-base unix-compat vector zip-archive ]; @@ -69364,22 +69516,6 @@ self: { }) {}; "data-reify" = callPackage - ({ mkDerivation, base, containers, hashable, unordered-containers - }: - mkDerivation { - pname = "data-reify"; - version = "0.6.2"; - sha256 = "19mljyx1v86plnwqm5y1livw5qd8cc9z5k1kfchqiiwj1vsq660v"; - isLibrary = true; - isExecutable = true; - libraryHaskellDepends = [ - base containers hashable unordered-containers - ]; - description = "Reify a recursive data structure into an explicit graph"; - license = stdenv.lib.licenses.bsd3; - }) {}; - - "data-reify_0_6_3" = callPackage ({ mkDerivation, base, base-compat, containers, hashable, hspec , hspec-discover, unordered-containers }: @@ -69396,7 +69532,6 @@ self: { testToolDepends = [ hspec-discover ]; description = "Reify a recursive data structure into an explicit graph"; license = stdenv.lib.licenses.bsd3; - hydraPlatforms = stdenv.lib.platforms.none; }) {}; "data-reify-cse" = callPackage @@ -71568,28 +71703,6 @@ self: { }) {}; "deferred-folds" = callPackage - ({ mkDerivation, base, bytestring, containers, foldl, hashable - , primitive, QuickCheck, quickcheck-instances, rerebase, tasty - , tasty-hunit, tasty-quickcheck, transformers, unordered-containers - , vector - }: - mkDerivation { - pname = "deferred-folds"; - version = "0.9.10.1"; - sha256 = "15lwcc7i7wmi1gkkmak677qw0fnz4a4ldnv842xaimfi64753shv"; - libraryHaskellDepends = [ - base bytestring containers foldl hashable primitive transformers - unordered-containers vector - ]; - testHaskellDepends = [ - QuickCheck quickcheck-instances rerebase tasty tasty-hunit - tasty-quickcheck - ]; - description = "Abstractions over deferred folds"; - license = stdenv.lib.licenses.mit; - }) {}; - - "deferred-folds_0_9_11" = callPackage ({ mkDerivation, base, bytestring, containers, foldl, hashable , primitive, QuickCheck, quickcheck-instances, rerebase, tasty , tasty-hunit, tasty-quickcheck, transformers, unordered-containers @@ -71609,7 +71722,6 @@ self: { ]; description = "Abstractions over deferred folds"; license = stdenv.lib.licenses.mit; - hydraPlatforms = stdenv.lib.platforms.none; }) {}; "definitive-base" = callPackage @@ -73171,7 +73283,7 @@ self: { license = stdenv.lib.licenses.bsd3; }) {}; - "dhall_1_35_0" = callPackage + "dhall_1_36_0" = callPackage ({ mkDerivation, aeson, aeson-pretty, ansi-terminal, atomic-write , base, bytestring, case-insensitive, cborg, cborg-json, containers , contravariant, cryptonite, data-fix, deepseq, Diff, directory @@ -73190,10 +73302,8 @@ self: { }: mkDerivation { pname = "dhall"; - version = "1.35.0"; - sha256 = "19h0afgxqq9da1apx4xx9p4p0f2r6miivc4l1dkhbbvfk2r5wkw3"; - revision = "2"; - editedCabalFile = "0jfgmh4mh7v2srwvz76zpffhgnrqx9fgrhn2hdsfgrzh95zjx0my"; + version = "1.36.0"; + sha256 = "014bdxmrcxzc2yrk838fxbz521714fk3a7c6idb9065wrfzch1wj"; isLibrary = true; isExecutable = true; enableSeparateDataOutput = true; @@ -73212,11 +73322,12 @@ self: { executableHaskellDepends = [ base ]; testHaskellDepends = [ base bytestring cborg containers data-fix deepseq directory doctest - either filepath foldl generic-random lens-family-core megaparsec - mockery prettyprinter QuickCheck quickcheck-instances scientific - serialise special-values spoon tasty tasty-expected-failure - tasty-hunit tasty-quickcheck tasty-silver template-haskell text - transformers turtle unordered-containers vector + either filepath foldl generic-random http-client http-client-tls + lens-family-core megaparsec mockery prettyprinter QuickCheck + quickcheck-instances scientific serialise special-values spoon + tasty tasty-expected-failure tasty-hunit tasty-quickcheck + tasty-silver template-haskell text transformers turtle + unordered-containers vector ]; benchmarkHaskellDepends = [ base bytestring containers directory gauge text @@ -73250,16 +73361,14 @@ self: { license = stdenv.lib.licenses.bsd3; }) {}; - "dhall-bash_1_0_33" = callPackage + "dhall-bash_1_0_34" = callPackage ({ mkDerivation, base, bytestring, containers, dhall , neat-interpolation, optparse-generic, shell-escape, text }: mkDerivation { pname = "dhall-bash"; - version = "1.0.33"; - sha256 = "0b920cscim2mqcav0yy4s00gcgjqfybvbmfvnnbvarxswknw8z1v"; - revision = "1"; - editedCabalFile = "1r01himc5n19q9675i6i27yrfrx9l362ycsnvk48mcbrbmv1z5lf"; + version = "1.0.34"; + sha256 = "1p1zylrjk80lh8rxpw2z3wyvk9x7q65lwyfwfacx8rrbgzx54riy"; isLibrary = true; isExecutable = true; libraryHaskellDepends = [ @@ -73302,8 +73411,8 @@ self: { }: mkDerivation { pname = "dhall-docs"; - version = "1.0.1"; - sha256 = "0632l4h72zrddknhha8lz53ynzbdrhb11mvj09qfmr4b1rd01amz"; + version = "1.0.2"; + sha256 = "17l8vwj02lbkqy8p4j7rhmwidrxx1ln375cv8lgwwx4n0fgvmgfc"; isLibrary = true; isExecutable = true; enableSeparateDataOutput = true; @@ -73389,7 +73498,7 @@ self: { license = stdenv.lib.licenses.bsd3; }) {}; - "dhall-json_1_7_2" = callPackage + "dhall-json_1_7_3" = callPackage ({ mkDerivation, aeson, aeson-pretty, aeson-yaml, ansi-terminal , base, bytestring, containers, dhall, exceptions, filepath , lens-family-core, optparse-applicative, prettyprinter @@ -73398,8 +73507,8 @@ self: { }: mkDerivation { pname = "dhall-json"; - version = "1.7.2"; - sha256 = "189mpnh2fnm1gwc1lvqa3wy9wk2wh8jj3216dvidik545008yvcj"; + version = "1.7.3"; + sha256 = "0as1n4qy0rynmj1y7h39l1lazqarwgizbzsn0g7apixzzdfm53kx"; isLibrary = true; isExecutable = true; libraryHaskellDepends = [ @@ -73467,7 +73576,7 @@ self: { license = stdenv.lib.licenses.mit; }) {}; - "dhall-lsp-server_1_0_10" = callPackage + "dhall-lsp-server_1_0_11" = callPackage ({ mkDerivation, aeson, aeson-pretty, base, bytestring, containers , data-default, dhall, dhall-json, directory, doctest, filepath , haskell-lsp, haskell-lsp-types, hslogger, lens, lens-family-core @@ -73477,8 +73586,8 @@ self: { }: mkDerivation { pname = "dhall-lsp-server"; - version = "1.0.10"; - sha256 = "0z6b3yq8fijxycabwrbqn2z94lb2ak2fmajlxgawyd1723cl2wsb"; + version = "1.0.11"; + sha256 = "0xp4mbk26p22xs5f2bz493yi9ijbiiz1jwmc462yk1bxxz5lbx5n"; isLibrary = true; isExecutable = true; libraryHaskellDepends = [ @@ -73503,10 +73612,8 @@ self: { }: mkDerivation { pname = "dhall-nix"; - version = "1.1.17"; - sha256 = "1c696f0if218pbmir4rmkb6shcgk9acw5g1iwcb2mslshmncbyfd"; - revision = "1"; - editedCabalFile = "0vdni3cmx3p6a0p587avja4zg6278fmdfv6jh5h4wfx0b7z1sphg"; + version = "1.1.18"; + sha256 = "0d947iz98mkmz7chxcp2402kid711na7xwwx8xzh8jg5lh41sm7w"; isLibrary = true; isExecutable = true; libraryHaskellDepends = [ @@ -73518,6 +73625,8 @@ self: { ]; description = "Dhall to Nix compiler"; license = stdenv.lib.licenses.bsd3; + hydraPlatforms = stdenv.lib.platforms.none; + broken = true; }) {}; "dhall-nixpkgs" = callPackage @@ -73528,8 +73637,8 @@ self: { }: mkDerivation { pname = "dhall-nixpkgs"; - version = "1.0.1"; - sha256 = "1dw3bygs3da7yfcm5h376ppswv3dcny42yqjy7fabyzw72d4586z"; + version = "1.0.2"; + sha256 = "1r76zbqk2pc5pryrbdj425j6bb86x28pqfkav3kw9kr4703afhni"; isLibrary = false; isExecutable = true; executableHaskellDepends = [ @@ -73539,6 +73648,8 @@ self: { ]; description = "Convert Dhall projects to Nix packages"; license = stdenv.lib.licenses.bsd3; + hydraPlatforms = stdenv.lib.platforms.none; + broken = true; }) {}; "dhall-text" = callPackage @@ -73622,7 +73733,7 @@ self: { broken = true; }) {}; - "dhall-yaml_1_2_2" = callPackage + "dhall-yaml_1_2_3" = callPackage ({ mkDerivation, aeson, ansi-terminal, base, bytestring, dhall , dhall-json, exceptions, HsYAML, HsYAML-aeson , optparse-applicative, prettyprinter, prettyprinter-ansi-terminal @@ -73630,8 +73741,8 @@ self: { }: mkDerivation { pname = "dhall-yaml"; - version = "1.2.2"; - sha256 = "1mswyac77p0zpjdfr86x4ddwlnvqz0ibf98hr8q0zm1a9ibds982"; + version = "1.2.3"; + sha256 = "1n42brr1yifb4pyl26960rsm8b1wzw0hvv6mmq8m5ml5av61ymf3"; isLibrary = true; isExecutable = true; libraryHaskellDepends = [ @@ -75291,6 +75402,8 @@ self: { ]; description = "Gemini client"; license = stdenv.lib.licenses.gpl3; + hydraPlatforms = stdenv.lib.platforms.none; + broken = true; }) {}; "diophantine" = callPackage @@ -75600,6 +75713,27 @@ self: { broken = true; }) {}; + "dirichlet" = callPackage + ({ mkDerivation, base, hspec, hspec-discover, log-domain + , math-functions, mwc-random, primitive, vector + }: + mkDerivation { + pname = "dirichlet"; + version = "0.1.0.0"; + sha256 = "173mw8706fjrqdjwrjfcb8g140hp4xdjbpvhvq71f8lj8527b9ia"; + libraryHaskellDepends = [ + base log-domain math-functions mwc-random primitive vector + ]; + testHaskellDepends = [ + base hspec hspec-discover log-domain mwc-random vector + ]; + testToolDepends = [ hspec-discover ]; + description = "Multivariate dirichlet distribution"; + license = stdenv.lib.licenses.bsd3; + hydraPlatforms = stdenv.lib.platforms.none; + broken = true; + }) {}; + "dirstream" = callPackage ({ mkDerivation, base, directory, pipes, pipes-safe, system-fileio , system-filepath, unix @@ -78907,6 +79041,34 @@ self: { broken = true; }) {}; + "dropbox" = callPackage + ({ mkDerivation, aeson, aeson-qq, base, hspec, hspec-core + , http-api-data, http-client-tls, servant, servant-auth + , servant-auth-client, servant-client, servant-client-core, text + }: + mkDerivation { + pname = "dropbox"; + version = "0.0.4"; + sha256 = "1syfzlgjph7nn2231sn0cm3q0f32inc5r9zc95f8kl43qa003zrz"; + isLibrary = true; + isExecutable = true; + libraryHaskellDepends = [ + aeson base http-api-data http-client-tls servant servant-auth + servant-auth-client servant-client servant-client-core text + ]; + executableHaskellDepends = [ + aeson base http-api-data http-client-tls servant servant-auth + servant-auth-client servant-client servant-client-core text + ]; + testHaskellDepends = [ + aeson aeson-qq base hspec hspec-core http-api-data http-client-tls + servant servant-auth servant-auth-client servant-client + servant-client-core text + ]; + description = "Dropbox API client"; + license = stdenv.lib.licenses.mit; + }) {}; + "dropbox-sdk" = callPackage ({ mkDerivation, base, blaze-builder, bytestring, case-insensitive , certificate, conduit, HTTP, http-conduit, http-types, json @@ -79122,6 +79284,28 @@ self: { broken = true; }) {}; + "dsv" = callPackage + ({ mkDerivation, attoparsec, base, bytestring, cassava, containers + , doctest, foldl, hedgehog, pipes, pipes-bytestring, pipes-safe + , safe-exceptions, template-haskell, text, validation, vector + }: + mkDerivation { + pname = "dsv"; + version = "1.0.0.0"; + sha256 = "0fjfpa8qfaiy7wxmq9lsacxywrsqahl8s8wamxfiai7mzq2201gn"; + enableSeparateDataOutput = true; + libraryHaskellDepends = [ + attoparsec base bytestring cassava containers foldl pipes + pipes-bytestring pipes-safe template-haskell text validation vector + ]; + testHaskellDepends = [ + base bytestring containers doctest foldl hedgehog safe-exceptions + text vector + ]; + description = "DSV (delimiter-separated values)"; + license = stdenv.lib.licenses.mit; + }) {}; + "dtab" = callPackage ({ mkDerivation, alex, array, base, binary, bytestring, containers , data-binary-ieee754, happy, pretty, transformers @@ -81053,17 +81237,21 @@ self: { }) {}; "effet" = callPackage - ({ mkDerivation, base, containers, monad-control, template-haskell - , transformers, transformers-base + ({ mkDerivation, base, containers, hspec, monad-control + , template-haskell, transformers, transformers-base }: mkDerivation { pname = "effet"; - version = "0.3.0.1"; - sha256 = "18cmgap4a3qnglmysh2l8pmag0vx8nqrrzx52zn9zrb54l1ldgm2"; + version = "0.3.0.2"; + sha256 = "1yy8hpq74bp4ffz7b5h7j9ja6akizl7d3b9n7n42c0iwlzr1hi4s"; libraryHaskellDepends = [ base containers monad-control template-haskell transformers transformers-base ]; + testHaskellDepends = [ + base containers hspec monad-control template-haskell transformers + transformers-base + ]; description = "An Effect System based on Type Classes"; license = stdenv.lib.licenses.bsd3; }) {}; @@ -85263,8 +85451,8 @@ self: { }: mkDerivation { pname = "eve"; - version = "0.1.8"; - sha256 = "1bhv9mh61f69xff5y8nagri1flc3m87sxx3b17kbxi5d2hhzsaqz"; + version = "0.1.9.0"; + sha256 = "06b2qybglsww0f7wpy2fnmr3l9r5a0aikybd23cjl6ribq86l8y9"; libraryHaskellDepends = [ base containers data-default free lens mtl ]; @@ -86270,6 +86458,8 @@ self: { ]; description = "Haskell bindings to ExifTool"; license = stdenv.lib.licenses.mit; + hydraPlatforms = stdenv.lib.platforms.none; + broken = true; }) {}; "exigo-schema" = callPackage @@ -88311,6 +88501,8 @@ self: { pname = "fastsum"; version = "0.1.1.1"; sha256 = "0j9jd068xgk7nn2ilgdkv1pxngflqqgxz1pnhdssgiih04v8zw5l"; + revision = "1"; + editedCabalFile = "0mmdkpgxlc6fsl5pq8kgdh41h08m86s0y4wnan293h3c74q1xd6x"; isLibrary = true; isExecutable = true; libraryHaskellDepends = [ @@ -91490,31 +91682,37 @@ self: { }) {}; "flashblast" = callPackage - ({ mkDerivation, attoparsec, base, composite-base, dhall - , formatting, lucid, megaparsec, path, path-dhall-instance - , path-utils, polysemy, polysemy-video, replace-megaparsec, rio - , semialign, subtitleParser, these, turtle, unliftio-path, vinyl + ({ mkDerivation, aeson, attoparsec, base, co-log-polysemy + , co-log-polysemy-formatting, composite-base, dhall, formatting + , http-conduit, lucid, megaparsec, path, path-dhall-instance + , path-utils, polysemy, polysemy-plugin, polysemy-video + , polysemy-zoo, replace-megaparsec, rio, semialign, subtitleParser + , temporary, these, turtle, unliftio-path, vinyl }: mkDerivation { pname = "flashblast"; - version = "0.0.1.1"; - sha256 = "0syqfjg373sq3326nxqaq4zipb342df8av78cm63j78mnl7xjq0x"; + version = "0.0.4.0"; + sha256 = "13n90wkmj69lkyvsw34dhr173m8qfdclkygnh7v5xwdrk5fgpb5s"; isLibrary = true; isExecutable = true; libraryHaskellDepends = [ - attoparsec base composite-base dhall formatting lucid megaparsec - path path-dhall-instance path-utils polysemy polysemy-video - replace-megaparsec rio semialign subtitleParser these turtle - unliftio-path vinyl + aeson attoparsec base co-log-polysemy co-log-polysemy-formatting + composite-base dhall formatting http-conduit lucid megaparsec path + path-dhall-instance path-utils polysemy polysemy-plugin + polysemy-video polysemy-zoo replace-megaparsec rio semialign + subtitleParser temporary these turtle unliftio-path vinyl ]; executableHaskellDepends = [ - attoparsec base composite-base dhall formatting lucid megaparsec - path path-dhall-instance path-utils polysemy polysemy-video - replace-megaparsec rio semialign subtitleParser these turtle - unliftio-path vinyl + aeson attoparsec base co-log-polysemy co-log-polysemy-formatting + composite-base dhall formatting http-conduit lucid megaparsec path + path-dhall-instance path-utils polysemy polysemy-plugin + polysemy-video polysemy-zoo replace-megaparsec rio semialign + subtitleParser temporary these turtle unliftio-path vinyl ]; description = "Generate language learning flashcards from video"; license = stdenv.lib.licenses.mit; + hydraPlatforms = stdenv.lib.platforms.none; + broken = true; }) {}; "flat" = callPackage @@ -91797,6 +91995,8 @@ self: { libraryToolDepends = [ proto-lens-protoc ]; description = "Flink stateful functions SDK"; license = stdenv.lib.licenses.mpl20; + hydraPlatforms = stdenv.lib.platforms.none; + broken = true; }) {}; "flip-cmd" = callPackage @@ -92611,6 +92811,24 @@ self: { license = stdenv.lib.licenses.mit; }) {}; + "focus_1_0_1_4" = callPackage + ({ mkDerivation, base, QuickCheck, quickcheck-instances, rerebase + , tasty, tasty-hunit, tasty-quickcheck, transformers + }: + mkDerivation { + pname = "focus"; + version = "1.0.1.4"; + sha256 = "1knaiwnxcl2hrx4b3k954rd5v995gxa48db1z9mp58s646ymlmfl"; + libraryHaskellDepends = [ base transformers ]; + testHaskellDepends = [ + QuickCheck quickcheck-instances rerebase tasty tasty-hunit + tasty-quickcheck + ]; + description = "A general abstraction for manipulating elements of container data structures"; + license = stdenv.lib.licenses.mit; + hydraPlatforms = stdenv.lib.platforms.none; + }) {}; + "focuslist" = callPackage ({ mkDerivation, base, Cabal, cabal-doctest, containers, doctest , genvalidity-containers, genvalidity-hspec, hedgehog, lens @@ -96203,6 +96421,8 @@ self: { benchmarkHaskellDepends = [ base fused-effects-random gauge ]; description = "High-quality random number generation as an effect"; license = stdenv.lib.licenses.bsd3; + hydraPlatforms = stdenv.lib.platforms.none; + broken = true; }) {}; "fused-effects-optics" = callPackage @@ -96361,6 +96581,8 @@ self: { pname = "futhark"; version = "0.18.1"; sha256 = "12nbksr3qywqg88cj4yy5z9qnn24cdxjg8ym70bxym8a8m52928c"; + revision = "1"; + editedCabalFile = "0598rwva6svavwka9m6vr1raz1x8wvn9bfvcc7j8kvdh6m6y9w4m"; isLibrary = true; isExecutable = true; libraryHaskellDepends = [ @@ -96381,6 +96603,8 @@ self: { ]; description = "An optimising compiler for a functional, array-oriented language"; license = stdenv.lib.licenses.isc; + hydraPlatforms = stdenv.lib.platforms.none; + broken = true; }) {}; "futhask" = callPackage @@ -97068,12 +97292,12 @@ self: { }) {}; "gasp" = callPackage - ({ mkDerivation, base, binary, containers, mtl }: + ({ mkDerivation, base, binary, containers, mtl, QuickCheck }: mkDerivation { pname = "gasp"; - version = "1.2.0.0"; - sha256 = "0dq867kgil7xp7wqk8ylmx9ninxrqwc375g5l13iskvyz1li7474"; - libraryHaskellDepends = [ base binary containers mtl ]; + version = "1.3.0.0"; + sha256 = "0dhna3mj7mdyk1n0x3barpn5g4hkjl9fnbr403xym1dm8rl7r7hg"; + libraryHaskellDepends = [ base binary containers mtl QuickCheck ]; description = "A framework of algebraic classes"; license = stdenv.lib.licenses.bsd3; }) {}; @@ -99857,20 +100081,20 @@ self: { ({ mkDerivation, base, blaze-svg, bytestring, containers , diagrams-lib, diagrams-svg, filepath, ghc-events, hashable, lens , mtl, optparse-applicative, parsec, regex-base, regex-pcre-builtin - , SVGFonts, template-haskell, th-lift, transformers - , unordered-containers + , SVGFonts, template-haskell, text, th-lift, th-lift-instances + , transformers, unordered-containers }: mkDerivation { pname = "ghc-events-analyze"; - version = "0.2.7"; - sha256 = "01395ncya596fw6il2ddlziwcygvahswx0q9fjy7j7v7jqgzva3x"; + version = "0.2.8"; + sha256 = "1aam80l76dy76b8wbkjnbmxkmbgvczs591yjnbb9rm5bv9ggcb29"; isLibrary = false; isExecutable = true; executableHaskellDepends = [ base blaze-svg bytestring containers diagrams-lib diagrams-svg filepath ghc-events hashable lens mtl optparse-applicative parsec - regex-base regex-pcre-builtin SVGFonts template-haskell th-lift - transformers unordered-containers + regex-base regex-pcre-builtin SVGFonts template-haskell text + th-lift th-lift-instances transformers unordered-containers ]; description = "Analyze and visualize event logs"; license = stdenv.lib.licenses.bsd3; @@ -102413,6 +102637,8 @@ self: { libraryPkgconfigDepends = [ gtksheet ]; description = "GtkSheet bindings"; license = stdenv.lib.licenses.lgpl21; + hydraPlatforms = stdenv.lib.platforms.none; + broken = true; }) {gtksheet = null;}; "gi-gtksource" = callPackage @@ -108339,8 +108565,8 @@ self: { }: mkDerivation { pname = "gopro-plus"; - version = "0.3.1.1"; - sha256 = "0gjdz5c165hk4nbynp3s633kzivq62y3riz45w0l0k2qrirpkd14"; + version = "0.4.1.0"; + sha256 = "1xim8kr58nnpfh1sj66p73alm1l8wwxqafx5b77wc51dwrjyz1p8"; libraryHaskellDepends = [ aeson base bytestring containers exceptions filepath generic-deriving lens lens-aeson mtl random retry text time @@ -108594,8 +108820,8 @@ self: { }: mkDerivation { pname = "gotta-go-fast"; - version = "0.3.0.0"; - sha256 = "067jmp0p21bw7mpsrlpawphjmlq9f85lsfiihp37pvs8sxb36lg9"; + version = "0.3.0.6"; + sha256 = "1cv8l54wg2gsbk7wr0zmw47k9v8vs5dzj4k1wp5b17p3wp92s1av"; isLibrary = false; isExecutable = true; executableHaskellDepends = [ @@ -109547,6 +109773,8 @@ self: { ]; description = "A client for Haskell programs to query a GraphQL API"; license = stdenv.lib.licenses.bsd3; + hydraPlatforms = stdenv.lib.platforms.none; + broken = true; }) {}; "graphql-utils" = callPackage @@ -112130,6 +112358,8 @@ self: { executableHaskellDepends = [ base optparse-applicative text ]; description = "A blog system"; license = stdenv.lib.licenses.mit; + hydraPlatforms = stdenv.lib.platforms.none; + broken = true; }) {}; "hacanon-light" = callPackage @@ -113289,6 +113519,35 @@ self: { license = stdenv.lib.licenses.gpl3; }) {}; + "hadolint_1_18_2" = callPackage + ({ mkDerivation, aeson, async, base, bytestring, containers + , directory, filepath, gitrev, hspec, HsYAML, HUnit + , language-docker, megaparsec, mtl, optparse-applicative, parallel + , ShellCheck, split, text, void + }: + mkDerivation { + pname = "hadolint"; + version = "1.18.2"; + sha256 = "0ifcnpbc667x7cl44fkdj4j968zpyz57jh8b5givqdnmvw9x8wf5"; + isLibrary = true; + isExecutable = true; + libraryHaskellDepends = [ + aeson async base bytestring containers directory filepath HsYAML + language-docker megaparsec mtl parallel ShellCheck split text void + ]; + executableHaskellDepends = [ + base containers gitrev language-docker megaparsec + optparse-applicative text + ]; + testHaskellDepends = [ + aeson base bytestring hspec HsYAML HUnit language-docker megaparsec + ShellCheck split text + ]; + description = "Dockerfile Linter JavaScript API"; + license = stdenv.lib.licenses.gpl3; + hydraPlatforms = stdenv.lib.platforms.none; + }) {}; + "hadoop-formats" = callPackage ({ mkDerivation, attoparsec, base, bytestring, filepath, snappy , text, vector @@ -114552,6 +114811,8 @@ self: { ]; testHaskellDepends = [ base bytestring ]; license = "GPL"; + hydraPlatforms = stdenv.lib.platforms.none; + broken = true; }) {}; "hamid" = callPackage @@ -115641,6 +115902,35 @@ self: { license = stdenv.lib.licenses.bsd3; }) {}; + "happstack-server_7_7_0" = callPackage + ({ mkDerivation, base, base64-bytestring, blaze-html, bytestring + , containers, directory, exceptions, extensible-exceptions + , filepath, hslogger, html, HUnit, monad-control, mtl, network + , network-bsd, network-uri, old-locale, parsec, process, semigroups + , sendfile, syb, system-filepath, text, threads, time, transformers + , transformers-base, transformers-compat, unix, utf8-string, xhtml + , zlib + }: + mkDerivation { + pname = "happstack-server"; + version = "7.7.0"; + sha256 = "0jyjnksgwvasnhwwn8scqms1kja4hzlbpn0lmyr6yng5n4989d0x"; + libraryHaskellDepends = [ + base base64-bytestring blaze-html bytestring containers directory + exceptions extensible-exceptions filepath hslogger html + monad-control mtl network network-bsd network-uri old-locale parsec + process semigroups sendfile syb system-filepath text threads time + transformers transformers-base transformers-compat unix utf8-string + xhtml zlib + ]; + testHaskellDepends = [ + base bytestring containers HUnit parsec zlib + ]; + description = "Web related tools and services"; + license = stdenv.lib.licenses.bsd3; + hydraPlatforms = stdenv.lib.platforms.none; + }) {}; + "happstack-server-tls" = callPackage ({ mkDerivation, base, bytestring, extensible-exceptions , happstack-server, hslogger, HsOpenSSL, network, openssl, sendfile @@ -115648,8 +115938,8 @@ self: { }: mkDerivation { pname = "happstack-server-tls"; - version = "7.2.1"; - sha256 = "1cihzjxl1v5sgmaxn8qny8b9yzm7p1gccgy1iaa3dk2jpl07a2dp"; + version = "7.2.1.1"; + sha256 = "0bply7dxz2046h0v0ydkicjvl491k0llapf2shxjqnskjjr5rqnk"; libraryHaskellDepends = [ base bytestring extensible-exceptions happstack-server hslogger HsOpenSSL network sendfile time unix @@ -117315,6 +117605,8 @@ self: { doHaddock = false; description = "Cabal package script generator for Travis-CI"; license = stdenv.lib.licenses.gpl3Plus; + hydraPlatforms = stdenv.lib.platforms.none; + broken = true; }) {}; "haskell-cnc" = callPackage @@ -117512,8 +117804,8 @@ self: { ({ mkDerivation, base, syb, template-haskell }: mkDerivation { pname = "haskell-exp-parser"; - version = "0.1.3"; - sha256 = "0cswfpdw6sgmd0fhdpyfi2nk0mhvl8xpv4zfkl9l3wdk5ipbcxdf"; + version = "0.1.4"; + sha256 = "0adz1bazcayyhlwpcqn7nn73pv1mwmagslq0b3mjpgr9wg8lx2ys"; libraryHaskellDepends = [ base template-haskell ]; testHaskellDepends = [ base syb template-haskell ]; description = "Simple parser parser from Haskell to TemplateHaskell expressions"; @@ -119992,7 +120284,7 @@ self: { license = stdenv.lib.licenses.publicDomain; }) {}; - "haskoin-core_0_15_0" = callPackage + "haskoin-core_0_17_0" = callPackage ({ mkDerivation, aeson, array, base, base16-bytestring, bytestring , cereal, conduit, containers, cryptonite, deepseq, entropy , hashable, hspec, hspec-discover, HUnit, lens, lens-aeson, memory @@ -120002,8 +120294,8 @@ self: { }: mkDerivation { pname = "haskoin-core"; - version = "0.15.0"; - sha256 = "1mvhp7khbjf3wxvgwgdxgbl8ylb4vhgiirq50dwi62p65w75xw1v"; + version = "0.17.0"; + sha256 = "0zsi5390ig611clahj3p2l3h3w7b3lzl3dfiqliihanivlnrmkag"; libraryHaskellDepends = [ aeson array base base16-bytestring bytestring cereal conduit containers cryptonite deepseq entropy hashable hspec memory mtl @@ -120080,7 +120372,7 @@ self: { broken = true; }) {}; - "haskoin-node_0_16_0" = callPackage + "haskoin-node_0_17_0" = callPackage ({ mkDerivation, base, base64, bytestring, cereal, conduit , conduit-extra, containers, data-default, hashable, haskoin-core , hspec, hspec-discover, HUnit, monad-logger, mtl, network, nqe @@ -120090,8 +120382,8 @@ self: { }: mkDerivation { pname = "haskoin-node"; - version = "0.16.0"; - sha256 = "0az8lv5xkbhfff9hq3r0kndz2hp3q6f1h6za85qj8v5755za61c8"; + version = "0.17.0"; + sha256 = "0lgphbjam3ml9j1q39ddv2cwz35vfvmbnxsf570s91ja86lyfbhy"; libraryHaskellDepends = [ base bytestring cereal conduit conduit-extra containers data-default hashable haskoin-core monad-logger mtl network nqe @@ -120171,8 +120463,8 @@ self: { }: mkDerivation { pname = "haskoin-store"; - version = "0.37.5"; - sha256 = "0ac1znif59fzcxcl3nmvrv6v49rzlcgsv138zgjnk7zxarp8alyg"; + version = "0.38.0"; + sha256 = "0hw14mxlz6pbf9694vknypq6q60n8qglixx6sp1h43nqpmc52q8q"; isLibrary = true; isExecutable = true; libraryHaskellDepends = [ @@ -120213,8 +120505,8 @@ self: { }: mkDerivation { pname = "haskoin-store-data"; - version = "0.37.5"; - sha256 = "1p8hsnwr0h0sbnwg1kwbal36q4bh3s0daz1a5n2c8xal5xdkbdra"; + version = "0.38.0"; + sha256 = "05218mbwdzz61c0d4fwj9pyr69zb4jc9fir2mp7bjfyrnymb08f5"; libraryHaskellDepends = [ aeson base bytestring cereal containers data-default deepseq hashable haskoin-core http-client http-types lens mtl network @@ -121989,24 +122281,24 @@ self: { "haxl" = callPackage ({ mkDerivation, aeson, base, binary, bytestring, containers - , deepseq, exceptions, filepath, ghc-prim, hashable, HUnit, pretty - , stm, test-framework, test-framework-hunit, text, time - , transformers, unordered-containers, vector + , deepseq, exceptions, filepath, ghc-prim, hashable, hashtables + , HUnit, pretty, stm, test-framework, test-framework-hunit, text + , time, transformers, unordered-containers, vector }: mkDerivation { pname = "haxl"; - version = "2.1.2.0"; - sha256 = "1lwm9rs9r0qs32n3nw49j3sz41qzq2wxv0a9gpiziaw0sjlk00jy"; + version = "2.3.0.0"; + sha256 = "149k26iaas3sb9qyagzjkb0n86k34nf0r06fyvvqyap1w476fd3c"; isLibrary = true; isExecutable = true; libraryHaskellDepends = [ aeson base binary bytestring containers deepseq exceptions filepath - ghc-prim hashable pretty stm text time transformers + ghc-prim hashable hashtables pretty stm text time transformers unordered-containers vector ]; testHaskellDepends = [ aeson base binary bytestring containers deepseq filepath hashable - HUnit test-framework test-framework-hunit text time + hashtables HUnit test-framework test-framework-hunit text time unordered-containers ]; description = "A Haskell library for efficient, concurrent, and concise data access"; @@ -123241,6 +123533,8 @@ self: { ]; description = "More informative parser"; license = stdenv.lib.licenses.mit; + hydraPlatforms = stdenv.lib.platforms.none; + broken = true; }) {}; "headergen" = callPackage @@ -123856,31 +124150,6 @@ self: { }) {}; "hedis" = callPackage - ({ mkDerivation, async, base, bytestring, bytestring-lexing - , deepseq, doctest, errors, exceptions, HTTP, HUnit, mtl, network - , network-uri, resource-pool, scanner, stm, test-framework - , test-framework-hunit, text, time, tls, unordered-containers - , vector - }: - mkDerivation { - pname = "hedis"; - version = "0.12.14"; - sha256 = "14qd248ccijakksbaj72nwz8dx8qg4bifla3p0vsm6v96xb2qjbw"; - libraryHaskellDepends = [ - async base bytestring bytestring-lexing deepseq errors exceptions - HTTP mtl network network-uri resource-pool scanner stm text time - tls unordered-containers vector - ]; - testHaskellDepends = [ - async base bytestring doctest HUnit mtl stm test-framework - test-framework-hunit text time - ]; - benchmarkHaskellDepends = [ base mtl time ]; - description = "Client library for the Redis datastore: supports full command set, pipelining"; - license = stdenv.lib.licenses.bsd3; - }) {}; - - "hedis_0_12_15" = callPackage ({ mkDerivation, async, base, bytestring, bytestring-lexing , deepseq, doctest, errors, exceptions, HTTP, HUnit, mtl, network , network-uri, resource-pool, scanner, stm, test-framework @@ -123903,7 +124172,6 @@ self: { benchmarkHaskellDepends = [ base mtl time ]; description = "Client library for the Redis datastore: supports full command set, pipelining"; license = stdenv.lib.licenses.bsd3; - hydraPlatforms = stdenv.lib.platforms.none; }) {}; "hedis-config" = callPackage @@ -125052,24 +125320,6 @@ self: { }) {}; "heterocephalus" = callPackage - ({ mkDerivation, base, blaze-html, blaze-markup, containers, dlist - , doctest, Glob, mtl, parsec, shakespeare, template-haskell, text - , transformers - }: - mkDerivation { - pname = "heterocephalus"; - version = "1.0.5.3"; - sha256 = "0kvrv15xm6igd6nkyfij1h982jqpbf61pzinv8jdb4fcjqwf08s7"; - libraryHaskellDepends = [ - base blaze-html blaze-markup containers dlist mtl parsec - shakespeare template-haskell text transformers - ]; - testHaskellDepends = [ base doctest Glob ]; - description = "A type-safe template engine for working with popular front end development tools"; - license = stdenv.lib.licenses.mit; - }) {}; - - "heterocephalus_1_0_5_4" = callPackage ({ mkDerivation, base, blaze-html, blaze-markup, containers, dlist , doctest, Glob, mtl, parsec, shakespeare, template-haskell, text , transformers @@ -125085,7 +125335,6 @@ self: { testHaskellDepends = [ base doctest Glob ]; description = "A type-safe template engine for working with front end development tools"; license = stdenv.lib.licenses.mit; - hydraPlatforms = stdenv.lib.platforms.none; }) {}; "heterogeneous-list-literals" = callPackage @@ -135372,8 +135621,8 @@ self: { }: mkDerivation { pname = "hslua-aeson"; - version = "1.0.3"; - sha256 = "0qqcf9km39bmw29d2s5zw91rxgmmm8nqfnfs5hkhmsgh5kvaal5h"; + version = "1.0.3.1"; + sha256 = "0kvsk0lfhg29dy5qlays9xbd5h9as01mcdbdx2ingx94br6d3h5r"; libraryHaskellDepends = [ aeson base hashable hslua scientific text unordered-containers vector @@ -135420,24 +135669,6 @@ self: { }) {}; "hslua-module-system" = callPackage - ({ mkDerivation, base, containers, directory, exceptions, hslua - , tasty, tasty-hunit, tasty-lua, temporary, text - }: - mkDerivation { - pname = "hslua-module-system"; - version = "0.2.2"; - sha256 = "0swl20v40kkh67vn6546a0afjcsq56x3ww854x3pwypxz1p6dyri"; - libraryHaskellDepends = [ - base containers directory exceptions hslua temporary - ]; - testHaskellDepends = [ - base hslua tasty tasty-hunit tasty-lua text - ]; - description = "Lua module wrapper around Haskell's System module"; - license = stdenv.lib.licenses.mit; - }) {}; - - "hslua-module-system_0_2_2_1" = callPackage ({ mkDerivation, base, containers, directory, exceptions, hslua , tasty, tasty-hunit, tasty-lua, temporary, text }: @@ -135453,7 +135684,6 @@ self: { ]; description = "Lua module wrapper around Haskell's System module"; license = stdenv.lib.licenses.mit; - hydraPlatforms = stdenv.lib.platforms.none; }) {}; "hslua-module-text" = callPackage @@ -138604,6 +138834,8 @@ self: { ]; description = "Glue code for http-client and websockets"; license = stdenv.lib.licenses.cc0; + hydraPlatforms = stdenv.lib.platforms.none; + broken = true; }) {}; "http-common" = callPackage @@ -138725,6 +138957,8 @@ self: { ]; description = "HTTP downloader tailored for web-crawler needs"; license = stdenv.lib.licenses.bsd3; + hydraPlatforms = stdenv.lib.platforms.none; + broken = true; }) {}; "http-date" = callPackage @@ -140821,10 +141055,8 @@ self: { }: mkDerivation { pname = "hw-json"; - version = "1.3.2.1"; - sha256 = "11lf4nxnkk8l25a44g1pkr9j1w03l69gqjgli5yfj6k68lzml7bf"; - revision = "2"; - editedCabalFile = "0ks3aj2xdphq9sp5vsblyz13fmwl5cb402awqy3pz3d21g8fl4sn"; + version = "1.3.2.2"; + sha256 = "03h5zv94ndsz4vh0jql8rg8pl95rbf8xkyzvr3r55i3kpmb85sbg"; isLibrary = true; isExecutable = true; libraryHaskellDepends = [ @@ -145805,31 +146037,6 @@ self: { }) {}; "inline-c" = callPackage - ({ mkDerivation, ansi-wl-pprint, base, bytestring, containers - , hashable, hspec, mtl, parsec, parsers, QuickCheck, raw-strings-qq - , regex-posix, split, template-haskell, transformers - , unordered-containers, vector - }: - mkDerivation { - pname = "inline-c"; - version = "0.9.1.2"; - sha256 = "1lvsjjxnjwfnqlq4i5mz2xizpx052nq25wjgm47302akpjzpym6n"; - isLibrary = true; - isExecutable = true; - libraryHaskellDepends = [ - ansi-wl-pprint base bytestring containers hashable mtl parsec - parsers template-haskell transformers unordered-containers vector - ]; - testHaskellDepends = [ - ansi-wl-pprint base containers hashable hspec parsers QuickCheck - raw-strings-qq regex-posix split template-haskell transformers - unordered-containers vector - ]; - description = "Write Haskell source files including C code inline. No FFI required."; - license = stdenv.lib.licenses.mit; - }) {}; - - "inline-c_0_9_1_3" = callPackage ({ mkDerivation, ansi-wl-pprint, base, bytestring, containers , hashable, hspec, mtl, parsec, parsers, QuickCheck, raw-strings-qq , regex-posix, split, template-haskell, transformers @@ -145852,7 +146059,6 @@ self: { ]; description = "Write Haskell source files including C code inline. No FFI required."; license = stdenv.lib.licenses.mit; - hydraPlatforms = stdenv.lib.platforms.none; }) {}; "inline-c-cpp_0_1_0_0" = callPackage @@ -146358,6 +146564,8 @@ self: { testHaskellDepends = [ base containers doctest primitive ]; description = "Advent of Code 2019 intcode interpreter"; license = stdenv.lib.licenses.isc; + hydraPlatforms = stdenv.lib.platforms.none; + broken = true; }) {}; "integer-gmp_1_0_3_0" = callPackage @@ -149397,6 +149605,8 @@ self: { testHaskellDepends = [ base bytestring repa tasty tasty-hunit ]; description = "J in Haskell"; license = stdenv.lib.licenses.bsd3; + hydraPlatforms = stdenv.lib.platforms.none; + broken = true; }) {}; "j2hs" = callPackage @@ -150326,12 +150536,16 @@ self: { }) {}; "joint" = callPackage - ({ mkDerivation, base, transformers }: + ({ mkDerivation, adjunctions, base, comonad, distributive + , transformers + }: mkDerivation { pname = "joint"; - version = "0.1.7"; - sha256 = "193ygi06hfn1smdhh7fz74lz2gffcvg66cxp6qlvi7m3rbhm1f1l"; - libraryHaskellDepends = [ base transformers ]; + version = "0.1.8"; + sha256 = "174i51nlck81h9pc9jgmd0yj3d6xpvza0i4a8y4f1fpnz1zrqxg5"; + libraryHaskellDepends = [ + adjunctions base comonad distributive transformers + ]; description = "Trying to compose non-composable"; license = stdenv.lib.licenses.bsd3; }) {}; @@ -151660,21 +151874,25 @@ self: { }) {}; "jsonifier" = callPackage - ({ mkDerivation, aeson, base, bytestring, gauge, hedgehog - , numeric-limits, ptr-poker, rerebase, scientific, text + ({ mkDerivation, aeson, base, buffer-builder, bytestring, gauge + , hedgehog, numeric-limits, ptr-poker, rerebase, scientific, text , text-builder }: mkDerivation { pname = "jsonifier"; - version = "0.1.0.2"; - sha256 = "1vm7qp38wkv2l3wi32kv2hcbzpzk7yf9xffh09ani395dggw94hx"; + version = "0.1.0.4"; + sha256 = "1fkjib6v9kk5vbw0sh5cb0wr0m3mxf878lcbj3jc0xyalpvz07ni"; libraryHaskellDepends = [ base bytestring ptr-poker scientific text ]; testHaskellDepends = [ aeson hedgehog numeric-limits rerebase ]; - benchmarkHaskellDepends = [ aeson gauge rerebase text-builder ]; + benchmarkHaskellDepends = [ + aeson buffer-builder gauge rerebase text-builder + ]; description = "Fast and simple JSON encoding toolkit"; license = stdenv.lib.licenses.mit; + hydraPlatforms = stdenv.lib.platforms.none; + broken = true; }) {}; "jsonpath" = callPackage @@ -153225,6 +153443,18 @@ self: { license = stdenv.lib.licenses.bsd3; }) {}; + "keep-alive" = callPackage + ({ mkDerivation, base }: + mkDerivation { + pname = "keep-alive"; + version = "0.1.1.0"; + sha256 = "1h1x28adh7y561pmmbw064vyz9qx013spkcr8pwg9hjcnzn03yvw"; + libraryHaskellDepends = [ base ]; + testHaskellDepends = [ base ]; + description = "TCP keep alive implementation"; + license = stdenv.lib.licenses.bsd3; + }) {}; + "keera-callbacks" = callPackage ({ mkDerivation, base, mtl }: mkDerivation { @@ -154204,6 +154434,8 @@ self: { executableHaskellDepends = [ base ]; description = "Advanced keyboard remapping utility"; license = stdenv.lib.licenses.mit; + hydraPlatforms = stdenv.lib.platforms.none; + broken = true; }) {}; "kmp-dfa" = callPackage @@ -154510,6 +154742,8 @@ self: { ]; description = "Krank checks your code source comments for important markers"; license = stdenv.lib.licenses.bsd3; + hydraPlatforms = stdenv.lib.platforms.none; + broken = true; }) {}; "krapsh" = callPackage @@ -156291,6 +156525,28 @@ self: { license = stdenv.lib.licenses.gpl3; }) {}; + "language-docker_9_1_2" = callPackage + ({ mkDerivation, base, bytestring, containers, data-default-class + , hspec, HUnit, megaparsec, prettyprinter, QuickCheck, split, text + , time + }: + mkDerivation { + pname = "language-docker"; + version = "9.1.2"; + sha256 = "014rb5jf650fhsmc02v4xc60w7v1261ri1w9ig6dw0xjdgxalvbs"; + libraryHaskellDepends = [ + base bytestring containers data-default-class megaparsec + prettyprinter split text time + ]; + testHaskellDepends = [ + base bytestring containers data-default-class hspec HUnit + megaparsec prettyprinter QuickCheck split text time + ]; + description = "Dockerfile parser, pretty-printer and embedded DSL"; + license = stdenv.lib.licenses.gpl3; + hydraPlatforms = stdenv.lib.platforms.none; + }) {}; + "language-dockerfile" = callPackage ({ mkDerivation, aeson, base, bytestring, directory, filepath, free , Glob, hspec, HUnit, mtl, parsec, pretty, process, QuickCheck @@ -158976,14 +159232,15 @@ self: { }: mkDerivation { pname = "lens-filesystem"; - version = "0.0.0.0"; - sha256 = "0295n9hfdq72c1knx170ccfyi93wp09szahb2q5jym0mcryvdls8"; + version = "0.1.0.1"; + sha256 = "0rx5b49ka3281nnwvfmkdnfrv56kvfkl2h45nf54rdgxj11b7v28"; libraryHaskellDepends = [ base directory filepath lens lens-action ]; testHaskellDepends = [ base directory filepath hspec lens lens-action ]; + description = "Lens interface for your filesystem; still a bit experimental"; license = stdenv.lib.licenses.bsd3; hydraPlatforms = stdenv.lib.platforms.none; broken = true; @@ -159387,6 +159644,28 @@ self: { hydraPlatforms = stdenv.lib.platforms.none; }) {}; + "less-arbitrary" = callPackage + ({ mkDerivation, base, containers, generic-arbitrary, hashable, mtl + , QuickCheck, quickcheck-classes, quickcheck-instances, random + , scientific, text, transformers, unordered-containers, vector + }: + mkDerivation { + pname = "less-arbitrary"; + version = "0.1.0.1"; + sha256 = "1hbiwyk49qqqdfglydywj02ycymdb486nv5cp8710gfwh75i29xw"; + libraryHaskellDepends = [ + base containers generic-arbitrary hashable mtl QuickCheck random + scientific text transformers unordered-containers vector + ]; + testHaskellDepends = [ + base containers generic-arbitrary hashable mtl QuickCheck + quickcheck-classes quickcheck-instances random scientific text + transformers unordered-containers vector + ]; + description = "Linear time testing with variant of Arbitrary class that always terminates"; + license = stdenv.lib.licenses.bsd3; + }) {}; + "level-monad" = callPackage ({ mkDerivation, base, fmlist }: mkDerivation { @@ -160006,6 +160285,8 @@ self: { ]; description = "A Haskell implementation of JSON Web Token (JWT)"; license = stdenv.lib.licenses.mpl20; + hydraPlatforms = stdenv.lib.platforms.none; + broken = true; }) {}; "liblastfm" = callPackage @@ -162964,19 +163245,20 @@ self: { broken = true; }) {}; - "little-logger_0_2_0" = callPackage + "little-logger_0_3_1" = callPackage ({ mkDerivation, base, co-log, co-log-core, microlens, mtl, tasty - , tasty-hunit, text + , tasty-hunit, text, unliftio-core }: mkDerivation { pname = "little-logger"; - version = "0.2.0"; - sha256 = "0bzfd0s67g074vp274jq83fdl8z2m87qjkslkxvl29bdlrl3w17b"; + version = "0.3.1"; + sha256 = "0iqnidlv7r2kw6764aq3dlvxbmvm1c7qk8jkgbhbpm5g07k97c68"; libraryHaskellDepends = [ - base co-log co-log-core microlens mtl text + base co-log co-log-core microlens mtl text unliftio-core ]; testHaskellDepends = [ base co-log co-log-core microlens mtl tasty tasty-hunit text + unliftio-core ]; description = "Basic logging based on co-log"; license = stdenv.lib.licenses.bsd3; @@ -165161,6 +165443,8 @@ self: { ]; description = "EDSL for the Michelson Language"; license = stdenv.lib.licenses.mit; + hydraPlatforms = stdenv.lib.platforms.none; + broken = true; }) {}; "loris" = callPackage @@ -165284,8 +165568,8 @@ self: { }: mkDerivation { pname = "lp-diagrams"; - version = "2.1.2"; - sha256 = "0q0qzij6j0nv01hhrd417swyyf5vhgi2m83bmk98dvrd0309l9xl"; + version = "2.1.4"; + sha256 = "035kaj2cawpkd5xry3wkl8slzga4qxklvjw91g9lh179zzpq6skj"; libraryHaskellDepends = [ base containers gasp graphviz labeled-tree lens mtl parsek polynomials-bernstein process reflection text typography-geometry @@ -165429,6 +165713,8 @@ self: { testToolDepends = [ hspec-discover ]; description = "Haskell library for the Microsoft Language Server Protocol"; license = stdenv.lib.licenses.mit; + hydraPlatforms = stdenv.lib.platforms.none; + broken = true; }) {}; "lsp-test" = callPackage @@ -171600,8 +171886,6 @@ self: { ]; description = "A tiny JSON library with light dependency footprint"; license = stdenv.lib.licenses.gpl3; - hydraPlatforms = stdenv.lib.platforms.none; - broken = true; }) {}; "microbase" = callPackage @@ -172697,6 +172981,44 @@ self: { license = stdenv.lib.licenses.asl20; }) {}; + "minio-hs_1_5_3" = callPackage + ({ mkDerivation, aeson, base, base64-bytestring, binary, bytestring + , case-insensitive, conduit, conduit-extra, connection, cryptonite + , cryptonite-conduit, digest, directory, exceptions, filepath + , http-client, http-client-tls, http-conduit, http-types, ini + , memory, protolude, QuickCheck, raw-strings-qq, resourcet, retry + , tasty, tasty-hunit, tasty-quickcheck, tasty-smallcheck, text + , time, transformers, unliftio, unliftio-core, unordered-containers + , xml-conduit + }: + mkDerivation { + pname = "minio-hs"; + version = "1.5.3"; + sha256 = "0nbrvkj8dn9m2i60iqk2wmf7fnj8bv4n65r4wxpimwb06yrvrfj2"; + isLibrary = true; + isExecutable = true; + libraryHaskellDepends = [ + aeson base base64-bytestring binary bytestring case-insensitive + conduit conduit-extra connection cryptonite cryptonite-conduit + digest directory exceptions filepath http-client http-client-tls + http-conduit http-types ini memory protolude raw-strings-qq + resourcet retry text time transformers unliftio unliftio-core + unordered-containers xml-conduit + ]; + testHaskellDepends = [ + aeson base base64-bytestring binary bytestring case-insensitive + conduit conduit-extra connection cryptonite cryptonite-conduit + digest directory exceptions filepath http-client http-client-tls + http-conduit http-types ini memory protolude QuickCheck + raw-strings-qq resourcet retry tasty tasty-hunit tasty-quickcheck + tasty-smallcheck text time transformers unliftio unliftio-core + unordered-containers xml-conduit + ]; + description = "A MinIO Haskell Library for Amazon S3 compatible cloud storage"; + license = stdenv.lib.licenses.asl20; + hydraPlatforms = stdenv.lib.platforms.none; + }) {}; + "minions" = callPackage ({ mkDerivation, ansi-terminal, base, MissingH, process, time }: mkDerivation { @@ -173257,17 +173579,18 @@ self: { "miv" = callPackage ({ mkDerivation, aeson, async, base, concurrent-output, directory , filepath, ghc-prim, hashable, hspec, monad-parallel, process - , text, time, unix-compat, unordered-containers, xdg-basedir, yaml + , SafeSemaphore, text, time, unix-compat, unordered-containers + , xdg-basedir, yaml }: mkDerivation { pname = "miv"; - version = "0.4.2"; - sha256 = "0yhfinygsb2fnjspg87fx447kajrbldhddm24vxl41741xmwjl8a"; + version = "0.4.3"; + sha256 = "0i2ikjr36qdr2i92bapx2p4lq4jvfmzh12b2nslhqq4xnf2fs2ib"; isLibrary = false; isExecutable = true; executableHaskellDepends = [ aeson async base concurrent-output directory filepath ghc-prim - hashable monad-parallel process text time unix-compat + hashable monad-parallel process SafeSemaphore text time unix-compat unordered-containers xdg-basedir yaml ]; testHaskellDepends = [ @@ -173593,6 +173916,8 @@ self: { ]; description = "The \"glue\" between electronic tables and GraphViz"; license = stdenv.lib.licenses.mit; + hydraPlatforms = stdenv.lib.platforms.none; + broken = true; }) {}; "mmsyn5" = callPackage @@ -176521,6 +176846,8 @@ self: { ]; description = "Developer tools for the Michelson Language"; license = stdenv.lib.licenses.mit; + hydraPlatforms = stdenv.lib.platforms.none; + broken = true; }) {}; "morley-prelude" = callPackage @@ -177936,8 +178263,8 @@ self: { }: mkDerivation { pname = "mu-avro"; - version = "0.4.0.0"; - sha256 = "08hkw54llgyc7gmr3srx0im6im3x23cc0fkgmfv541ak6sq7by3h"; + version = "0.4.0.1"; + sha256 = "1nbslmb30yys61a5sn8nv7lczcagi4jidrfyw2wfqagkgj3afsyq"; isLibrary = true; isExecutable = true; enableSeparateDataOutput = true; @@ -178688,8 +179015,8 @@ self: { ({ mkDerivation, base, bytestring, parsec, stringsearch }: mkDerivation { pname = "multipart"; - version = "0.2.0"; - sha256 = "1rw668hxj04zpkfwhjqbd0ph0wy9k2khsrbsni9sxi2px49vnmym"; + version = "0.2.1"; + sha256 = "0p6n4knxpjv70nbl6cmd6x7gkdjsjqp4ya7fz00bfrqp7jvhlivn"; libraryHaskellDepends = [ base bytestring parsec stringsearch ]; description = "Parsers for the HTTP multipart format"; license = stdenv.lib.licenses.bsd3; @@ -180688,6 +181015,8 @@ self: { sha256 = "0ixpm43sgir02a9y8i7rvalxh6h7vlcwgi2hmis0lq0w8pmw5m53"; libraryHaskellDepends = [ base named servant ]; license = stdenv.lib.licenses.bsd3; + hydraPlatforms = stdenv.lib.platforms.none; + broken = true; }) {}; "named-servant-client" = callPackage @@ -180703,6 +181032,8 @@ self: { ]; description = "client support for named-servant"; license = stdenv.lib.licenses.bsd3; + hydraPlatforms = stdenv.lib.platforms.none; + broken = true; }) {}; "named-servant-server" = callPackage @@ -180718,6 +181049,8 @@ self: { ]; description = "server support for named-servant"; license = stdenv.lib.licenses.bsd3; + hydraPlatforms = stdenv.lib.platforms.none; + broken = true; }) {}; "named-sop" = callPackage @@ -184138,8 +184471,8 @@ self: { }: mkDerivation { pname = "ngx-export-tools"; - version = "0.4.8.0"; - sha256 = "1jw6ny4qnckxyvszislqy079bh6vnq9q0f4wig8n1diljs057waj"; + version = "0.4.9.0"; + sha256 = "0z1b3vzq11ifx3n8pmwary138ccqsfafzpl1nf27094rvr1ijjyn"; libraryHaskellDepends = [ aeson base binary bytestring ngx-export safe template-haskell ]; @@ -184156,8 +184489,8 @@ self: { }: mkDerivation { pname = "ngx-export-tools-extra"; - version = "0.5.5.1"; - sha256 = "0x3c1r0ddbk740182gwv43s2zxr6aj9k6y4npv7vi0fwyxjcqgkj"; + version = "0.5.6.0"; + sha256 = "08a13v1fx7lad7wdibij79vdcbqn10lcb2n6lhzq70097f8a06vm"; libraryHaskellDepends = [ aeson ansi-wl-pprint array base base64 binary bytestring case-insensitive containers ede enclosed-exceptions http-client @@ -184589,8 +184922,8 @@ self: { }: mkDerivation { pname = "nix-thunk"; - version = "0.1.0.0"; - sha256 = "0jg3j78dwq31g18fkmcbn4d8vlmdb0vpnicac2kmg0dwrw64v2gb"; + version = "0.2.0.0"; + sha256 = "1bkdcq4qvgnavpkvfvy6il691wwpw6lyba0hhxzjxbm132q46v2y"; isLibrary = true; isExecutable = true; libraryHaskellDepends = [ @@ -184602,7 +184935,7 @@ self: { executableHaskellDepends = [ base cli-extras optparse-applicative text ]; - description = "Virtual vendorization with Nix"; + description = "Lightweight dependency management with Nix"; license = stdenv.lib.licenses.bsd3; hydraPlatforms = stdenv.lib.platforms.none; broken = true; @@ -185613,6 +185946,8 @@ self: { ]; description = "Examine values for unexpected thunks"; license = stdenv.lib.licenses.mit; + hydraPlatforms = stdenv.lib.platforms.none; + broken = true; }) {}; "notifications-tray-icon" = callPackage @@ -185659,6 +185994,8 @@ self: { libraryToolDepends = [ c2hs ]; description = "Haskell binding to Notmuch, the mail indexer"; license = stdenv.lib.licenses.gpl3; + hydraPlatforms = stdenv.lib.platforms.none; + broken = true; }) {inherit (pkgs) notmuch; inherit (pkgs) talloc;}; "notmuch-haskell" = callPackage @@ -186459,6 +186796,8 @@ self: { testHaskellDepends = [ base doctest numhask ]; description = "See readme.md"; license = stdenv.lib.licenses.bsd3; + hydraPlatforms = stdenv.lib.platforms.none; + broken = true; }) {}; "numhask-hedgehog" = callPackage @@ -186539,8 +186878,8 @@ self: { }: mkDerivation { pname = "numhask-space"; - version = "0.6.0"; - sha256 = "0zm64spljv7pvl68b60y7hr46fa82i44j7yk8q6i33nhr78qv7wy"; + version = "0.6.1"; + sha256 = "0kqq2p0j7p7my33lw0alcc6il3chvsaj75cm1py0wa681jfmzxcv"; libraryHaskellDepends = [ adjunctions base containers distributive numhask semigroupoids tdigest text time @@ -188286,6 +188625,8 @@ self: { ]; description = "Open algebraic data types"; license = stdenv.lib.licenses.bsd3; + hydraPlatforms = stdenv.lib.platforms.none; + broken = true; }) {}; "open-adt-tutorial" = callPackage @@ -188305,6 +188646,8 @@ self: { executableHaskellDepends = [ base ]; description = "Open algebraic data type examples"; license = stdenv.lib.licenses.bsd3; + hydraPlatforms = stdenv.lib.platforms.none; + broken = true; }) {}; "open-browser" = callPackage @@ -189586,6 +189929,8 @@ self: { ]; description = "Compiler for OpLang, an esoteric programming language"; license = stdenv.lib.licenses.mit; + hydraPlatforms = stdenv.lib.platforms.none; + broken = true; }) {}; "opml" = callPackage @@ -190400,15 +190745,15 @@ self: { }) {}; "ordinal" = callPackage - ({ mkDerivation, base, containers, hspec, hspec-discover - , QuickCheck, regex, template-haskell, text, vector + ({ mkDerivation, base, containers, data-default, hspec + , hspec-discover, QuickCheck, regex, template-haskell, text, vector }: mkDerivation { pname = "ordinal"; - version = "0.2.0.0"; - sha256 = "01ja268zk5pwdjzl5msiycy41zkg66apchjg5g2x4642qmn0rsxd"; + version = "0.3.1.0"; + sha256 = "16y8a4xrrna6cwzy8lvvykdb9jgk5qswrwd8dn7iqgmhqck271x8"; libraryHaskellDepends = [ - base containers regex template-haskell text vector + base containers data-default regex template-haskell text vector ]; testHaskellDepends = [ base hspec QuickCheck text ]; testToolDepends = [ hspec-discover ]; @@ -190720,6 +191065,8 @@ self: { ]; description = "Multidimensional arrays inspired by APL"; license = stdenv.lib.licenses.asl20; + hydraPlatforms = stdenv.lib.platforms.none; + broken = true; }) {}; "os-release" = callPackage @@ -192404,8 +192751,8 @@ self: { ({ mkDerivation }: mkDerivation { pname = "pandora"; - version = "0.3.0"; - sha256 = "1k9b714rb9cgapn0vgwymrq7ma1lmq6klmlv37c6gqmb1c5k7ijh"; + version = "0.3.1"; + sha256 = "0b6xh5fzxw5v9hh1xjksh2bwzmlnv7wra5l1s9gzfwl623xgh445"; description = "A box of patterns and paradigms"; license = stdenv.lib.licenses.mit; }) {}; @@ -193917,8 +194264,8 @@ self: { ({ mkDerivation, base }: mkDerivation { pname = "parsek"; - version = "1.0.2.0"; - sha256 = "05hi14wn6pzhknahyvjkw4cg9qfy20krig2pkx00r4s095zmpqza"; + version = "1.0.4.0"; + sha256 = "090yhbbh2i5lwfwrfml0n54ziy8mz3mgmwnykr4ab06w1ylc2zh4"; libraryHaskellDepends = [ base ]; description = "Parallel Parsing Processes"; license = stdenv.lib.licenses.gpl3; @@ -194715,10 +195062,8 @@ self: { }: mkDerivation { pname = "path-io"; - version = "1.6.0"; - sha256 = "0hcdxxwkhdhm59p6x74k1fsgsrqfa100c83cslm1h9ln0anj1r3k"; - revision = "3"; - editedCabalFile = "0rd7svl3jxzqnf8l2h4f7xwlv8av67y85bwmr40954disq714l74"; + version = "1.6.1"; + sha256 = "1qbnjwx72idbqwi5gkhnphf2phdszdf6y1aqf77y17kks3992vmn"; libraryHaskellDepends = [ base containers directory dlist exceptions filepath path temporary time transformers unix-compat @@ -194731,6 +195076,27 @@ self: { license = stdenv.lib.licenses.bsd3; }) {}; + "path-io_1_6_2" = callPackage + ({ mkDerivation, base, containers, directory, dlist, exceptions + , filepath, hspec, path, temporary, time, transformers, unix-compat + }: + mkDerivation { + pname = "path-io"; + version = "1.6.2"; + sha256 = "11mrs0awd343far3rmcphdli65g737haxg7fwx3pl04fgdxfbpdq"; + libraryHaskellDepends = [ + base containers directory dlist exceptions filepath path temporary + time transformers unix-compat + ]; + testHaskellDepends = [ + base directory exceptions filepath hspec path transformers + unix-compat + ]; + description = "Interface to ‘directory’ package for users of ‘path’"; + license = stdenv.lib.licenses.bsd3; + hydraPlatforms = stdenv.lib.platforms.none; + }) {}; + "path-like" = callPackage ({ mkDerivation, base, path }: mkDerivation { @@ -196311,6 +196677,8 @@ self: { ]; description = "Periodic task system haskell client"; license = stdenv.lib.licenses.bsd3; + hydraPlatforms = stdenv.lib.platforms.none; + broken = true; }) {}; "periodic-client-exe" = callPackage @@ -196335,6 +196703,8 @@ self: { ]; description = "Periodic task system haskell client executables"; license = stdenv.lib.licenses.bsd3; + hydraPlatforms = stdenv.lib.platforms.none; + broken = true; }) {}; "periodic-common" = callPackage @@ -196391,6 +196761,8 @@ self: { ]; description = "Periodic task system haskell server"; license = stdenv.lib.licenses.bsd3; + hydraPlatforms = stdenv.lib.platforms.none; + broken = true; }) {}; "perm" = callPackage @@ -197951,8 +198323,8 @@ self: { ({ mkDerivation, base }: mkDerivation { pname = "phonetic-languages-rhythmicity"; - version = "0.1.0.1"; - sha256 = "1qrypqbc9fhnscgxiqr79l25pgphj6wnaw8g4vqpzn3cgw9v70s4"; + version = "0.1.2.0"; + sha256 = "1ljblyk0m1fs3n2gj72w6gs62dxjk5gsn8x6p7fwlwhvaa316wm3"; libraryHaskellDepends = [ base ]; description = "Allows to estimate the rhythmicity metrices for the text (usually, the Ukrainian poetic one)"; license = stdenv.lib.licenses.mit; @@ -201772,8 +202144,8 @@ self: { }: mkDerivation { pname = "polysemy-video"; - version = "0.1.0.1"; - sha256 = "0gpq4105lw24ddp7i4hqc9dnhn9pph4s3p37idfhrmkbyf52y8k8"; + version = "0.1.1.0"; + sha256 = "1f8fzhxjg3cpqb8sdrdl8mx9dwas5l32aw98s5m2p4xv1amnjl39"; libraryHaskellDepends = [ base formatting path path-utils polysemy text turtle ]; @@ -202853,8 +203225,8 @@ self: { }: mkDerivation { pname = "postgres-websockets"; - version = "0.9.0.0"; - sha256 = "1c7has1vyp8i3my5126m8ciimcyyv4prav94wpl861gz7npdqxym"; + version = "0.10.0.0"; + sha256 = "1rhpv9dams24iy9wpj0v69blr2109xprz7yj1y0ng9cw3bnsrldm"; isLibrary = true; isExecutable = true; libraryHaskellDepends = [ @@ -207015,6 +207387,8 @@ self: { ]; description = "Profunctor-based lightweight implementation of optics"; license = stdenv.lib.licenses.mpl20; + hydraPlatforms = stdenv.lib.platforms.none; + broken = true; }) {}; "prolog" = callPackage @@ -207095,16 +207469,16 @@ self: { }) {}; "prolude" = callPackage - ({ mkDerivation, aeson, base, bytestring, mongoDB, safe-exceptions - , scientific, text, time, vector + ({ mkDerivation, aeson, base, bytestring, containers, mongoDB + , safe-exceptions, scientific, text, time, vector }: mkDerivation { pname = "prolude"; - version = "0.0.0.2"; - sha256 = "01md9n18kwsm2myr1wfv16z404c4d92iz4g7nhixrkl6dvgq8fyc"; + version = "0.0.0.4"; + sha256 = "147kn423jxc4rcb4vbsj7av8pxdz8lgcgblbmrvq821h26vgc1ai"; libraryHaskellDepends = [ - aeson base bytestring mongoDB safe-exceptions scientific text time - vector + aeson base bytestring containers mongoDB safe-exceptions scientific + text time vector ]; description = "ITProTV's custom prelude"; license = stdenv.lib.licenses.mit; @@ -208396,13 +208770,15 @@ self: { }: mkDerivation { pname = "ptr-poker"; - version = "0.1.1"; - sha256 = "09dklmyarwn4s3lp2l2i1641cs57r6jamqkbyn6qb91nl0f46z52"; + version = "0.1.1.2"; + sha256 = "06h267z01cvk2sck7ycbi8vssg4985nh7cxx2mw92hiqj1kqp0gp"; libraryHaskellDepends = [ base bytestring scientific text ]; testHaskellDepends = [ hedgehog numeric-limits rerebase ]; benchmarkHaskellDepends = [ gauge rerebase ]; description = "Pointer poking action construction and composition toolkit"; license = stdenv.lib.licenses.mit; + hydraPlatforms = stdenv.lib.platforms.none; + broken = true; }) {}; "pub" = callPackage @@ -209511,6 +209887,25 @@ self: { license = stdenv.lib.licenses.bsd3; }) {}; + "pvar_1_0_0_0" = callPackage + ({ mkDerivation, async, base, deepseq, genvalidity, hspec + , primitive, QuickCheck + }: + mkDerivation { + pname = "pvar"; + version = "1.0.0.0"; + sha256 = "0f28wb89zlddgmh0302x73lphmd6kmx1829yh6kwsz7a6asq79ln"; + revision = "1"; + editedCabalFile = "0r3r7w9x31pimrzmp5fjabgcx8caxf1g0mk9izksw2wnn1anhjix"; + libraryHaskellDepends = [ base deepseq primitive ]; + testHaskellDepends = [ + async base deepseq genvalidity hspec primitive QuickCheck + ]; + description = "Mutable variable with primitive values"; + license = stdenv.lib.licenses.bsd3; + hydraPlatforms = stdenv.lib.platforms.none; + }) {}; + "pvd" = callPackage ({ mkDerivation, array, base, Codec-Image-DevIL, containers , haskell98, libdevil, mtl, network, stm, X11 @@ -209800,6 +210195,8 @@ self: { ]; description = "Command line tool qhs, SQL queries on CSV and TSV files"; license = stdenv.lib.licenses.mit; + hydraPlatforms = stdenv.lib.platforms.none; + broken = true; }) {}; "qhull-simple" = callPackage @@ -211046,8 +211443,8 @@ self: { }: mkDerivation { pname = "quickjs-hs"; - version = "0.1.2.2"; - sha256 = "1zis42hsvljrqli9469n9k0h44i79a9v9qcd10agq1gylkhgsmkr"; + version = "0.1.2.3"; + sha256 = "1azd2173hwij0z2qxn4k6fi7bkiyaar0q751z15byhbdzil7pf1d"; libraryHaskellDepends = [ aeson base bytestring containers exceptions inline-c mtl scientific string-conv text time transformers unliftio-core @@ -214410,6 +214807,8 @@ self: { ]; description = "Animation library based on SVGs"; license = stdenv.lib.licenses.publicDomain; + hydraPlatforms = stdenv.lib.platforms.none; + broken = true; }) {}; "reanimate_1_1_1_0" = callPackage @@ -214448,6 +214847,7 @@ self: { description = "Animation library based on SVGs"; license = stdenv.lib.licenses.publicDomain; hydraPlatforms = stdenv.lib.platforms.none; + broken = true; }) {}; "reanimate-svg" = callPackage @@ -215303,6 +215703,8 @@ self: { ]; description = "Extra stuff for mutable references"; license = stdenv.lib.licenses.bsd3; + hydraPlatforms = stdenv.lib.platforms.none; + broken = true; }) {}; "ref-fd" = callPackage @@ -216644,8 +217046,8 @@ self: { }: mkDerivation { pname = "regex-pcre-builtin"; - version = "0.95.1.2.8.43"; - sha256 = "1bxn8d3g9w1a5q5vcz744yx019d2rd79i07qcjq4jqkjafni1bml"; + version = "0.95.1.3.8.43"; + sha256 = "0n1sbsjch0n5cgv2lhw2yfaxb611mckyg0jpz2kcbyj5hcrvzv3c"; libraryHaskellDepends = [ array base bytestring containers regex-base text ]; @@ -218606,7 +219008,7 @@ self: { license = stdenv.lib.licenses.bsd3; }) {}; - "req_3_6_0" = callPackage + "req_3_7_0" = callPackage ({ mkDerivation, aeson, authenticate-oauth, base, blaze-builder , bytestring, case-insensitive, connection, exceptions, hspec , hspec-core, hspec-discover, http-api-data, http-client @@ -218616,10 +219018,8 @@ self: { }: mkDerivation { pname = "req"; - version = "3.6.0"; - sha256 = "1ks9iqnnsa8m65ndyblyndb95fc4r4xachq1zrik04adxrdj3b50"; - revision = "1"; - editedCabalFile = "1vr4926n5ac8h4i71q0hqwgf78l7f572wal22ndys3dscvg4a7f1"; + version = "3.7.0"; + sha256 = "1ajak1845dx5vzc7mb5wyh6rilggnm0y5bh93f955zby1mr3mhi1"; enableSeparateDataOutput = true; libraryHaskellDepends = [ aeson authenticate-oauth base blaze-builder bytestring @@ -221067,6 +221467,8 @@ self: { ]; description = "Automatic session-aware servant testing"; license = stdenv.lib.licenses.bsd3; + hydraPlatforms = stdenv.lib.platforms.none; + broken = true; }) {}; "robot" = callPackage @@ -221205,6 +221607,8 @@ self: { ]; description = "Haskell bindings to RocksDB"; license = stdenv.lib.licenses.bsd3; + hydraPlatforms = stdenv.lib.platforms.none; + broken = true; }) {inherit (pkgs) rocksdb;}; "rocksdb-haskell-jprupp" = callPackage @@ -225440,6 +225844,8 @@ self: { ]; description = "Html form validation using `ditto`"; license = stdenv.lib.licenses.gpl2; + hydraPlatforms = stdenv.lib.platforms.none; + broken = true; }) {}; "scotty-format" = callPackage @@ -226710,12 +227116,12 @@ self: { }) {}; "selections" = callPackage - ({ mkDerivation, base, bifunctors, comonad, profunctors }: + ({ mkDerivation, base }: mkDerivation { pname = "selections"; - version = "0.2.0.0"; - sha256 = "000hdwdp56pc67j1iw0mc6m74dfim67g16ib4yr7vyilq8rfccb0"; - libraryHaskellDepends = [ base bifunctors comonad profunctors ]; + version = "0.3.0.0"; + sha256 = "0vl7rqrz0p5m7iwymaw3b8l2kbaikwhmkhq82hq79581vj99fdpw"; + libraryHaskellDepends = [ base ]; description = "Combinators for operating with selections over an underlying functor"; license = stdenv.lib.licenses.bsd3; }) {}; @@ -228159,6 +228565,8 @@ self: { testToolDepends = [ hspec-discover ]; description = "servant-docs/servant-auth compatibility"; license = stdenv.lib.licenses.bsd3; + hydraPlatforms = stdenv.lib.platforms.none; + broken = true; }) {}; "servant-auth-hmac" = callPackage @@ -228694,6 +229102,8 @@ self: { ]; description = "A servant client for frontend JavaScript"; license = stdenv.lib.licenses.bsd3; + hydraPlatforms = stdenv.lib.platforms.none; + broken = true; }) {}; "servant-client-namedargs" = callPackage @@ -229722,6 +230132,8 @@ self: { testToolDepends = [ hspec-discover ]; description = "Generate a Swagger/OpenAPI/OAS 3.0 specification for your servant API."; license = stdenv.lib.licenses.bsd3; + hydraPlatforms = stdenv.lib.platforms.none; + broken = true; }) {}; "servant-options" = callPackage @@ -232175,6 +232587,8 @@ self: { ]; description = "Dependency tracking for Futhark"; license = stdenv.lib.licenses.bsd3; + hydraPlatforms = stdenv.lib.platforms.none; + broken = true; }) {}; "shake-google-closure-compiler" = callPackage @@ -233768,6 +234182,8 @@ self: { ]; description = "Deterministic serialisation and signatures with proto-lens support"; license = stdenv.lib.licenses.bsd3; + hydraPlatforms = stdenv.lib.platforms.none; + broken = true; }) {}; "signable-haskell-protoc" = callPackage @@ -233867,11 +234283,13 @@ self: { ({ mkDerivation, base, prettyprinter }: mkDerivation { pname = "silkscreen"; - version = "0.0.0.2"; - sha256 = "0839minsb7n7170xw3qh62sszggh4ap95v06s3d4l7a76s42bmic"; + version = "0.0.0.3"; + sha256 = "0gmp71cipwc0ymydckhvw9g8q3j4pm8cq2la2rbvm0rr9z7c2l40"; libraryHaskellDepends = [ base prettyprinter ]; description = "Prettyprinting transformers"; license = stdenv.lib.licenses.bsd3; + hydraPlatforms = stdenv.lib.platforms.none; + broken = true; }) {}; "silvi" = callPackage @@ -235849,14 +236267,14 @@ self: { license = stdenv.lib.licenses.gpl2; }) {}; - "skylighting_0_10_0_2" = callPackage + "skylighting_0_10_0_3" = callPackage ({ mkDerivation, base, binary, blaze-html, bytestring, containers , directory, filepath, pretty-show, skylighting-core, text }: mkDerivation { pname = "skylighting"; - version = "0.10.0.2"; - sha256 = "0m2z4hmv2m6h6kmvn8n3fskwyhq6pj28bjfvs61qg9pnga3xbf26"; + version = "0.10.0.3"; + sha256 = "1fzcvhkzrzf0rlic61fjbz7n9vfxjyc45kn57pw48qdl77shqhga"; configureFlags = [ "-fexecutable" ]; isLibrary = true; isExecutable = true; @@ -235904,7 +236322,7 @@ self: { license = stdenv.lib.licenses.bsd3; }) {}; - "skylighting-core_0_10_0_2" = callPackage + "skylighting-core_0_10_0_3" = callPackage ({ mkDerivation, aeson, ansi-terminal, attoparsec, base , base64-bytestring, binary, blaze-html, bytestring , case-insensitive, colour, containers, criterion, Diff, directory @@ -235914,8 +236332,8 @@ self: { }: mkDerivation { pname = "skylighting-core"; - version = "0.10.0.2"; - sha256 = "07gdvmz8lvqkzzgnxakx015g2ijmqd2jmni1phz6x79xf9q7s5vw"; + version = "0.10.0.3"; + sha256 = "1c2r0gsy4c5l6m3w0i3zzv1fvaaqzn2636sd0mmzd9a8ncsgyzf6"; isLibrary = true; isExecutable = true; libraryHaskellDepends = [ @@ -240819,17 +241237,17 @@ self: { license = stdenv.lib.licenses.bsd3; }) {}; - "splitmix_0_1_0_1" = callPackage + "splitmix_0_1_0_3" = callPackage ({ mkDerivation, async, base, base-compat, base-compat-batteries , bytestring, clock, containers, criterion, deepseq, HUnit , math-functions, process, random, test-framework - , test-framework-hunit, tf-random, time, vector + , test-framework-hunit, tf-random, vector }: mkDerivation { pname = "splitmix"; - version = "0.1.0.1"; - sha256 = "0ahr3zxx0n9pjxpldrphqx5rhanar6alq3km7qvszipa8r46jjsd"; - libraryHaskellDepends = [ base deepseq time ]; + version = "0.1.0.3"; + sha256 = "0das5n44dhlcv5i233iakx37d17kidqvhrvp6w9nd7hc015ry026"; + libraryHaskellDepends = [ base deepseq ]; testHaskellDepends = [ async base base-compat base-compat-batteries bytestring containers deepseq HUnit math-functions process random test-framework @@ -241980,6 +242398,8 @@ self: { pname = "stack"; version = "2.5.1"; sha256 = "1ffbgs5wgdcvvwbg3pkpgih5dqcbw8mpjj2p49fd8f79cfxmjq20"; + revision = "1"; + editedCabalFile = "0k5hapiyq2qv8sn2l2j5sh6w9b8493apwwsbrhpym5m1llxrv29p"; configureFlags = [ "-fdisable-git-info" "-fhide-dependency-versions" "-fsupported-build" @@ -242911,8 +243331,6 @@ self: { doHaddock = false; description = "Haskell STatic ANalyser"; license = stdenv.lib.licenses.mpl20; - hydraPlatforms = stdenv.lib.platforms.none; - broken = true; }) {}; "standalone-derive-topdown" = callPackage @@ -243988,6 +244406,8 @@ self: { testHaskellDepends = [ base hspec mtl stm stm-queue ]; description = "A simplistic actor model based on STM"; license = stdenv.lib.licenses.mit; + hydraPlatforms = stdenv.lib.platforms.none; + broken = true; }) {}; "stm-channelize" = callPackage @@ -244061,8 +244481,8 @@ self: { }: mkDerivation { pname = "stm-containers"; - version = "1.1.0.4"; - sha256 = "0mcn4v9gjkqp27xcwvqphiqnaj4grvxpsflhq0rwqp5ymnzlccyl"; + version = "1.2"; + sha256 = "0yhpnxj7v880fy7vgjz5idpqfg2sm4dflp13k7fs0bqqlfv9hkbc"; libraryHaskellDepends = [ base deferred-folds focus hashable list-t stm-hamt transformers ]; @@ -244072,6 +244492,8 @@ self: { ]; description = "Containers for STM"; license = stdenv.lib.licenses.mit; + hydraPlatforms = stdenv.lib.platforms.none; + broken = true; }) {}; "stm-delay" = callPackage @@ -244218,8 +244640,8 @@ self: { }: mkDerivation { pname = "stm-queue"; - version = "0.1.2.0"; - sha256 = "06l5gavmf4x6vp54p1h27nnm5nnw6f8p82v5np93b25inc67vz4h"; + version = "0.1.2.1"; + sha256 = "0by8jga1wrzzasa442fi61nl5kv88vbl2030gidmgzrzbgf0q8yc"; libraryHaskellDepends = [ base stm ]; testHaskellDepends = [ async base hspec stm ]; benchmarkHaskellDepends = [ @@ -245069,27 +245491,6 @@ self: { }) {}; "streaming-bytestring" = callPackage - ({ mkDerivation, base, bytestring, deepseq, exceptions, mmorph, mtl - , resourcet, smallcheck, streaming, tasty, tasty-smallcheck - , transformers, transformers-base - }: - mkDerivation { - pname = "streaming-bytestring"; - version = "0.1.6"; - sha256 = "1lsklavhk6wcsgjr2rcwkkv827gnd9spv4zwz5i5zf3njvy27my1"; - libraryHaskellDepends = [ - base bytestring deepseq exceptions mmorph mtl resourcet streaming - transformers transformers-base - ]; - testHaskellDepends = [ - base bytestring smallcheck streaming tasty tasty-smallcheck - transformers - ]; - description = "effectful byte steams, or: bytestring io done right"; - license = stdenv.lib.licenses.bsd3; - }) {}; - - "streaming-bytestring_0_1_7" = callPackage ({ mkDerivation, base, bytestring, deepseq, exceptions, mmorph, mtl , resourcet, smallcheck, streaming, tasty, tasty-hunit , tasty-smallcheck, transformers, transformers-base @@ -245108,7 +245509,6 @@ self: { ]; description = "Fast, effectful byte streams"; license = stdenv.lib.licenses.bsd3; - hydraPlatforms = stdenv.lib.platforms.none; }) {}; "streaming-cassava" = callPackage @@ -248471,8 +248871,8 @@ self: { }: mkDerivation { pname = "sweet-egison"; - version = "0.1.1.2"; - sha256 = "0cf4wq7lmp5y40niwvlmj5l2bvjl16vbv2dx03m86mg1n16jb30y"; + version = "0.1.1.3"; + sha256 = "0b2rvfgj7l10plgri5ia3l07ip71c9c3259k78z140i57pfjlfh7"; libraryHaskellDepends = [ backtracking base egison-pattern-src egison-pattern-src-th-mode haskell-src-exts haskell-src-meta logict template-haskell @@ -251490,23 +251890,6 @@ self: { }) {}; "tasty-ant-xml" = callPackage - ({ mkDerivation, base, containers, directory, filepath - , generic-deriving, ghc-prim, mtl, stm, tagged, tasty, transformers - , xml - }: - mkDerivation { - pname = "tasty-ant-xml"; - version = "1.1.6"; - sha256 = "13qqpl1prr9dda87dp45mqybay24n8rhxxgvpc9j34kh72g8j5qw"; - libraryHaskellDepends = [ - base containers directory filepath generic-deriving ghc-prim mtl - stm tagged tasty transformers xml - ]; - description = "Render tasty output to XML for Jenkins"; - license = stdenv.lib.licenses.bsd3; - }) {}; - - "tasty-ant-xml_1_1_7" = callPackage ({ mkDerivation, base, containers, directory, filepath , generic-deriving, ghc-prim, mtl, stm, tagged, tasty, transformers , xml @@ -251521,7 +251904,6 @@ self: { ]; description = "Render tasty output to XML for Jenkins"; license = stdenv.lib.licenses.bsd3; - hydraPlatforms = stdenv.lib.platforms.none; }) {}; "tasty-auto" = callPackage @@ -251969,24 +252351,6 @@ self: { }) {}; "tasty-lua" = callPackage - ({ mkDerivation, base, bytestring, directory, file-embed, filepath - , hslua, tasty, tasty-hunit, text - }: - mkDerivation { - pname = "tasty-lua"; - version = "0.2.3"; - sha256 = "0kpmp51wyqbjv3nsrnybpms7flsl2bznqp8gf27zv2f5kraa77vk"; - libraryHaskellDepends = [ - base bytestring file-embed hslua tasty text - ]; - testHaskellDepends = [ - base directory filepath hslua tasty tasty-hunit - ]; - description = "Write tests in Lua, integrate into tasty"; - license = stdenv.lib.licenses.mit; - }) {}; - - "tasty-lua_0_2_3_1" = callPackage ({ mkDerivation, base, bytestring, directory, file-embed, filepath , hslua, tasty, tasty-hunit, text }: @@ -252002,7 +252366,6 @@ self: { ]; description = "Write tests in Lua, integrate into tasty"; license = stdenv.lib.licenses.mit; - hydraPlatforms = stdenv.lib.platforms.none; }) {}; "tasty-mgolden" = callPackage @@ -263877,18 +264240,6 @@ self: { }) {}; "type-fun" = callPackage - ({ mkDerivation, base }: - mkDerivation { - pname = "type-fun"; - version = "0.1.1"; - sha256 = "18axaln9ahrn6023pk4ig79d2qimmflikf608vgka4hhi91cfpnz"; - libraryHaskellDepends = [ base ]; - testHaskellDepends = [ base ]; - description = "Collection of widely reimplemented type families"; - license = stdenv.lib.licenses.bsd3; - }) {}; - - "type-fun_0_1_2" = callPackage ({ mkDerivation, base }: mkDerivation { pname = "type-fun"; @@ -263898,7 +264249,6 @@ self: { testHaskellDepends = [ base ]; description = "Collection of widely reimplemented type families"; license = stdenv.lib.licenses.bsd3; - hydraPlatforms = stdenv.lib.platforms.none; }) {}; "type-functions" = callPackage @@ -265016,8 +265366,8 @@ self: { }: mkDerivation { pname = "tz"; - version = "0.1.3.4"; - sha256 = "11sg11alwlibnl62bd9s3gvhha8c523625cn6y4x10avv6jv320y"; + version = "0.1.3.5"; + sha256 = "1svqcpcpy5mydkmf42a78khxa053jxbvrbdh5jzprh2b7g0dpvlb"; libraryHaskellDepends = [ base binary bytestring containers data-default deepseq template-haskell time tzdata vector @@ -265055,6 +265405,28 @@ self: { license = stdenv.lib.licenses.asl20; }) {}; + "tzdata_0_2_20201021_0" = callPackage + ({ mkDerivation, base, bytestring, containers, deepseq, HUnit + , test-framework, test-framework-hunit, test-framework-th, unix + , vector + }: + mkDerivation { + pname = "tzdata"; + version = "0.2.20201021.0"; + sha256 = "0bkd7k0q8dflp21hzf71kbqyk0jq279z7sgwlq1pdzs2ggmnrwm9"; + enableSeparateDataOutput = true; + libraryHaskellDepends = [ + base bytestring containers deepseq vector + ]; + testHaskellDepends = [ + base bytestring HUnit test-framework test-framework-hunit + test-framework-th unix + ]; + description = "Time zone database (as files and as a module)"; + license = stdenv.lib.licenses.asl20; + hydraPlatforms = stdenv.lib.platforms.none; + }) {}; + "u2f" = callPackage ({ mkDerivation, aeson, asn1-encoding, asn1-types, base , base64-bytestring, binary, bytestring, cryptohash, cryptonite @@ -265477,6 +265849,17 @@ self: { license = stdenv.lib.licenses.mit; }) {}; + "ukrainian-phonetics-basic" = callPackage + ({ mkDerivation, base, bytestring, mmsyn2, mmsyn5, vector }: + mkDerivation { + pname = "ukrainian-phonetics-basic"; + version = "0.1.1.0"; + sha256 = "0k7lv4lzmkjyfk5r664gmdaqbj08s1kp7n4w8lw7kn7fmxvwkraf"; + libraryHaskellDepends = [ base bytestring mmsyn2 mmsyn5 vector ]; + description = "A library to work with the basic Ukrainian phonetics and syllable segmentation"; + license = stdenv.lib.licenses.mit; + }) {}; + "ulid" = callPackage ({ mkDerivation, base, binary, bytestring, crypto-api, deepseq , format-numbers, hashable, hspec, random, text, time @@ -265597,17 +265980,18 @@ self: { "unbeliever" = callPackage ({ mkDerivation, base, bytestring, core-data, core-program - , core-text, fingertree, gauge, hashable, hspec, safe-exceptions - , text, text-short + , core-text, fingertree, gauge, hashable, hspec, prettyprinter + , safe-exceptions, text, text-short, unordered-containers }: mkDerivation { pname = "unbeliever"; - version = "0.10.0.6"; - sha256 = "08rw2krphvs2z0ic19mfwlz3fcmpnbwbpvp7ks22pasi2zy45sb2"; + version = "0.10.0.7"; + sha256 = "17yjw8lgwm93hhf4rk0npj35h77jfig3ziampdmg5cjhyy2h4sd7"; libraryHaskellDepends = [ base core-data core-program core-text ]; testHaskellDepends = [ base bytestring core-data core-program core-text fingertree - hashable hspec safe-exceptions text text-short + hashable hspec prettyprinter safe-exceptions text text-short + unordered-containers ]; benchmarkHaskellDepends = [ base bytestring core-data core-program core-text gauge text @@ -266180,28 +266564,6 @@ self: { }) {}; "unicode-transforms" = callPackage - ({ mkDerivation, base, bytestring, deepseq, filepath, gauge - , getopt-generics, ghc-prim, hspec, path, path-io, QuickCheck - , split, text - }: - mkDerivation { - pname = "unicode-transforms"; - version = "0.3.7"; - sha256 = "0pgxb4znvr39n0f7y5q0bdajc4l96zsih0a43n90qjlhj9084rp8"; - isLibrary = true; - isExecutable = true; - libraryHaskellDepends = [ base bytestring ghc-prim text ]; - testHaskellDepends = [ - base deepseq getopt-generics hspec QuickCheck split text - ]; - benchmarkHaskellDepends = [ - base deepseq filepath gauge path path-io text - ]; - description = "Unicode normalization"; - license = stdenv.lib.licenses.bsd3; - }) {}; - - "unicode-transforms_0_3_7_1" = callPackage ({ mkDerivation, base, bytestring, deepseq, filepath, gauge , getopt-generics, ghc-prim, hspec, path, path-io, QuickCheck , split, text @@ -266221,7 +266583,6 @@ self: { ]; description = "Unicode normalization"; license = stdenv.lib.licenses.bsd3; - hydraPlatforms = stdenv.lib.platforms.none; }) {}; "unicode-tricks" = callPackage @@ -266564,8 +266925,8 @@ self: { }) {}; "uniqueness-periods-vector-examples" = callPackage - ({ mkDerivation, base, lists-flines, mmsyn6ukr, parallel - , phonetic-languages-ukrainian, print-info + ({ mkDerivation, base, bytestring, lists-flines, mmsyn6ukr + , parallel, phonetic-languages-ukrainian, print-info , uniqueness-periods-vector, uniqueness-periods-vector-common , uniqueness-periods-vector-filters , uniqueness-periods-vector-general @@ -266574,8 +266935,8 @@ self: { }: mkDerivation { pname = "uniqueness-periods-vector-examples"; - version = "0.12.3.1"; - sha256 = "18k9my22zn2x6nf2adnwf340jnixzdkyyx2j24nqvcryxx9kagsi"; + version = "0.13.1.0"; + sha256 = "0z6jglwli11845x4nlk8b3wk4d6j6i1m7jr3vhgri64g34qj1767"; isLibrary = true; isExecutable = true; libraryHaskellDepends = [ @@ -266584,8 +266945,8 @@ self: { uniqueness-periods-vector-properties vector ]; executableHaskellDepends = [ - base lists-flines mmsyn6ukr parallel phonetic-languages-ukrainian - print-info uniqueness-periods-vector + base bytestring lists-flines mmsyn6ukr parallel + phonetic-languages-ukrainian print-info uniqueness-periods-vector uniqueness-periods-vector-common uniqueness-periods-vector-filters uniqueness-periods-vector-general uniqueness-periods-vector-properties @@ -267934,6 +268295,24 @@ self: { broken = true; }) {}; + "urbit-airlock" = callPackage + ({ mkDerivation, aeson, base, bytestring, conduit, conduit-extra + , http-client, modern-uri, req, req-conduit, text, uuid + }: + mkDerivation { + pname = "urbit-airlock"; + version = "0.1.0.0"; + sha256 = "1w6mkdx999jxr2c9004cp1n550wjnhj9gvi76nhq5bcibnl62jqw"; + libraryHaskellDepends = [ + aeson base bytestring conduit conduit-extra http-client modern-uri + req req-conduit text uuid + ]; + description = "Talk to Urbit from Haskell"; + license = stdenv.lib.licenses.bsd3; + hydraPlatforms = stdenv.lib.platforms.none; + broken = true; + }) {}; + "urbit-hob" = callPackage ({ mkDerivation, base, bytestring, criterion, deepseq, hspec , hspec-core, murmur3, QuickCheck, text, vector @@ -268074,8 +268453,8 @@ self: { }: mkDerivation { pname = "uri-encode"; - version = "1.5.0.6"; - sha256 = "1w74dqvcl0s26p1s7rszmfj3zphv4bcflpp54iq1kxsrqpd1bbv8"; + version = "1.5.0.7"; + sha256 = "0lj2h701af12539p957rw24bxr07mfqd5r4h52i42f43ax165767"; isLibrary = true; isExecutable = true; libraryHaskellDepends = [ @@ -269266,6 +269645,8 @@ self: { ]; description = "A program removing all version constraints of dependencies in .cabal file"; license = stdenv.lib.licenses.mit; + hydraPlatforms = stdenv.lib.platforms.none; + broken = true; }) {}; "uvector" = callPackage @@ -271190,6 +271571,27 @@ self: { license = stdenv.lib.licenses.bsd3; }) {}; + "versions_4_0_1" = callPackage + ({ mkDerivation, base, deepseq, hashable, megaparsec, microlens + , parser-combinators, QuickCheck, tasty, tasty-hunit + , tasty-quickcheck, text + }: + mkDerivation { + pname = "versions"; + version = "4.0.1"; + sha256 = "1s8bnxq3asq4wwgbsfvhkl6yih1sic9v8ylimcxwnvmdlh5ks58a"; + libraryHaskellDepends = [ + base deepseq hashable megaparsec parser-combinators text + ]; + testHaskellDepends = [ + base megaparsec microlens QuickCheck tasty tasty-hunit + tasty-quickcheck text + ]; + description = "Types and parsers for software version numbers"; + license = stdenv.lib.licenses.bsd3; + hydraPlatforms = stdenv.lib.platforms.none; + }) {}; + "vflow-types" = callPackage ({ mkDerivation, aeson, base, bytestring, ip, json-alt , json-autotype, neat-interpolation, QuickCheck, quickcheck-classes @@ -272296,6 +272698,8 @@ self: { ]; description = "Utils for the vulkan package"; license = stdenv.lib.licenses.bsd3; + hydraPlatforms = stdenv.lib.platforms.none; + broken = true; }) {}; "waargonaut" = callPackage @@ -275335,6 +275739,8 @@ self: { ]; description = "Web Authentication API"; license = stdenv.lib.licenses.bsd3; + hydraPlatforms = stdenv.lib.platforms.none; + broken = true; }) {}; "webby" = callPackage @@ -275345,8 +275751,8 @@ self: { }: mkDerivation { pname = "webby"; - version = "1.0.0"; - sha256 = "0pz80i94cqk2w07135mw7lmh7yvc3vn8pikav5l8pvq3hcfmhk0g"; + version = "1.0.1"; + sha256 = "00sdw1ly5848f4yq64j4an8w1c83gwry6n8bp7z7csh1y0lz4mm3"; libraryHaskellDepends = [ aeson base binary bytestring formatting http-api-data http-types relude resourcet text unliftio unliftio-core unordered-containers @@ -275359,6 +275765,8 @@ self: { ]; description = "A super-simple web server framework"; license = stdenv.lib.licenses.asl20; + hydraPlatforms = stdenv.lib.platforms.none; + broken = true; }) {}; "webcloud" = callPackage @@ -277558,6 +277966,8 @@ self: { doHaddock = false; description = "arbitrary bit size Words"; license = stdenv.lib.licenses.mit; + hydraPlatforms = stdenv.lib.platforms.none; + broken = true; }) {}; "wordpass" = callPackage @@ -280586,6 +280996,8 @@ self: { executableHaskellDepends = [ base dbus utf8-string ]; testHaskellDepends = [ base dbus utf8-string ]; license = stdenv.lib.licenses.bsd3; + hydraPlatforms = stdenv.lib.platforms.none; + broken = true; }) {}; "xmonad-entryhelper" = callPackage @@ -281827,33 +282239,6 @@ self: { }) {}; "yamlparse-applicative" = callPackage - ({ mkDerivation, aeson, base, bytestring, containers - , genvalidity-aeson, genvalidity-containers, genvalidity-hspec - , genvalidity-scientific, genvalidity-text - , genvalidity-unordered-containers, hspec, optparse-applicative - , path, path-io, prettyprinter, QuickCheck, scientific, text - , unordered-containers, validity, validity-text, vector, yaml - }: - mkDerivation { - pname = "yamlparse-applicative"; - version = "0.1.0.1"; - sha256 = "089s5f3i3yz833g7q2rd55v9hn93cdzprhniymw37qdmhv5jw960"; - libraryHaskellDepends = [ - aeson base bytestring containers optparse-applicative path path-io - prettyprinter scientific text unordered-containers validity - validity-text vector yaml - ]; - testHaskellDepends = [ - aeson base containers genvalidity-aeson genvalidity-containers - genvalidity-hspec genvalidity-scientific genvalidity-text - genvalidity-unordered-containers hspec QuickCheck scientific text - unordered-containers - ]; - description = "Declaritive configuration parsing with free docs"; - license = stdenv.lib.licenses.mit; - }) {}; - - "yamlparse-applicative_0_1_0_2" = callPackage ({ mkDerivation, aeson, base, bytestring, containers , genvalidity-aeson, genvalidity-containers, genvalidity-hspec , genvalidity-scientific, genvalidity-text @@ -281878,7 +282263,6 @@ self: { ]; description = "Declaritive configuration parsing with free docs"; license = stdenv.lib.licenses.mit; - hydraPlatforms = stdenv.lib.platforms.none; }) {}; "yampa-canvas" = callPackage @@ -282313,6 +282697,8 @@ self: { pname = "yeamer"; version = "0.1.0.5"; sha256 = "0c8yrh43h9qhhdiz0dnrh00frfz0cymzzz9k723jnp03b8994srq"; + revision = "1"; + editedCabalFile = "0ivw54131s99kblah7n0flccb9h6qfiz55ifs2cwjwxxmrs9xi1n"; isLibrary = true; isExecutable = true; libraryHaskellDepends = [ @@ -283244,6 +283630,44 @@ self: { license = stdenv.lib.licenses.mit; }) {}; + "yesod-core_1_6_18_5" = callPackage + ({ mkDerivation, aeson, async, auto-update, base, blaze-html + , blaze-markup, bytestring, case-insensitive, cereal, clientsession + , conduit, conduit-extra, containers, cookie, deepseq, fast-logger + , gauge, hspec, hspec-expectations, http-types, HUnit, memory + , monad-logger, mtl, network, parsec, path-pieces, primitive + , random, resourcet, shakespeare, streaming-commons + , 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.18.5"; + sha256 = "11f51x3slqnan07fp2bxswd3y994wccqg48gakdk272i2bcg2vfq"; + libraryHaskellDepends = [ + aeson auto-update base blaze-html blaze-markup bytestring + case-insensitive cereal clientsession conduit conduit-extra + containers cookie deepseq fast-logger http-types memory + monad-logger mtl parsec path-pieces primitive random resourcet + shakespeare template-haskell text time transformers unix-compat + unliftio unordered-containers vector wai wai-extra wai-logger warp + word8 + ]; + testHaskellDepends = [ + async base bytestring clientsession conduit conduit-extra + containers cookie hspec hspec-expectations http-types HUnit network + path-pieces random resourcet shakespeare streaming-commons + template-haskell text transformers unliftio wai wai-extra warp + ]; + benchmarkHaskellDepends = [ + base blaze-html bytestring gauge shakespeare text + ]; + description = "Creation of type-safe, RESTful web applications"; + license = stdenv.lib.licenses.mit; + hydraPlatforms = stdenv.lib.platforms.none; + }) {}; + "yesod-crud" = callPackage ({ mkDerivation, base, classy-prelude, containers, MissingH , monad-control, persistent, random, safe, stm, uuid, yesod-core diff --git a/pkgs/development/misc/haskell/hasura/graphql-engine/default.nix b/pkgs/development/misc/haskell/hasura/graphql-engine/default.nix index 0bd68afae4b..055459514e4 100644 --- a/pkgs/development/misc/haskell/hasura/graphql-engine/default.nix +++ b/pkgs/development/misc/haskell/hasura/graphql-engine/default.nix @@ -70,4 +70,6 @@ mkDerivation { description = "GraphQL API over Postgres"; license = stdenv.lib.licenses.asl20; maintainers = with stdenv.lib.maintainers; [ offline ]; + hydraPlatforms = []; + broken = true; }