commit 5942b67b0c3db3e01068c7f66e4f5bf3e00fc201 · pyrox.dev/nixpkgs

+6 -2

pkgs/applications/terminal-emulators/termonad/default.nix

···

       1
       1
       -
       { stdenv, ghcWithPackages, makeWrapper, packages ? (pkgSet: []) }:

     

       1
       1
       +
       { stdenv, haskellPackages, makeWrapper, packages ? (pkgSet: []) }:

     

       2
       2
        
       

     

       3
       3
        
       let

     

       4
       4
       -
         termonadEnv = ghcWithPackages (self: [ self.termonad ] ++ packages self);

     

       4
       4
       +
         termonadEnv = haskellPackages.ghcWithPackages (self: [ self.termonad ] ++ packages self);

     

       5
       5
        
       in stdenv.mkDerivation {

     

       6
       6
        
         name = "termonad-with-packages-${termonadEnv.version}";

     

       7
       7
        
       

     
···

       16
       16
        
         # trivial derivation

     

       17
       17
        
         preferLocalBuild = true;

     

       18
       18
        
         allowSubstitutes = false;

     

       19
       19
       +
       

     

       20
       20
       +
         meta = haskellPackages.termonad.meta // {

     

       21
       21
       +
           mainProgram = "termonad";

     

       22
       22
       +
         };

     

       19
       23
        
       }

+4 -4

pkgs/data/misc/hackage/pin.json

···

       1
       1
        
       {

     

       2
       2
       -
         "commit": "23315eb3220b0748c3aa71a9027dc39e5416ce9e",

     

       3
       3
       -
         "url": "https://github.com/commercialhaskell/all-cabal-hashes/archive/23315eb3220b0748c3aa71a9027dc39e5416ce9e.tar.gz",

     

       4
       4
       -
         "sha256": "0pgcyfb3lnl7kxpj87sbj50ljlg2l05v4kgcdwy568pcf24bh764",

     

       5
       5
       -
         "msg": "Update from Hackage at 2021-08-17T22:21:14Z"

     

       2
       2
       +
         "commit": "193a13be44c51ebfc8e991b7bb53a4065129ff4d",

     

       3
       3
       +
         "url": "https://github.com/commercialhaskell/all-cabal-hashes/archive/193a13be44c51ebfc8e991b7bb53a4065129ff4d.tar.gz",

     

       4
       4
       +
         "sha256": "08j6qx3jqcw7ydwnpjr132l2mlpq6dqvwqgm3gq0ym4kjzrbdwsd",

     

       5
       5
       +
         "msg": "Update from Hackage at 2021-08-23T13:50:03Z"

     

       6
       6
        
       }

+1 -1

pkgs/development/compilers/ghc/8.10.2-binary.nix

···

       374
       374
        
           # `pkgsMusl`.

     

       375
       375
        
           platforms = builtins.attrNames ghcBinDists.${distSetName};

     

       376
       376
        
           hydraPlatforms = builtins.filter (p: minimal || p != "aarch64-linux") platforms;

     

       377
       377
       -
           maintainers = with lib.maintainers; [ lostnet ];

     

       377
       377
       +
           maintainers = with lib.maintainers; [ lostnet guibou ];

     

       378
       378
        
         };

     

       379
       379
        
       }

+9 -8

pkgs/development/compilers/ghc/8.10.5-binary.nix pkgs/development/compilers/ghc/8.10.7-binary.nix

···

       17
       17
        
       let

     

       18
       18
        
         downloadsUrl = "https://downloads.haskell.org/ghc";

     

       19
       19
        
       

     

       20
       20
       -
         version = "8.10.5";

     

       20
       20
       +
         # Copy sha256 from https://downloads.haskell.org/~ghc/8.10.7/SHA256SUMS

     

       21
       21
       +
         version = "8.10.7";

     

       21
       22
        
       

     

       22
       23
        
         # Information about available bindists that we use in the build.

     

       23
       24
        
         #

     
···

       42
       43
        
             i686-linux = {

     

       43
       44
        
               src = {

     

       44
       45
        
                 url = "${downloadsUrl}/${version}/ghc-${version}-i386-deb9-linux.tar.xz";

     

       45
       45
       -
                 sha256 = "17cwmhhyz952psmp4j3pkdj0yrfxah3l2dawg5s4hdr228n5pjqc";

     

       46
       46
       +
                 sha256 = "fbfc1ef194f4e7a4c0da8c11cc69b17458a4b928b609b3622c97acc4acd5c5ab";

     

       46
       47
        
               };

     

       47
       48
        
               exePathForLibraryCheck = "ghc/stage2/build/tmp/ghc-stage2";

     

       48
       49
        
               archSpecificLibraries = [

     
···

       55
       56
        
             x86_64-linux = {

     

       56
       57
        
               src = {

     

       57
       58
        
                 url = "${downloadsUrl}/${version}/ghc-${version}-x86_64-deb10-linux.tar.xz";

     

       58
       58
       -
                 sha256 = "11v76wgljyszc6mgz6r16i6wkifgl15a26q7ablihp2cr8h3qqmw";

     

       59
       59
       +
                 sha256 = "a13719bca87a0d3ac0c7d4157a4e60887009a7f1a8dbe95c4759ec413e086d30";

     

       59
       60
        
               };

     

       60
       61
        
               exePathForLibraryCheck = "ghc/stage2/build/tmp/ghc-stage2";

     

       61
       62
        
               archSpecificLibraries = [

     
···

       65
       66
        
             armv7l-linux = {

     

       66
       67
        
               src = {

     

       67
       68
        
                 url = "${downloadsUrl}/${version}/ghc-${version}-armv7-deb10-linux.tar.xz";

     

       68
       68
       -
                 sha256 = "0v5bvhb2z9j26yr0n9gc4xdq2lm37mr98g62p5z8pqahhhd0s5sn";

     

       69
       69
       +
                 sha256 = "3949c31bdf7d3b4afb765ea8246bca4ca9707c5d988d9961a244f0da100956a2";

     

       69
       70
        
               };

     

       70
       71
        
               exePathForLibraryCheck = "ghc/stage2/build/tmp/ghc-stage2";

     

       71
       72
        
               archSpecificLibraries = [

     
···

       75
       76
        
             aarch64-linux = {

     

       76
       77
        
               src = {

     

       77
       78
        
                 url = "${downloadsUrl}/${version}/ghc-${version}-aarch64-deb10-linux.tar.xz";

     

       78
       78
       -
                 sha256 = "1p0dgyn1m2nd8ax1g25lchaz9z2nk9jvyzf63biarq7qlzc5q24s";

     

       79
       79
       +
                 sha256 = "fad2417f9b295233bf8ade79c0e6140896359e87be46cb61cd1d35863d9d0e55";

     

       79
       80
        
               };

     

       80
       81
        
               exePathForLibraryCheck = "ghc/stage2/build/tmp/ghc-stage2";

     

       81
       82
        
               archSpecificLibraries = [

     
···

       86
       87
        
             x86_64-darwin = {

     

       87
       88
        
               src = {

     

       88
       89
        
                 url = "${downloadsUrl}/${version}/ghc-${version}-x86_64-apple-darwin.tar.xz";

     

       89
       89
       -
                 sha256 = "08javwfqd21kglbr1bnhnbjw2cggz1n668vi8kx5hbcnz3plf3zg";

     

       90
       90
       +
                 sha256 = "287db0f9c338c9f53123bfa8731b0996803ee50f6ee847fe388092e5e5132047";

     

       90
       91
        
               };

     

       91
       92
        
               exePathForLibraryCheck = null; # we don't have a library check for darwin yet

     

       92
       93
        
               archSpecificLibraries = [

     
···

       97
       98
        
             aarch64-darwin = {

     

       98
       99
        
               src = {

     

       99
       100
        
                 url = "${downloadsUrl}/${version}/ghc-${version}-aarch64-apple-darwin.tar.xz";

     

       100
       100
       -
                 sha256 = "02fbcrzcc6m25z3ji867isml38jkg4blry70ljwl3l03zxq4ws03";

     

       101
       101
       +
                 sha256 = "dc469fc3c35fd2a33a5a575ffce87f13de7b98c2d349a41002e200a56d9bba1c";

     

       101
       102
        
               };

     

       102
       103
        
               exePathForLibraryCheck = null; # we don't have a library check for darwin yet

     

       103
       104
        
               archSpecificLibraries = [

     
···

       111
       112
        
             x86_64-linux = {

     

       112
       113
        
               src = {

     

       113
       114
        
                 url = "${downloadsUrl}/${version}/ghc-${version}-x86_64-alpine3.10-linux-integer-simple.tar.xz";

     

       114
       114
       -
                 sha256 = "1ql2qxywbbv0b9syvrm9kyh5d8midnl676lw4698ajras6gcvmzl";

     

       115
       115
       +
                 sha256 = "16903df850ef73d5246f2ff169cbf57ecab76c2ac5acfa9928934282cfad575c";

     

       115
       116
        
               };

     

       116
       117
        
               exePathForLibraryCheck = "bin/ghc";

     

       117
       118
        
               archSpecificLibraries = [

+7 -3

pkgs/development/compilers/ghc/8.10.6.nix pkgs/development/compilers/ghc/8.10.7.nix

···

       136
       136
        
       

     

       137
       137
        
       in

     

       138
       138
        
       stdenv.mkDerivation (rec {

     

       139
       139
       -
         version = "8.10.6";

     

       139
       139
       +
         version = "8.10.7";

     

       140
       140
        
         name = "${targetPrefix}ghc-${version}";

     

       141
       141
        
       

     

       142
       142
        
         src = fetchurl {

     

       143
       143
        
           url = "https://downloads.haskell.org/ghc/${version}/ghc-${version}-src.tar.xz";

     

       144
       144
       -
           sha256 = "43afba72a533408b42c1492bd047b5e37e5f7204e41a5cedd3182cc841610ce9";

     

       144
       144
       +
           sha256 = "e3eef6229ce9908dfe1ea41436befb0455fefb1932559e860ad4c606b0d03c9d";

     

       145
       145
        
         };

     

       146
       146
        
       

     

       147
       147
        
         enableParallelBuilding = true;

     
···

       284
       284
        
           # * https://gitlab.haskell.org/ghc/ghc/-/issues/19580

     

       285
       285
        
           ++ lib.optional stdenv.targetPlatform.isMusl "pie";

     

       286
       286
        
       

     

       287
       287
       +
         # big-parallel allows us to build with more than 2 cores on

     

       288
       288
       +
         # Hydra which already warrants a significant speedup

     

       289
       289
       +
         requiredSystemFeatures = [ "big-parallel" ];

     

       290
       290
       +
       

     

       287
       291
        
         postInstall = ''

     

       288
       292
        
           # Install the bash completion file.

     

       289
       293
        
           install -D -m 444 utils/completion/ghc.bash $out/share/bash-completion/completions/${targetPrefix}ghc

     
···

       309
       313
        
         meta = {

     

       310
       314
        
           homepage = "http://haskell.org/ghc";

     

       311
       315
        
           description = "The Glasgow Haskell Compiler";

     

       312
       312
       -
           maintainers = with lib.maintainers; [ marcweber andres peti ];

     

       316
       316
       +
           maintainers = with lib.maintainers; [ marcweber andres peti guibou ];

     

       313
       317
        
           timeout = 24 * 3600;

     

       314
       318
        
           inherit (ghc.meta) license platforms;

     

       315
       319

pkgs/development/compilers/ghc/8.6.5-binary.nix

···

       192
       192
        
           hydraPlatforms = builtins.filter (p: p != "aarch64-linux") platforms;

     

       193
       193
        
           # build segfaults, use ghc8102Binary which has proper musl support instead

     

       194
       194
        
           broken = stdenv.hostPlatform.isMusl;

     

       195
       195
       +
           maintainers = with lib.maintainers; [ guibou ];

     

       195
       196
        
         };

     

       196
       197
        
       }

+1 -1

pkgs/development/compilers/ghc/8.8.4.nix

···

       316
       316
        
         meta = {

     

       317
       317
        
           homepage = "http://haskell.org/ghc";

     

       318
       318
        
           description = "The Glasgow Haskell Compiler";

     

       319
       319
       -
           maintainers = with lib.maintainers; [ marcweber andres peti ];

     

       319
       319
       +
           maintainers = with lib.maintainers; [ marcweber andres peti guibou ];

     

       320
       320
        
           timeout = 24 * 3600;

     

       321
       321
        
           inherit (ghc.meta) license platforms;

     

       322
       322

+5 -1

pkgs/development/compilers/ghc/9.0.1.nix

···

       268
       268
        
           # * https://gitlab.haskell.org/ghc/ghc/-/issues/19580

     

       269
       269
        
           ++ lib.optional stdenv.targetPlatform.isMusl "pie";

     

       270
       270
        
       

     

       271
       271
       +
         # big-parallel allows us to build with more than 2 cores on

     

       272
       272
       +
         # Hydra which already warrants a significant speedup

     

       273
       273
       +
         requiredSystemFeatures = [ "big-parallel" ];

     

       274
       274
       +
       

     

       271
       275
        
         postInstall = ''

     

       272
       276
        
           # Install the bash completion file.

     

       273
       277
        
           install -D -m 444 utils/completion/ghc.bash $out/share/bash-completion/completions/${targetPrefix}ghc

     
···

       293
       297
        
         meta = {

     

       294
       298
        
           homepage = "http://haskell.org/ghc";

     

       295
       299
        
           description = "The Glasgow Haskell Compiler";

     

       296
       296
       -
           maintainers = with lib.maintainers; [ marcweber andres peti ];

     

       300
       300
       +
           maintainers = with lib.maintainers; [ marcweber andres peti guibou ];

     

       297
       301
        
           timeout = 24 * 3600;

     

       298
       302
        
           inherit (ghc.meta) license platforms;

     

       299
       303

+320

pkgs/development/compilers/ghc/9.2.1.nix

···

       1
       1
       +
       { lib, stdenv, pkgsBuildTarget, targetPackages

     

       2
       2
       +
       

     

       3
       3
       +
       # build-tools

     

       4
       4
       +
       , bootPkgs

     

       5
       5
       +
       , autoconf, automake, coreutils, fetchurl, perl, python3, m4, sphinx, xattr

     

       6
       6
       +
       , bash

     

       7
       7
       +
       

     

       8
       8
       +
       , libiconv ? null, ncurses

     

       9
       9
       +
       , glibcLocales ? null

     

       10
       10
       +
       

     

       11
       11
       +
       , # GHC can be built with system libffi or a bundled one.

     

       12
       12
       +
         libffi ? null

     

       13
       13
       +
       

     

       14
       14
       +
       , useLLVM ? !stdenv.targetPlatform.isx86

     

       15
       15
       +
       , # LLVM is conceptually a run-time-only depedendency, but for

     

       16
       16
       +
         # non-x86, we need LLVM to bootstrap later stages, so it becomes a

     

       17
       17
       +
         # build-time dependency too.

     

       18
       18
       +
         buildLlvmPackages, llvmPackages

     

       19
       19
       +
       

     

       20
       20
       +
       , # If enabled, GHC will be built with the GPL-free but slower integer-simple

     

       21
       21
       +
         # library instead of the faster but GPLed integer-gmp library.

     

       22
       22
       +
         enableIntegerSimple ? !(lib.meta.availableOn stdenv.hostPlatform gmp), gmp

     

       23
       23
       +
       

     

       24
       24
       +
       , # If enabled, use -fPIC when compiling static libs.

     

       25
       25
       +
         enableRelocatedStaticLibs ? stdenv.targetPlatform != stdenv.hostPlatform

     

       26
       26
       +
       

     

       27
       27
       +
         # aarch64 outputs otherwise exceed 2GB limit

     

       28
       28
       +
       , enableProfiledLibs ? !stdenv.targetPlatform.isAarch64

     

       29
       29
       +
       

     

       30
       30
       +
       , # Whether to build dynamic libs for the standard library (on the target

     

       31
       31
       +
         # platform). Static libs are always built.

     

       32
       32
       +
         enableShared ? !stdenv.targetPlatform.isWindows && !stdenv.targetPlatform.useiOSPrebuilt

     

       33
       33
       +
       

     

       34
       34
       +
       , # Whether to build terminfo.

     

       35
       35
       +
         enableTerminfo ? !stdenv.targetPlatform.isWindows

     

       36
       36
       +
       

     

       37
       37
       +
       , # What flavour to build. An empty string indicates no

     

       38
       38
       +
         # specific flavour and falls back to ghc default values.

     

       39
       39
       +
         ghcFlavour ? lib.optionalString (stdenv.targetPlatform != stdenv.hostPlatform)

     

       40
       40
       +
           (if useLLVM then "perf-cross" else "perf-cross-ncg")

     

       41
       41
       +
       

     

       42
       42
       +
       , #  Whether to build sphinx documentation.

     

       43
       43
       +
         enableDocs ? (

     

       44
       44
       +
           # Docs disabled for musl and cross because it's a large task to keep

     

       45
       45
       +
           # all `sphinx` dependencies building in those environments.

     

       46
       46
       +
           # `sphinx` pullls in among others:

     

       47
       47
       +
           # Ruby, Python, Perl, Rust, OpenGL, Xorg, gtk, LLVM.

     

       48
       48
       +
           (stdenv.targetPlatform == stdenv.hostPlatform)

     

       49
       49
       +
           && !stdenv.hostPlatform.isMusl

     

       50
       50
       +
         )

     

       51
       51
       +
       

     

       52
       52
       +
       , enableHaddockProgram ?

     

       53
       53
       +
           # Disabled for cross; see note [HADDOCK_DOCS].

     

       54
       54
       +
           (stdenv.targetPlatform == stdenv.hostPlatform)

     

       55
       55
       +
       

     

       56
       56
       +
       , # Whether to disable the large address space allocator

     

       57
       57
       +
         # necessary fix for iOS: https://www.reddit.com/r/haskell/comments/4ttdz1/building_an_osxi386_to_iosarm64_cross_compiler/d5qvd67/

     

       58
       58
       +
         disableLargeAddressSpace ? stdenv.targetPlatform.isDarwin && stdenv.targetPlatform.isAarch64

     

       59
       59
       +
       }:

     

       60
       60
       +
       

     

       61
       61
       +
       assert !enableIntegerSimple -> gmp != null;

     

       62
       62
       +
       

     

       63
       63
       +
       # Cross cannot currently build the `haddock` program for silly reasons,

     

       64
       64
       +
       # see note [HADDOCK_DOCS].

     

       65
       65
       +
       assert (stdenv.targetPlatform != stdenv.hostPlatform) -> !enableHaddockProgram;

     

       66
       66
       +
       

     

       67
       67
       +
       let

     

       68
       68
       +
         inherit (stdenv) buildPlatform hostPlatform targetPlatform;

     

       69
       69
       +
       

     

       70
       70
       +
         inherit (bootPkgs) ghc;

     

       71
       71
       +
       

     

       72
       72
       +
         # TODO(@Ericson2314) Make unconditional

     

       73
       73
       +
         targetPrefix = lib.optionalString

     

       74
       74
       +
           (targetPlatform != hostPlatform)

     

       75
       75
       +
           "${targetPlatform.config}-";

     

       76
       76
       +
       

     

       77
       77
       +
         buildMK = ''

     

       78
       78
       +
           BuildFlavour = ${ghcFlavour}

     

       79
       79
       +
           ifneq \"\$(BuildFlavour)\" \"\"

     

       80
       80
       +
           include mk/flavours/\$(BuildFlavour).mk

     

       81
       81
       +
           endif

     

       82
       82
       +
           BUILD_SPHINX_HTML = ${if enableDocs then "YES" else "NO"}

     

       83
       83
       +
           BUILD_SPHINX_PDF = NO

     

       84
       84
       +
         '' +

     

       85
       85
       +
         # Note [HADDOCK_DOCS]:

     

       86
       86
       +
         # Unfortunately currently `HADDOCK_DOCS` controls both whether the `haddock`

     

       87
       87
       +
         # program is built (which we generally always want to have a complete GHC install)

     

       88
       88
       +
         # and whether it is run on the GHC sources to generate hyperlinked source code

     

       89
       89
       +
         # (which is impossible for cross-compilation); see:

     

       90
       90
       +
         # https://gitlab.haskell.org/ghc/ghc/-/issues/20077

     

       91
       91
       +
         # This implies that currently a cross-compiled GHC will never have a `haddock`

     

       92
       92
       +
         # program, so it can never generate haddocks for any packages.

     

       93
       93
       +
         # If this is solved in the future, we'd like to unconditionally

     

       94
       94
       +
         # build the haddock program (removing the `enableHaddockProgram` option).

     

       95
       95
       +
         ''

     

       96
       96
       +
           HADDOCK_DOCS = ${if enableHaddockProgram then "YES" else "NO"}

     

       97
       97
       +
           DYNAMIC_GHC_PROGRAMS = ${if enableShared then "YES" else "NO"}

     

       98
       98
       +
           INTEGER_LIBRARY = ${if enableIntegerSimple then "integer-simple" else "integer-gmp"}

     

       99
       99
       +
         '' + lib.optionalString (targetPlatform != hostPlatform) ''

     

       100
       100
       +
           Stage1Only = ${if targetPlatform.system == hostPlatform.system then "NO" else "YES"}

     

       101
       101
       +
           CrossCompilePrefix = ${targetPrefix}

     

       102
       102
       +
         '' + lib.optionalString (!enableProfiledLibs) ''

     

       103
       103
       +
           GhcLibWays = "v dyn"

     

       104
       104
       +
         '' + lib.optionalString enableRelocatedStaticLibs ''

     

       105
       105
       +
           GhcLibHcOpts += -fPIC

     

       106
       106
       +
           GhcRtsHcOpts += -fPIC

     

       107
       107
       +
         '' + lib.optionalString targetPlatform.useAndroidPrebuilt ''

     

       108
       108
       +
           EXTRA_CC_OPTS += -std=gnu99

     

       109
       109
       +
         '';

     

       110
       110
       +
       

     

       111
       111
       +
         # Splicer will pull out correct variations

     

       112
       112
       +
         libDeps = platform: lib.optional enableTerminfo ncurses

     

       113
       113
       +
           ++ [libffi]

     

       114
       114
       +
           ++ lib.optional (!enableIntegerSimple) gmp

     

       115
       115
       +
           ++ lib.optional (platform.libc != "glibc" && !targetPlatform.isWindows) libiconv;

     

       116
       116
       +
       

     

       117
       117
       +
         toolsForTarget = [

     

       118
       118
       +
           pkgsBuildTarget.targetPackages.stdenv.cc

     

       119
       119
       +
         ] ++ lib.optional useLLVM buildLlvmPackages.llvm;

     

       120
       120
       +
       

     

       121
       121
       +
         targetCC = builtins.head toolsForTarget;

     

       122
       122
       +
       

     

       123
       123
       +
         # Use gold either following the default, or to avoid the BFD linker due to some bugs / perf issues.

     

       124
       124
       +
         # But we cannot avoid BFD when using musl libc due to https://sourceware.org/bugzilla/show_bug.cgi?id=23856

     

       125
       125
       +
         # see #84670 and #49071 for more background.

     

       126
       126
       +
         useLdGold = targetPlatform.linker == "gold" || (targetPlatform.linker == "bfd" && !targetPlatform.isMusl);

     

       127
       127
       +
       

     

       128
       128
       +
         runtimeDeps = [

     

       129
       129
       +
           targetPackages.stdenv.cc.bintools

     

       130
       130
       +
           coreutils

     

       131
       131
       +
         ]

     

       132
       132
       +
         # On darwin, we need unwrapped bintools as well (for otool)

     

       133
       133
       +
         ++ lib.optionals (stdenv.targetPlatform.linker == "cctools") [

     

       134
       134
       +
           targetPackages.stdenv.cc.bintools.bintools

     

       135
       135
       +
         ];

     

       136
       136
       +
       

     

       137
       137
       +
       in

     

       138
       138
       +
       stdenv.mkDerivation (rec {

     

       139
       139
       +
         version = "9.2.0.20210821";

     

       140
       140
       +
         name = "${targetPrefix}ghc-${version}";

     

       141
       141
       +
       

     

       142
       142
       +
         src = fetchurl {

     

       143
       143
       +
           url = "https://downloads.haskell.org/ghc/9.2.1-rc1/ghc-${version}-src.tar.xz";

     

       144
       144
       +
           sha256 = "1q2pppxv2avhykyxvyq72r5p97rkkiqp19b77yhp85ralbcp4ivw";

     

       145
       145
       +
         };

     

       146
       146
       +
       

     

       147
       147
       +
         enableParallelBuilding = true;

     

       148
       148
       +
       

     

       149
       149
       +
         outputs = [ "out" "doc" ];

     

       150
       150
       +
       

     

       151
       151
       +
         postPatch = "patchShebangs .";

     

       152
       152
       +
       

     

       153
       153
       +
         # GHC needs the locale configured during the Haddock phase.

     

       154
       154
       +
         LANG = "en_US.UTF-8";

     

       155
       155
       +
       

     

       156
       156
       +
         # GHC is a bit confused on its cross terminology.

     

       157
       157
       +
         preConfigure = ''

     

       158
       158
       +
           for env in $(env | grep '^TARGET_' | sed -E 's|\+?=.*||'); do

     

       159
       159
       +
             export "''${env#TARGET_}=''${!env}"

     

       160
       160
       +
           done

     

       161
       161
       +
           # GHC is a bit confused on its cross terminology, as these would normally be

     

       162
       162
       +
           # the *host* tools.

     

       163
       163
       +
           export CC="${targetCC}/bin/${targetCC.targetPrefix}cc"

     

       164
       164
       +
           export CXX="${targetCC}/bin/${targetCC.targetPrefix}cxx"

     

       165
       165
       +
           # Use gold to work around https://sourceware.org/bugzilla/show_bug.cgi?id=16177

     

       166
       166
       +
           export LD="${targetCC.bintools}/bin/${targetCC.bintools.targetPrefix}ld${lib.optionalString useLdGold ".gold"}"

     

       167
       167
       +
           export AS="${targetCC.bintools.bintools}/bin/${targetCC.bintools.targetPrefix}as"

     

       168
       168
       +
           export AR="${targetCC.bintools.bintools}/bin/${targetCC.bintools.targetPrefix}ar"

     

       169
       169
       +
           export NM="${targetCC.bintools.bintools}/bin/${targetCC.bintools.targetPrefix}nm"

     

       170
       170
       +
           export RANLIB="${targetCC.bintools.bintools}/bin/${targetCC.bintools.targetPrefix}ranlib"

     

       171
       171
       +
           export READELF="${targetCC.bintools.bintools}/bin/${targetCC.bintools.targetPrefix}readelf"

     

       172
       172
       +
           export STRIP="${targetCC.bintools.bintools}/bin/${targetCC.bintools.targetPrefix}strip"

     

       173
       173
       +
       

     

       174
       174
       +
           echo -n "${buildMK}" > mk/build.mk

     

       175
       175
       +
           sed -i -e 's|-isysroot /Developer/SDKs/MacOSX10.5.sdk||' configure

     

       176
       176
       +
         '' + lib.optionalString (stdenv.isLinux && hostPlatform.libc == "glibc") ''

     

       177
       177
       +
           export LOCALE_ARCHIVE="${glibcLocales}/lib/locale/locale-archive"

     

       178
       178
       +
         '' + lib.optionalString (!stdenv.isDarwin) ''

     

       179
       179
       +
           export NIX_LDFLAGS+=" -rpath $out/lib/ghc-${version}"

     

       180
       180
       +
         '' + lib.optionalString stdenv.isDarwin ''

     

       181
       181
       +
           export NIX_LDFLAGS+=" -no_dtrace_dof"

     

       182
       182
       +
         '' + lib.optionalString targetPlatform.useAndroidPrebuilt ''

     

       183
       183
       +
           sed -i -e '5i ,("armv7a-unknown-linux-androideabi", ("e-m:e-p:32:32-i64:64-v128:64:128-a:0:32-n32-S64", "cortex-a8", ""))' llvm-targets

     

       184
       184
       +
         '' + lib.optionalString targetPlatform.isMusl ''

     

       185
       185
       +
             echo "patching llvm-targets for musl targets..."

     

       186
       186
       +
             echo "Cloning these existing '*-linux-gnu*' targets:"

     

       187
       187
       +
             grep linux-gnu llvm-targets | sed 's/^/  /'

     

       188
       188
       +
             echo "(go go gadget sed)"

     

       189
       189
       +
             sed -i 's,\(^.*linux-\)gnu\(.*\)$,\0\n\1musl\2,' llvm-targets

     

       190
       190
       +
             echo "llvm-targets now contains these '*-linux-musl*' targets:"

     

       191
       191
       +
             grep linux-musl llvm-targets | sed 's/^/  /'

     

       192
       192
       +
       

     

       193
       193
       +
             echo "And now patching to preserve '-musleabi' as done with '-gnueabi'"

     

       194
       194
       +
             # (aclocal.m4 is actual source, but patch configure as well since we don't re-gen)

     

       195
       195
       +
             for x in configure aclocal.m4; do

     

       196
       196
       +
               substituteInPlace $x \

     

       197
       197
       +
                 --replace '*-android*|*-gnueabi*)' \

     

       198
       198
       +
                           '*-android*|*-gnueabi*|*-musleabi*)'

     

       199
       199
       +
             done

     

       200
       200
       +
         '';

     

       201
       201
       +
       

     

       202
       202
       +
         # TODO(@Ericson2314): Always pass "--target" and always prefix.

     

       203
       203
       +
         configurePlatforms = [ "build" "host" ]

     

       204
       204
       +
           ++ lib.optional (targetPlatform != hostPlatform) "target";

     

       205
       205
       +
       

     

       206
       206
       +
         # `--with` flags for libraries needed for RTS linker

     

       207
       207
       +
         configureFlags = [

     

       208
       208
       +
           "--datadir=$doc/share/doc/ghc"

     

       209
       209
       +
           "--with-curses-includes=${ncurses.dev}/include" "--with-curses-libraries=${ncurses.out}/lib"

     

       210
       210
       +
         ] ++ lib.optionals (libffi != null) [

     

       211
       211
       +
           "--with-system-libffi"

     

       212
       212
       +
           "--with-ffi-includes=${targetPackages.libffi.dev}/include"

     

       213
       213
       +
           "--with-ffi-libraries=${targetPackages.libffi.out}/lib"

     

       214
       214
       +
         ] ++ lib.optionals (targetPlatform == hostPlatform && !enableIntegerSimple) [

     

       215
       215
       +
           "--with-gmp-includes=${targetPackages.gmp.dev}/include"

     

       216
       216
       +
           "--with-gmp-libraries=${targetPackages.gmp.out}/lib"

     

       217
       217
       +
         ] ++ lib.optionals (targetPlatform == hostPlatform && hostPlatform.libc != "glibc" && !targetPlatform.isWindows) [

     

       218
       218
       +
           "--with-iconv-includes=${libiconv}/include"

     

       219
       219
       +
           "--with-iconv-libraries=${libiconv}/lib"

     

       220
       220
       +
         ] ++ lib.optionals (targetPlatform != hostPlatform) [

     

       221
       221
       +
           "--enable-bootstrap-with-devel-snapshot"

     

       222
       222
       +
         ] ++ lib.optionals useLdGold [

     

       223
       223
       +
           "CFLAGS=-fuse-ld=gold"

     

       224
       224
       +
           "CONF_GCC_LINKER_OPTS_STAGE1=-fuse-ld=gold"

     

       225
       225
       +
           "CONF_GCC_LINKER_OPTS_STAGE2=-fuse-ld=gold"

     

       226
       226
       +
         ] ++ lib.optionals (disableLargeAddressSpace) [

     

       227
       227
       +
           "--disable-large-address-space"

     

       228
       228
       +
         ];

     

       229
       229
       +
       

     

       230
       230
       +
         # Make sure we never relax`$PATH` and hooks support for compatibility.

     

       231
       231
       +
         strictDeps = true;

     

       232
       232
       +
       

     

       233
       233
       +
         # Don’t add -liconv to LDFLAGS automatically so that GHC will add it itself.

     

       234
       234
       +
         dontAddExtraLibs = true;

     

       235
       235
       +
       

     

       236
       236
       +
         nativeBuildInputs = [

     

       237
       237
       +
           perl autoconf automake m4 python3

     

       238
       238
       +
           ghc bootPkgs.alex bootPkgs.happy bootPkgs.hscolour

     

       239
       239
       +
         ] ++ lib.optionals enableDocs [

     

       240
       240
       +
           sphinx

     

       241
       241
       +
         ] ++ lib.optionals stdenv.isDarwin [

     

       242
       242
       +
           # TODO(@sternenseemann): use XATTR env var after backport of

     

       243
       243
       +
           # https://gitlab.haskell.org/ghc/ghc/-/merge_requests/6447

     

       244
       244
       +
           xattr

     

       245
       245
       +
         ];

     

       246
       246
       +
       

     

       247
       247
       +
         # For building runtime libs

     

       248
       248
       +
         depsBuildTarget = toolsForTarget;

     

       249
       249
       +
       

     

       250
       250
       +
         buildInputs = [ perl bash ] ++ (libDeps hostPlatform);

     

       251
       251
       +
       

     

       252
       252
       +
         propagatedBuildInputs = [ targetPackages.stdenv.cc ]

     

       253
       253
       +
           ++ lib.optional useLLVM llvmPackages.llvm;

     

       254
       254
       +
       

     

       255
       255
       +
         depsTargetTarget = map lib.getDev (libDeps targetPlatform);

     

       256
       256
       +
         depsTargetTargetPropagated = map (lib.getOutput "out") (libDeps targetPlatform);

     

       257
       257
       +
       

     

       258
       258
       +
         # required, because otherwise all symbols from HSffi.o are stripped, and

     

       259
       259
       +
         # that in turn causes GHCi to abort

     

       260
       260
       +
         stripDebugFlags = [ "-S" ] ++ lib.optional (!targetPlatform.isDarwin) "--keep-file-symbols";

     

       261
       261
       +
       

     

       262
       262
       +
         checkTarget = "test";

     

       263
       263
       +
       

     

       264
       264
       +
         hardeningDisable =

     

       265
       265
       +
           [ "format" ]

     

       266
       266
       +
           # In nixpkgs, musl based builds currently enable `pie` hardening by default

     

       267
       267
       +
           # (see `defaultHardeningFlags` in `make-derivation.nix`).

     

       268
       268
       +
           # But GHC cannot currently produce outputs that are ready for `-pie` linking.

     

       269
       269
       +
           # Thus, disable `pie` hardening, otherwise `recompile with -fPIE` errors appear.

     

       270
       270
       +
           # See:

     

       271
       271
       +
           # * https://github.com/NixOS/nixpkgs/issues/129247

     

       272
       272
       +
           # * https://gitlab.haskell.org/ghc/ghc/-/issues/19580

     

       273
       273
       +
           ++ lib.optional stdenv.targetPlatform.isMusl "pie";

     

       274
       274
       +
       

     

       275
       275
       +
         # big-parallel allows us to build with more than 2 cores on

     

       276
       276
       +
         # Hydra which already warrants a significant speedup

     

       277
       277
       +
         requiredSystemFeatures = [ "big-parallel" ];

     

       278
       278
       +
       

     

       279
       279
       +
         postInstall = ''

     

       280
       280
       +
           # Install the bash completion file.

     

       281
       281
       +
           install -D -m 444 utils/completion/ghc.bash $out/share/bash-completion/completions/${targetPrefix}ghc

     

       282
       282
       +
       

     

       283
       283
       +
           # Patch scripts to include "readelf" and "cat" in $PATH.

     

       284
       284
       +
           for i in "$out/bin/"*; do

     

       285
       285
       +
             test ! -h $i || continue

     

       286
       286
       +
             egrep --quiet '^#!' <(head -n 1 $i) || continue

     

       287
       287
       +
             sed -i -e '2i export PATH="$PATH:${lib.makeBinPath runtimeDeps}"' $i

     

       288
       288
       +
           done

     

       289
       289
       +
         '';

     

       290
       290
       +
       

     

       291
       291
       +
         passthru = {

     

       292
       292
       +
           inherit bootPkgs targetPrefix;

     

       293
       293
       +
       

     

       294
       294
       +
           inherit llvmPackages;

     

       295
       295
       +
           inherit enableShared;

     

       296
       296
       +
       

     

       297
       297
       +
           # Our Cabal compiler name

     

       298
       298
       +
           haskellCompilerName = "ghc-${version}";

     

       299
       299
       +
         };

     

       300
       300
       +
       

     

       301
       301
       +
         meta = {

     

       302
       302
       +
           homepage = "http://haskell.org/ghc";

     

       303
       303
       +
           description = "The Glasgow Haskell Compiler";

     

       304
       304
       +
           maintainers = with lib.maintainers; [ marcweber andres peti guibou ];

     

       305
       305
       +
           timeout = 24 * 3600;

     

       306
       306
       +
           inherit (ghc.meta) license platforms;

     

       307
       307
       +
       

     

       308
       308
       +
           # integer-simple builds are broken when GHC links against musl.

     

       309
       309
       +
           # See https://github.com/NixOS/nixpkgs/pull/129606#issuecomment-881323743.

     

       310
       310
       +
           # Linker failure on macOS:

     

       311
       311
       +
           # https://gitlab.haskell.org/ghc/ghc/-/issues/19950#note_373726

     

       312
       312
       +
           broken = (enableIntegerSimple && hostPlatform.isMusl)

     

       313
       313
       +
             || stdenv.hostPlatform.isDarwin;

     

       314
       314
       +
         };

     

       315
       315
       +
       

     

       316
       316
       +
       } // lib.optionalAttrs targetPlatform.useAndroidPrebuilt {

     

       317
       317
       +
         dontStrip = true;

     

       318
       318
       +
         dontPatchELF = true;

     

       319
       319
       +
         noAuditTmpdir = true;

     

       320
       320
       +
       })

+10 -2

pkgs/development/compilers/ghc/head.nix

···

       2
       2
        
       

     

       3
       3
        
       # build-tools

     

       4
       4
        
       , bootPkgs

     

       5
       5
       -
       , autoconf, autoreconfHook, automake, coreutils, fetchgit, perl, python3, m4, sphinx

     

       5
       5
       +
       , autoconf, autoreconfHook, automake, coreutils, fetchgit, perl, python3, m4, sphinx, xattr

     

       6
       6
        
       , bash

     

       7
       7
        
       

     

       8
       8
        
       , libiconv ? null, ncurses

     
···

       255
       255
        
           ghc bootPkgs.alex bootPkgs.happy bootPkgs.hscolour

     

       256
       256
        
         ] ++ lib.optionals enableDocs [

     

       257
       257
        
           sphinx

     

       258
       258
       +
         ] ++ lib.optionals stdenv.isDarwin [

     

       259
       259
       +
           # TODO(@sternenseemann): use XATTR env var once we have

     

       260
       260
       +
           # https://gitlab.haskell.org/ghc/ghc/-/merge_requests/6447

     

       261
       261
       +
           xattr

     

       258
       262
        
         ];

     

       259
       263
        
       

     

       260
       264
        
         # For building runtime libs

     
···

       285
       289
        
           # * https://gitlab.haskell.org/ghc/ghc/-/issues/19580

     

       286
       290
        
           ++ lib.optional stdenv.targetPlatform.isMusl "pie";

     

       287
       291
        
       

     

       292
       292
       +
         # big-parallel allows us to build with more than 2 cores on

     

       293
       293
       +
         # Hydra which already warrants a significant speedup

     

       294
       294
       +
         requiredSystemFeatures = [ "big-parallel" ];

     

       295
       295
       +
       

     

       288
       296
        
         postInstall = ''

     

       289
       297
        
           # Install the bash completion file.

     

       290
       298
        
           install -D -m 444 utils/completion/ghc.bash $out/share/bash-completion/completions/${targetPrefix}ghc

     
···

       310
       318
        
         meta = {

     

       311
       319
        
           homepage = "http://haskell.org/ghc";

     

       312
       320
        
           description = "The Glasgow Haskell Compiler";

     

       313
       313
       -
           maintainers = with lib.maintainers; [ marcweber andres peti ];

     

       321
       321
       +
           maintainers = with lib.maintainers; [ marcweber andres peti guibou ];

     

       314
       322
        
           timeout = 24 * 3600;

     

       315
       323
        
           inherit (ghc.meta) license platforms;

     

       316
       324
        
           # ghcHEAD times out on aarch64-linux on Hydra.

+3 -3

pkgs/development/haskell-modules/cabal2nix-unstable.nix

···

       8
       8
        
       }:

     

       9
       9
        
       mkDerivation {

     

       10
       10
        
         pname = "cabal2nix";

     

       11
       11
       -
         version = "unstable-2021-08-21";

     

       11
       11
       +
         version = "unstable-2021-08-27";

     

       12
       12
        
         src = fetchzip {

     

       13
       13
       -
           url = "https://github.com/NixOS/cabal2nix/archive/51a4082fefad4642af67a0ae4bf3bb3a7d9b45e0.tar.gz";

     

       14
       14
       -
           sha256 = "1qd991ziv54drb0n655dg4ymknlfa0ndx9nq9wb5v00a15i4c04x";

     

       13
       13
       +
           url = "https://github.com/NixOS/cabal2nix/archive/05b1b404e20eb6252f93c821d4d7974ab7277d90.tar.gz";

     

       14
       14
       +
           sha256 = "03zvp3wwqph9niadgbvkfcqabafgyhnw12r09cw23hm69hsb64d5";

     

       15
       15
        
         };

     

       16
       16
        
         isLibrary = true;

     

       17
       17
        
         isExecutable = true;

+8 -8

pkgs/development/haskell-modules/configuration-common.nix

···

       120
       120
        
         # Jailbreak is necessary for QuickCheck dependency.

     

       121
       121
        
         vector = doJailbreak (if pkgs.stdenv.isi686 then appendConfigureFlag super.vector "--ghc-options=-msse2" else super.vector);

     

       122
       122
        
       

     

       123
       123
       -
         # Test suite fails due golden tests checking text representation

     

       124
       124
       -
         # of normalized dhall expressions, and newer dhall versions format

     

       125
       125
       -
         # differently.

     

       126
       126
       -
         hpack-dhall =

     

       127
       127
       -
           if pkgs.lib.versionOlder "0.5.2" super.hpack-dhall.version

     

       128
       128
       -
           then throw "Drop dontCheck override for hpack-dhall > 0.5.2"

     

       129
       129
       -
           else dontCheck super.hpack-dhall;

     

       130
       130
       -
       

     

       131
       123
        
         inline-c-cpp = overrideCabal super.inline-c-cpp (drv: {

     

       132
       124
        
           postPatch = (drv.postPatch or "") + ''

     

       133
       125
        
             substituteInPlace inline-c-cpp.cabal --replace "-optc-std=c++11" ""

     
···

       1957
       1949
        
       

     

       1958
       1950
        
         # 2021-08-18: streamly-posix was released with hspec 2.8.2, but it works with older versions too.

     

       1959
       1951
        
         streamly-posix = doJailbreak super.streamly-posix;

     

       1952
       1952
       +
       

     

       1953
       1953
       +
         distribution-nixpkgs = assert super.distribution-nixpkgs.version == "1.6.0";

     

       1954
       1954
       +
           overrideCabal super.distribution-nixpkgs {

     

       1955
       1955
       +
             version = "1.6.1";

     

       1956
       1956
       +
             revision = null;

     

       1957
       1957
       +
             sha256 = "136q893in07iw53m9pqr65h3mrnpvfda272bl4rq1b0z3hzpyhkm";

     

       1958
       1958
       +
             editedCabalFile = null;

     

       1959
       1959
       +
           };

     

       1960
       1960
        
       

     

       1961
       1961
        
       } // import ./configuration-tensorflow.nix {inherit pkgs haskellLib;} self super

+10 -2

pkgs/development/haskell-modules/configuration-darwin.nix

···

       8
       8
        
       

     

       9
       9
        
       with haskellLib;

     

       10
       10
        
       

     

       11
       11
       -
       self: super: {

     

       11
       11
       +
       self: super: ({

     

       12
       12
        
       

     

       13
       13
        
         # the tests for shell-conduit on Darwin illegitimatey assume non-GNU echo

     

       14
       14
        
         # see: https://github.com/psibi/shell-conduit/issues/12

     
···

       196
       196
        
         hls-ormolu-plugin = dontCheck super.hls-ormolu-plugin;

     

       197
       197
        
         hls-pragmas-plugin = dontCheck super.hls-pragmas-plugin;

     

       198
       198
        
         hls-haddock-comments-plugin = dontCheck super.hls-haddock-comments-plugin;

     

       199
       199
       +
         hls-floskell-plugin = dontCheck super.hls-floskell-plugin;

     

       199
       200
        
       

     

       200
       201
        
         # We are lacking pure pgrep at the moment for tests to work

     

       201
       202
        
         tmp-postgres = dontCheck super.tmp-postgres;

     
···

       252
       253
        
         # Otherwise impure gcc is used, which is Apple's weird wrapper

     

       253
       254
        
         c2hsc = addTestToolDepends super.c2hsc [ pkgs.gcc ];

     

       254
       255
        
       

     

       255
       255
       -
       }

     

       256
       256
       +
       } // lib.optionalAttrs pkgs.stdenv.isAarch64 {  # aarch64-darwin

     

       257
       257
       +
       

     

       258
       258
       +
         # https://github.com/fpco/unliftio/issues/87

     

       259
       259
       +
         unliftio = dontCheck super.unliftio;

     

       260
       260
       +
       

     

       261
       261
       +
         # https://github.com/fpco/inline-c/issues/127

     

       262
       262
       +
         inline-c-cpp = dontCheck super.inline-c-cpp;

     

       263
       263
       +
       })

+115

pkgs/development/haskell-modules/configuration-ghc-9.2.x.nix

···

       1
       1
       +
       { pkgs, haskellLib }:

     

       2
       2
       +
       

     

       3
       3
       +
       with haskellLib;

     

       4
       4
       +
       

     

       5
       5
       +
       self: super: {

     

       6
       6
       +
       

     

       7
       7
       +
         # This compiler version needs llvm 10.x.

     

       8
       8
       +
         llvmPackages = pkgs.lib.dontRecurseIntoAttrs pkgs.llvmPackages_10;

     

       9
       9
       +
       

     

       10
       10
       +
         # Disable GHC 9.2.x core libraries.

     

       11
       11
       +
         array = null;

     

       12
       12
       +
         base = null;

     

       13
       13
       +
         binary = null;

     

       14
       14
       +
         bytestring = null;

     

       15
       15
       +
         Cabal = null;

     

       16
       16
       +
         containers = null;

     

       17
       17
       +
         deepseq = null;

     

       18
       18
       +
         directory = null;

     

       19
       19
       +
         exceptions = null;

     

       20
       20
       +
         filepath = null;

     

       21
       21
       +
         ghc-bignum = null;

     

       22
       22
       +
         ghc-boot = null;

     

       23
       23
       +
         ghc-boot-th = null;

     

       24
       24
       +
         ghc-compact = null;

     

       25
       25
       +
         ghc-heap = null;

     

       26
       26
       +
         ghc-prim = null;

     

       27
       27
       +
         ghci = null;

     

       28
       28
       +
         haskeline = null;

     

       29
       29
       +
         hpc = null;

     

       30
       30
       +
         integer-gmp = null;

     

       31
       31
       +
         libiserv = null;

     

       32
       32
       +
         mtl = null;

     

       33
       33
       +
         parsec = null;

     

       34
       34
       +
         pretty = null;

     

       35
       35
       +
         process = null;

     

       36
       36
       +
         rts = null;

     

       37
       37
       +
         stm = null;

     

       38
       38
       +
         template-haskell = null;

     

       39
       39
       +
         terminfo = null;

     

       40
       40
       +
         text = null;

     

       41
       41
       +
         time = null;

     

       42
       42
       +
         transformers = null;

     

       43
       43
       +
         unix = null;

     

       44
       44
       +
         xhtml = null;

     

       45
       45
       +
       

     

       46
       46
       +
         # cabal-install needs more recent versions of Cabal and base16-bytestring.

     

       47
       47
       +
         cabal-install = (doJailbreak super.cabal-install).overrideScope (self: super: {

     

       48
       48
       +
           Cabal = null;

     

       49
       49
       +
           base16-bytestring = self.base16-bytestring_0_1_1_7;

     

       50
       50
       +
         });

     

       51
       51
       +
       

     

       52
       52
       +
         # Jailbreaks & Version Updates

     

       53
       53
       +
         async = doJailbreak super.async;

     

       54
       54
       +
         ChasingBottoms = markBrokenVersion "1.3.1.9" super.ChasingBottoms;

     

       55
       55
       +
         data-fix = doJailbreak super.data-fix;

     

       56
       56
       +
         dec = doJailbreak super.dec;

     

       57
       57
       +
         ed25519 = doJailbreak super.ed25519;

     

       58
       58
       +
         hackage-security = doJailbreak super.hackage-security;

     

       59
       59
       +
         hashable = overrideCabal (doJailbreak (dontCheck super.hashable)) (drv: { postPatch = "sed -i -e 's,integer-gmp .*<1.1,integer-gmp < 2,' hashable.cabal"; });

     

       60
       60
       +
         hashable-time = doJailbreak super.hashable-time;

     

       61
       61
       +
         HTTP = overrideCabal (doJailbreak super.HTTP) (drv: { postPatch = "sed -i -e 's,! Socket,!Socket,' Network/TCP.hs"; });

     

       62
       62
       +
         integer-logarithms = overrideCabal (doJailbreak super.integer-logarithms) (drv: { postPatch = "sed -i -e 's,integer-gmp <1.1,integer-gmp < 2,' integer-logarithms.cabal"; });

     

       63
       63
       +
         lukko = doJailbreak super.lukko;

     

       64
       64
       +
         parallel = doJailbreak super.parallel;

     

       65
       65
       +
         primitive = doJailbreak (dontCheck super.primitive);

     

       66
       66
       +
         regex-posix = doJailbreak super.regex-posix;

     

       67
       67
       +
         resolv = doJailbreak super.resolv;

     

       68
       68
       +
         singleton-bool = doJailbreak super.singleton-bool;

     

       69
       69
       +
         split = doJailbreak super.split;

     

       70
       70
       +
         tar = doJailbreak super.tar;

     

       71
       71
       +
         time-compat = doJailbreak super.time-compat;

     

       72
       72
       +
         vector = doJailbreak (dontCheck super.vector);

     

       73
       73
       +
         vector-binary-instances = doJailbreak super.vector-binary-instances;

     

       74
       74
       +
         vector-th-unbox = doJailbreak super.vector-th-unbox;

     

       75
       75
       +
         zlib = doJailbreak super.zlib;

     

       76
       76
       +
       

     

       77
       77
       +
         # Apply patches from head.hackage.

     

       78
       78
       +
         alex = appendPatch (dontCheck super.alex) (pkgs.fetchpatch {

     

       79
       79
       +
           url = "https://gitlab.haskell.org/ghc/head.hackage/-/raw/fe192e12b88b09499d4aff0e562713e820544bd6/patches/alex-3.2.6.patch";

     

       80
       80
       +
           sha256 = "1rzs764a0nhx002v4fadbys98s6qblw4kx4g46galzjf5f7n2dn4";

     

       81
       81
       +
         });

     

       82
       82
       +
         doctest = dontCheck (doJailbreak super.doctest_0_18_1);

     

       83
       83
       +
         language-haskell-extract = appendPatch (doJailbreak super.language-haskell-extract) (pkgs.fetchpatch {

     

       84
       84
       +
           url = "https://gitlab.haskell.org/ghc/head.hackage/-/raw/master/patches/language-haskell-extract-0.2.4.patch";

     

       85
       85
       +
           sha256 = "0rgzrq0513nlc1vw7nw4km4bcwn4ivxcgi33jly4a7n3c1r32v1f";

     

       86
       86
       +
         });

     

       87
       87
       +
       

     

       88
       88
       +
         # The test suite depends on ChasingBottoms, which is broken with ghc-9.0.x.

     

       89
       89
       +
         unordered-containers = dontCheck super.unordered-containers;

     

       90
       90
       +
       

     

       91
       91
       +
         # The test suite seems pretty broken.

     

       92
       92
       +
         base64-bytestring = dontCheck super.base64-bytestring;

     

       93
       93
       +
       

     

       94
       94
       +
         # 5 introduced support for GHC 9.0.x, but hasn't landed in stackage yet

     

       95
       95
       +
         lens = super.lens_5_0_1;

     

       96
       96
       +
       

     

       97
       97
       +
         # 0.16.0 introduced support for GHC 9.0.x, stackage has 0.15.0

     

       98
       98
       +
         memory = super.memory_0_16_0;

     

       99
       99
       +
       

     

       100
       100
       +
         # GHC 9.0.x doesn't like `import Spec (main)` in Main.hs

     

       101
       101
       +
         # https://github.com/snoyberg/mono-traversable/issues/192

     

       102
       102
       +
         mono-traversable = dontCheck super.mono-traversable;

     

       103
       103
       +
       

     

       104
       104
       +
         # Disable tests pending resolution of

     

       105
       105
       +
         # https://github.com/Soostone/retry/issues/71

     

       106
       106
       +
         retry = dontCheck super.retry;

     

       107
       107
       +
       

     

       108
       108
       +
         # hlint 3.3 needs a ghc-lib-parser newer than the one from stackage

     

       109
       109
       +
         hlint = super.hlint_3_3_1.overrideScope (self: super: {

     

       110
       110
       +
           ghc-lib-parser = overrideCabal self.ghc-lib-parser_9_0_1_20210324 {

     

       111
       111
       +
             doHaddock = false;

     

       112
       112
       +
           };

     

       113
       113
       +
           ghc-lib-parser-ex = self.ghc-lib-parser-ex_9_0_0_4;

     

       114
       114
       +
         });

     

       115
       115
       +
       }

+5 -2

pkgs/development/haskell-modules/configuration-hackage2nix/broken.yaml

···

       632
       632
        
         - cio

     

       633
       633
        
         - cipher-blowfish

     

       634
       634
        
         - circlehs

     

       635
       635
       -
         - circular

     

       636
       635
        
         - citeproc-hs

     

       637
       636
        
         - cjk

     

       638
       637
        
         - cj-token

     
···

       1021
       1020
        
         - dgim

     

       1022
       1021
        
         - dgs

     

       1023
       1022
        
         - dhall-check

     

       1023
       1023
       +
         - dhall-csv

     

       1024
       1024
        
         - dhall-fly

     

       1025
       1025
        
         - dhall-text

     

       1026
       1026
        
         - dhall-to-cabal

     

       1027
       1027
       +
         - dhall-toml

     

       1027
       1028
        
         - dhcp-lease-parser

     

       1028
       1029
        
         - dhrun

     

       1029
       1030
        
         - dia-base

     
···

       2535
       2536
        
         - IsNull

     

       2536
       2537
        
         - iso8601-duration

     

       2537
       2538
        
         - isobmff

     

       2539
       2539
       +
         - isocline

     

       2538
       2540
        
         - isotope

     

       2539
       2541
        
         - itcli

     

       2540
       2542
        
         - itemfield

     
···

       3194
       3196
        
         - nanomsg-haskell

     

       3195
       3197
        
         - nanoparsec

     

       3196
       3198
        
         - NanoProlog

     

       3197
       3197
       -
         - nanovg

     

       3198
       3199
        
         - nanq

     

       3199
       3200
        
         - naperian

     

       3200
       3201
        
         - naqsha

     
···

       4802
       4803
        
         - th-traced

     

       4803
       4804
        
         - thumbnail-plus

     

       4804
       4805
        
         - tianbar

     

       4806
       4806
       +
         - ticket-management

     

       4805
       4807
        
         - TicTacToe

     

       4806
       4808
        
         - tictactoe3d

     

       4807
       4809
        
         - tidal-midi

     
···

       5329
       5331
        
         - yandex-translate

     

       5330
       5332
        
         - yaop

     

       5331
       5333
        
         - yap

     

       5334
       5334
       +
         - yapb

     

       5332
       5335
        
         - yarr

     

       5333
       5336
        
         - yaya-test

     

       5334
       5337
        
         - yaya-unsafe-test

+111 -110

pkgs/development/haskell-modules/configuration-hackage2nix/main.yaml

···

       63
       63
        
       # available on Hackage, `hackage2nix` would generate two packages, `aeson`

     

       64
       64
        
       # at version 1.4.6.0 and `aeson_1_5_0_0` at version 1.5.0.0.

     

       65
       65
        
       #

     

       66
       66
       -
       # WARNING: This list is generated semiautomatically based on the most recent

     

       67
       67
       -
       # LTS package set. If you want to add entries to it, you must do so before the

     

       68
       68
       -
       # comment saying "# LTS Haskell x.y". Any changes after that comment will be

     

       69
       69
       -
       # lost the next time `update-stackage.sh` runs.

     

       66
       66
       +
       # WARNING: We import a list of default-package-overrides from stackage which is

     

       67
       67
       +
       # tracked in stackage.yaml. Adding conflicting overrides with stackage here will

     

       68
       68
       +
       # not work.

     

       70
       69
        
       default-package-overrides:

     

       71
       70
        
         # This was only intended for ghc-7.0.4, and has very old deps, one hidden behind a flag

     

       72
       71
        
         - MissingH ==1.4.2.0

     
···

       91
       90
        
         - streamly-bytestring < 0.1.3

     

       92
       91
        
         - streamly-lmdb < 0.3.0

     

       93
       92
        
         - streamly-process

     

       93
       93
       +
         # dhall-nix is not part of stackage, remove if dhall >= 1.40

     

       94
       94
       +
         - dhall-nix < 1.1.22

     

       94
       95
        
       

     

       95
       96
        
       extra-packages:

     

       96
       97
        
         - base16-bytestring < 1               # required for cabal-install etc.

     
···

       337
       338
        
           - nix-tree

     

       338
       339
        
       

     

       339
       340
        
       unsupported-platforms:

     

       340
       340
       -
         Allure:                                       [ x86_64-darwin ]

     

       341
       341
       -
         alsa-mixer:                                   [ x86_64-darwin ]

     

       342
       342
       -
         alsa-pcm:                                     [ x86_64-darwin ]

     

       343
       343
       -
         alsa-seq:                                     [ x86_64-darwin ]

     

       344
       344
       -
         AWin32Console:                                [ i686-linux, x86_64-linux, x86_64-darwin, aarch64-linux, armv7l-linux ]

     

       341
       341
       +
         Allure:                                       [ x86_64-darwin, aarch64-darwin ]

     

       342
       342
       +
         alsa-mixer:                                   [ x86_64-darwin, aarch64-darwin ]

     

       343
       343
       +
         alsa-pcm:                                     [ x86_64-darwin, aarch64-darwin ]

     

       344
       344
       +
         alsa-seq:                                     [ x86_64-darwin, aarch64-darwin ]

     

       345
       345
       +
         AWin32Console:                                [ i686-linux, x86_64-linux, x86_64-darwin, aarch64-darwin, aarch64-linux, armv7l-linux ]

     

       345
       346
        
         barbly:                                       [ i686-linux, x86_64-linux, aarch64-linux, armv7l-linux ]

     

       346
       346
       -
         bdcs-api:                                     [ x86_64-darwin ]

     

       347
       347
       -
         bindings-directfb:                            [ x86_64-darwin ]

     

       348
       348
       -
         bindings-parport:                             [ x86_64-darwin ] # parport is a linux kernel component

     

       349
       349
       -
         bindings-sane:                                [ x86_64-darwin ]

     

       350
       350
       -
         btrfs:                                        [ x86_64-darwin ] # depends on linux

     

       351
       351
       -
         bustle:                                       [ x86_64-darwin ] # uses glibc-specific ptsname_r

     

       347
       347
       +
         bdcs-api:                                     [ x86_64-darwin, aarch64-darwin ]

     

       348
       348
       +
         bindings-directfb:                            [ x86_64-darwin, aarch64-darwin ]

     

       349
       349
       +
         bindings-parport:                             [ x86_64-darwin, aarch64-darwin ] # parport is a linux kernel component

     

       350
       350
       +
         bindings-sane:                                [ x86_64-darwin, aarch64-darwin ]

     

       351
       351
       +
         btrfs:                                        [ x86_64-darwin, aarch64-darwin ] # depends on linux

     

       352
       352
       +
         bustle:                                       [ x86_64-darwin, aarch64-darwin ] # uses glibc-specific ptsname_r

     

       352
       353
        
         charsetdetect:                                [ aarch64-linux ] # not supported by vendored lib / not configured properly https://github.com/batterseapower/libcharsetdetect/issues/3

     

       353
       354
        
         crackNum:                                     [ aarch64-linux ] # depends on sbv, which is not supported on aarch64-linux

     

       354
       354
       -
         cut-the-crap:                                 [ x86_64-darwin ]

     

       355
       355
       -
         d3d11binding:                                 [ i686-linux, x86_64-linux, x86_64-darwin, aarch64-linux, armv7l-linux ]

     

       356
       356
       -
         DirectSound:                                  [ i686-linux, x86_64-linux, x86_64-darwin, aarch64-linux, armv7l-linux ]

     

       357
       357
       -
         dx9base:                                      [ i686-linux, x86_64-linux, x86_64-darwin, aarch64-linux, armv7l-linux ]

     

       358
       358
       -
         dx9d3d:                                       [ i686-linux, x86_64-linux, x86_64-darwin, aarch64-linux, armv7l-linux ]

     

       359
       359
       -
         dx9d3dx:                                      [ i686-linux, x86_64-linux, x86_64-darwin, aarch64-linux, armv7l-linux ]

     

       360
       360
       -
         Euterpea:                                     [ x86_64-darwin ]

     

       361
       361
       -
         follow-file:                                  [ x86_64-darwin ]

     

       362
       362
       -
         freenect:                                     [ x86_64-darwin ]

     

       363
       363
       -
         FTGL:                                         [ x86_64-darwin ]

     

       364
       364
       -
         fuzzytime:                                    [ x86_64-darwin ] # https://github.com/kamwitsta/fuzzytime/issues/2

     

       365
       365
       -
         ghcjs-dom-hello:                              [ x86_64-darwin ]

     

       366
       366
       -
         gi-dbusmenugtk3:                              [ x86_64-darwin ]

     

       367
       367
       -
         gi-dbusmenu:                                  [ x86_64-darwin ]

     

       368
       368
       -
         gi-ggit:                                      [ x86_64-darwin ]

     

       369
       369
       -
         gi-ibus:                                      [ x86_64-darwin ]

     

       370
       370
       -
         gi-ostree:                                    [ x86_64-darwin ]

     

       371
       371
       -
         gi-vte:                                       [ x86_64-darwin ]

     

       372
       372
       -
         gi-wnck:                                      [ x86_64-darwin ]

     

       373
       373
       -
         gnome-keyring:                                [ x86_64-darwin ]

     

       355
       355
       +
         cut-the-crap:                                 [ x86_64-darwin, aarch64-darwin ]

     

       356
       356
       +
         d3d11binding:                                 [ i686-linux, x86_64-linux, x86_64-darwin, aarch64-darwin, aarch64-linux, armv7l-linux ]

     

       357
       357
       +
         DirectSound:                                  [ i686-linux, x86_64-linux, x86_64-darwin, aarch64-darwin, aarch64-linux, armv7l-linux ]

     

       358
       358
       +
         dx9base:                                      [ i686-linux, x86_64-linux, x86_64-darwin, aarch64-darwin, aarch64-linux, armv7l-linux ]

     

       359
       359
       +
         dx9d3d:                                       [ i686-linux, x86_64-linux, x86_64-darwin, aarch64-darwin, aarch64-linux, armv7l-linux ]

     

       360
       360
       +
         dx9d3dx:                                      [ i686-linux, x86_64-linux, x86_64-darwin, aarch64-darwin, aarch64-linux, armv7l-linux ]

     

       361
       361
       +
         Euterpea:                                     [ x86_64-darwin, aarch64-darwin ]

     

       362
       362
       +
         follow-file:                                  [ x86_64-darwin, aarch64-darwin ]

     

       363
       363
       +
         freenect:                                     [ x86_64-darwin, aarch64-darwin ]

     

       364
       364
       +
         FTGL:                                         [ x86_64-darwin, aarch64-darwin ]

     

       365
       365
       +
         fuzzytime:                                    [ x86_64-darwin, aarch64-darwin ] # https://github.com/kamwitsta/fuzzytime/issues/2

     

       366
       366
       +
         ghcjs-dom-hello:                              [ x86_64-darwin, aarch64-darwin ]

     

       367
       367
       +
         gi-dbusmenugtk3:                              [ x86_64-darwin, aarch64-darwin ]

     

       368
       368
       +
         gi-dbusmenu:                                  [ x86_64-darwin, aarch64-darwin ]

     

       369
       369
       +
         gi-ggit:                                      [ x86_64-darwin, aarch64-darwin ]

     

       370
       370
       +
         gi-ibus:                                      [ x86_64-darwin, aarch64-darwin ]

     

       371
       371
       +
         gi-ostree:                                    [ x86_64-darwin, aarch64-darwin ]

     

       372
       372
       +
         gi-vte:                                       [ x86_64-darwin, aarch64-darwin ]

     

       373
       373
       +
         gi-wnck:                                      [ x86_64-darwin, aarch64-darwin ]

     

       374
       374
       +
         gnome-keyring:                                [ x86_64-darwin, aarch64-darwin ]

     

       374
       375
        
         gtk-mac-integration:                          [ i686-linux, x86_64-linux, aarch64-linux, armv7l-linux ]

     

       375
       375
       -
         gtk-sni-tray:                                 [ x86_64-darwin ]

     

       376
       376
       -
         haskell-snake:                                [ x86_64-darwin ]

     

       377
       377
       -
         hcwiid:                                       [ x86_64-darwin ]

     

       376
       376
       +
         gtk-sni-tray:                                 [ x86_64-darwin, aarch64-darwin ]

     

       377
       377
       +
         haskell-snake:                                [ x86_64-darwin, aarch64-darwin ]

     

       378
       378
       +
         hcwiid:                                       [ x86_64-darwin, aarch64-darwin ]

     

       378
       379
        
         hevm:                                         [ aarch64-linux ] # depends on sbv, which is not supported on aarch64-linux

     

       379
       379
       -
         HFuse:                                        [ x86_64-darwin ]

     

       380
       380
       -
         hidapi:                                       [ x86_64-darwin ]

     

       381
       381
       -
         hinotify-bytestring:                          [ x86_64-darwin ]

     

       382
       382
       -
         hommage-ds:                                   [ i686-linux, x86_64-linux, x86_64-darwin, aarch64-linux, armv7l-linux ]

     

       383
       383
       -
         honk:                                         [ x86_64-darwin ]

     

       384
       384
       -
         hpapi:                                        [ x86_64-darwin ]

     

       380
       380
       +
         HFuse:                                        [ x86_64-darwin, aarch64-darwin ]

     

       381
       381
       +
         hidapi:                                       [ x86_64-darwin, aarch64-darwin ]

     

       382
       382
       +
         hinotify-bytestring:                          [ x86_64-darwin, aarch64-darwin ]

     

       383
       383
       +
         hommage-ds:                                   [ i686-linux, x86_64-linux, x86_64-darwin, aarch64-darwin, aarch64-linux, armv7l-linux ]

     

       384
       384
       +
         honk:                                         [ x86_64-darwin, aarch64-darwin ]

     

       385
       385
       +
         hpapi:                                        [ x86_64-darwin, aarch64-darwin ]

     

       385
       386
        
         HQu:                                          [ aarch64-linux, armv7l-linux ] # unsupported by vendored C++ library, TODO: explicitly list supported platforms

     

       386
       386
       -
         HSoM:                                         [ x86_64-darwin ]

     

       387
       387
       -
         iwlib:                                        [ x86_64-darwin ]

     

       388
       388
       -
         jsaddle-webkit2gtk:                           [ x86_64-darwin ]

     

       387
       387
       +
         HSoM:                                         [ x86_64-darwin, aarch64-darwin ]

     

       388
       388
       +
         iwlib:                                        [ x86_64-darwin, aarch64-darwin ]

     

       389
       389
       +
         jsaddle-webkit2gtk:                           [ x86_64-darwin, aarch64-darwin ]

     

       389
       390
        
         kqueue:                                       [ x86_64-linux, aarch64-linux, i686-linux, armv7l-linux ] # BSD / Darwin only API

     

       390
       390
       -
         LambdaHack:                                   [ x86_64-darwin ]

     

       391
       391
       +
         LambdaHack:                                   [ x86_64-darwin, aarch64-darwin ]

     

       391
       392
        
         large-hashable:                               [ aarch64-linux ] # https://github.com/factisresearch/large-hashable/issues/17

     

       392
       392
       -
         libmodbus:                                    [ x86_64-darwin ]

     

       393
       393
       -
         libsystemd-journal:                           [ x86_64-darwin ]

     

       394
       394
       -
         libtelnet:                                    [ x86_64-darwin ]

     

       395
       395
       -
         libzfs:                                       [ x86_64-darwin ]

     

       393
       393
       +
         libmodbus:                                    [ x86_64-darwin, aarch64-darwin ]

     

       394
       394
       +
         libsystemd-journal:                           [ x86_64-darwin, aarch64-darwin ]

     

       395
       395
       +
         libtelnet:                                    [ x86_64-darwin, aarch64-darwin ]

     

       396
       396
       +
         libzfs:                                       [ x86_64-darwin, aarch64-darwin ]

     

       396
       397
        
         linearEqSolver:                               [ aarch64-linux ]

     

       397
       397
       -
         linux-evdev:                                  [ x86_64-darwin ]

     

       398
       398
       -
         linux-file-extents:                           [ x86_64-darwin ]

     

       399
       399
       -
         linux-inotify:                                [ x86_64-darwin ]

     

       400
       400
       -
         linux-mount:                                  [ x86_64-darwin ]

     

       401
       401
       -
         linux-namespaces:                             [ x86_64-darwin ]

     

       402
       402
       -
         lio-fs:                                       [ x86_64-darwin ]

     

       403
       403
       -
         logging-facade-journald:                      [ x86_64-darwin ]

     

       404
       404
       -
         midi-alsa:                                    [ x86_64-darwin ]

     

       405
       405
       -
         mpi-hs:                                       [ aarch64-linux, x86_64-darwin ]

     

       406
       406
       -
         mpi-hs-binary:                                [ aarch64-linux, x86_64-darwin ]

     

       407
       407
       -
         mpi-hs-cereal:                                [ aarch64-linux, x86_64-darwin ]

     

       408
       408
       -
         mpi-hs-store:                                 [ aarch64-linux, x86_64-darwin ]

     

       398
       398
       +
         linux-evdev:                                  [ x86_64-darwin, aarch64-darwin ]

     

       399
       399
       +
         linux-file-extents:                           [ x86_64-darwin, aarch64-darwin ]

     

       400
       400
       +
         linux-inotify:                                [ x86_64-darwin, aarch64-darwin ]

     

       401
       401
       +
         linux-mount:                                  [ x86_64-darwin, aarch64-darwin ]

     

       402
       402
       +
         linux-namespaces:                             [ x86_64-darwin, aarch64-darwin ]

     

       403
       403
       +
         lio-fs:                                       [ x86_64-darwin, aarch64-darwin ]

     

       404
       404
       +
         logging-facade-journald:                      [ x86_64-darwin, aarch64-darwin ]

     

       405
       405
       +
         midi-alsa:                                    [ x86_64-darwin, aarch64-darwin ]

     

       406
       406
       +
         mpi-hs:                                       [ aarch64-linux, x86_64-darwin, aarch64-darwin ]

     

       407
       407
       +
         mpi-hs-binary:                                [ aarch64-linux, x86_64-darwin, aarch64-darwin ]

     

       408
       408
       +
         mpi-hs-cereal:                                [ aarch64-linux, x86_64-darwin, aarch64-darwin ]

     

       409
       409
       +
         mpi-hs-store:                                 [ aarch64-linux, x86_64-darwin, aarch64-darwin ]

     

       409
       410
        
         mplayer-spot:                                 [ aarch64-linux ]

     

       410
       410
       -
         mptcp-pm:                                     [ x86_64-darwin ]

     

       411
       411
       -
         netlink:                                      [ x86_64-darwin ]

     

       412
       412
       -
         notifications-tray-icon:                      [ x86_64-darwin ] # depends on gi-dbusmenu

     

       413
       413
       -
         oculus:                                       [ x86_64-darwin ]

     

       414
       414
       -
         pam:                                          [ x86_64-darwin ]

     

       415
       415
       -
         parport:                                      [ x86_64-darwin ]

     

       411
       411
       +
         mptcp-pm:                                     [ x86_64-darwin, aarch64-darwin ]

     

       412
       412
       +
         netlink:                                      [ x86_64-darwin, aarch64-darwin ]

     

       413
       413
       +
         notifications-tray-icon:                      [ x86_64-darwin, aarch64-darwin ] # depends on gi-dbusmenu

     

       414
       414
       +
         oculus:                                       [ x86_64-darwin, aarch64-darwin ]

     

       415
       415
       +
         pam:                                          [ x86_64-darwin, aarch64-darwin ]

     

       416
       416
       +
         parport:                                      [ x86_64-darwin, aarch64-darwin ]

     

       416
       417
        
         password:                                     [ aarch64-linux, armv7l-linux ] # uses scrypt, which requries x86

     

       417
       418
        
         password-instances:                           [ aarch64-linux, armv7l-linux ] # uses scrypt, which requries x86

     

       418
       419
        
         persist-state:                                [ aarch64-linux, armv7l-linux ] # https://github.com/minad/persist-state/blob/6fd68c0b8b93dec78218f6d5a1f4fa06ced4e896/src/Data/PersistState.hs#L122-L128

     

       419
       419
       -
         piyo:                                         [ x86_64-darwin ]

     

       420
       420
       -
         PortMidi-simple:                              [ x86_64-darwin ]

     

       421
       421
       -
         PortMidi:                                     [ x86_64-darwin ]

     

       422
       422
       -
         posix-api:                                    [ x86_64-darwin ]

     

       423
       423
       -
         Raincat:                                      [ x86_64-darwin ]

     

       424
       424
       -
         reactive-balsa:                               [ x86_64-darwin ] # depends on alsa-core

     

       425
       425
       -
         reactivity:                                   [ i686-linux, x86_64-linux, x86_64-darwin, aarch64-linux, armv7l-linux ]

     

       426
       426
       -
         reflex-dom-fragment-shader-canvas:            [ x86_64-darwin, aarch64-linux ]

     

       427
       427
       -
         reflex-dom:                                   [ x86_64-darwin, aarch64-linux ]

     

       428
       428
       -
         reflex-localize-dom:                          [ x86_64-darwin, aarch64-linux ]

     

       429
       429
       -
         rtlsdr:                                       [ x86_64-darwin ]

     

       430
       430
       -
         rubberband:                                   [ x86_64-darwin ]

     

       420
       420
       +
         piyo:                                         [ x86_64-darwin, aarch64-darwin ]

     

       421
       421
       +
         PortMidi-simple:                              [ x86_64-darwin, aarch64-darwin ]

     

       422
       422
       +
         PortMidi:                                     [ x86_64-darwin, aarch64-darwin ]

     

       423
       423
       +
         posix-api:                                    [ x86_64-darwin, aarch64-darwin ]

     

       424
       424
       +
         Raincat:                                      [ x86_64-darwin, aarch64-darwin ]

     

       425
       425
       +
         reactive-balsa:                               [ x86_64-darwin, aarch64-darwin ] # depends on alsa-core

     

       426
       426
       +
         reactivity:                                   [ i686-linux, x86_64-linux, x86_64-darwin, aarch64-darwin, aarch64-linux, armv7l-linux ]

     

       427
       427
       +
         reflex-dom-fragment-shader-canvas:            [ x86_64-darwin, aarch64-darwin, aarch64-linux ]

     

       428
       428
       +
         reflex-dom:                                   [ x86_64-darwin, aarch64-darwin, aarch64-linux ]

     

       429
       429
       +
         reflex-localize-dom:                          [ x86_64-darwin, aarch64-darwin, aarch64-linux ]

     

       430
       430
       +
         rtlsdr:                                       [ x86_64-darwin, aarch64-darwin ]

     

       431
       431
       +
         rubberband:                                   [ x86_64-darwin, aarch64-darwin ]

     

       431
       432
        
         sbv:                                          [ aarch64-linux ]

     

       432
       433
        
         scat:                                         [ aarch64-linux, armv7l-linux ] # uses scrypt, which requries x86

     

       433
       434
        
         scrypt:                                       [ aarch64-linux, armv7l-linux ] # https://github.com/informatikr/scrypt/issues/8

     

       434
       434
       -
         sdl2-mixer:                                   [ x86_64-darwin ]

     

       435
       435
       -
         sdl2-ttf:                                     [ x86_64-darwin ]

     

       436
       436
       -
         synthesizer-alsa:                             [ x86_64-darwin ]

     

       437
       437
       -
         taffybar:                                     [ x86_64-darwin ]

     

       438
       438
       -
         termonad:                                     [ x86_64-darwin ]

     

       439
       439
       -
         tokyotyrant-haskell:                          [ x86_64-darwin ]

     

       440
       440
       -
         udev:                                         [ x86_64-darwin ]

     

       441
       441
       -
         Unixutils-shadow:                             [ x86_64-darwin ]

     

       435
       435
       +
         sdl2-mixer:                                   [ x86_64-darwin, aarch64-darwin ]

     

       436
       436
       +
         sdl2-ttf:                                     [ x86_64-darwin, aarch64-darwin ]

     

       437
       437
       +
         synthesizer-alsa:                             [ x86_64-darwin, aarch64-darwin ]

     

       438
       438
       +
         taffybar:                                     [ x86_64-darwin, aarch64-darwin ]

     

       439
       439
       +
         termonad:                                     [ x86_64-darwin, aarch64-darwin ]

     

       440
       440
       +
         tokyotyrant-haskell:                          [ x86_64-darwin, aarch64-darwin ]

     

       441
       441
       +
         udev:                                         [ x86_64-darwin, aarch64-darwin ]

     

       442
       442
       +
         Unixutils-shadow:                             [ x86_64-darwin, aarch64-darwin ]

     

       442
       443
        
         verifiable-expressions:                       [ aarch64-linux ]

     

       443
       443
       -
         vrpn:                                         [ x86_64-darwin ]

     

       444
       444
       -
         vulkan:                                       [ i686-linux, armv7l-linux, x86_64-darwin ]

     

       445
       445
       -
         VulkanMemoryAllocator:                        [ i686-linux, armv7l-linux, x86_64-darwin ]

     

       446
       446
       -
         vulkan-utils:                                 [ x86_64-darwin ]

     

       447
       447
       -
         webkit2gtk3-javascriptcore:                   [ x86_64-darwin ]

     

       448
       448
       -
         Win32-console:                                [ i686-linux, x86_64-linux, x86_64-darwin, aarch64-linux, armv7l-linux ]

     

       449
       449
       -
         Win32-dhcp-server:                            [ i686-linux, x86_64-linux, x86_64-darwin, aarch64-linux, armv7l-linux ]

     

       450
       450
       -
         Win32-errors:                                 [ i686-linux, x86_64-linux, x86_64-darwin, aarch64-linux, armv7l-linux ]

     

       451
       451
       -
         Win32-extras:                                 [ i686-linux, x86_64-linux, x86_64-darwin, aarch64-linux, armv7l-linux ]

     

       452
       452
       -
         Win32:                                        [ i686-linux, x86_64-linux, x86_64-darwin, aarch64-linux, armv7l-linux ]

     

       453
       453
       -
         Win32-junction-point:                         [ i686-linux, x86_64-linux, x86_64-darwin, aarch64-linux, armv7l-linux ]

     

       454
       454
       -
         Win32-notify:                                 [ i686-linux, x86_64-linux, x86_64-darwin, aarch64-linux, armv7l-linux ]

     

       455
       455
       -
         Win32-security:                               [ i686-linux, x86_64-linux, x86_64-darwin, aarch64-linux, armv7l-linux ]

     

       456
       456
       -
         Win32-services:                               [ i686-linux, x86_64-linux, x86_64-darwin, aarch64-linux, armv7l-linux ]

     

       457
       457
       -
         Win32-services-wrapper:                       [ i686-linux, x86_64-linux, x86_64-darwin, aarch64-linux, armv7l-linux ]

     

       458
       458
       -
         xattr:                                        [ x86_64-darwin ]

     

       444
       444
       +
         vrpn:                                         [ x86_64-darwin, aarch64-darwin ]

     

       445
       445
       +
         vulkan:                                       [ i686-linux, armv7l-linux, x86_64-darwin, aarch64-darwin ]

     

       446
       446
       +
         VulkanMemoryAllocator:                        [ i686-linux, armv7l-linux, x86_64-darwin, aarch64-darwin ]

     

       447
       447
       +
         vulkan-utils:                                 [ x86_64-darwin, aarch64-darwin ]

     

       448
       448
       +
         webkit2gtk3-javascriptcore:                   [ x86_64-darwin, aarch64-darwin ]

     

       449
       449
       +
         Win32-console:                                [ i686-linux, x86_64-linux, x86_64-darwin, aarch64-darwin, aarch64-linux, armv7l-linux ]

     

       450
       450
       +
         Win32-dhcp-server:                            [ i686-linux, x86_64-linux, x86_64-darwin, aarch64-darwin, aarch64-linux, armv7l-linux ]

     

       451
       451
       +
         Win32-errors:                                 [ i686-linux, x86_64-linux, x86_64-darwin, aarch64-darwin, aarch64-linux, armv7l-linux ]

     

       452
       452
       +
         Win32-extras:                                 [ i686-linux, x86_64-linux, x86_64-darwin, aarch64-darwin, aarch64-linux, armv7l-linux ]

     

       453
       453
       +
         Win32:                                        [ i686-linux, x86_64-linux, x86_64-darwin, aarch64-darwin, aarch64-linux, armv7l-linux ]

     

       454
       454
       +
         Win32-junction-point:                         [ i686-linux, x86_64-linux, x86_64-darwin, aarch64-darwin, aarch64-linux, armv7l-linux ]

     

       455
       455
       +
         Win32-notify:                                 [ i686-linux, x86_64-linux, x86_64-darwin, aarch64-darwin, aarch64-linux, armv7l-linux ]

     

       456
       456
       +
         Win32-security:                               [ i686-linux, x86_64-linux, x86_64-darwin, aarch64-darwin, aarch64-linux, armv7l-linux ]

     

       457
       457
       +
         Win32-services:                               [ i686-linux, x86_64-linux, x86_64-darwin, aarch64-darwin, aarch64-linux, armv7l-linux ]

     

       458
       458
       +
         Win32-services-wrapper:                       [ i686-linux, x86_64-linux, x86_64-darwin, aarch64-darwin, aarch64-linux, armv7l-linux ]

     

       459
       459
       +
         xattr:                                        [ x86_64-darwin, aarch64-darwin ]

     

       459
       460
        
         xgboost-haskell:                              [ aarch64-linux, armv7l-linux ]

     

       460
       460
       -
         XInput:                                       [ i686-linux, x86_64-linux, x86_64-darwin, aarch64-linux, armv7l-linux ]

     

       461
       461
       -
         xmobar:                                       [ x86_64-darwin ]

     

       462
       462
       -
         xmonad-extras:                                [ x86_64-darwin ]

     

       463
       463
       -
         xmonad-volume:                                [ x86_64-darwin ]

     

       461
       461
       +
         XInput:                                       [ i686-linux, x86_64-linux, x86_64-darwin, aarch64-darwin, aarch64-linux, armv7l-linux ]

     

       462
       462
       +
         xmobar:                                       [ x86_64-darwin, aarch64-darwin ]

     

       463
       463
       +
         xmonad-extras:                                [ x86_64-darwin, aarch64-darwin ]

     

       464
       464
       +
         xmonad-volume:                                [ x86_64-darwin, aarch64-darwin ]

     

       464
       465
        
       

     

       465
       466
        
       dont-distribute-packages:

     

       466
       467
        
         # Depends on shine, which is a ghcjs project.

+59 -53

pkgs/development/haskell-modules/configuration-hackage2nix/stackage.yaml

···

       1
       1
       -
       # Stackage LTS 18.5

     

       1
       1
       +
       # Stackage LTS 18.7

     

       2
       2
        
       # This file is auto-generated by

     

       3
       3
        
       # maintainers/scripts/haskell/update-stackage.sh

     

       4
       4
        
       default-package-overrides:

     
···

       11
       11
        
         - ad ==4.4.1

     

       12
       12
        
         - adjunctions ==4.4

     

       13
       13
        
         - adler32 ==0.1.2.0

     

       14
       14
       -
         - aern2-mp ==0.2.7.0

     

       15
       15
       -
         - aern2-real ==0.2.7.0

     

       14
       14
       +
         - aern2-mp ==0.2.8.0

     

       15
       15
       +
         - aern2-real ==0.2.8.0

     

       16
       16
        
         - aeson ==1.5.6.0

     

       17
       17
        
         - aeson-attoparsec ==0.0.0

     

       18
       18
        
         - aeson-better-errors ==0.9.1.0

     
···

       145
       145
        
         - ansi-terminal ==0.11

     

       146
       146
        
         - ansi-wl-pprint ==0.6.9

     

       147
       147
        
         - ANum ==0.2.0.2

     

       148
       148
       -
         - apecs ==0.9.2

     

       148
       148
       +
         - apecs ==0.9.3

     

       149
       149
        
         - apecs-gloss ==0.2.4

     

       150
       150
        
         - apecs-physics ==0.4.5

     

       151
       151
        
         - api-field-json-th ==0.1.0.2

     
···

       269
       269
        
         - blake2 ==0.3.0

     

       270
       270
        
         - blanks ==0.5.0

     

       271
       271
        
         - blas-carray ==0.1.0.1

     

       272
       272
       -
         - blas-comfort-array ==0.0.0.2

     

       272
       272
       +
         - blas-comfort-array ==0.0.0.3

     

       273
       273
        
         - blas-ffi ==0.1

     

       274
       274
        
         - blaze-bootstrap ==0.1.0.1

     

       275
       275
        
         - blaze-builder ==0.4.2.1

     
···

       288
       288
        
         - boots ==0.2.0.1

     

       289
       289
        
         - bordacount ==0.1.0.0

     

       290
       290
        
         - boring ==0.2

     

       291
       291
       -
         - both ==0.1.1.1

     

       291
       291
       +
         - both ==0.1.1.2

     

       292
       292
        
         - bound ==2.0.3

     

       293
       293
        
         - BoundedChan ==1.0.3.0

     

       294
       294
        
         - bounded-queue ==1.0.0

     
···

       311
       311
        
         - bv ==0.5

     

       312
       312
        
         - bv-little ==1.1.1

     

       313
       313
        
         - byteable ==0.1.1

     

       314
       314
       -
         - byte-count-reader ==0.10.1.3

     

       314
       314
       +
         - byte-count-reader ==0.10.1.5

     

       315
       315
        
         - bytedump ==1.0

     

       316
       316
        
         - byte-order ==0.1.2.0

     

       317
       317
        
         - byteorder ==1.0.4

     
···

       331
       331
        
         - c2hs ==0.28.8

     

       332
       332
        
         - cabal2spec ==2.6.2

     

       333
       333
        
         - cabal-appimage ==0.3.0.2

     

       334
       334
       +
         - cabal-clean ==0.1.20210815

     

       334
       335
        
         - cabal-debian ==5.1

     

       335
       336
        
         - cabal-doctest ==1.0.8

     

       336
       337
        
         - cabal-file ==0.1.1

     

       337
       338
        
         - cabal-flatpak ==0.1.0.2

     

       338
       339
        
         - cabal-plan ==0.7.2.0

     

       339
       339
       -
         - cabal-rpm ==2.0.9

     

       340
       340
       +
         - cabal-rpm ==2.0.10

     

       340
       341
        
         - cache ==0.1.3.0

     

       342
       342
       +
         - cached-json-file ==0.1.0

     

       341
       343
        
         - cacophony ==0.10.1

     

       342
       344
        
         - calendar-recycling ==0.0.0.1

     

       343
       345
        
         - call-stack ==0.3.0

     
···

       381
       383
        
         - cheapskate-lucid ==0.1.0.0

     

       382
       384
        
         - checkers ==0.5.6

     

       383
       385
        
         - checksum ==0.0

     

       384
       384
       -
         - chimera ==0.3.1.0

     

       386
       386
       +
         - chimera ==0.3.2.0

     

       385
       387
        
         - chiphunk ==0.1.4.0

     

       386
       388
        
         - choice ==0.2.2

     

       387
       389
        
         - chronologique ==0.3.1.3

     
···

       395
       397
        
         - circle-packing ==0.1.0.6

     

       396
       398
        
         - circular ==0.4.0.0

     

       397
       399
        
         - citeproc ==0.4.0.1

     

       398
       398
       -
         - clash-ghc ==1.4.2

     

       399
       399
       -
         - clash-lib ==1.4.2

     

       400
       400
       -
         - clash-prelude ==1.4.2

     

       400
       400
       +
         - clash-ghc ==1.4.3

     

       401
       401
       +
         - clash-lib ==1.4.3

     

       402
       402
       +
         - clash-prelude ==1.4.3

     

       401
       403
        
         - classy-prelude ==1.5.0

     

       402
       404
        
         - classy-prelude-conduit ==1.5.0

     

       403
       405
        
         - clay ==0.13.3

     
···

       415
       417
        
         - codec-beam ==0.2.0

     

       416
       418
        
         - code-page ==0.2.1

     

       417
       419
        
         - collect-errors ==0.1.5.0

     

       418
       418
       -
         - co-log-concurrent ==0.5.0.0

     

       420
       420
       +
         - co-log-concurrent ==0.5.1.0

     

       419
       421
        
         - co-log-core ==0.2.1.1

     

       420
       422
        
         - Color ==0.3.2

     

       421
       423
        
         - colorful-monoids ==0.2.1.3

     
···

       439
       441
        
         - composition ==1.0.2.2

     

       440
       442
        
         - composition-extra ==2.0.0

     

       441
       443
        
         - concise ==0.1.0.1

     

       442
       442
       -
         - concurrency ==1.11.0.1

     

       444
       444
       +
         - concurrency ==1.11.0.2

     

       443
       445
        
         - concurrent-extra ==0.7.0.12

     

       444
       446
        
         - concurrent-output ==1.10.12

     

       445
       447
        
         - concurrent-split ==0.0.1.1

     
···

       579
       581
        
         - deepseq-generics ==0.2.0.0

     

       580
       582
        
         - deepseq-instances ==0.1.0.1

     

       581
       583
        
         - deferred-folds ==0.9.17

     

       582
       582
       -
         - dejafu ==2.4.0.2

     

       584
       584
       +
         - dejafu ==2.4.0.3

     

       583
       585
        
         - dense-linear-algebra ==0.1.0.0

     

       584
       586
        
         - dependent-map ==0.4.0.0

     

       585
       587
        
         - dependent-sum ==0.7.1.0

     
···

       743
       745
        
         - fakefs ==0.3.0.2

     

       744
       746
        
         - fakepull ==0.3.0.2

     

       745
       747
        
         - faktory ==1.0.3.1

     

       746
       746
       -
         - fast-digits ==0.3.0.0

     

       748
       748
       +
         - fast-digits ==0.3.1.0

     

       747
       749
        
         - fast-logger ==3.0.5

     

       748
       750
        
         - fast-math ==1.0.2

     

       749
       751
        
         - fb ==2.1.1

     
···

       759
       761
        
         - file-embed-lzma ==0

     

       760
       762
        
         - filelock ==0.1.1.5

     

       761
       763
        
         - filemanip ==0.3.6.3

     

       762
       762
       -
         - filepath-bytestring ==1.4.2.1.7

     

       764
       764
       +
         - filepath-bytestring ==1.4.2.1.8

     

       763
       765
        
         - file-path-th ==0.1.0.0

     

       764
       766
        
         - filepattern ==0.1.2

     

       765
       767
        
         - fileplow ==0.1.0.0

     
···

       890
       892
        
         - ghcid ==0.8.7

     

       891
       893
        
         - ghci-hexcalc ==0.1.1.0

     

       892
       894
        
         - ghcjs-codemirror ==0.0.0.2

     

       893
       893
       -
         - ghc-lib ==8.10.5.20210606

     

       894
       894
       -
         - ghc-lib-parser ==8.10.5.20210606

     

       895
       895
       -
         - ghc-lib-parser-ex ==8.10.0.21

     

       895
       895
       +
         - ghc-lib ==8.10.6.20210814

     

       896
       896
       +
         - ghc-lib-parser ==8.10.6.20210814

     

       897
       897
       +
         - ghc-lib-parser-ex ==8.10.0.22

     

       896
       898
        
         - ghc-parser ==0.2.3.0

     

       897
       899
        
         - ghc-paths ==0.1.0.12

     

       898
       900
        
         - ghc-prof ==1.4.1.9

     
···

       985
       987
        
         - hashing ==0.1.0.1

     

       986
       988
        
         - hashmap ==1.3.3

     

       987
       989
        
         - hashtables ==1.2.4.1

     

       988
       988
       -
         - haskeline ==0.8.1.2

     

       990
       990
       +
         - haskeline ==0.8.2

     

       989
       991
        
         - haskell-awk ==1.2.0.1

     

       990
       992
        
         - haskell-gi ==0.25.0

     

       991
       993
        
         - haskell-gi-base ==0.25.0

     
···

       1081
       1083
        
         - hourglass-orphans ==0.1.0.0

     

       1082
       1084
        
         - hp2pretty ==0.10

     

       1083
       1085
        
         - hpack ==0.34.4

     

       1084
       1084
       -
         - hpack-dhall ==0.5.2

     

       1086
       1086
       +
         - hpack-dhall ==0.5.3

     

       1085
       1087
        
         - hpc-codecov ==0.3.0.0

     

       1086
       1088
        
         - hpc-lcov ==1.0.1

     

       1087
       1089
        
         - hprotoc ==2.4.17

     
···

       1134
       1136
        
         - hs-php-session ==0.0.9.3

     

       1135
       1137
        
         - hsshellscript ==3.5.0

     

       1136
       1138
        
         - hs-tags ==0.1.5

     

       1137
       1137
       -
         - HStringTemplate ==0.8.7

     

       1139
       1139
       +
         - HStringTemplate ==0.8.8

     

       1138
       1140
        
         - HSvm ==0.1.1.3.22

     

       1139
       1141
        
         - HsYAML ==0.2.1.0

     

       1140
       1142
        
         - HsYAML-aeson ==0.2.0.0

     
···

       1142
       1144
        
         - htaglib ==1.2.0

     

       1143
       1145
        
         - HTF ==0.14.0.6

     

       1144
       1146
        
         - html ==1.0.1.2

     

       1145
       1145
       -
         - html-conduit ==1.3.2.1

     

       1147
       1147
       +
         - html-conduit ==1.3.2.2

     

       1146
       1148
        
         - html-entities ==1.1.4.5

     

       1147
       1149
        
         - html-entity-map ==0.1.0.0

     

       1148
       1150
        
         - htoml ==1.0.0.3

     
···

       1168
       1170
        
         - human-readable-duration ==0.2.1.4

     

       1169
       1171
        
         - HUnit ==1.6.2.0

     

       1170
       1172
        
         - HUnit-approx ==1.1.1.1

     

       1171
       1171
       -
         - hunit-dejafu ==2.0.0.4

     

       1173
       1173
       +
         - hunit-dejafu ==2.0.0.5

     

       1172
       1174
        
         - hvect ==0.4.0.0

     

       1173
       1175
        
         - hvega ==0.11.0.1

     

       1174
       1176
        
         - hw-balancedparens ==0.4.1.1

     
···

       1255
       1257
        
         - intern ==0.9.4

     

       1256
       1258
        
         - interpolate ==0.2.1

     

       1257
       1259
        
         - interpolatedstring-perl6 ==1.0.2

     

       1258
       1258
       -
         - interpolation ==0.1.1.1

     

       1260
       1260
       +
         - interpolation ==0.1.1.2

     

       1259
       1261
        
         - interpolator ==1.1.0.2

     

       1260
       1262
        
         - IntervalMap ==0.6.1.2

     

       1261
       1263
        
         - intervals ==0.9.2

     
···

       1278
       1280
        
         - ipynb ==0.1.0.1

     

       1279
       1281
        
         - ipython-kernel ==0.10.2.1

     

       1280
       1282
        
         - irc ==0.6.1.0

     

       1281
       1281
       -
         - irc-client ==1.1.2.1

     

       1282
       1282
       -
         - irc-conduit ==0.3.0.4

     

       1283
       1283
       -
         - irc-ctcp ==0.1.3.0

     

       1283
       1283
       +
         - irc-client ==1.1.2.2

     

       1284
       1284
       +
         - irc-conduit ==0.3.0.5

     

       1285
       1285
       +
         - irc-ctcp ==0.1.3.1

     

       1284
       1286
        
         - isbn ==1.1.0.2

     

       1285
       1287
        
         - islink ==0.1.0.0

     

       1286
       1288
        
         - iso3166-country-codes ==0.20140203.8

     
···

       1294
       1296
        
         - ix-shapable ==0.1.0

     

       1295
       1297
        
         - jack ==0.7.2

     

       1296
       1298
        
         - jalaali ==1.0.0.0

     

       1299
       1299
       +
         - java-adt ==0.2018.11.4

     

       1297
       1300
        
         - jira-wiki-markup ==1.4.0

     

       1298
       1301
        
         - jose ==0.8.4

     

       1299
       1302
        
         - jose-jwt ==0.9.2

     
···

       1335
       1338
        
         - l10n ==0.1.0.1

     

       1336
       1339
        
         - labels ==0.3.3

     

       1337
       1340
        
         - lackey ==1.0.15

     

       1338
       1338
       -
         - lambdabot-core ==5.3.0.1

     

       1341
       1341
       +
         - lambdabot-core ==5.3.0.2

     

       1339
       1342
        
         - LambdaHack ==0.10.2.0

     

       1340
       1343
        
         - lame ==0.2.0

     

       1341
       1344
        
         - language-avro ==0.1.3.1

     

       1342
       1345
        
         - language-bash ==0.9.2

     

       1343
       1346
        
         - language-c ==0.9.0.1

     

       1344
       1347
        
         - language-c-quote ==0.13

     

       1345
       1345
       -
         - language-docker ==10.0.1

     

       1348
       1348
       +
         - language-docker ==10.0.2

     

       1346
       1349
        
         - language-java ==0.2.9

     

       1347
       1350
        
         - language-javascript ==0.7.1.0

     

       1348
       1351
        
         - language-protobuf ==1.0.1

     
···

       1350
       1353
        
         - language-thrift ==0.12.0.0

     

       1351
       1354
        
         - lapack ==0.3.2

     

       1352
       1355
        
         - lapack-carray ==0.0.3

     

       1353
       1353
       -
         - lapack-comfort-array ==0.0.0.1

     

       1356
       1356
       +
         - lapack-comfort-array ==0.0.1

     

       1354
       1357
        
         - lapack-ffi ==0.0.3

     

       1355
       1358
        
         - lapack-ffi-tools ==0.1.2.1

     

       1356
       1359
        
         - largeword ==1.2.5

     
···

       1510
       1513
        
         - min-max-pqueue ==0.1.0.2

     

       1511
       1514
        
         - mintty ==0.1.2

     

       1512
       1515
        
         - missing-foreign ==0.1.1

     

       1513
       1513
       -
         - mixed-types-num ==0.5.8.0

     

       1516
       1516
       +
         - mixed-types-num ==0.5.9.1

     

       1514
       1517
        
         - mltool ==0.2.0.1

     

       1515
       1518
        
         - mmap ==0.5.9

     

       1516
       1519
        
         - mmark ==0.0.7.2

     
···

       1526
       1529
        
         - modern-uri ==0.3.4.1

     

       1527
       1530
        
         - modular ==0.1.0.8

     

       1528
       1531
        
         - monad-chronicle ==1.0.0.1

     

       1529
       1529
       -
         - monad-control ==1.0.3

     

       1532
       1532
       +
         - monad-control ==1.0.3.1

     

       1530
       1533
        
         - monad-control-aligned ==0.0.1.1

     

       1531
       1531
       -
         - monad-coroutine ==0.9.1.2

     

       1534
       1534
       +
         - monad-coroutine ==0.9.1.3

     

       1532
       1535
        
         - monad-extras ==0.6.0

     

       1533
       1536
        
         - monadic-arrays ==0.2.2

     

       1534
       1537
        
         - monad-journal ==0.8.1

     
···

       1541
       1544
        
         - monad-memo ==0.5.3

     

       1542
       1545
        
         - monad-metrics ==0.2.2.0

     

       1543
       1546
        
         - monad-par ==0.3.5

     

       1544
       1544
       -
         - monad-parallel ==0.7.2.4

     

       1547
       1547
       +
         - monad-parallel ==0.7.2.5

     

       1545
       1548
        
         - monad-par-extras ==0.3.3

     

       1546
       1549
        
         - monad-peel ==0.2.1.2

     

       1547
       1550
        
         - monad-primitive ==0.1

     
···

       1586
       1589
        
         - mustache ==2.3.1

     

       1587
       1590
        
         - mutable-containers ==0.3.4

     

       1588
       1591
        
         - mwc-probability ==2.3.1

     

       1589
       1589
       -
         - mwc-random ==0.15.0.1

     

       1592
       1592
       +
         - mwc-random ==0.15.0.2

     

       1590
       1593
        
         - mwc-random-monad ==0.7.3.1

     

       1591
       1594
        
         - mx-state-codes ==1.0.0.0

     

       1592
       1595
        
         - mysql ==0.2.0.1

     
···

       1604
       1607
        
         - neat-interpolation ==0.5.1.2

     

       1605
       1608
        
         - netcode-io ==0.0.2

     

       1606
       1609
        
         - netlib-carray ==0.1

     

       1607
       1607
       -
         - netlib-comfort-array ==0.0.0.1

     

       1610
       1610
       +
         - netlib-comfort-array ==0.0.0.2

     

       1608
       1611
        
         - netlib-ffi ==0.1.1

     

       1609
       1612
        
         - net-mqtt ==0.7.1.1

     

       1610
       1613
        
         - net-mqtt-lens ==0.1.1.0

     
···

       1674
       1677
        
         - OneTuple ==0.2.2.1

     

       1675
       1678
        
         - Only ==0.1

     

       1676
       1679
        
         - oo-prototypes ==0.1.0.0

     

       1677
       1677
       -
         - opaleye ==0.7.3.0

     

       1680
       1680
       +
         - opaleye ==0.7.4.0

     

       1678
       1681
        
         - OpenAL ==1.7.0.5

     

       1679
       1682
        
         - openapi3 ==3.1.0

     

       1680
       1683
        
         - open-browser ==0.2.1.0

     
···

       1803
       1806
        
         - pointedlist ==0.6.1

     

       1804
       1807
        
         - pointless-fun ==1.1.0.6

     

       1805
       1808
        
         - poll ==0.0.0.2

     

       1809
       1809
       +
         - polling-cache ==0.1.1.0

     

       1806
       1810
        
         - poly ==0.5.0.0

     

       1807
       1811
        
         - poly-arity ==0.1.0

     

       1808
       1812
        
         - polynomials-bernstein ==1.1.2

     
···

       1844
       1848
        
         - pretty-sop ==0.2.0.3

     

       1845
       1849
        
         - pretty-terminal ==0.1.0.0

     

       1846
       1850
        
         - primes ==0.2.1.0

     

       1847
       1847
       -
         - primitive ==0.7.1.0

     

       1851
       1851
       +
         - primitive ==0.7.2.0

     

       1848
       1852
        
         - primitive-addr ==0.1.0.2

     

       1849
       1853
        
         - primitive-extras ==0.10.1

     

       1850
       1854
        
         - primitive-unaligned ==0.1.1.1

     
···

       1971
       1975
        
         - regex-pcre ==0.95.0.0

     

       1972
       1976
        
         - regex-pcre-builtin ==0.95.2.3.8.43

     

       1973
       1977
        
         - regex-posix ==0.96.0.1

     

       1978
       1978
       +
         - regex-posix-clib ==2.7

     

       1974
       1979
        
         - regex-tdfa ==1.3.1.1

     

       1975
       1980
        
         - regex-with-pcre ==1.1.0.0

     

       1976
       1981
        
         - registry ==0.2.0.3

     
···

       1983
       1988
        
         - reliable-io ==0.0.1

     

       1984
       1989
        
         - relude ==0.7.0.0

     

       1985
       1990
        
         - renderable ==0.2.0.1

     

       1986
       1986
       -
         - replace-attoparsec ==1.4.4.0

     

       1991
       1991
       +
         - replace-attoparsec ==1.4.5.0

     

       1987
       1992
        
         - replace-megaparsec ==1.4.4.0

     

       1988
       1993
        
         - repline ==0.4.0.0

     

       1989
       1994
        
         - req ==3.9.0

     

       1990
       1990
       -
         - req-conduit ==1.0.0

     

       1995
       1995
       +
         - req-conduit ==1.0.1

     

       1991
       1996
        
         - rerebase ==1.13.0.1

     

       1992
       1997
        
         - rescue ==0.4.2.1

     

       1993
       1998
        
         - resistor-cube ==0.0.1.2

     

       1994
       1999
        
         - resolv ==0.1.2.0

     

       1995
       2000
        
         - resource-pool ==0.2.3.2

     

       1996
       1996
       -
         - resourcet ==1.2.4.2

     

       2001
       2001
       +
         - resourcet ==1.2.4.3

     

       1997
       2002
        
         - result ==0.2.6.0

     

       1998
       2003
        
         - rethinkdb-client-driver ==0.0.25

     

       1999
       2004
        
         - retry ==0.8.1.2

     
···

       2004
       2009
        
         - rhine ==0.7.0

     

       2005
       2010
        
         - rhine-gloss ==0.7.0

     

       2006
       2011
        
         - rigel-viz ==0.2.0.0

     

       2007
       2007
       -
         - rio ==0.1.20.0

     

       2012
       2012
       +
         - rio ==0.1.21.0

     

       2008
       2013
        
         - rio-orphans ==0.1.2.0

     

       2009
       2014
        
         - rio-prettyprint ==0.1.1.0

     

       2010
       2015
        
         - roc-id ==0.1.0.0

     
···

       2158
       2163
        
         - singletons ==2.7

     

       2159
       2164
        
         - singletons-presburger ==0.6.0.0

     

       2160
       2165
        
         - siphash ==1.0.3

     

       2166
       2166
       +
         - Sit ==0.2021.1.18

     

       2161
       2167
        
         - sitemap-gen ==0.1.0.0

     

       2162
       2168
        
         - sized ==1.0.0.0

     

       2163
       2169
        
         - skein ==1.0.9.4

     
···

       2239
       2245
        
         - storable-record ==0.0.5

     

       2240
       2246
        
         - storable-tuple ==0.0.3.3

     

       2241
       2247
        
         - storablevector ==0.2.13.1

     

       2242
       2242
       -
         - store ==0.7.11

     

       2248
       2248
       +
         - store ==0.7.12

     

       2243
       2249
        
         - store-core ==0.4.4.4

     

       2244
       2250
        
         - store-streaming ==0.2.0.3

     

       2245
       2251
        
         - stratosphere ==0.59.1

     
···

       2315
       2321
        
         - tasty ==1.4.1

     

       2316
       2322
        
         - tasty-ant-xml ==1.1.8

     

       2317
       2323
        
         - tasty-bench ==0.2.5

     

       2318
       2318
       -
         - tasty-dejafu ==2.0.0.7

     

       2324
       2324
       +
         - tasty-dejafu ==2.0.0.8

     

       2319
       2325
        
         - tasty-discover ==4.2.2

     

       2320
       2326
        
         - tasty-expected-failure ==0.12.3

     

       2321
       2327
        
         - tasty-focus ==1.0.1

     
···

       2356
       2362
        
         - test-framework-smallcheck ==0.2

     

       2357
       2363
        
         - test-fun ==0.1.0.0

     

       2358
       2364
        
         - testing-type-modifiers ==0.1.0.1

     

       2359
       2359
       -
         - texmath ==0.12.3

     

       2365
       2365
       +
         - texmath ==0.12.3.1

     

       2360
       2366
        
         - text-ansi ==0.1.1

     

       2361
       2367
        
         - text-binary ==0.2.1.1

     

       2362
       2368
        
         - text-builder ==0.6.6.2

     
···

       2427
       2433
        
         - timezone-series ==0.1.9

     

       2428
       2434
        
         - tinylog ==0.15.0

     

       2429
       2435
        
         - titlecase ==1.0.1

     

       2430
       2430
       -
         - tldr ==0.9.0

     

       2436
       2436
       +
         - tldr ==0.9.1

     

       2431
       2437
        
         - tls ==1.5.5

     

       2432
       2438
        
         - tls-debug ==0.4.8

     

       2433
       2439
        
         - tls-session-manager ==0.0.4

     
···

       2441
       2447
        
         - torsor ==0.1

     

       2442
       2448
        
         - tostring ==0.2.1.1

     

       2443
       2449
        
         - transaction ==0.1.1.3

     

       2444
       2444
       -
         - transformers-base ==0.4.5.2

     

       2450
       2450
       +
         - transformers-base ==0.4.6

     

       2445
       2451
        
         - transformers-bifunctors ==0.1

     

       2446
       2452
        
         - transformers-compat ==0.6.6

     

       2447
       2453
        
         - transformers-fix ==1.0

     
···

       2463
       2469
        
         - turtle ==1.5.22

     

       2464
       2470
        
         - typecheck-plugin-nat-simple ==0.1.0.2

     

       2465
       2471
        
         - TypeCompose ==0.9.14

     

       2466
       2466
       -
         - typed-process ==0.2.6.0

     

       2472
       2472
       +
         - typed-process ==0.2.6.1

     

       2467
       2473
        
         - typed-uuid ==0.1.0.0

     

       2468
       2474
        
         - type-equality ==1

     

       2469
       2475
        
         - type-errors ==0.2.0.0

     

       2470
       2470
       -
         - type-errors-pretty ==0.0.1.1

     

       2476
       2476
       +
         - type-errors-pretty ==0.0.1.2

     

       2471
       2477
        
         - type-hint ==0.1

     

       2472
       2478
        
         - type-level-integers ==0.0.1

     

       2473
       2479
        
         - type-level-kv-list ==1.1.0

     
···

       2593
       2599
        
         - wai-feature-flags ==0.1.0.1

     

       2594
       2600
        
         - wai-handler-launch ==3.0.3.1

     

       2595
       2601
        
         - wai-logger ==2.3.6

     

       2596
       2596
       -
         - wai-middleware-auth ==0.2.5.0

     

       2602
       2602
       +
         - wai-middleware-auth ==0.2.5.1

     

       2597
       2603
        
         - wai-middleware-caching ==0.1.0.2

     

       2598
       2604
        
         - wai-middleware-clacks ==0.1.0.1

     

       2599
       2605
        
         - wai-middleware-prometheus ==1.0.0

     
···

       2649
       2655
        
         - writer-cps-transformers ==0.5.6.1

     

       2650
       2656
        
         - wss-client ==0.3.0.0

     

       2651
       2657
        
         - wuss ==1.1.18

     

       2652
       2652
       -
         - X11 ==1.10

     

       2658
       2658
       +
         - X11 ==1.10.1

     

       2653
       2659
        
         - X11-xft ==0.3.1

     

       2654
       2660
        
         - x11-xim ==0.0.9.0

     

       2655
       2661
        
         - x509 ==1.7.5

+5 -11

pkgs/development/haskell-modules/configuration-hackage2nix/transitive-broken.yaml

···

       391
       391
        
        - adict

     

       392
       392
        
        - adp-multi-monadiccp

     

       393
       393
        
        - aern2-real

     

       394
       394
       -
        - aern2-real_0_2_8_0

     

       395
       394
        
        - aeson-native

     

       396
       395
        
        - afv

     

       397
       396
        
        - agda-server

     
···

       712
       711
        
        - claferwiki

     

       713
       712
        
        - clash

     

       714
       713
        
        - clash-ghc

     

       715
       715
       -
        - clash-ghc_1_4_3

     

       716
       714
        
        - clash-lib

     

       717
       717
       -
        - clash-lib_1_4_3

     

       718
       715
        
        - clash-multisignal

     

       719
       716
        
        - clash-prelude-quickcheck

     

       717
       717
       +
        - clash-shake

     

       720
       718
        
        - clash-systemverilog

     

       721
       719
        
        - clash-verilog

     

       722
       720
        
        - clash-vhdl

     

       721
       721
       +
        - clashilator

     

       723
       722
        
        - classify-frog

     

       724
       723
        
        - classy-miso

     

       725
       724
        
        - clckwrks

     
···

       1063
       1062
        
        - falling-turnip

     

       1064
       1063
        
        - fallingblocks

     

       1065
       1064
        
        - family-tree

     

       1066
       1066
       -
        - fast-digits

     

       1067
       1065
        
        - fastirc

     

       1068
       1066
        
        - fault-tree

     

       1069
       1067
        
        - fbrnch

     
···

       1131
       1129
        
        - fplll

     

       1132
       1130
        
        - fpnla-examples

     

       1133
       1131
        
        - frame-markdown

     

       1132
       1132
       +
        - freckle-app

     

       1134
       1133
        
        - free-theorems-counterexamples

     

       1135
       1134
        
        - free-theorems-seq

     

       1136
       1135
        
        - free-theorems-seq-webui

     
···

       1855
       1854
        
        - knots

     

       1856
       1855
        
        - korfu

     

       1857
       1856
        
        - ks-test

     

       1858
       1858
       -
        - kubernetes-client

     

       1859
       1857
        
        - kurita

     

       1860
       1858
        
        - laborantin-hs

     

       1861
       1859
        
        - labsat

     
···

       1895
       1893
        
        - lapack

     

       1896
       1894
        
        - lapack-carray

     

       1897
       1895
        
        - lapack-comfort-array

     

       1898
       1898
       -
        - lapack-comfort-array_0_0_1

     

       1899
       1896
        
        - lapack-hmatrix

     

       1900
       1897
        
        - lapack_0_4

     

       1901
       1898
        
        - lat

     
···

       2006
       2003
        
        - loup

     

       2007
       2004
        
        - ls-usb

     

       2008
       2005
        
        - lsystem

     

       2009
       2009
       -
        - lti13

     

       2010
       2006
        
        - luachunk

     

       2011
       2007
        
        - lucid-colonnade

     

       2012
       2008
        
        - lucienne

     
···

       2064
       2060
        
        - maxent

     

       2065
       2061
        
        - maxent-learner-hw-gui

     

       2066
       2062
        
        - maxsharing

     

       2067
       2067
       -
        - mcmc

     

       2068
       2063
        
        - mcmc-samplers

     

       2069
       2064
        
        - mealy

     

       2070
       2065
        
        - mediabus-fdk-aac

     
···

       2114
       2109
        
        - monetdb-mapi

     

       2115
       2110
        
        - mongrel2-handler

     

       2116
       2111
        
        - monky

     

       2117
       2117
       -
        - monomer

     

       2118
       2112
        
        - monte-carlo

     

       2119
       2113
        
        - moo

     

       2120
       2114
        
        - moo-nad

     
···

       2172
       2166
        
        - mywatch

     

       2173
       2167
        
        - n2o-web

     

       2174
       2168
        
        - nakadi-client

     

       2175
       2175
       -
        - nanovg-simple

     

       2176
       2169
        
        - nats-queue

     

       2177
       2170
        
        - natural-number

     

       2178
       2171
        
        - nemesis-titan

     
···

       2591
       2584
        
        - restful-snap

     

       2592
       2585
        
        - restricted-workers

     

       2593
       2586
        
        - rethinkdb-model

     

       2587
       2587
       +
        - retroclash-lib

     

       2588
       2588
       +
        - retroclash-sim

     

       2594
       2589
        
        - rewrite

     

       2595
       2590
        
        - rewriting

     

       2596
       2591
        
        - rezoom

     
···

       3270
       3265
        
        - yeshql

     

       3271
       3266
        
        - yesod-articles

     

       3272
       3267
        
        - yesod-auth-ldap

     

       3273
       3273
       -
        - yesod-auth-lti13

     

       3274
       3268
        
        - yesod-colonnade

     

       3275
       3269
        
        - yesod-continuations

     

       3276
       3270
        
        - yesod-examples

+4 -7

pkgs/development/haskell-modules/configuration-nix.nix

···

       223
       223
        
         wxcore = super.wxcore.override { wxGTK = pkgs.wxGTK30; };

     

       224
       224
        
       

     

       225
       225
        
         # Test suite wants to connect to $DISPLAY.

     

       226
       226
       +
         bindings-GLFW = dontCheck super.bindings-GLFW;

     

       227
       227
       +
         gi-gtk-declarative = dontCheck super.gi-gtk-declarative;

     

       228
       228
       +
         gi-gtk-declarative-app-simple = dontCheck super.gi-gtk-declarative-app-simple;

     

       226
       229
        
         hsqml = dontCheck (addExtraLibraries (super.hsqml.override { qt5 = pkgs.qt5Full; }) [pkgs.libGLU pkgs.libGL]);

     

       230
       230
       +
         monomer = dontCheck super.monomer;

     

       227
       231
        
       

     

       228
       232
        
         # Wants to check against a real DB, Needs freetds

     

       229
       233
        
         odbc = dontCheck (addExtraLibraries super.odbc [ pkgs.freetds ]);

     
···

       351
       355
        
       

     

       352
       356
        
         # Looks like Avahi provides the missing library

     

       353
       357
        
         dnssd = super.dnssd.override { dns_sd = pkgs.avahi.override { withLibdnssdCompat = true; }; };

     

       354
       354
       -
       

     

       355
       355
       -
         # requires an X11 display

     

       356
       356
       -
         bindings-GLFW = dontCheck super.bindings-GLFW;

     

       357
       357
       -
       

     

       358
       358
       -
         # requires an X11 display in test suite

     

       359
       359
       -
         gi-gtk-declarative = dontCheck super.gi-gtk-declarative;

     

       360
       360
       -
         gi-gtk-declarative-app-simple = dontCheck super.gi-gtk-declarative-app-simple;

     

       361
       358
        
       

     

       362
       359
        
         # tests depend on executable

     

       363
       360
        
         ghcide = overrideCabal super.ghcide (drv: {

+1001 -1173

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

···

       8804
       8804
        
            }) {};

     

       8805
       8805
        
       

     

       8806
       8806
        
         "HMock" = callPackage

     

       8807
       8807
       -
           ({ mkDerivation, base, constraints, containers, data-default

     

       8807
       8807
       +
           ({ mkDerivation, array, base, constraints, containers, data-default

     

       8808
       8808
        
            , deepseq, directory, doctest-exitcode-stdio, doctest-lib

     

       8809
       8809
        
            , exceptions, extra, hspec, monad-control, mono-traversable, mtl

     

       8810
       8810
        
            , QuickCheck, regex-tdfa, stm, syb, template-haskell

     
···

       8812
       8812
        
            }:

     

       8813
       8813
        
            mkDerivation {

     

       8814
       8814
        
              pname = "HMock";

     

       8815
       8815
       -
              version = "0.3.0.0";

     

       8816
       8816
       -
              sha256 = "0rvb3a0nbf8i0qfg7na5rvd966amids07l8w8ka6b7hdw46lkczn";

     

       8815
       8815
       +
              version = "0.4.0.0";

     

       8816
       8816
       +
              sha256 = "1xkb4qyccpp5iws0jysgmcypbcab8yig6hnc756890z1dz5d1vy5";

     

       8817
       8817
        
              libraryHaskellDepends = [

     

       8818
       8818
       -
                base constraints containers data-default exceptions extra

     

       8818
       8818
       +
                array base constraints containers data-default exceptions extra

     

       8819
       8819
        
                monad-control mono-traversable mtl regex-tdfa stm syb

     

       8820
       8820
        
                template-haskell transformers-base unliftio

     

       8821
       8821
        
              ];

     
···

       9041
       9041
        
              benchmarkHaskellDepends = [ base gauge ];

     

       9042
       9042
        
              description = "quantitative finance library";

     

       9043
       9043
        
              license = lib.licenses.mit;

     

       9044
       9044
       -
              platforms = [ "i686-linux" "x86_64-darwin" "x86_64-linux" ];

     

       9044
       9044
       +
              platforms = [

     

       9045
       9045
       +
                "aarch64-darwin" "i686-linux" "x86_64-darwin" "x86_64-linux"

     

       9046
       9046
       +
              ];

     

       9045
       9047
        
            }) {inherit (pkgs) gsl;};

     

       9046
       9048
        
       

     

       9047
       9049
        
         "HROOT" = callPackage

     
···

       9329
       9331
        
       

     

       9330
       9332
        
         "HStringTemplate" = callPackage

     

       9331
       9333
        
           ({ mkDerivation, array, base, blaze-builder, bytestring, containers

     

       9332
       9332
       -
            , deepseq, directory, filepath, mtl, old-locale, parsec, pretty

     

       9333
       9333
       -
            , semigroups, syb, template-haskell, text, time, void

     

       9334
       9334
       -
            }:

     

       9335
       9335
       -
            mkDerivation {

     

       9336
       9336
       -
              pname = "HStringTemplate";

     

       9337
       9337
       -
              version = "0.8.7";

     

       9338
       9338
       -
              sha256 = "03kbmyh0713j3qhhrl7jqbmsvyq1q82h2yxq45cc9rs55sma8kjg";

     

       9339
       9339
       -
              revision = "2";

     

       9340
       9340
       -
              editedCabalFile = "082d1lm6q1jb7rrl20jz0y4ca1qf87ihbq3v6mji9ibacl6adjaq";

     

       9341
       9341
       -
              libraryHaskellDepends = [

     

       9342
       9342
       -
                array base blaze-builder bytestring containers deepseq directory

     

       9343
       9343
       -
                filepath mtl old-locale parsec pretty semigroups syb

     

       9344
       9344
       -
                template-haskell text time void

     

       9345
       9345
       -
              ];

     

       9346
       9346
       -
              description = "StringTemplate implementation in Haskell";

     

       9347
       9347
       -
              license = lib.licenses.bsd3;

     

       9348
       9348
       -
            }) {};

     

       9349
       9349
       -
       

     

       9350
       9350
       -
         "HStringTemplate_0_8_8" = callPackage

     

       9351
       9351
       -
           ({ mkDerivation, array, base, blaze-builder, bytestring, containers

     

       9352
       9334
        
            , deepseq, directory, filepath, HUnit, mtl, old-locale, parsec

     

       9353
       9335
        
            , pretty, QuickCheck, random, semigroups, syb, template-haskell

     

       9354
       9336
        
            , text, time, void

     
···

       9365
       9347
        
              testHaskellDepends = [ base containers HUnit QuickCheck random ];

     

       9366
       9348
        
              description = "StringTemplate implementation in Haskell";

     

       9367
       9349
        
              license = lib.licenses.bsd3;

     

       9368
       9368
       -
              hydraPlatforms = lib.platforms.none;

     

       9369
       9350
        
            }) {};

     

       9370
       9351
        
       

     

       9371
       9352
        
         "HStringTemplateHelpers" = callPackage

     
···

       17794
       17775
        
              license = lib.licenses.bsd3;

     

       17795
       17776
        
            }) {};

     

       17796
       17777
        
       

     

       17778
       17778
       +
         "STMonadTrans_0_4_6" = callPackage

     

       17779
       17779
       +
           ({ mkDerivation, array, base, mtl, tasty, tasty-hunit

     

       17780
       17780
       +
            , tasty-quickcheck, transformers

     

       17781
       17781
       +
            }:

     

       17782
       17782
       +
            mkDerivation {

     

       17783
       17783
       +
              pname = "STMonadTrans";

     

       17784
       17784
       +
              version = "0.4.6";

     

       17785
       17785
       +
              sha256 = "0rvhh0hhwz601ibpzisry7xf3j61r5sxfgp47imaa37i5bvrlynb";

     

       17786
       17786
       +
              libraryHaskellDepends = [ array base mtl ];

     

       17787
       17787
       +
              testHaskellDepends = [

     

       17788
       17788
       +
                array base tasty tasty-hunit tasty-quickcheck transformers

     

       17789
       17789
       +
              ];

     

       17790
       17790
       +
              description = "A monad transformer version of the ST monad";

     

       17791
       17791
       +
              license = lib.licenses.bsd3;

     

       17792
       17792
       +
              hydraPlatforms = lib.platforms.none;

     

       17793
       17793
       +
            }) {};

     

       17794
       17794
       +
       

     

       17797
       17795
        
         "SVD2HS" = callPackage

     

       17798
       17796
        
           ({ mkDerivation, base, containers, pretty, text, xml-conduit

     

       17799
       17797
        
            , xml-lens

     
···

       17839
       17837
        
              pname = "SVGFonts";

     

       17840
       17838
        
              version = "1.7.0.1";

     

       17841
       17839
        
              sha256 = "06vnpkkr19s9b1wjp7l2w29vr7fsghcrffd2knlxvdhjacrfpc9h";

     

       17840
       17840
       +
              revision = "1";

     

       17841
       17841
       +
              editedCabalFile = "110zlafis1rivba3za7in92fq6a7738hh57w5gkivi50d7pfbw24";

     

       17842
       17842
        
              enableSeparateDataOutput = true;

     

       17843
       17843
        
              libraryHaskellDepends = [

     

       17844
       17844
        
                attoparsec base blaze-markup blaze-svg bytestring cereal

     
···

       21502
       21502
        
            }:

     

       21503
       21503
        
            mkDerivation {

     

       21504
       21504
        
              pname = "X11";

     

       21505
       21505
       -
              version = "1.10";

     

       21506
       21506
       -
              sha256 = "1zrdqryx99izjvsrsalb65ihpmikm9r6cjlci7cfp6wlwa3i585n";

     

       21507
       21507
       -
              libraryHaskellDepends = [ base data-default-class ];

     

       21508
       21508
       -
              librarySystemDepends = [

     

       21509
       21509
       -
                libX11 libXext libXinerama libXrandr libXrender libXScrnSaver

     

       21510
       21510
       -
              ];

     

       21511
       21511
       -
              description = "A binding to the X11 graphics library";

     

       21512
       21512
       -
              license = lib.licenses.bsd3;

     

       21513
       21513
       -
            }) {inherit (pkgs.xorg) libX11; inherit (pkgs.xorg) libXScrnSaver; 

     

       21514
       21514
       -
                inherit (pkgs.xorg) libXext; inherit (pkgs.xorg) libXinerama; 

     

       21515
       21515
       -
                inherit (pkgs.xorg) libXrandr; inherit (pkgs.xorg) libXrender;};

     

       21516
       21516
       -
       

     

       21517
       21517
       -
         "X11_1_10_1" = callPackage

     

       21518
       21518
       -
           ({ mkDerivation, base, data-default-class, libX11, libXext

     

       21519
       21519
       -
            , libXinerama, libXrandr, libXrender, libXScrnSaver

     

       21520
       21520
       -
            }:

     

       21521
       21521
       -
            mkDerivation {

     

       21522
       21522
       -
              pname = "X11";

     

       21523
       21505
        
              version = "1.10.1";

     

       21524
       21506
        
              sha256 = "13a0qf8rwn1s43wcl39f1pcq3h1kw1ddfq205j1ry0j3yafnazxg";

     

       21525
       21507
        
              libraryHaskellDepends = [ base data-default-class ];

     
···

       21528
       21510
        
              ];

     

       21529
       21511
        
              description = "A binding to the X11 graphics library";

     

       21530
       21512
        
              license = lib.licenses.bsd3;

     

       21531
       21531
       -
              hydraPlatforms = lib.platforms.none;

     

       21532
       21513
        
            }) {inherit (pkgs.xorg) libX11; inherit (pkgs.xorg) libXScrnSaver; 

     

       21533
       21514
        
                inherit (pkgs.xorg) libXext; inherit (pkgs.xorg) libXinerama; 

     

       21534
       21515
        
                inherit (pkgs.xorg) libXrandr; inherit (pkgs.xorg) libXrender;};

     
···

       24376
       24357
        
            }:

     

       24377
       24358
        
            mkDerivation {

     

       24378
       24359
        
              pname = "aern2-mp";

     

       24379
       24379
       -
              version = "0.2.7.0";

     

       24380
       24380
       -
              sha256 = "1gsqaggg6mpcpl9s3z566gmbynj4l6n1fhni5b0p8pf5hj8n93gg";

     

       24381
       24381
       -
              libraryHaskellDepends = [

     

       24382
       24382
       -
                base cdar-mBound collect-errors deepseq hspec integer-logarithms

     

       24383
       24383
       -
                mixed-types-num QuickCheck reflection regex-tdfa template-haskell

     

       24384
       24384
       -
              ];

     

       24385
       24385
       -
              testHaskellDepends = [

     

       24386
       24386
       -
                base cdar-mBound collect-errors deepseq hspec integer-logarithms

     

       24387
       24387
       -
                mixed-types-num QuickCheck reflection regex-tdfa template-haskell

     

       24388
       24388
       -
              ];

     

       24389
       24389
       -
              description = "Multi-precision ball (interval) arithmetic";

     

       24390
       24390
       -
              license = lib.licenses.bsd3;

     

       24391
       24391
       -
              hydraPlatforms = lib.platforms.none;

     

       24392
       24392
       -
              broken = true;

     

       24393
       24393
       -
            }) {};

     

       24394
       24394
       -
       

     

       24395
       24395
       -
         "aern2-mp_0_2_8_0" = callPackage

     

       24396
       24396
       -
           ({ mkDerivation, base, cdar-mBound, collect-errors, deepseq, hspec

     

       24397
       24397
       -
            , integer-logarithms, mixed-types-num, QuickCheck, reflection

     

       24398
       24398
       -
            , regex-tdfa, template-haskell

     

       24399
       24399
       -
            }:

     

       24400
       24400
       -
            mkDerivation {

     

       24401
       24401
       -
              pname = "aern2-mp";

     

       24402
       24360
        
              version = "0.2.8.0";

     

       24403
       24361
        
              sha256 = "0nfd2r05jm93idsgijccxzqkkpjkpkn8jz3kqwanlma0x3wj02cj";

     

       24404
       24362
        
              libraryHaskellDepends = [

     
···

       24421
       24379
        
            }:

     

       24422
       24380
        
            mkDerivation {

     

       24423
       24381
        
              pname = "aern2-real";

     

       24424
       24424
       -
              version = "0.2.7.0";

     

       24425
       24425
       -
              sha256 = "0dsph1775rifr9vvx4w7v55bryqmh04fhk6nyk7d91yhn1sf6wc9";

     

       24426
       24426
       -
              libraryHaskellDepends = [

     

       24427
       24427
       -
                aern2-mp base collect-errors hspec integer-logarithms

     

       24428
       24428
       -
                mixed-types-num QuickCheck

     

       24429
       24429
       -
              ];

     

       24430
       24430
       -
              testHaskellDepends = [

     

       24431
       24431
       -
                aern2-mp base collect-errors hspec integer-logarithms

     

       24432
       24432
       -
                mixed-types-num QuickCheck

     

       24433
       24433
       -
              ];

     

       24434
       24434
       -
              description = "Real numbers as sequences of MPBalls";

     

       24435
       24435
       -
              license = lib.licenses.bsd3;

     

       24436
       24436
       -
              hydraPlatforms = lib.platforms.none;

     

       24437
       24437
       -
            }) {};

     

       24438
       24438
       -
       

     

       24439
       24439
       -
         "aern2-real_0_2_8_0" = callPackage

     

       24440
       24440
       -
           ({ mkDerivation, aern2-mp, base, collect-errors, hspec

     

       24441
       24441
       -
            , integer-logarithms, mixed-types-num, QuickCheck

     

       24442
       24442
       -
            }:

     

       24443
       24443
       -
            mkDerivation {

     

       24444
       24444
       -
              pname = "aern2-real";

     

       24445
       24382
        
              version = "0.2.8.0";

     

       24446
       24383
        
              sha256 = "13nk4s5r7h7wg4q0x01f8aiy432zngynd5qbqsqi9fz149k7mik1";

     

       24447
       24384
        
              libraryHaskellDepends = [

     
···

       31165
       31102
        
            }:

     

       31166
       31103
        
            mkDerivation {

     

       31167
       31104
        
              pname = "apecs";

     

       31168
       31168
       -
              version = "0.9.2";

     

       31169
       31169
       -
              sha256 = "1ca9wpp60jslj63q77v55qql46f20jknfqsz7cjmqns41ml5g3q8";

     

       31170
       31170
       -
              libraryHaskellDepends = [

     

       31171
       31171
       -
                array base containers exceptions mtl template-haskell vector

     

       31172
       31172
       -
              ];

     

       31173
       31173
       -
              testHaskellDepends = [ base containers linear QuickCheck vector ];

     

       31174
       31174
       -
              benchmarkHaskellDepends = [ base criterion linear ];

     

       31175
       31175
       -
              description = "Fast Entity-Component-System library for game programming";

     

       31176
       31176
       -
              license = lib.licenses.bsd3;

     

       31177
       31177
       -
            }) {};

     

       31178
       31178
       -
       

     

       31179
       31179
       -
         "apecs_0_9_3" = callPackage

     

       31180
       31180
       -
           ({ mkDerivation, array, base, containers, criterion, exceptions

     

       31181
       31181
       -
            , linear, mtl, QuickCheck, template-haskell, vector

     

       31182
       31182
       -
            }:

     

       31183
       31183
       -
            mkDerivation {

     

       31184
       31184
       -
              pname = "apecs";

     

       31185
       31105
        
              version = "0.9.3";

     

       31186
       31106
        
              sha256 = "02qi63bj0prvmxi6ksw2cq0b7fvhcdv8fgbsjbv7vf51p4c6rbh7";

     

       31187
       31107
        
              libraryHaskellDepends = [

     
···

       31191
       31111
        
              benchmarkHaskellDepends = [ base criterion linear ];

     

       31192
       31112
        
              description = "Fast Entity-Component-System library for game programming";

     

       31193
       31113
        
              license = lib.licenses.bsd3;

     

       31194
       31194
       -
              hydraPlatforms = lib.platforms.none;

     

       31195
       31114
        
            }) {};

     

       31196
       31115
        
       

     

       31197
       31116
        
         "apecs-gloss" = callPackage

     
···

       38156
       38075
        
              ];

     

       38157
       38076
        
              description = "Create status bar menus for macOS from executables";

     

       38158
       38077
        
              license = lib.licenses.bsd3;

     

       38159
       38159
       -
              platforms = [ "x86_64-darwin" ];

     

       38078
       38078
       +
              platforms = [ "aarch64-darwin" "x86_64-darwin" ];

     

       38160
       38079
        
            }) {};

     

       38161
       38080
        
       

     

       38162
       38081
        
         "barchart" = callPackage

     
···

       43844
       43763
        
            }:

     

       43845
       43764
        
            mkDerivation {

     

       43846
       43765
        
              pname = "blas-comfort-array";

     

       43847
       43847
       -
              version = "0.0.0.2";

     

       43848
       43848
       -
              sha256 = "1n9w905ppb08w0d8xbxvgipr9fv1iapwq3ybvk0dbj009w341kd1";

     

       43849
       43849
       -
              libraryHaskellDepends = [

     

       43850
       43850
       -
                base blas-ffi comfort-array netlib-comfort-array netlib-ffi

     

       43851
       43851
       -
                storable-complex transformers

     

       43852
       43852
       -
              ];

     

       43853
       43853
       -
              description = "Auto-generated interface to Fortran BLAS via comfort-array";

     

       43854
       43854
       -
              license = lib.licenses.bsd3;

     

       43855
       43855
       -
            }) {};

     

       43856
       43856
       -
       

     

       43857
       43857
       -
         "blas-comfort-array_0_0_0_3" = callPackage

     

       43858
       43858
       -
           ({ mkDerivation, base, blas-ffi, comfort-array

     

       43859
       43859
       -
            , netlib-comfort-array, netlib-ffi, storable-complex, transformers

     

       43860
       43860
       -
            }:

     

       43861
       43861
       -
            mkDerivation {

     

       43862
       43862
       -
              pname = "blas-comfort-array";

     

       43863
       43766
        
              version = "0.0.0.3";

     

       43864
       43767
        
              sha256 = "1g0bvag205ag520vlxv24cv63idjg6j8nwnadq9gbcibn4gvsisz";

     

       43865
       43768
        
              libraryHaskellDepends = [

     
···

       43868
       43771
        
              ];

     

       43869
       43772
        
              description = "Auto-generated interface to Fortran BLAS via comfort-array";

     

       43870
       43773
        
              license = lib.licenses.bsd3;

     

       43871
       43871
       -
              hydraPlatforms = lib.platforms.none;

     

       43872
       43774
        
            }) {};

     

       43873
       43775
        
       

     

       43874
       43776
        
         "blas-ffi" = callPackage

     
···

       45552
       45454
        
           ({ mkDerivation, base, semigroups, zero }:

     

       45553
       45455
        
            mkDerivation {

     

       45554
       45456
        
              pname = "both";

     

       45555
       45555
       -
              version = "0.1.1.1";

     

       45556
       45556
       -
              sha256 = "0kdqz901fpdgggmkm9rpnpv7gma9c8d887bszhnz6xd3v96gg7xn";

     

       45557
       45557
       -
              libraryHaskellDepends = [ base semigroups zero ];

     

       45558
       45558
       -
              description = "Like Maybe, but with a different Monoid instance";

     

       45559
       45559
       -
              license = lib.licenses.mit;

     

       45560
       45560
       -
            }) {};

     

       45561
       45561
       -
       

     

       45562
       45562
       -
         "both_0_1_1_2" = callPackage

     

       45563
       45563
       -
           ({ mkDerivation, base, semigroups, zero }:

     

       45564
       45564
       -
            mkDerivation {

     

       45565
       45565
       -
              pname = "both";

     

       45566
       45457
        
              version = "0.1.1.2";

     

       45567
       45458
        
              sha256 = "1bf9fvc2ajbwwx31lmmyc1rzp3xzypwb3yjcmbhn6si5xnlbvqhl";

     

       45568
       45459
        
              libraryHaskellDepends = [ base semigroups zero ];

     

       45569
       45460
        
              description = "Like Maybe, but with a different Monoid instance";

     

       45570
       45461
        
              license = lib.licenses.mit;

     

       45571
       45571
       -
              hydraPlatforms = lib.platforms.none;

     

       45572
       45462
        
            }) {};

     

       45573
       45463
        
       

     

       45574
       45464
        
         "botpp" = callPackage

     
···

       47662
       47552
        
            }:

     

       47663
       47553
        
            mkDerivation {

     

       47664
       47554
        
              pname = "byte-count-reader";

     

       47665
       47665
       -
              version = "0.10.1.3";

     

       47666
       47666
       -
              sha256 = "1z02g8mkjwxdrbyxncbvrwg18knyiqa3w9n0x01y2xmbr279rsh0";

     

       47667
       47667
       -
              libraryHaskellDepends = [ base extra parsec parsec-numbers text ];

     

       47668
       47668
       -
              testHaskellDepends = [

     

       47669
       47669
       -
                base extra hspec parsec parsec-numbers text

     

       47670
       47670
       -
              ];

     

       47671
       47671
       -
              description = "Read strings describing a number of bytes like 2Kb and 0.5 MiB";

     

       47672
       47672
       -
              license = lib.licenses.gpl3Only;

     

       47673
       47673
       -
            }) {};

     

       47674
       47674
       -
       

     

       47675
       47675
       -
         "byte-count-reader_0_10_1_5" = callPackage

     

       47676
       47676
       -
           ({ mkDerivation, base, extra, hspec, parsec, parsec-numbers, text

     

       47677
       47677
       -
            }:

     

       47678
       47678
       -
            mkDerivation {

     

       47679
       47679
       -
              pname = "byte-count-reader";

     

       47680
       47555
        
              version = "0.10.1.5";

     

       47681
       47556
        
              sha256 = "0iq40gnfw8z1rkri1rpaqx5av1ay45h6518cg0a0m4ypdzf03r0s";

     

       47682
       47557
        
              libraryHaskellDepends = [ base extra parsec parsec-numbers text ];

     
···

       47685
       47560
        
              ];

     

       47686
       47561
        
              description = "Read strings describing a number of bytes like 2Kb and 0.5 MiB";

     

       47687
       47562
        
              license = lib.licenses.gpl3Only;

     

       47688
       47688
       -
              hydraPlatforms = lib.platforms.none;

     

       47689
       47563
        
            }) {};

     

       47690
       47564
        
       

     

       47691
       47565
        
         "byte-order" = callPackage

     
···

       49601
       49475
        
            }:

     

       49602
       49476
        
            mkDerivation {

     

       49603
       49477
        
              pname = "cabal-rpm";

     

       49604
       49604
       -
              version = "2.0.9";

     

       49605
       49605
       -
              sha256 = "1r6a0dki4wsrmq5xfjb9bkj0dl7cnhwdf46427k71ay90hmc6ncq";

     

       49606
       49606
       -
              isLibrary = false;

     

       49607
       49607
       -
              isExecutable = true;

     

       49608
       49608
       -
              executableHaskellDepends = [

     

       49609
       49609
       -
                base bytestring Cabal directory extra filepath http-client

     

       49610
       49610
       -
                http-client-tls http-conduit optparse-applicative process

     

       49611
       49611
       -
                simple-cabal simple-cmd simple-cmd-args time unix

     

       49612
       49612
       -
              ];

     

       49613
       49613
       -
              description = "RPM packaging tool for Haskell Cabal-based packages";

     

       49614
       49614
       -
              license = lib.licenses.gpl3Only;

     

       49615
       49615
       -
            }) {};

     

       49616
       49616
       -
       

     

       49617
       49617
       -
         "cabal-rpm_2_0_10" = callPackage

     

       49618
       49618
       -
           ({ mkDerivation, base, bytestring, Cabal, directory, extra

     

       49619
       49619
       -
            , filepath, http-client, http-client-tls, http-conduit

     

       49620
       49620
       -
            , optparse-applicative, process, simple-cabal, simple-cmd

     

       49621
       49621
       -
            , simple-cmd-args, time, unix

     

       49622
       49622
       -
            }:

     

       49623
       49623
       -
            mkDerivation {

     

       49624
       49624
       -
              pname = "cabal-rpm";

     

       49625
       49478
        
              version = "2.0.10";

     

       49626
       49479
        
              sha256 = "028kvvdm8dqjmk16ag8p1mb4d3nfyz1i6x8ijfcr45hrb93hdd77";

     

       49627
       49480
        
              isLibrary = false;

     
···

       49633
       49486
        
              ];

     

       49634
       49487
        
              description = "RPM packaging tool for Haskell Cabal-based packages";

     

       49635
       49488
        
              license = lib.licenses.gpl3Only;

     

       49636
       49636
       -
              hydraPlatforms = lib.platforms.none;

     

       49637
       49489
        
            }) {};

     

       49638
       49490
        
       

     

       49639
       49491
        
         "cabal-scripts" = callPackage

     
···

       53814
       53666
        
              description = "Character set detection using Mozilla's Universal Character Set Detector";

     

       53815
       53667
        
              license = "LGPL";

     

       53816
       53668
        
              platforms = [

     

       53817
       53817
       -
                "armv7l-linux" "i686-linux" "x86_64-darwin" "x86_64-linux"

     

       53669
       53669
       +
                "aarch64-darwin" "armv7l-linux" "i686-linux" "x86_64-darwin"

     

       53670
       53670
       +
                "x86_64-linux"

     

       53818
       53671
        
              ];

     

       53819
       53672
        
            }) {};

     

       53820
       53673
        
       

     
···

       54391
       54244
        
            }:

     

       54392
       54245
        
            mkDerivation {

     

       54393
       54246
        
              pname = "chessIO";

     

       54394
       54394
       -
              version = "0.9.0.0";

     

       54395
       54395
       -
              sha256 = "0f8dd3w8az8fzidwiv2h6m52fppfp5b9zd0c1s4c815z3a3rxr4v";

     

       54247
       54247
       +
              version = "0.9.1.0";

     

       54248
       54248
       +
              sha256 = "19lkjrqji01kmfjm065xmlxsrwwr0z2vz2cz19wr0bx6sz4hw3zr";

     

       54396
       54249
        
              isLibrary = true;

     

       54397
       54250
        
              isExecutable = true;

     

       54398
       54251
        
              libraryHaskellDepends = [

     
···

       54491
       54344
        
            }) {};

     

       54492
       54345
        
       

     

       54493
       54346
        
         "chimera" = callPackage

     

       54494
       54494
       -
           ({ mkDerivation, adjunctions, base, distributive, gauge, mtl

     

       54495
       54495
       -
            , QuickCheck, random, tasty, tasty-hunit, tasty-quickcheck

     

       54496
       54496
       -
            , tasty-smallcheck, vector

     

       54497
       54497
       -
            }:

     

       54498
       54498
       -
            mkDerivation {

     

       54499
       54499
       -
              pname = "chimera";

     

       54500
       54500
       -
              version = "0.3.1.0";

     

       54501
       54501
       -
              sha256 = "09dk9x2har2k6apm1wlm2k5k97jf3qxy4rzx94rbfmhs5fhz0i99";

     

       54502
       54502
       -
              libraryHaskellDepends = [

     

       54503
       54503
       -
                adjunctions base distributive mtl vector

     

       54504
       54504
       -
              ];

     

       54505
       54505
       -
              testHaskellDepends = [

     

       54506
       54506
       -
                base QuickCheck tasty tasty-hunit tasty-quickcheck tasty-smallcheck

     

       54507
       54507
       -
                vector

     

       54508
       54508
       -
              ];

     

       54509
       54509
       -
              benchmarkHaskellDepends = [ base gauge mtl random ];

     

       54510
       54510
       -
              description = "Lazy infinite streams with O(1) indexing";

     

       54511
       54511
       -
              license = lib.licenses.bsd3;

     

       54512
       54512
       -
            }) {};

     

       54513
       54513
       -
       

     

       54514
       54514
       -
         "chimera_0_3_2_0" = callPackage

     

       54515
       54347
        
           ({ mkDerivation, adjunctions, base, distributive, mtl, QuickCheck

     

       54516
       54348
        
            , random, tasty, tasty-bench, tasty-hunit, tasty-quickcheck

     

       54517
       54349
        
            , tasty-smallcheck, vector

     
···

       54530
       54362
        
              benchmarkHaskellDepends = [ base mtl random tasty-bench ];

     

       54531
       54363
        
              description = "Lazy infinite streams with O(1) indexing and applications for memoization";

     

       54532
       54364
        
              license = lib.licenses.bsd3;

     

       54533
       54533
       -
              hydraPlatforms = lib.platforms.none;

     

       54534
       54365
        
            }) {};

     

       54535
       54366
        
       

     

       54536
       54367
        
         "chiphunk" = callPackage

     
···

       55475
       55306
        
              benchmarkHaskellDepends = [ base criterion vector ];

     

       55476
       55307
        
              description = "Circular fixed-sized mutable vectors";

     

       55477
       55308
        
              license = lib.licenses.bsd3;

     

       55478
       55478
       -
              hydraPlatforms = lib.platforms.none;

     

       55479
       55479
       -
              broken = true;

     

       55480
       55309
        
            }) {};

     

       55481
       55310
        
       

     

       55482
       55311
        
         "circus" = callPackage

     
···

       55959
       55788
        
            }:

     

       55960
       55789
        
            mkDerivation {

     

       55961
       55790
        
              pname = "clash-ghc";

     

       55962
       55962
       -
              version = "1.4.2";

     

       55963
       55963
       -
              sha256 = "04sj88mcxszgbr8rxnrwa48r2pkf7h612507gcyk131f5kf6mkss";

     

       55964
       55964
       -
              isLibrary = true;

     

       55965
       55965
       -
              isExecutable = true;

     

       55966
       55966
       -
              libraryHaskellDepends = [

     

       55967
       55967
       -
                array base bifunctors bytestring Cabal clash-lib clash-prelude

     

       55968
       55968
       -
                concurrent-supply containers deepseq directory exceptions extra

     

       55969
       55969
       -
                filepath ghc ghc-boot ghc-prim ghc-typelits-extra

     

       55970
       55970
       -
                ghc-typelits-knownnat ghc-typelits-natnormalise ghci hashable

     

       55971
       55971
       -
                haskeline integer-gmp lens mtl primitive process reflection split

     

       55972
       55972
       -
                template-haskell text time transformers uniplate unix

     

       55973
       55973
       -
                unordered-containers utf8-string vector

     

       55974
       55974
       -
              ];

     

       55975
       55975
       -
              executableHaskellDepends = [ base ];

     

       55976
       55976
       -
              description = "Clash: a functional hardware description language - GHC frontend";

     

       55977
       55977
       -
              license = lib.licenses.bsd2;

     

       55978
       55978
       -
              hydraPlatforms = lib.platforms.none;

     

       55979
       55979
       -
            }) {};

     

       55980
       55980
       -
       

     

       55981
       55981
       -
         "clash-ghc_1_4_3" = callPackage

     

       55982
       55982
       -
           ({ mkDerivation, array, base, bifunctors, bytestring, Cabal

     

       55983
       55983
       -
            , clash-lib, clash-prelude, concurrent-supply, containers, deepseq

     

       55984
       55984
       -
            , directory, exceptions, extra, filepath, ghc, ghc-boot, ghc-prim

     

       55985
       55985
       -
            , ghc-typelits-extra, ghc-typelits-knownnat

     

       55986
       55986
       -
            , ghc-typelits-natnormalise, ghci, hashable, haskeline, integer-gmp

     

       55987
       55987
       -
            , lens, mtl, primitive, process, reflection, split

     

       55988
       55988
       -
            , template-haskell, text, time, transformers, uniplate, unix

     

       55989
       55989
       -
            , unordered-containers, utf8-string, vector

     

       55990
       55990
       -
            }:

     

       55991
       55991
       -
            mkDerivation {

     

       55992
       55992
       -
              pname = "clash-ghc";

     

       55993
       55791
        
              version = "1.4.3";

     

       55994
       55792
        
              sha256 = "00ipx45s2qdjv5cj6v3cg7dgwsw3sd8ai3cr1q9n1k6g26dzc3pw";

     

       55995
       55793
        
              isLibrary = true;

     
···

       56026
       55824
        
            }:

     

       56027
       55825
        
            mkDerivation {

     

       56028
       55826
        
              pname = "clash-lib";

     

       56029
       56029
       -
              version = "1.4.2";

     

       56030
       56030
       -
              sha256 = "1gismfz0pahhgfgra8kn34i3g82ip5nfy9aj38ym3rcnpg4aw10m";

     

       56031
       56031
       -
              enableSeparateDataOutput = true;

     

       56032
       56032
       -
              libraryHaskellDepends = [

     

       56033
       56033
       -
                aeson aeson-pretty ansi-terminal array attoparsec base

     

       56034
       56034
       -
                base16-bytestring binary bytestring clash-prelude concurrent-supply

     

       56035
       56035
       -
                containers cryptohash-sha256 data-binary-ieee754 data-default

     

       56036
       56036
       -
                deepseq directory dlist errors exceptions extra filepath ghc

     

       56037
       56037
       -
                ghc-boot-th hashable haskell-src-meta hint integer-gmp interpolate

     

       56038
       56038
       -
                lens mtl ordered-containers parsers pretty-show prettyprinter

     

       56039
       56039
       -
                primitive process reducers template-haskell temporary terminal-size

     

       56040
       56040
       -
                text text-show time transformers trifecta unordered-containers

     

       56041
       56041
       -
                utf8-string vector vector-binary-instances

     

       56042
       56042
       -
              ];

     

       56043
       56043
       -
              testHaskellDepends = [

     

       56044
       56044
       -
                aeson aeson-pretty base base16-bytestring bytestring clash-prelude

     

       56045
       56045
       -
                concurrent-supply containers data-default deepseq ghc

     

       56046
       56046
       -
                ghc-typelits-knownnat haskell-src-exts lens pretty-show

     

       56047
       56047
       -
                quickcheck-text tasty tasty-hunit tasty-quickcheck template-haskell

     

       56048
       56048
       -
                text transformers unordered-containers

     

       56049
       56049
       -
              ];

     

       56050
       56050
       -
              description = "Clash: a functional hardware description language - As a library";

     

       56051
       56051
       -
              license = lib.licenses.bsd2;

     

       56052
       56052
       -
              hydraPlatforms = lib.platforms.none;

     

       56053
       56053
       -
            }) {};

     

       56054
       56054
       -
       

     

       56055
       56055
       -
         "clash-lib_1_4_3" = callPackage

     

       56056
       56056
       -
           ({ mkDerivation, aeson, aeson-pretty, ansi-terminal, array

     

       56057
       56057
       -
            , attoparsec, base, base16-bytestring, binary, bytestring

     

       56058
       56058
       -
            , clash-prelude, concurrent-supply, containers, cryptohash-sha256

     

       56059
       56059
       -
            , data-binary-ieee754, data-default, deepseq, directory, dlist

     

       56060
       56060
       -
            , errors, exceptions, extra, filepath, ghc, ghc-boot-th

     

       56061
       56061
       -
            , ghc-typelits-knownnat, hashable, haskell-src-exts

     

       56062
       56062
       -
            , haskell-src-meta, hint, integer-gmp, interpolate, lens, mtl

     

       56063
       56063
       -
            , ordered-containers, parsers, pretty-show, prettyprinter

     

       56064
       56064
       -
            , primitive, process, quickcheck-text, reducers, tasty, tasty-hunit

     

       56065
       56065
       -
            , tasty-quickcheck, template-haskell, temporary, terminal-size

     

       56066
       56066
       -
            , text, text-show, time, transformers, trifecta

     

       56067
       56067
       -
            , unordered-containers, utf8-string, vector

     

       56068
       56068
       -
            , vector-binary-instances

     

       56069
       56069
       -
            }:

     

       56070
       56070
       -
            mkDerivation {

     

       56071
       56071
       -
              pname = "clash-lib";

     

       56072
       55827
        
              version = "1.4.3";

     

       56073
       55828
        
              sha256 = "0p6sf9wn25i1f0isqskpy35x6qm2ym63x9fpb54kbd1pp9xqgysl";

     

       56074
       55829
        
              enableSeparateDataOutput = true;

     
···

       56125
       55880
        
            }:

     

       56126
       55881
        
            mkDerivation {

     

       56127
       55882
        
              pname = "clash-prelude";

     

       56128
       56128
       -
              version = "1.4.2";

     

       56129
       56129
       -
              sha256 = "04hshjdddd9sk697zvbwlq6cdvyvdfrw670ksfdxxgssyrcsid95";

     

       56130
       56130
       -
              setupHaskellDepends = [ base Cabal cabal-doctest ];

     

       56131
       56131
       -
              libraryHaskellDepends = [

     

       56132
       56132
       -
                array arrows base bifunctors binary bytestring constraints

     

       56133
       56133
       -
                containers data-binary-ieee754 data-default-class deepseq ghc-prim

     

       56134
       56134
       -
                ghc-typelits-extra ghc-typelits-knownnat ghc-typelits-natnormalise

     

       56135
       56135
       -
                half hashable integer-gmp interpolate lens QuickCheck

     

       56136
       56136
       -
                recursion-schemes reflection singletons template-haskell text

     

       56137
       56137
       -
                text-show th-abstraction th-lift th-orphans time transformers

     

       56138
       56138
       -
                type-errors uniplate vector

     

       56139
       56139
       -
              ];

     

       56140
       56140
       -
              testHaskellDepends = [

     

       56141
       56141
       -
                base deepseq doctest ghc-typelits-extra ghc-typelits-knownnat

     

       56142
       56142
       -
                ghc-typelits-natnormalise hedgehog hint quickcheck-classes-base

     

       56143
       56143
       -
                tasty tasty-hedgehog tasty-hunit tasty-quickcheck tasty-th

     

       56144
       56144
       -
                template-haskell

     

       56145
       56145
       -
              ];

     

       56146
       56146
       -
              benchmarkHaskellDepends = [

     

       56147
       56147
       -
                base criterion deepseq template-haskell

     

       56148
       56148
       -
              ];

     

       56149
       56149
       -
              description = "Clash: a functional hardware description language - Prelude library";

     

       56150
       56150
       -
              license = lib.licenses.bsd2;

     

       56151
       56151
       -
              hydraPlatforms = lib.platforms.none;

     

       56152
       56152
       -
              broken = true;

     

       56153
       56153
       -
            }) {};

     

       56154
       56154
       -
       

     

       56155
       56155
       -
         "clash-prelude_1_4_3" = callPackage

     

       56156
       56156
       -
           ({ mkDerivation, array, arrows, base, bifunctors, binary

     

       56157
       56157
       -
            , bytestring, Cabal, cabal-doctest, constraints, containers

     

       56158
       56158
       -
            , criterion, data-binary-ieee754, data-default-class, deepseq

     

       56159
       56159
       -
            , doctest, ghc-prim, ghc-typelits-extra, ghc-typelits-knownnat

     

       56160
       56160
       -
            , ghc-typelits-natnormalise, half, hashable, hedgehog, hint

     

       56161
       56161
       -
            , integer-gmp, interpolate, lens, QuickCheck

     

       56162
       56162
       -
            , quickcheck-classes-base, recursion-schemes, reflection

     

       56163
       56163
       -
            , singletons, tasty, tasty-hedgehog, tasty-hunit, tasty-quickcheck

     

       56164
       56164
       -
            , tasty-th, template-haskell, text, text-show, th-abstraction

     

       56165
       56165
       -
            , th-lift, th-orphans, time, transformers, type-errors, uniplate

     

       56166
       56166
       -
            , vector

     

       56167
       56167
       -
            }:

     

       56168
       56168
       -
            mkDerivation {

     

       56169
       56169
       -
              pname = "clash-prelude";

     

       56170
       55883
        
              version = "1.4.3";

     

       56171
       55884
        
              sha256 = "07mdl3196yb971hpcbysyaj6vciyrm1p5m9prcymkhkqh7vw9igy";

     

       56172
       55885
        
              setupHaskellDepends = [ base Cabal cabal-doctest ];

     
···

       56207
       55920
        
              hydraPlatforms = lib.platforms.none;

     

       56208
       55921
        
            }) {};

     

       56209
       55922
        
       

     

       55923
       55923
       +
         "clash-shake" = callPackage

     

       55924
       55924
       +
           ({ mkDerivation, aeson, base, bytestring, clash-ghc, clash-lib

     

       55925
       55925
       +
            , clash-prelude, directory, ghc-typelits-extra

     

       55926
       55926
       +
            , ghc-typelits-knownnat, ghc-typelits-natnormalise, shake, split

     

       55927
       55927
       +
            , stache, text, unordered-containers

     

       55928
       55928
       +
            }:

     

       55929
       55929
       +
            mkDerivation {

     

       55930
       55930
       +
              pname = "clash-shake";

     

       55931
       55931
       +
              version = "0.1.0";

     

       55932
       55932
       +
              sha256 = "0zjlbi8p0wxaxgfxhljbp9vzhki3ll8g1qqv3gghqkh7cym73kgq";

     

       55933
       55933
       +
              libraryHaskellDepends = [

     

       55934
       55934
       +
                aeson base bytestring clash-ghc clash-lib clash-prelude directory

     

       55935
       55935
       +
                ghc-typelits-extra ghc-typelits-knownnat ghc-typelits-natnormalise

     

       55936
       55936
       +
                shake split stache text unordered-containers

     

       55937
       55937
       +
              ];

     

       55938
       55938
       +
              description = "Shake rules for building Clash programs";

     

       55939
       55939
       +
              license = lib.licenses.mit;

     

       55940
       55940
       +
              hydraPlatforms = lib.platforms.none;

     

       55941
       55941
       +
            }) {};

     

       55942
       55942
       +
       

     

       56210
       55943
        
         "clash-systemverilog" = callPackage

     

       56211
       55944
        
           ({ mkDerivation, base, clash-lib, clash-prelude, fgl, hashable

     

       56212
       55945
        
            , lens, mtl, text, unordered-containers, wl-pprint-text

     
···

       56258
       55991
        
              ];

     

       56259
       55992
        
              description = "CAES Language for Synchronous Hardware - VHDL backend";

     

       56260
       55993
        
              license = lib.licenses.bsd2;

     

       55994
       55994
       +
              hydraPlatforms = lib.platforms.none;

     

       55995
       55995
       +
            }) {};

     

       55996
       55996
       +
       

     

       55997
       55997
       +
         "clashilator" = callPackage

     

       55998
       55998
       +
           ({ mkDerivation, aeson, base, Cabal, clash-ghc, clash-lib

     

       55999
       55999
       +
            , containers, filepath, ghc, lens, optparse-applicative, shake

     

       56000
       56000
       +
            , stache, text, unordered-containers

     

       56001
       56001
       +
            }:

     

       56002
       56002
       +
            mkDerivation {

     

       56003
       56003
       +
              pname = "clashilator";

     

       56004
       56004
       +
              version = "0.1.0";

     

       56005
       56005
       +
              sha256 = "0nlyjhf4vy5ypimdv3ac9qw9aljm2k99y42b2pkhhw84iblv4qgy";

     

       56006
       56006
       +
              isLibrary = true;

     

       56007
       56007
       +
              isExecutable = true;

     

       56008
       56008
       +
              libraryHaskellDepends = [

     

       56009
       56009
       +
                aeson base Cabal clash-ghc clash-lib containers filepath ghc lens

     

       56010
       56010
       +
                optparse-applicative shake stache text unordered-containers

     

       56011
       56011
       +
              ];

     

       56012
       56012
       +
              executableHaskellDepends = [

     

       56013
       56013
       +
                aeson base Cabal clash-ghc clash-lib containers filepath ghc lens

     

       56014
       56014
       +
                optparse-applicative shake stache text unordered-containers

     

       56015
       56015
       +
              ];

     

       56016
       56016
       +
              description = "Automated Clash to Verilator bridge";

     

       56017
       56017
       +
              license = lib.licenses.mit;

     

       56261
       56018
        
              hydraPlatforms = lib.platforms.none;

     

       56262
       56019
        
            }) {};

     

       56263
       56020
        
       

     
···

       58186
       57943
        
           ({ mkDerivation, base, co-log-core, stm }:

     

       58187
       57944
        
            mkDerivation {

     

       58188
       57945
        
              pname = "co-log-concurrent";

     

       58189
       58189
       -
              version = "0.5.0.0";

     

       58190
       58190
       -
              sha256 = "07z4aklk7dc2fhbc30kd9hbdvq71sa4ip6r2pyifcpn3p2pr3mna";

     

       58191
       58191
       -
              libraryHaskellDepends = [ base co-log-core stm ];

     

       58192
       58192
       -
              description = "Asynchronous backend for co-log library";

     

       58193
       58193
       -
              license = lib.licenses.mpl20;

     

       58194
       58194
       -
            }) {};

     

       58195
       58195
       -
       

     

       58196
       58196
       -
         "co-log-concurrent_0_5_1_0" = callPackage

     

       58197
       58197
       -
           ({ mkDerivation, base, co-log-core, stm }:

     

       58198
       58198
       -
            mkDerivation {

     

       58199
       58199
       -
              pname = "co-log-concurrent";

     

       58200
       57946
        
              version = "0.5.1.0";

     

       58201
       57947
        
              sha256 = "07qmx9z03vmgq2cgz4352fsav7r1nx8n7svmrhg2lkdiyp0j7a59";

     

       58202
       57948
        
              libraryHaskellDepends = [ base co-log-core stm ];

     

       58203
       57949
        
              description = "Asynchronous backend for co-log library";

     

       58204
       57950
        
              license = lib.licenses.mpl20;

     

       58205
       58205
       -
              hydraPlatforms = lib.platforms.none;

     

       58206
       57951
        
            }) {};

     

       58207
       57952
        
       

     

       58208
       57953
        
         "co-log-core" = callPackage

     
···

       58722
       58467
        
           ({ mkDerivation, base, profunctors }:

     

       58723
       58468
        
            mkDerivation {

     

       58724
       58469
        
              pname = "coercible-subtypes";

     

       58725
       58725
       -
              version = "0.1.0.0";

     

       58726
       58726
       -
              sha256 = "1z5fmdgv52x410x2z4gxyac18f98226dymzdvhcvkx7mw2k9q44x";

     

       58727
       58727
       -
              revision = "1";

     

       58728
       58728
       -
              editedCabalFile = "05bd9lp5jp31ac039vq0p58kr03g5ai3cyymc4ikhbnl3x44hx4d";

     

       58470
       58470
       +
              version = "0.1.1.0";

     

       58471
       58471
       +
              sha256 = "1q6a38y49a31vl19i5c5kym36fjxspxj6vfi0b35j4gb9b7r642r";

     

       58729
       58472
        
              libraryHaskellDepends = [ base profunctors ];

     

       58730
       58473
        
              description = "Coercible but only in one direction";

     

       58731
       58474
        
              license = lib.licenses.bsd3;

     
···

       61424
       61167
        
            }:

     

       61425
       61168
        
            mkDerivation {

     

       61426
       61169
        
              pname = "concurrency";

     

       61427
       61427
       -
              version = "1.11.0.1";

     

       61428
       61428
       -
              sha256 = "0ds55wpkxlrw2x5ql34p9b05xlycnc4v7962f27a54nhrjfhb2ah";

     

       61429
       61429
       -
              libraryHaskellDepends = [

     

       61430
       61430
       -
                array atomic-primops base exceptions monad-control mtl stm

     

       61431
       61431
       -
                transformers

     

       61432
       61432
       -
              ];

     

       61433
       61433
       -
              description = "Typeclasses, functions, and data types for concurrency and STM";

     

       61434
       61434
       -
              license = lib.licenses.mit;

     

       61435
       61435
       -
            }) {};

     

       61436
       61436
       -
       

     

       61437
       61437
       -
         "concurrency_1_11_0_2" = callPackage

     

       61438
       61438
       -
           ({ mkDerivation, array, atomic-primops, base, exceptions

     

       61439
       61439
       -
            , monad-control, mtl, stm, transformers

     

       61440
       61440
       -
            }:

     

       61441
       61441
       -
            mkDerivation {

     

       61442
       61442
       -
              pname = "concurrency";

     

       61443
       61170
        
              version = "1.11.0.2";

     

       61444
       61171
        
              sha256 = "0c7nq4d29s49a3h9wzjdi3idm6r68vxn6ybphsbrk2vmwqyfq36y";

     

       61445
       61172
        
              libraryHaskellDepends = [

     
···

       61448
       61175
        
              ];

     

       61449
       61176
        
              description = "Typeclasses, functions, and data types for concurrency and STM";

     

       61450
       61177
        
              license = lib.licenses.mit;

     

       61451
       61451
       -
              hydraPlatforms = lib.platforms.none;

     

       61452
       61178
        
            }) {};

     

       61453
       61179
        
       

     

       61454
       61180
        
         "concurrency-benchmarks" = callPackage

     
···

       65811
       65537
        
              description = "Crack various integer, floating-point data formats";

     

       65812
       65538
        
              license = lib.licenses.bsd3;

     

       65813
       65539
        
              platforms = [

     

       65814
       65814
       -
                "armv7l-linux" "i686-linux" "x86_64-darwin" "x86_64-linux"

     

       65540
       65540
       +
                "aarch64-darwin" "armv7l-linux" "i686-linux" "x86_64-darwin"

     

       65541
       65541
       +
                "x86_64-linux"

     

       65815
       65542
        
              ];

     

       65816
       65543
        
              hydraPlatforms = lib.platforms.none;

     

       65817
       65544
        
            }) {};

     
···

       65832
       65559
        
              description = "Crack various integer and floating-point data formats";

     

       65833
       65560
        
              license = lib.licenses.bsd3;

     

       65834
       65561
        
              platforms = [

     

       65835
       65835
       -
                "armv7l-linux" "i686-linux" "x86_64-darwin" "x86_64-linux"

     

       65562
       65562
       +
                "aarch64-darwin" "armv7l-linux" "i686-linux" "x86_64-darwin"

     

       65563
       65563
       +
                "x86_64-linux"

     

       65836
       65564
        
              ];

     

       65837
       65565
        
            }) {};

     

       65838
       65566
        
       

     
···

       65852
       65580
        
              description = "Crack various integer and floating-point data formats";

     

       65853
       65581
        
              license = lib.licenses.bsd3;

     

       65854
       65582
        
              platforms = [

     

       65855
       65855
       -
                "armv7l-linux" "i686-linux" "x86_64-darwin" "x86_64-linux"

     

       65583
       65583
       +
                "aarch64-darwin" "armv7l-linux" "i686-linux" "x86_64-darwin"

     

       65584
       65584
       +
                "x86_64-linux"

     

       65856
       65585
        
              ];

     

       65857
       65586
        
              hydraPlatforms = lib.platforms.none;

     

       65858
       65587
        
            }) {};

     
···

       66094
       65823
        
            }:

     

       66095
       65824
        
            mkDerivation {

     

       66096
       65825
        
              pname = "creatur";

     

       66097
       66097
       -
              version = "5.9.28";

     

       66098
       66098
       -
              sha256 = "11fscbkzyzajgg6m50s5x4rmxy1mxrgiqflamqxiwsyj9szw16xl";

     

       65826
       65826
       +
              version = "5.9.30";

     

       65827
       65827
       +
              sha256 = "1zxg8zkm1n78c80z6xqnnx6x8jzpfx0lfdjn26i9p3rr3wd78bf3";

     

       66099
       65828
        
              libraryHaskellDepends = [

     

       66100
       65829
        
                array base binary bytestring cereal cond directory exceptions

     

       66101
       65830
        
                filepath gray-extended hdaemonize hsyslog MonadRandom mtl random

     
···

       66323
       66052
        
              license = lib.licenses.bsd3;

     

       66324
       66053
        
            }) {};

     

       66325
       66054
        
       

     

       66055
       66055
       +
         "criterion_1_5_10_0" = callPackage

     

       66056
       66056
       +
           ({ mkDerivation, aeson, ansi-wl-pprint, base, base-compat

     

       66057
       66057
       +
            , base-compat-batteries, binary, binary-orphans, bytestring

     

       66058
       66058
       +
            , cassava, code-page, containers, criterion-measurement, deepseq

     

       66059
       66059
       +
            , directory, exceptions, filepath, Glob, HUnit, js-chart

     

       66060
       66060
       +
            , microstache, mtl, mwc-random, optparse-applicative, parsec

     

       66061
       66061
       +
            , QuickCheck, statistics, tasty, tasty-hunit, tasty-quickcheck

     

       66062
       66062
       +
            , text, time, transformers, transformers-compat, vector

     

       66063
       66063
       +
            , vector-algorithms

     

       66064
       66064
       +
            }:

     

       66065
       66065
       +
            mkDerivation {

     

       66066
       66066
       +
              pname = "criterion";

     

       66067
       66067
       +
              version = "1.5.10.0";

     

       66068
       66068
       +
              sha256 = "0akws27z3i9381xrb0p0h5qicz4w5nnxy8jq7gk68gi50gj0flxq";

     

       66069
       66069
       +
              isLibrary = true;

     

       66070
       66070
       +
              isExecutable = true;

     

       66071
       66071
       +
              enableSeparateDataOutput = true;

     

       66072
       66072
       +
              libraryHaskellDepends = [

     

       66073
       66073
       +
                aeson ansi-wl-pprint base base-compat-batteries binary

     

       66074
       66074
       +
                binary-orphans bytestring cassava code-page containers

     

       66075
       66075
       +
                criterion-measurement deepseq directory exceptions filepath Glob

     

       66076
       66076
       +
                js-chart microstache mtl mwc-random optparse-applicative parsec

     

       66077
       66077
       +
                statistics text time transformers transformers-compat vector

     

       66078
       66078
       +
                vector-algorithms

     

       66079
       66079
       +
              ];

     

       66080
       66080
       +
              executableHaskellDepends = [

     

       66081
       66081
       +
                base base-compat-batteries optparse-applicative

     

       66082
       66082
       +
              ];

     

       66083
       66083
       +
              testHaskellDepends = [

     

       66084
       66084
       +
                aeson base base-compat base-compat-batteries bytestring deepseq

     

       66085
       66085
       +
                directory HUnit QuickCheck statistics tasty tasty-hunit

     

       66086
       66086
       +
                tasty-quickcheck vector

     

       66087
       66087
       +
              ];

     

       66088
       66088
       +
              description = "Robust, reliable performance measurement and analysis";

     

       66089
       66089
       +
              license = lib.licenses.bsd3;

     

       66090
       66090
       +
              hydraPlatforms = lib.platforms.none;

     

       66091
       66091
       +
            }) {};

     

       66092
       66092
       +
       

     

       66326
       66093
        
         "criterion-cmp" = callPackage

     

       66327
       66094
        
           ({ mkDerivation, ansi-terminal, base, boxes, bytestring, cassava

     

       66328
       66095
        
            , containers, filepath, optparse-applicative, vector

     
···

       73186
       72953
        
            }:

     

       73187
       72954
        
            mkDerivation {

     

       73188
       72955
        
              pname = "dejafu";

     

       73189
       73189
       -
              version = "2.4.0.2";

     

       73190
       73190
       -
              sha256 = "1hwhyxjjwapk6jgsbs0vh033xbc9b8mr5iqd93vskvvljnb40v9h";

     

       73191
       73191
       -
              libraryHaskellDepends = [

     

       73192
       73192
       -
                base concurrency containers contravariant deepseq exceptions

     

       73193
       73193
       -
                leancheck profunctors random transformers

     

       73194
       73194
       -
              ];

     

       73195
       73195
       -
              description = "A library for unit-testing concurrent programs";

     

       73196
       73196
       -
              license = lib.licenses.mit;

     

       73197
       73197
       -
            }) {};

     

       73198
       73198
       -
       

     

       73199
       73199
       -
         "dejafu_2_4_0_3" = callPackage

     

       73200
       73200
       -
           ({ mkDerivation, base, concurrency, containers, contravariant

     

       73201
       73201
       -
            , deepseq, exceptions, leancheck, profunctors, random, transformers

     

       73202
       73202
       -
            }:

     

       73203
       73203
       -
            mkDerivation {

     

       73204
       73204
       -
              pname = "dejafu";

     

       73205
       72956
        
              version = "2.4.0.3";

     

       73206
       72957
        
              sha256 = "1qzc8jbl6zwbncfmfmcwwmmhwzgbwc7wmnxxxa3mbcjbwhyibf92";

     

       73207
       72958
        
              libraryHaskellDepends = [

     
···

       73210
       72961
        
              ];

     

       73211
       72962
        
              description = "A library for unit-testing concurrent programs";

     

       73212
       72963
        
              license = lib.licenses.mit;

     

       73213
       73213
       -
              hydraPlatforms = lib.platforms.none;

     

       73214
       72964
        
            }) {};

     

       73215
       72965
        
       

     

       73216
       72966
        
         "deka" = callPackage

     
···

       74686
       74436
        
              maintainers = with lib.maintainers; [ Gabriel439 ];

     

       74687
       74437
        
            }) {};

     

       74688
       74438
        
       

     

       74439
       74439
       +
         "dhall_1_40_0" = callPackage

     

       74440
       74440
       +
           ({ mkDerivation, aeson, aeson-pretty, ansi-terminal, atomic-write

     

       74441
       74441
       +
            , base, bytestring, case-insensitive, cborg, cborg-json, containers

     

       74442
       74442
       +
            , contravariant, cryptonite, data-fix, deepseq, Diff, directory

     

       74443
       74443
       +
            , doctest, dotgen, either, exceptions, filepath, foldl, gauge

     

       74444
       74444
       +
            , generic-random, half, hashable, haskeline, http-client

     

       74445
       74445
       +
            , http-client-tls, http-types, lens-family-core, megaparsec, memory

     

       74446
       74446
       +
            , mmorph, mockery, mtl, network-uri, optparse-applicative

     

       74447
       74447
       +
            , parser-combinators, parsers, pretty-simple, prettyprinter

     

       74448
       74448
       +
            , prettyprinter-ansi-terminal, profunctors, QuickCheck

     

       74449
       74449
       +
            , quickcheck-instances, repline, scientific, serialise

     

       74450
       74450
       +
            , special-values, spoon, tasty, tasty-expected-failure, tasty-hunit

     

       74451
       74451
       +
            , tasty-quickcheck, tasty-silver, template-haskell, temporary, text

     

       74452
       74452
       +
            , text-manipulate, th-lift-instances, time, transformers, turtle

     

       74453
       74453
       +
            , unordered-containers, uri-encode, vector

     

       74454
       74454
       +
            }:

     

       74455
       74455
       +
            mkDerivation {

     

       74456
       74456
       +
              pname = "dhall";

     

       74457
       74457
       +
              version = "1.40.0";

     

       74458
       74458
       +
              sha256 = "1a5hvfrygk9y9jlldyrbhfv9nzl03s6lqlmzf5dkwycwmfb7cc66";

     

       74459
       74459
       +
              isLibrary = true;

     

       74460
       74460
       +
              isExecutable = true;

     

       74461
       74461
       +
              enableSeparateDataOutput = true;

     

       74462
       74462
       +
              libraryHaskellDepends = [

     

       74463
       74463
       +
                aeson aeson-pretty ansi-terminal atomic-write base bytestring

     

       74464
       74464
       +
                case-insensitive cborg cborg-json containers contravariant

     

       74465
       74465
       +
                cryptonite data-fix deepseq Diff directory dotgen either exceptions

     

       74466
       74466
       +
                filepath half hashable haskeline http-client http-client-tls

     

       74467
       74467
       +
                http-types lens-family-core megaparsec memory mmorph mtl

     

       74468
       74468
       +
                network-uri optparse-applicative parser-combinators parsers

     

       74469
       74469
       +
                pretty-simple prettyprinter prettyprinter-ansi-terminal profunctors

     

       74470
       74470
       +
                repline scientific serialise template-haskell text text-manipulate

     

       74471
       74471
       +
                th-lift-instances time transformers unordered-containers uri-encode

     

       74472
       74472
       +
                vector

     

       74473
       74473
       +
              ];

     

       74474
       74474
       +
              executableHaskellDepends = [ base ];

     

       74475
       74475
       +
              testHaskellDepends = [

     

       74476
       74476
       +
                base bytestring cborg containers data-fix deepseq directory doctest

     

       74477
       74477
       +
                either filepath foldl generic-random http-client http-client-tls

     

       74478
       74478
       +
                lens-family-core megaparsec mockery prettyprinter QuickCheck

     

       74479
       74479
       +
                quickcheck-instances scientific serialise special-values spoon

     

       74480
       74480
       +
                tasty tasty-expected-failure tasty-hunit tasty-quickcheck

     

       74481
       74481
       +
                tasty-silver template-haskell temporary text time transformers

     

       74482
       74482
       +
                turtle unordered-containers vector

     

       74483
       74483
       +
              ];

     

       74484
       74484
       +
              benchmarkHaskellDepends = [

     

       74485
       74485
       +
                base bytestring containers directory gauge text

     

       74486
       74486
       +
              ];

     

       74487
       74487
       +
              doCheck = false;

     

       74488
       74488
       +
              description = "A configuration language guaranteed to terminate";

     

       74489
       74489
       +
              license = lib.licenses.bsd3;

     

       74490
       74490
       +
              hydraPlatforms = lib.platforms.none;

     

       74491
       74491
       +
              maintainers = with lib.maintainers; [ Gabriel439 ];

     

       74492
       74492
       +
            }) {};

     

       74493
       74493
       +
       

     

       74689
       74494
        
         "dhall-bash" = callPackage

     

       74690
       74495
        
           ({ mkDerivation, base, bytestring, containers, dhall

     

       74691
       74496
        
            , neat-interpolation, optparse-generic, shell-escape, text

     
···

       74708
       74513
        
              maintainers = with lib.maintainers; [ Gabriel439 ];

     

       74709
       74514
        
            }) {};

     

       74710
       74515
        
       

     

       74516
       74516
       +
         "dhall-bash_1_0_38" = callPackage

     

       74517
       74517
       +
           ({ mkDerivation, base, bytestring, containers, dhall

     

       74518
       74518
       +
            , neat-interpolation, optparse-generic, shell-escape, text

     

       74519
       74519
       +
            }:

     

       74520
       74520
       +
            mkDerivation {

     

       74521
       74521
       +
              pname = "dhall-bash";

     

       74522
       74522
       +
              version = "1.0.38";

     

       74523
       74523
       +
              sha256 = "0pfwqz4l3nn4mr16pv5703j517g3nsgzpmiv18kzl4fs6141d881";

     

       74524
       74524
       +
              isLibrary = true;

     

       74525
       74525
       +
              isExecutable = true;

     

       74526
       74526
       +
              libraryHaskellDepends = [

     

       74527
       74527
       +
                base bytestring containers dhall neat-interpolation shell-escape

     

       74528
       74528
       +
                text

     

       74529
       74529
       +
              ];

     

       74530
       74530
       +
              executableHaskellDepends = [

     

       74531
       74531
       +
                base bytestring dhall optparse-generic text

     

       74532
       74532
       +
              ];

     

       74533
       74533
       +
              description = "Compile Dhall to Bash";

     

       74534
       74534
       +
              license = lib.licenses.bsd3;

     

       74535
       74535
       +
              hydraPlatforms = lib.platforms.none;

     

       74536
       74536
       +
              maintainers = with lib.maintainers; [ Gabriel439 ];

     

       74537
       74537
       +
            }) {};

     

       74538
       74538
       +
       

     

       74711
       74539
        
         "dhall-check" = callPackage

     

       74712
       74540
        
           ({ mkDerivation, base, containers, dhall, directory, filepath

     

       74713
       74541
        
            , fsnotify, text, trifecta

     
···

       74727
       74555
        
              broken = true;

     

       74728
       74556
        
            }) {};

     

       74729
       74557
        
       

     

       74558
       74558
       +
         "dhall-csv" = callPackage

     

       74559
       74559
       +
           ({ mkDerivation, ansi-terminal, base, bytestring, cassava

     

       74560
       74560
       +
            , containers, dhall, either, exceptions, filepath

     

       74561
       74561
       +
            , optparse-applicative, prettyprinter, prettyprinter-ansi-terminal

     

       74562
       74562
       +
            , tasty, tasty-hunit, tasty-silver, text, unordered-containers

     

       74563
       74563
       +
            , vector

     

       74564
       74564
       +
            }:

     

       74565
       74565
       +
            mkDerivation {

     

       74566
       74566
       +
              pname = "dhall-csv";

     

       74567
       74567
       +
              version = "1.0.0";

     

       74568
       74568
       +
              sha256 = "1dg310mq4c00ykkm1vsvrcicls25zbx7iypcg0nqa8ggchac5jmh";

     

       74569
       74569
       +
              isLibrary = true;

     

       74570
       74570
       +
              isExecutable = true;

     

       74571
       74571
       +
              libraryHaskellDepends = [

     

       74572
       74572
       +
                base bytestring cassava containers dhall either exceptions filepath

     

       74573
       74573
       +
                optparse-applicative prettyprinter text unordered-containers vector

     

       74574
       74574
       +
              ];

     

       74575
       74575
       +
              executableHaskellDepends = [

     

       74576
       74576
       +
                ansi-terminal base bytestring cassava dhall optparse-applicative

     

       74577
       74577
       +
                prettyprinter prettyprinter-ansi-terminal text unordered-containers

     

       74578
       74578
       +
                vector

     

       74579
       74579
       +
              ];

     

       74580
       74580
       +
              testHaskellDepends = [

     

       74581
       74581
       +
                base bytestring cassava dhall filepath tasty tasty-hunit

     

       74582
       74582
       +
                tasty-silver text unordered-containers vector

     

       74583
       74583
       +
              ];

     

       74584
       74584
       +
              description = "Convert bidirectionally between Dhall and CSV files";

     

       74585
       74585
       +
              license = lib.licenses.bsd3;

     

       74586
       74586
       +
              hydraPlatforms = lib.platforms.none;

     

       74587
       74587
       +
              broken = true;

     

       74588
       74588
       +
            }) {};

     

       74589
       74589
       +
       

     

       74730
       74590
        
         "dhall-docs" = callPackage

     

       74731
       74591
        
           ({ mkDerivation, base, bytestring, containers, cryptonite, dhall

     

       74732
       74592
        
            , directory, doctest, file-embed, filepath, foldl, hashable

     
···

       74736
       74596
        
            }:

     

       74737
       74597
        
            mkDerivation {

     

       74738
       74598
        
              pname = "dhall-docs";

     

       74739
       74739
       -
              version = "1.0.6";

     

       74740
       74740
       -
              sha256 = "004n8kh8riw67aqwp6z9199jwv2c9r1dbkg92s71vd9zc04wxljv";

     

       74741
       74741
       -
              revision = "2";

     

       74742
       74742
       -
              editedCabalFile = "1z41z96qawc1i818ycp1ycdpxnysynipjjbi1pmrrgglv89hqjlq";

     

       74599
       74599
       +
              version = "1.0.7";

     

       74600
       74600
       +
              sha256 = "1h7bzpp3xa5m8zknhi24q0wh1n6w6z26ka780mdsbmchhhj59njm";

     

       74743
       74601
        
              isLibrary = true;

     

       74744
       74602
        
              isExecutable = true;

     

       74745
       74603
        
              enableSeparateDataOutput = true;

     
···

       74824
       74682
        
              maintainers = with lib.maintainers; [ Gabriel439 ];

     

       74825
       74683
        
            }) {};

     

       74826
       74684
        
       

     

       74685
       74685
       +
         "dhall-json_1_7_8" = callPackage

     

       74686
       74686
       +
           ({ mkDerivation, aeson, aeson-pretty, aeson-yaml, ansi-terminal

     

       74687
       74687
       +
            , base, bytestring, containers, dhall, exceptions, filepath

     

       74688
       74688
       +
            , lens-family-core, optparse-applicative, prettyprinter

     

       74689
       74689
       +
            , prettyprinter-ansi-terminal, scientific, tasty, tasty-hunit

     

       74690
       74690
       +
            , tasty-silver, text, unordered-containers, vector

     

       74691
       74691
       +
            }:

     

       74692
       74692
       +
            mkDerivation {

     

       74693
       74693
       +
              pname = "dhall-json";

     

       74694
       74694
       +
              version = "1.7.8";

     

       74695
       74695
       +
              sha256 = "0g4c71di93r6vnbhajsj5k3ivhzvn0n0aicvvc2j9nbjfhvahd3h";

     

       74696
       74696
       +
              isLibrary = true;

     

       74697
       74697
       +
              isExecutable = true;

     

       74698
       74698
       +
              libraryHaskellDepends = [

     

       74699
       74699
       +
                aeson aeson-pretty aeson-yaml base bytestring containers dhall

     

       74700
       74700
       +
                exceptions filepath lens-family-core optparse-applicative

     

       74701
       74701
       +
                prettyprinter scientific text unordered-containers vector

     

       74702
       74702
       +
              ];

     

       74703
       74703
       +
              executableHaskellDepends = [

     

       74704
       74704
       +
                aeson aeson-pretty ansi-terminal base bytestring dhall exceptions

     

       74705
       74705
       +
                optparse-applicative prettyprinter prettyprinter-ansi-terminal text

     

       74706
       74706
       +
              ];

     

       74707
       74707
       +
              testHaskellDepends = [

     

       74708
       74708
       +
                aeson base bytestring dhall tasty tasty-hunit tasty-silver text

     

       74709
       74709
       +
              ];

     

       74710
       74710
       +
              description = "Convert between Dhall and JSON or YAML";

     

       74711
       74711
       +
              license = lib.licenses.bsd3;

     

       74712
       74712
       +
              hydraPlatforms = lib.platforms.none;

     

       74713
       74713
       +
              maintainers = with lib.maintainers; [ Gabriel439 ];

     

       74714
       74714
       +
            }) {};

     

       74715
       74715
       +
       

     

       74827
       74716
        
         "dhall-lex" = callPackage

     

       74828
       74717
        
           ({ mkDerivation, alex, array, base, bytestring, criterion, deepseq

     

       74829
       74718
        
            , hspec, hspec-dirstream, scientific

     
···

       74875
       74764
        
              maintainers = with lib.maintainers; [ Gabriel439 ];

     

       74876
       74765
        
            }) {};

     

       74877
       74766
        
       

     

       74767
       74767
       +
         "dhall-lsp-server_1_0_16" = callPackage

     

       74768
       74768
       +
           ({ mkDerivation, aeson, aeson-pretty, base, bytestring, containers

     

       74769
       74769
       +
            , data-default, dhall, dhall-json, directory, doctest, filepath

     

       74770
       74770
       +
            , haskell-lsp, haskell-lsp-types, hslogger, hspec, lens, lsp-test

     

       74771
       74771
       +
            , megaparsec, mtl, network-uri, optparse-applicative, prettyprinter

     

       74772
       74772
       +
            , QuickCheck, rope-utf16-splay, tasty, tasty-hspec, text

     

       74773
       74773
       +
            , transformers, unordered-containers, uri-encode

     

       74774
       74774
       +
            }:

     

       74775
       74775
       +
            mkDerivation {

     

       74776
       74776
       +
              pname = "dhall-lsp-server";

     

       74777
       74777
       +
              version = "1.0.16";

     

       74778
       74778
       +
              sha256 = "04s4kvbjp4ai17l64syram0br3qc4fpz669ps24r8fkcbbaczckq";

     

       74779
       74779
       +
              isLibrary = true;

     

       74780
       74780
       +
              isExecutable = true;

     

       74781
       74781
       +
              libraryHaskellDepends = [

     

       74782
       74782
       +
                aeson aeson-pretty base bytestring containers data-default dhall

     

       74783
       74783
       +
                dhall-json directory filepath haskell-lsp hslogger lens megaparsec

     

       74784
       74784
       +
                mtl network-uri prettyprinter rope-utf16-splay text transformers

     

       74785
       74785
       +
                unordered-containers uri-encode

     

       74786
       74786
       +
              ];

     

       74787
       74787
       +
              executableHaskellDepends = [ base optparse-applicative ];

     

       74788
       74788
       +
              testHaskellDepends = [

     

       74789
       74789
       +
                base directory doctest filepath haskell-lsp-types hspec lsp-test

     

       74790
       74790
       +
                QuickCheck tasty tasty-hspec text

     

       74791
       74791
       +
              ];

     

       74792
       74792
       +
              description = "Language Server Protocol (LSP) server for Dhall";

     

       74793
       74793
       +
              license = lib.licenses.mit;

     

       74794
       74794
       +
              hydraPlatforms = lib.platforms.none;

     

       74795
       74795
       +
              maintainers = with lib.maintainers; [ Gabriel439 ];

     

       74796
       74796
       +
            }) {};

     

       74797
       74797
       +
       

     

       74878
       74798
        
         "dhall-nix" = callPackage

     

       74879
       74799
        
           ({ mkDerivation, base, containers, data-fix, dhall, hnix

     

       74880
       74800
        
            , lens-family-core, neat-interpolation, optparse-generic, text

     
···

       74899
       74819
        
              maintainers = with lib.maintainers; [ Gabriel439 ];

     

       74900
       74820
        
            }) {};

     

       74901
       74821
        
       

     

       74822
       74822
       +
         "dhall-nix_1_1_22" = callPackage

     

       74823
       74823
       +
           ({ mkDerivation, base, containers, data-fix, dhall, hnix

     

       74824
       74824
       +
            , lens-family-core, neat-interpolation, optparse-generic, text

     

       74825
       74825
       +
            }:

     

       74826
       74826
       +
            mkDerivation {

     

       74827
       74827
       +
              pname = "dhall-nix";

     

       74828
       74828
       +
              version = "1.1.22";

     

       74829
       74829
       +
              sha256 = "1da64h52fz4imvk7hqblri27zg54r9rcs6hlyzkbnqg4yivpiclg";

     

       74830
       74830
       +
              isLibrary = true;

     

       74831
       74831
       +
              isExecutable = true;

     

       74832
       74832
       +
              libraryHaskellDepends = [

     

       74833
       74833
       +
                base containers data-fix dhall hnix lens-family-core

     

       74834
       74834
       +
                neat-interpolation text

     

       74835
       74835
       +
              ];

     

       74836
       74836
       +
              executableHaskellDepends = [

     

       74837
       74837
       +
                base dhall hnix optparse-generic text

     

       74838
       74838
       +
              ];

     

       74839
       74839
       +
              description = "Dhall to Nix compiler";

     

       74840
       74840
       +
              license = lib.licenses.bsd3;

     

       74841
       74841
       +
              hydraPlatforms = lib.platforms.none;

     

       74842
       74842
       +
              maintainers = with lib.maintainers; [ Gabriel439 ];

     

       74843
       74843
       +
            }) {};

     

       74844
       74844
       +
       

     

       74902
       74845
        
         "dhall-nixpkgs" = callPackage

     

       74903
       74846
        
           ({ mkDerivation, aeson, base, data-fix, dhall, foldl, hnix

     

       74904
       74847
        
            , lens-family-core, megaparsec, mmorph, neat-interpolation

     
···

       74907
       74850
        
            }:

     

       74908
       74851
        
            mkDerivation {

     

       74909
       74852
        
              pname = "dhall-nixpkgs";

     

       74910
       74910
       -
              version = "1.0.5";

     

       74911
       74911
       -
              sha256 = "10gvkw2rdmz7pgr9675xqnhkgi8pwjid77mwsriid81d703z2b6j";

     

       74912
       74912
       -
              revision = "2";

     

       74913
       74913
       -
              editedCabalFile = "1kb2bn9v6p6ma016gaq3332vpcd6rdalrmcvxzzys4vaa0l6nl68";

     

       74853
       74853
       +
              version = "1.0.6";

     

       74854
       74854
       +
              sha256 = "12sfxz7n86m69m1xbnrrr1ybggh70rfwmr4maflq522bhkc2hgvk";

     

       74914
       74855
        
              isLibrary = false;

     

       74915
       74856
        
              isExecutable = true;

     

       74916
       74857
        
              executableHaskellDepends = [

     
···

       74930
       74871
        
            }:

     

       74931
       74872
        
            mkDerivation {

     

       74932
       74873
        
              pname = "dhall-openapi";

     

       74933
       74933
       -
              version = "1.0.1";

     

       74934
       74934
       -
              sha256 = "1n34amb97dqpvz0s3mhqb46gjq1ix1gicsq700z6v6y7xssrgbz2";

     

       74935
       74935
       -
              revision = "1";

     

       74936
       74936
       -
              editedCabalFile = "03axb4pqa5p8fkdqxjz1xni8fxg66xr3pshfs2p3y13bgn0kn5z2";

     

       74874
       74874
       +
              version = "1.0.2";

     

       74875
       74875
       +
              sha256 = "1p678nn1gfj2xp0kmw8i5pzsv6s5bpnsmyng45adb9pnpiyxbcyj";

     

       74937
       74876
        
              isLibrary = true;

     

       74938
       74877
        
              isExecutable = true;

     

       74939
       74878
        
              libraryHaskellDepends = [

     
···

       74958
       74897
        
              pname = "dhall-recursive-adt";

     

       74959
       74898
        
              version = "0.1.0.1";

     

       74960
       74899
        
              sha256 = "09s3m86vflj5im2walab8d0wpvihsvxc5mzy55m10pfzr3gxsd11";

     

       74900
       74900
       +
              revision = "1";

     

       74901
       74901
       +
              editedCabalFile = "0phfa1y6fic6wyvm3bp56z4sj43wbf75rzggzgf763vivlnvc7xw";

     

       74961
       74902
        
              libraryHaskellDepends = [ base data-fix dhall recursion-schemes ];

     

       74962
       74903
        
              testHaskellDepends = [

     

       74963
       74904
        
                base dhall either hedgehog recursion-schemes tasty tasty-hedgehog

     
···

       75013
       74954
        
              ];

     

       75014
       74955
        
              description = "Compile Dhall expressions to Cabal files";

     

       75015
       74956
        
              license = lib.licenses.mit;

     

       74957
       74957
       +
              hydraPlatforms = lib.platforms.none;

     

       74958
       74958
       +
              broken = true;

     

       74959
       74959
       +
            }) {};

     

       74960
       74960
       +
       

     

       74961
       74961
       +
         "dhall-toml" = callPackage

     

       74962
       74962
       +
           ({ mkDerivation, base, containers, dhall, directory, doctest

     

       74963
       74963
       +
            , filepath, prettyprinter, tasty, tasty-hunit, text, tomland

     

       74964
       74964
       +
            , unordered-containers

     

       74965
       74965
       +
            }:

     

       74966
       74966
       +
            mkDerivation {

     

       74967
       74967
       +
              pname = "dhall-toml";

     

       74968
       74968
       +
              version = "1.0.0";

     

       74969
       74969
       +
              sha256 = "13pz6y0l70h3x62wkhay2jiws6s5m6dy9v7kpd2c5mqzaspfy0w2";

     

       74970
       74970
       +
              isLibrary = true;

     

       74971
       74971
       +
              isExecutable = true;

     

       74972
       74972
       +
              libraryHaskellDepends = [

     

       74973
       74973
       +
                base containers dhall prettyprinter text tomland

     

       74974
       74974
       +
                unordered-containers

     

       74975
       74975
       +
              ];

     

       74976
       74976
       +
              executableHaskellDepends = [ base ];

     

       74977
       74977
       +
              testHaskellDepends = [

     

       74978
       74978
       +
                base dhall directory doctest filepath tasty tasty-hunit text

     

       74979
       74979
       +
                tomland

     

       74980
       74980
       +
              ];

     

       74981
       74981
       +
              description = "Convert between Dhall and TOML";

     

       74982
       74982
       +
              license = lib.licenses.bsd3;

     

       75016
       74983
        
              hydraPlatforms = lib.platforms.none;

     

       75017
       74984
        
              broken = true;

     

       75018
       74985
        
            }) {};

     
···

       75046
       75013
        
              maintainers = with lib.maintainers; [ Gabriel439 ];

     

       75047
       75014
        
            }) {};

     

       75048
       75015
        
       

     

       75016
       75016
       +
         "dhall-yaml_1_2_8" = callPackage

     

       75017
       75017
       +
           ({ mkDerivation, aeson, ansi-terminal, base, bytestring, dhall

     

       75018
       75018
       +
            , dhall-json, exceptions, HsYAML, HsYAML-aeson

     

       75019
       75019
       +
            , optparse-applicative, prettyprinter, prettyprinter-ansi-terminal

     

       75020
       75020
       +
            , tasty, tasty-expected-failure, tasty-hunit, text, vector

     

       75021
       75021
       +
            }:

     

       75022
       75022
       +
            mkDerivation {

     

       75023
       75023
       +
              pname = "dhall-yaml";

     

       75024
       75024
       +
              version = "1.2.8";

     

       75025
       75025
       +
              sha256 = "1p766ybwib3f2i5h7m1hh71vc255ahvf7237bpprdapqw3ag8nak";

     

       75026
       75026
       +
              isLibrary = true;

     

       75027
       75027
       +
              isExecutable = true;

     

       75028
       75028
       +
              libraryHaskellDepends = [

     

       75029
       75029
       +
                aeson base bytestring dhall dhall-json HsYAML HsYAML-aeson

     

       75030
       75030
       +
                optparse-applicative text vector

     

       75031
       75031
       +
              ];

     

       75032
       75032
       +
              executableHaskellDepends = [

     

       75033
       75033
       +
                aeson ansi-terminal base bytestring dhall dhall-json exceptions

     

       75034
       75034
       +
                optparse-applicative prettyprinter prettyprinter-ansi-terminal text

     

       75035
       75035
       +
              ];

     

       75036
       75036
       +
              testHaskellDepends = [

     

       75037
       75037
       +
                base bytestring dhall dhall-json tasty tasty-expected-failure

     

       75038
       75038
       +
                tasty-hunit text

     

       75039
       75039
       +
              ];

     

       75040
       75040
       +
              description = "Convert between Dhall and YAML";

     

       75041
       75041
       +
              license = lib.licenses.gpl3Only;

     

       75042
       75042
       +
              hydraPlatforms = lib.platforms.none;

     

       75043
       75043
       +
              maintainers = with lib.maintainers; [ Gabriel439 ];

     

       75044
       75044
       +
            }) {};

     

       75045
       75045
       +
       

     

       75049
       75046
        
         "dhcp-lease-parser" = callPackage

     

       75050
       75047
        
           ({ mkDerivation, attoparsec, base, bytestring, chronos, ip, tasty

     

       75051
       75048
        
            , tasty-hunit, text

     
···

       75297
       75294
        
              pname = "diagrams-builder";

     

       75298
       75295
        
              version = "0.8.0.5";

     

       75299
       75296
        
              sha256 = "0dz617kfkvjf3f2zbphkdx1scglcjj162qsfk9xj7slbapnj918m";

     

       75300
       75300
       -
              revision = "1";

     

       75301
       75301
       -
              editedCabalFile = "0rcj755n729gs9rgmjwai1xacigwpyk4b91x0cadfsl7xrgqax0c";

     

       75297
       75297
       +
              revision = "2";

     

       75298
       75298
       +
              editedCabalFile = "1jys7j2s8shwh5yr7w597qd46ip5xqvszaqgpjvnx9fxazqp6r0v";

     

       75302
       75299
        
              configureFlags = [ "-fcairo" "-fps" "-frasterific" "-fsvg" ];

     

       75303
       75300
        
              isLibrary = true;

     

       75304
       75301
        
              isExecutable = true;

     
···

       75328
       75325
        
              pname = "diagrams-cairo";

     

       75329
       75326
        
              version = "1.4.1.1";

     

       75330
       75327
        
              sha256 = "0vyd2yr55n7x71194i18lnbcshdjpnqw4qyq7vj5zx377rsz711k";

     

       75331
       75331
       -
              revision = "2";

     

       75332
       75332
       -
              editedCabalFile = "0ngbshqmb86sc9djmgkn3zc9l69bn3kdml7ld6qx36dsyq6mafq9";

     

       75328
       75328
       +
              revision = "3";

     

       75329
       75329
       +
              editedCabalFile = "16jm9g9rfc7d1dy2kwq3n9wfgcj8l6c0d54lym1r6b0arc7yjqlb";

     

       75333
       75330
        
              libraryHaskellDepends = [

     

       75334
       75331
        
                array base bytestring cairo colour containers data-default-class

     

       75335
       75332
        
                diagrams-core diagrams-lib filepath hashable JuicyPixels lens mtl

     
···

       75349
       75346
        
              pname = "diagrams-canvas";

     

       75350
       75347
        
              version = "1.4.1";

     

       75351
       75348
        
              sha256 = "1ihmv42412d8dk3s894zd70xd386wrk9ycxkid19barry1vz5plj";

     

       75352
       75352
       -
              revision = "1";

     

       75353
       75353
       -
              editedCabalFile = "12p6n6g4ab81b39d031vzwfj89qi5wm27srpyigf2v0zswppdyvn";

     

       75349
       75349
       +
              revision = "2";

     

       75350
       75350
       +
              editedCabalFile = "0x8iv0998nn42l0ph90xq50ca514m3zhac4s9zl1hc5hzivj10sl";

     

       75354
       75351
        
              libraryHaskellDepends = [

     

       75355
       75352
        
                base blank-canvas cmdargs containers data-default-class

     

       75356
       75353
        
                diagrams-core diagrams-lib lens mtl NumInstances

     
···

       75374
       75371
        
              pname = "diagrams-contrib";

     

       75375
       75372
        
              version = "1.4.4";

     

       75376
       75373
        
              sha256 = "043jpr7lqg708lzmv6cqys7312lfdwnf8ijcnpl4jkbvcwl87c1m";

     

       75377
       75377
       -
              revision = "2";

     

       75378
       75378
       -
              editedCabalFile = "1mkpq356z7b2q6ifa4f1k7whsmhgn3hww8scacca0q2wnc8p4xjg";

     

       75374
       75374
       +
              revision = "3";

     

       75375
       75375
       +
              editedCabalFile = "03drxpqhyv62kzsxiabhfjiayk79fpv8wrq4qapsjbv7ph2jhx2v";

     

       75379
       75376
        
              libraryHaskellDepends = [

     

       75380
       75377
        
                base circle-packing colour containers cubicbezier data-default

     

       75381
       75378
        
                data-default-class diagrams-core diagrams-lib diagrams-solve

     
···

       75437
       75434
        
              pname = "diagrams-graphviz";

     

       75438
       75435
        
              version = "1.4.1.1";

     

       75439
       75436
        
              sha256 = "0lscrxd682jvyrl5bj4dxp7593qwyis01sl0p4jm2jfn335wdq40";

     

       75440
       75440
       -
              revision = "1";

     

       75441
       75441
       -
              editedCabalFile = "1qx69541pxf71whfz2a913yzbhfcks2pyzfprkgrcmiiyv0a3i7b";

     

       75437
       75437
       +
              revision = "2";

     

       75438
       75438
       +
              editedCabalFile = "0cxg21lsahkrf129k5h82d4znm3861dqc597mgzwyl5f0ywhllzr";

     

       75442
       75439
        
              libraryHaskellDepends = [

     

       75443
       75440
        
                base containers diagrams-lib fgl graphviz split

     

       75444
       75441
        
              ];

     
···

       75476
       75473
        
              pname = "diagrams-haddock";

     

       75477
       75474
        
              version = "0.4.1";

     

       75478
       75475
        
              sha256 = "0p978saxsfad6d8wkjnp6i300cf58ps02yw7a1zzhjfgk5ih2qlb";

     

       75476
       75476
       +
              revision = "1";

     

       75477
       75477
       +
              editedCabalFile = "063j6drlybzbm6bf9yfix86hs3hvgb98sgh4rzgrqkq9kvarj2ij";

     

       75479
       75478
        
              isLibrary = true;

     

       75480
       75479
        
              isExecutable = true;

     

       75481
       75480
        
              libraryHaskellDepends = [

     
···

       75675
       75674
        
              pname = "diagrams-postscript";

     

       75676
       75675
        
              version = "1.5";

     

       75677
       75676
        
              sha256 = "00j58mc84srjvrf21v6zjxxlbw6b8ahhn1jmbq697w8kw3cvygpa";

     

       75678
       75678
       -
              revision = "2";

     

       75679
       75679
       -
              editedCabalFile = "0dyji1b8mcxaxwzgckkk3p3ji0prrp7rsin98f1hmyjlj3ih735b";

     

       75677
       75677
       +
              revision = "3";

     

       75678
       75678
       +
              editedCabalFile = "1aq214837jk85b2l79adm5rcrv8y929aspvix7yjq1skyrqgk7pa";

     

       75680
       75679
        
              libraryHaskellDepends = [

     

       75681
       75680
        
                base bytestring containers data-default-class diagrams-core

     

       75682
       75681
        
                diagrams-lib hashable lens monoid-extras mtl semigroups split

     
···

       75712
       75711
        
              pname = "diagrams-rasterific";

     

       75713
       75712
        
              version = "1.4.2.1";

     

       75714
       75713
        
              sha256 = "09a1jnpc4kplg1yhv5kxhi0ph22m5xyr0vmnjv2c5wlz72c72z2z";

     

       75715
       75715
       -
              revision = "1";

     

       75716
       75716
       -
              editedCabalFile = "1nc12hm4qbj2lmbpk3a77cd46n5bcf20vwd075qj2vglbca2yl9b";

     

       75714
       75714
       +
              revision = "2";

     

       75715
       75715
       +
              editedCabalFile = "1vd8njhanjaa86h0g8hb6khz11bv9zvg8l4pfx0dj4ypknz4hwak";

     

       75717
       75716
        
              libraryHaskellDepends = [

     

       75718
       75717
        
                base bytestring containers data-default-class diagrams-core

     

       75719
       75718
        
                diagrams-lib file-embed filepath FontyFruity hashable JuicyPixels

     
···

       75785
       75784
        
              pname = "diagrams-svg";

     

       75786
       75785
        
              version = "1.4.3";

     

       75787
       75786
        
              sha256 = "1ysv6cz0fngrndl4wjmw4hrdj2rik5fxa1dkxzwnlgf1xwpvxgk8";

     

       75788
       75788
       -
              revision = "3";

     

       75789
       75789
       -
              editedCabalFile = "19n3g9wvp2fj4dlz3ssyjqx1b6ihskg5s595x9z2c99bpbzyykkv";

     

       75787
       75787
       +
              revision = "4";

     

       75788
       75788
       +
              editedCabalFile = "0irjf0g1barr06fy409r0ld2hypihrhh6n80ig3487xxny6gfzs0";

     

       75790
       75789
        
              libraryHaskellDepends = [

     

       75791
       75790
        
                base base64-bytestring bytestring colour containers diagrams-core

     

       75792
       75791
        
                diagrams-lib filepath hashable JuicyPixels lens monoid-extras mtl

     
···

       89798
       89797
        
              broken = true;

     

       89799
       89798
        
            }) {};

     

       89800
       89799
        
       

     

       89801
       89801
       -
         "faktory_1_1_0_0" = callPackage

     

       89802
       89802
       -
           ({ mkDerivation, aeson, aeson-casing, async, base, bytestring

     

       89803
       89803
       -
            , connection, cryptonite, errors, hspec, markdown-unlit, megaparsec

     

       89804
       89804
       -
            , memory, mtl, network, random, safe-exceptions, scanner

     

       89805
       89805
       -
            , semigroups, text, time, unix, unordered-containers

     

       89800
       89800
       +
         "faktory_1_1_1_0" = callPackage

     

       89801
       89801
       +
           ({ mkDerivation, aeson, aeson-casing, aeson-qq, async, base

     

       89802
       89802
       +
            , bytestring, connection, cryptonite, errors, hspec, markdown-unlit

     

       89803
       89803
       +
            , megaparsec, memory, mtl, network, random, safe-exceptions

     

       89804
       89804
       +
            , scanner, semigroups, text, time, unix, unordered-containers

     

       89806
       89805
        
            }:

     

       89807
       89806
        
            mkDerivation {

     

       89808
       89807
        
              pname = "faktory";

     

       89809
       89809
       -
              version = "1.1.0.0";

     

       89810
       89810
       -
              sha256 = "0bxwrrypkwhq7whaj79dkibad022bdxd8r5vh1dnd4aka3bdk8mj";

     

       89808
       89808
       +
              version = "1.1.1.0";

     

       89809
       89809
       +
              sha256 = "1lh427lq991pclzqr112dw4jjalcxpkwl440ygg2fhl6bgn082wx";

     

       89811
       89810
        
              isLibrary = true;

     

       89812
       89811
        
              isExecutable = true;

     

       89813
       89812
        
              libraryHaskellDepends = [

     
···

       89817
       89816
        
              ];

     

       89818
       89817
        
              executableHaskellDepends = [ aeson base safe-exceptions ];

     

       89819
       89818
        
              testHaskellDepends = [

     

       89820
       89820
       -
                aeson async base hspec markdown-unlit mtl time

     

       89819
       89819
       +
                aeson aeson-qq async base hspec markdown-unlit mtl time

     

       89821
       89820
        
              ];

     

       89822
       89821
        
              testToolDepends = [ markdown-unlit ];

     

       89823
       89822
        
              description = "Faktory Worker for Haskell";

     
···

       89942
       89941
        
            }:

     

       89943
       89942
        
            mkDerivation {

     

       89944
       89943
        
              pname = "fast-builder";

     

       89945
       89945
       -
              version = "0.1.2.1";

     

       89946
       89946
       -
              sha256 = "0j11ahdmbni56car4zblwz9yz1qkrr6qbmpbah4fgpiyq6177cn9";

     

       89944
       89944
       +
              version = "0.1.3.0";

     

       89945
       89945
       +
              sha256 = "0j2dfh6y689sk5ahh232zl8glbmwp34xnqkmaq9n9jwbddw4fg5z";

     

       89947
       89946
        
              libraryHaskellDepends = [ base bytestring ghc-prim ];

     

       89948
       89947
        
              testHaskellDepends = [ base bytestring process QuickCheck stm ];

     

       89949
       89948
        
              benchmarkHaskellDepends = [

     
···

       89975
       89974
        
            }) {};

     

       89976
       89975
        
       

     

       89977
       89976
        
         "fast-digits" = callPackage

     

       89978
       89978
       -
           ({ mkDerivation, base, digits, gauge, integer-gmp, QuickCheck

     

       89979
       89979
       -
            , smallcheck, tasty, tasty-quickcheck, tasty-smallcheck

     

       89980
       89980
       -
            }:

     

       89981
       89981
       -
            mkDerivation {

     

       89982
       89982
       -
              pname = "fast-digits";

     

       89983
       89983
       -
              version = "0.3.0.0";

     

       89984
       89984
       -
              sha256 = "1vlmjlkmv1nmw1rriafm2hzkmqd5xnwgzmvrg6xxqj1ab5sdsafs";

     

       89985
       89985
       -
              libraryHaskellDepends = [ base integer-gmp ];

     

       89986
       89986
       -
              testHaskellDepends = [

     

       89987
       89987
       -
                base digits QuickCheck smallcheck tasty tasty-quickcheck

     

       89988
       89988
       -
                tasty-smallcheck

     

       89989
       89989
       -
              ];

     

       89990
       89990
       -
              benchmarkHaskellDepends = [ base digits gauge ];

     

       89991
       89991
       -
              doHaddock = false;

     

       89992
       89992
       -
              description = "Integer-to-digits conversion";

     

       89993
       89993
       -
              license = lib.licenses.gpl3Only;

     

       89994
       89994
       -
              hydraPlatforms = lib.platforms.none;

     

       89995
       89995
       -
            }) {};

     

       89996
       89996
       -
       

     

       89997
       89997
       -
         "fast-digits_0_3_1_0" = callPackage

     

       89998
       89977
        
           ({ mkDerivation, base, integer-gmp, QuickCheck, smallcheck, tasty

     

       89999
       89978
        
            , tasty-bench, tasty-quickcheck, tasty-smallcheck

     

       90000
       89979
        
            }:

     
···

       90010
       89989
        
              doHaddock = false;

     

       90011
       89990
        
              description = "Integer-to-digits conversion";

     

       90012
       89991
        
              license = lib.licenses.gpl3Only;

     

       90013
       90013
       -
              hydraPlatforms = lib.platforms.none;

     

       90014
       89992
        
            }) {};

     

       90015
       89993
        
       

     

       90016
       89994
        
         "fast-downward" = callPackage

     
···

       92104
       92082
        
            }) {};

     

       92105
       92083
        
       

     

       92106
       92084
        
         "filepath-bytestring" = callPackage

     

       92107
       92107
       -
           ({ mkDerivation, base, bytestring, filepath, QuickCheck, unix }:

     

       92108
       92108
       -
            mkDerivation {

     

       92109
       92109
       -
              pname = "filepath-bytestring";

     

       92110
       92110
       -
              version = "1.4.2.1.7";

     

       92111
       92111
       -
              sha256 = "00xayqjq2qvb4yj0ppx838cabg5cx9swh0mzfb8c6njk9y5rc41n";

     

       92112
       92112
       -
              libraryHaskellDepends = [ base bytestring unix ];

     

       92113
       92113
       -
              testHaskellDepends = [ base bytestring filepath QuickCheck ];

     

       92114
       92114
       -
              description = "Library for manipulating RawFilePaths in a cross platform way";

     

       92115
       92115
       -
              license = lib.licenses.bsd3;

     

       92116
       92116
       -
            }) {};

     

       92117
       92117
       -
       

     

       92118
       92118
       -
         "filepath-bytestring_1_4_2_1_8" = callPackage

     

       92119
       92085
        
           ({ mkDerivation, base, bytestring, criterion, filepath, QuickCheck

     

       92120
       92086
        
            , unix

     

       92121
       92087
        
            }:

     
···

       92128
       92094
        
              benchmarkHaskellDepends = [ base criterion filepath ];

     

       92129
       92095
        
              description = "Library for manipulating RawFilePaths in a cross platform way";

     

       92130
       92096
        
              license = lib.licenses.bsd3;

     

       92131
       92131
       -
              hydraPlatforms = lib.platforms.none;

     

       92132
       92097
        
            }) {};

     

       92133
       92098
        
       

     

       92134
       92099
        
         "filepath-crypto" = callPackage

     
···

       96179
       96144
        
              broken = true;

     

       96180
       96145
        
            }) {};

     

       96181
       96146
        
       

     

       96147
       96147
       +
         "freckle-app" = callPackage

     

       96148
       96148
       +
           ({ mkDerivation, aeson, ansi-terminal, base, bytestring

     

       96149
       96149
       +
            , case-insensitive, conduit, data-default, datadog, directory

     

       96150
       96150
       +
            , doctest, errors, exceptions, fast-logger, filepath, Glob, hspec

     

       96151
       96151
       +
            , hspec-core, hspec-expectations-lifted, hspec-junit-formatter

     

       96152
       96152
       +
            , http-client, http-conduit, http-link-header, http-types, immortal

     

       96153
       96153
       +
            , iproute, lens, lens-aeson, load-env, monad-control, monad-logger

     

       96154
       96154
       +
            , MonadRandom, mtl, network, network-uri, persistent

     

       96155
       96155
       +
            , persistent-postgresql, postgresql-simple, primitive, process

     

       96156
       96156
       +
            , resource-pool, retry, rio, temporary, text, time, transformers

     

       96157
       96157
       +
            , transformers-base, unliftio, unliftio-core, wai, wai-extra, yaml

     

       96158
       96158
       +
            , yesod, yesod-core

     

       96159
       96159
       +
            }:

     

       96160
       96160
       +
            mkDerivation {

     

       96161
       96161
       +
              pname = "freckle-app";

     

       96162
       96162
       +
              version = "1.0.0.2";

     

       96163
       96163
       +
              sha256 = "1mrydqmwzwa391cb6pzxmjd5yl04f5xggz0wha7rm2a0pksgxphy";

     

       96164
       96164
       +
              libraryHaskellDepends = [

     

       96165
       96165
       +
                aeson ansi-terminal base bytestring case-insensitive conduit

     

       96166
       96166
       +
                data-default datadog doctest errors exceptions fast-logger filepath

     

       96167
       96167
       +
                Glob hspec hspec-core hspec-expectations-lifted

     

       96168
       96168
       +
                hspec-junit-formatter http-client http-conduit http-link-header

     

       96169
       96169
       +
                http-types immortal iproute lens load-env monad-control

     

       96170
       96170
       +
                monad-logger MonadRandom mtl network network-uri persistent

     

       96171
       96171
       +
                persistent-postgresql postgresql-simple primitive process

     

       96172
       96172
       +
                resource-pool retry rio text time transformers transformers-base

     

       96173
       96173
       +
                unliftio unliftio-core wai wai-extra yaml yesod yesod-core

     

       96174
       96174
       +
              ];

     

       96175
       96175
       +
              testHaskellDepends = [

     

       96176
       96176
       +
                aeson base bytestring directory hspec http-types lens lens-aeson

     

       96177
       96177
       +
                process temporary text time wai wai-extra

     

       96178
       96178
       +
              ];

     

       96179
       96179
       +
              description = "Haskell application toolkit used at Freckle";

     

       96180
       96180
       +
              license = lib.licenses.mit;

     

       96181
       96181
       +
              hydraPlatforms = lib.platforms.none;

     

       96182
       96182
       +
            }) {};

     

       96183
       96183
       +
       

     

       96182
       96184
        
         "freddy" = callPackage

     

       96183
       96185
        
           ({ mkDerivation, amqp, async, base, broadcast-chan, bytestring

     

       96184
       96186
        
            , data-default, hspec, random, text, uuid

     
···

       101931
       101933
        
           ({ mkDerivation, base, ghc }:

     

       101932
       101934
        
            mkDerivation {

     

       101933
       101935
        
              pname = "ghc-api-compat";

     

       101934
       101934
       -
              version = "8.10.5";

     

       101935
       101935
       -
              sha256 = "09g04k7zvzjs312yn9hhk8bk3l6k2vbb8qrdpnlr12a6az4adq3s";

     

       101936
       101936
       +
              version = "8.10.6";

     

       101937
       101937
       +
              sha256 = "1zrwa266v776w8rvcjggdpnyhs8kk36w5wrh63l16kxh58yc2vjz";

     

       101936
       101938
        
              libraryHaskellDepends = [ base ghc ];

     

       101937
       101939
        
              doHaddock = false;

     

       101938
       101940
        
              description = "GHC-API compatibility helpers";

     
···

       102528
       102530
        
            }:

     

       102529
       102531
        
            mkDerivation {

     

       102530
       102532
        
              pname = "ghc-lib";

     

       102531
       102531
       -
              version = "8.10.5.20210606";

     

       102532
       102532
       -
              sha256 = "0bl2jp44s3pd1a1sg0kslkhi97f4z2423kdkizg65m6cvmk25ijs";

     

       102533
       102533
       +
              version = "8.10.6.20210814";

     

       102534
       102534
       +
              sha256 = "0gnjps6xf5wq0nl4rlm4c1mqp3a3rbkwskv85fm852n5cf7bicd6";

     

       102533
       102535
        
              enableSeparateDataOutput = true;

     

       102534
       102536
        
              libraryHaskellDepends = [

     

       102535
       102537
        
                array base binary bytestring containers deepseq directory filepath

     
···

       102564
       102566
        
       

     

       102565
       102567
        
         "ghc-lib-parser" = callPackage

     

       102566
       102568
        
           ({ mkDerivation, alex, array, base, binary, bytestring, containers

     

       102567
       102567
       -
            , deepseq, directory, filepath, ghc-prim, happy, hpc, pretty

     

       102568
       102568
       -
            , process, time, transformers, unix

     

       102569
       102569
       +
            , deepseq, directory, filepath, ghc-prim, happy, pretty, process

     

       102570
       102570
       +
            , time, transformers, unix

     

       102569
       102571
        
            }:

     

       102570
       102572
        
            mkDerivation {

     

       102571
       102573
        
              pname = "ghc-lib-parser";

     

       102572
       102572
       -
              version = "8.10.5.20210606";

     

       102573
       102573
       -
              sha256 = "0pqsq49kvqwgbi6jw0dycbdzyldi0sannyqkfzavhqjf4mwjzn4a";

     

       102574
       102574
       +
              version = "8.10.6.20210814";

     

       102575
       102575
       +
              sha256 = "16kmm5wv3kym3qjq43pldycnira64zyga2c4b2vccvlvbi0v40hi";

     

       102574
       102576
        
              enableSeparateDataOutput = true;

     

       102575
       102577
        
              libraryHaskellDepends = [

     

       102576
       102578
        
                array base binary bytestring containers deepseq directory filepath

     

       102577
       102577
       -
                ghc-prim hpc pretty process time transformers unix

     

       102579
       102579
       +
                ghc-prim pretty process time transformers unix

     

       102578
       102580
        
              ];

     

       102579
       102581
        
              libraryToolDepends = [ alex happy ];

     

       102580
       102582
        
              description = "The GHC API, decoupled from GHC versions";

     
···

       102609
       102611
        
            }:

     

       102610
       102612
        
            mkDerivation {

     

       102611
       102613
        
              pname = "ghc-lib-parser-ex";

     

       102612
       102612
       -
              version = "8.10.0.21";

     

       102613
       102613
       -
              sha256 = "0ynrn7qdmim35fs9qdlbajqwyz559x1l9cqmjhb54vbrs2xnk6vp";

     

       102614
       102614
       +
              version = "8.10.0.22";

     

       102615
       102615
       +
              sha256 = "1a1yhm8rflln6m8sn2bbh5x6cbn20zfq91vfk1ywmia0v5y2sx03";

     

       102614
       102616
        
              libraryHaskellDepends = [

     

       102615
       102617
        
                base bytestring containers ghc ghc-boot ghc-boot-th uniplate

     

       102616
       102618
        
              ];

     
···

       112156
       112158
        
            }:

     

       112157
       112159
        
            mkDerivation {

     

       112158
       112160
        
              pname = "gray-extended";

     

       112159
       112159
       -
              version = "1.5.8";

     

       112160
       112160
       -
              sha256 = "1vli6dc0wc1an6vfhchai6s8xrg8rfds2k07x2xszaqg7r2njc9k";

     

       112161
       112161
       +
              version = "1.5.9";

     

       112162
       112162
       +
              sha256 = "0j2qw42fv5pg6v6bq51hk6lw3gcz35xd1gfvm8i74irv6bqialgy";

     

       112161
       112163
        
              libraryHaskellDepends = [ base ];

     

       112162
       112164
        
              testHaskellDepends = [

     

       112163
       112165
        
                base QuickCheck test-framework test-framework-quickcheck2

     
···

       112396
       112398
        
            }:

     

       112397
       112399
        
            mkDerivation {

     

       112398
       112400
        
              pname = "grid";

     

       112399
       112399
       -
              version = "7.8.14";

     

       112400
       112400
       -
              sha256 = "11rnsl6bs6qpx90p8jzdigncv6m5wbn6sav8gb3mlbm40fpi3p93";

     

       112401
       112401
       +
              version = "7.8.15";

     

       112402
       112402
       +
              sha256 = "0fsgax3xpdhnwn67s4wqqpvmm98j7b1fp6lrx98m15nxmjqb7rcc";

     

       112401
       112403
        
              libraryHaskellDepends = [ base containers ];

     

       112402
       112404
        
              testHaskellDepends = [

     

       112403
       112405
        
                base QuickCheck test-framework test-framework-quickcheck2

     
···

       113330
       113332
        
              libraryPkgconfigDepends = [ gtk-mac-integration-gtk2 ];

     

       113331
       113333
        
              description = "Bindings for the Gtk/OS X integration library";

     

       113332
       113334
        
              license = lib.licenses.lgpl21Only;

     

       113333
       113333
       -
              platforms = [ "x86_64-darwin" ];

     

       113335
       113335
       +
              platforms = [ "aarch64-darwin" "x86_64-darwin" ];

     

       113334
       113336
        
              hydraPlatforms = lib.platforms.none;

     

       113335
       113337
        
              broken = true;

     

       113336
       113338
        
            }) {inherit (pkgs) gtk-mac-integration-gtk2;};

     
···

       118869
       118871
        
              pname = "hashable";

     

       118870
       118872
        
              version = "1.3.2.0";

     

       118871
       118873
        
              sha256 = "0dyn343wdwbm1facpcjiyd8w0s0hk23jqh7mbj108az5dx5rdgar";

     

       118874
       118874
       +
              revision = "1";

     

       118875
       118875
       +
              editedCabalFile = "05jwmd6d127vykb1y13q7sjn5mhfs5pbbkal33jq5kg1rx3hj6kq";

     

       118872
       118876
        
              libraryHaskellDepends = [

     

       118873
       118877
        
                base bytestring deepseq ghc-prim integer-gmp text

     

       118874
       118878
        
              ];

     
···

       122173
       122177
        
            }:

     

       122174
       122178
        
            mkDerivation {

     

       122175
       122179
        
              pname = "hasklepias";

     

       122176
       122176
       -
              version = "0.15.1";

     

       122177
       122177
       -
              sha256 = "00n9fan0g3xdl9k0f0rw32xgrwzxb8x85vrj98yyk1dk490pgfhm";

     

       122180
       122180
       +
                base containers criterion deepseq fingertree hashable random time

     

       122181
       122181
       +
              sha256 = "19bskg552zfkfxrkgp7s3pcwjccn3ra3qc13inis55gxg56gwcs0";

     

       122178
       122182
        
              isLibrary = true;

     

       122179
       122183
        
              isExecutable = true;

     

       122180
       122184
        
              libraryHaskellDepends = [

     
···

       127511
       127515
        
              description = "Ethereum virtual machine evaluator";

     

       127512
       127516
        
              license = lib.licenses.agpl3Only;

     

       127513
       127517
        
              platforms = [

     

       127514
       127514
       -
                "armv7l-linux" "i686-linux" "x86_64-darwin" "x86_64-linux"

     

       127518
       127518
       +
                "aarch64-darwin" "armv7l-linux" "i686-linux" "x86_64-darwin"

     

       127519
       127519
       +
                "x86_64-linux"

     

       127515
       127520
        
              ];

     

       127516
       127521
        
            }) {inherit (pkgs) libff; inherit (pkgs) secp256k1;};

     

       127517
       127522
        
       

     
···

       128147
       128152
        
                base containers criterion deepseq fingertree hashable random time

     

       128148
       128153
        
                base containers criterion deepseq fingertree hashable random time

     

       128149
       128154
        
              license = lib.licenses.bsd3;

     

       128150
       128150
       -
              platforms = [ "x86_64-darwin" ];

     

       128155
       128155
       +
              platforms = [ "aarch64-darwin" "x86_64-darwin" ];

     

       128151
       128156
        
                base containers criterion deepseq fingertree hashable random time

     

       128152
       128157
        
                base containers criterion deepseq fingertree hashable random time

     

       128153
       128158
        
       

     
···

       134726
       134731
        
       

     

       134727
       134732
        
         "hpack-dhall" = callPackage

     

       134728
       134733
        
           ({ mkDerivation, aeson, aeson-pretty, base, bytestring, Cabal

     

       134729
       134729
       -
            , dhall, dhall-json, Diff, directory, filepath, hpack, megaparsec

     

       134730
       134730
       -
            , microlens, optparse-applicative, prettyprinter, tasty

     

       134731
       134731
       -
            , tasty-golden, text, transformers, utf8-string, yaml

     

       134732
       134732
       -
            }:

     

       134733
       134733
       -
            mkDerivation {

     

       134734
       134734
       -
              pname = "hpack-dhall";

     

       134735
       134735
       -
              version = "0.5.2";

     

       134736
       134736
       -
              sha256 = "16mnh9hwp0224cn3rlpbjgqklgvbaffbzjskyksakpgxc0phk1zi";

     

       134737
       134737
       -
              isLibrary = true;

     

       134738
       134738
       -
              isExecutable = true;

     

       134739
       134739
       -
              libraryHaskellDepends = [

     

       134740
       134740
       -
                aeson aeson-pretty base bytestring dhall dhall-json filepath hpack

     

       134741
       134741
       -
                megaparsec microlens prettyprinter text transformers yaml

     

       134742
       134742
       -
              ];

     

       134743
       134743
       -
              executableHaskellDepends = [

     

       134744
       134744
       -
                aeson aeson-pretty base bytestring dhall dhall-json filepath hpack

     

       134745
       134745
       -
                megaparsec microlens optparse-applicative prettyprinter text

     

       134746
       134746
       -
                transformers yaml

     

       134747
       134747
       -
              ];

     

       134748
       134748
       -
              testHaskellDepends = [

     

       134749
       134749
       -
                aeson aeson-pretty base bytestring Cabal dhall dhall-json Diff

     

       134750
       134750
       -
                directory filepath hpack megaparsec microlens prettyprinter tasty

     

       134751
       134751
       -
                tasty-golden text transformers utf8-string yaml

     

       134752
       134752
       -
              ];

     

       134753
       134753
       -
              description = "hpack's dhalling";

     

       134754
       134754
       -
              license = lib.licenses.bsd3;

     

       134755
       134755
       -
            }) {};

     

       134756
       134756
       -
       

     

       134757
       134757
       -
         "hpack-dhall_0_5_3" = callPackage

     

       134758
       134758
       -
           ({ mkDerivation, aeson, aeson-pretty, base, bytestring, Cabal

     

       134759
       134734
        
            , dhall, dhall-json, Diff, directory, filepath, hlint, hpack

     

       134760
       134735
        
            , megaparsec, microlens, optparse-applicative, prettyprinter, tasty

     

       134761
       134736
        
            , tasty-golden, text, transformers, utf8-string, yaml

     
···

       134782
       134757
        
              ];

     

       134783
       134758
        
              description = "hpack's dhalling";

     

       134784
       134759
        
              license = lib.licenses.bsd3;

     

       134785
       134785
       -
              hydraPlatforms = lib.platforms.none;

     

       134786
       134760
        
            }) {};

     

       134787
       134761
        
       

     

       134788
       134762
        
         "hpaco" = callPackage

     
···

       136643
       136617
        
              isExecutable = true;

     

       136644
       136618
        
              executableHaskellDepends = [

     

       136645
       136619
        
                base Cabal containers directory filepath ghc mtl process strict

     

       136620
       136620
       +
              ];

     

       136621
       136621
       +
              description = "Create tag files (ctags and etags) for Haskell code";

     

       136622
       136622
       +
              license = lib.licenses.mit;

     

       136623
       136623
       +
              hydraPlatforms = lib.platforms.none;

     

       136624
       136624
       +
              broken = true;

     

       136625
       136625
       +
            }) {};

     

       136626
       136626
       +
       

     

       136627
       136627
       +
         "hs-tags_0_1_5_1" = callPackage

     

       136628
       136628
       +
           ({ mkDerivation, base, Cabal, containers, directory, filepath, ghc

     

       136629
       136629
       +
            , ghc-paths, mtl, process, strict

     

       136630
       136630
       +
            }:

     

       136631
       136631
       +
            mkDerivation {

     

       136632
       136632
       +
              pname = "hs-tags";

     

       136633
       136633
       +
              version = "0.1.5.1";

     

       136634
       136634
       +
              sha256 = "1yk1x24qar19hx47yjlr4f1qz3ld45hzpc74yxak73rsz08c08dx";

     

       136635
       136635
       +
              isLibrary = false;

     

       136636
       136636
       +
              isExecutable = true;

     

       136637
       136637
       +
              executableHaskellDepends = [

     

       136638
       136638
       +
                base Cabal containers directory filepath ghc ghc-paths mtl process

     

       136639
       136639
       +
                strict

     

       136646
       136640
        
              ];

     

       136647
       136641
        
              description = "Create tag files (ctags and etags) for Haskell code";

     

       136648
       136642
        
              license = lib.licenses.mit;

     
···

       140087
       140081
        
            }:

     

       140088
       140082
        
            mkDerivation {

     

       140089
       140083
        
              pname = "hspretty";

     

       140090
       140090
       -
              version = "0.1.0.0";

     

       140091
       140091
       -
              sha256 = "11mbrr785j6pa02zil705sy67cdvjhwq9l927mm74barf9ph776r";

     

       140084
       140084
       +
              version = "0.2.0.0";

     

       140085
       140085
       +
              sha256 = "1nxsw25a8g8xhfbcybsamn64bzrr7gl2q6ydd62zj073bkh413iq";

     

       140092
       140086
        
              isLibrary = true;

     

       140093
       140087
        
              isExecutable = true;

     

       140094
       140088
        
              libraryHaskellDepends = [

     
···

       141134
       141128
        
            }:

     

       141135
       141129
        
            mkDerivation {

     

       141136
       141130
        
              pname = "html-conduit";

     

       141137
       141137
       -
              version = "1.3.2.1";

     

       141138
       141138
       -
              sha256 = "196c8zcnjp1pc5qvqxd8arx3xkw0a90rvg9mmiw2l4zwnx65709n";

     

       141139
       141139
       -
              libraryHaskellDepends = [

     

       141140
       141140
       -
                attoparsec base bytestring conduit conduit-extra containers

     

       141141
       141141
       -
                resourcet text transformers xml-conduit xml-types

     

       141142
       141142
       -
              ];

     

       141143
       141143
       -
              testHaskellDepends = [

     

       141144
       141144
       -
                base bytestring containers deepseq hspec HUnit text xml-conduit

     

       141145
       141145
       -
              ];

     

       141146
       141146
       -
              description = "Parse HTML documents using xml-conduit datatypes";

     

       141147
       141147
       -
              license = lib.licenses.mit;

     

       141148
       141148
       -
            }) {};

     

       141149
       141149
       -
       

     

       141150
       141150
       -
         "html-conduit_1_3_2_2" = callPackage

     

       141151
       141151
       -
           ({ mkDerivation, attoparsec, base, bytestring, conduit

     

       141152
       141152
       -
            , conduit-extra, containers, deepseq, hspec, HUnit, resourcet, text

     

       141153
       141153
       -
            , transformers, xml-conduit, xml-types

     

       141154
       141154
       -
            }:

     

       141155
       141155
       -
            mkDerivation {

     

       141156
       141156
       -
              pname = "html-conduit";

     

       141157
       141131
        
              version = "1.3.2.2";

     

       141158
       141132
        
              sha256 = "09bwrdam3y47kqllgg6w098ghqb8jb10dp4wxirsvx5ddpx9zpi6";

     

       141159
       141133
        
              libraryHaskellDepends = [

     
···

       141165
       141139
        
              ];

     

       141166
       141140
        
              description = "Parse HTML documents using xml-conduit datatypes";

     

       141167
       141141
        
              license = lib.licenses.mit;

     

       141168
       141168
       -
              hydraPlatforms = lib.platforms.none;

     

       141169
       141142
        
            }) {};

     

       141170
       141143
        
       

     

       141171
       141144
        
         "html-email-validate" = callPackage

     
···

       141979
       141952
        
              license = lib.licenses.bsd3;

     

       141980
       141953
        
            }) {};

     

       141981
       141954
        
       

     

       141955
       141955
       +
         "http-common_0_8_3_4" = callPackage

     

       141956
       141956
       +
           ({ mkDerivation, base, base64-bytestring, blaze-builder, bytestring

     

       141957
       141957
       +
            , case-insensitive, directory, mtl, network, random, text

     

       141958
       141958
       +
            , transformers, unordered-containers

     

       141959
       141959
       +
            }:

     

       141960
       141960
       +
            mkDerivation {

     

       141961
       141961
       +
              pname = "http-common";

     

       141962
       141962
       +
              version = "0.8.3.4";

     

       141963
       141963
       +
              sha256 = "1xpbnfac0fqa5r670ggwm4kq3cmz9jpaw9bx40j9w9qiw6xi4i28";

     

       141964
       141964
       +
              libraryHaskellDepends = [

     

       141965
       141965
       +
                base base64-bytestring blaze-builder bytestring case-insensitive

     

       141966
       141966
       +
                directory mtl network random text transformers unordered-containers

     

       141967
       141967
       +
              ];

     

       141968
       141968
       +
              description = "Common types for HTTP clients and servers";

     

       141969
       141969
       +
              license = lib.licenses.bsd3;

     

       141970
       141970
       +
              hydraPlatforms = lib.platforms.none;

     

       141971
       141971
       +
            }) {};

     

       141972
       141972
       +
       

     

       141982
       141973
        
         "http-conduit" = callPackage

     

       141983
       141974
        
           ({ mkDerivation, aeson, attoparsec, base, blaze-builder, bytestring

     

       141984
       141975
        
            , case-insensitive, conduit, conduit-extra, connection, cookie

     
···

       142628
       142619
        
              license = lib.licenses.bsd3;

     

       142629
       142620
        
            }) {};

     

       142630
       142621
        
       

     

       142622
       142622
       +
         "http-streams_0_8_9_4" = callPackage

     

       142623
       142623
       +
           ({ mkDerivation, aeson, aeson-pretty, attoparsec, base

     

       142624
       142624
       +
            , base64-bytestring, blaze-builder, bytestring, case-insensitive

     

       142625
       142625
       +
            , directory, filepath, ghc-prim, HsOpenSSL, hspec

     

       142626
       142626
       +
            , hspec-expectations, http-common, HUnit, io-streams, lifted-base

     

       142627
       142627
       +
            , mtl, network, network-uri, openssl-streams, random, snap-core

     

       142628
       142628
       +
            , snap-server, system-fileio, system-filepath, text, transformers

     

       142629
       142629
       +
            , unordered-containers

     

       142630
       142630
       +
            }:

     

       142631
       142631
       +
            mkDerivation {

     

       142632
       142632
       +
              pname = "http-streams";

     

       142633
       142633
       +
              version = "0.8.9.4";

     

       142634
       142634
       +
              sha256 = "03xdcb0v735xdrkjlm1w56mskh3x08cbsjrcd7wn4li65ixc20xa";

     

       142635
       142635
       +
              libraryHaskellDepends = [

     

       142636
       142636
       +
                aeson attoparsec base base64-bytestring blaze-builder bytestring

     

       142637
       142637
       +
                case-insensitive directory filepath HsOpenSSL http-common

     

       142638
       142638
       +
                io-streams mtl network network-uri openssl-streams text

     

       142639
       142639
       +
                transformers unordered-containers

     

       142640
       142640
       +
              ];

     

       142641
       142641
       +
              testHaskellDepends = [

     

       142642
       142642
       +
                aeson aeson-pretty attoparsec base base64-bytestring blaze-builder

     

       142643
       142643
       +
                bytestring case-insensitive directory ghc-prim HsOpenSSL hspec

     

       142644
       142644
       +
                hspec-expectations http-common HUnit io-streams lifted-base mtl

     

       142645
       142645
       +
                network network-uri openssl-streams random snap-core snap-server

     

       142646
       142646
       +
                system-fileio system-filepath text transformers

     

       142647
       142647
       +
                unordered-containers

     

       142648
       142648
       +
              ];

     

       142649
       142649
       +
              description = "An HTTP client using io-streams";

     

       142650
       142650
       +
              license = lib.licenses.bsd3;

     

       142651
       142651
       +
              hydraPlatforms = lib.platforms.none;

     

       142652
       142652
       +
            }) {};

     

       142653
       142653
       +
       

     

       142631
       142654
        
         "http-test" = callPackage

     

       142632
       142655
        
           ({ mkDerivation, aeson, base, bytestring, http-client, lens

     

       142633
       142656
        
            , lens-aeson, mtl, tasty, tasty-hunit, text, time, wreq

     
···

       143276
       143299
        
           ({ mkDerivation, base, dejafu, exceptions, HUnit }:

     

       143277
       143300
        
            mkDerivation {

     

       143278
       143301
        
              pname = "hunit-dejafu";

     

       143279
       143279
       -
              version = "2.0.0.4";

     

       143280
       143280
       -
              sha256 = "11d52blw31mcsg7c3w1f7khy3vk2p03h4c5z6ja6wb9k5bg4d004";

     

       143281
       143281
       -
              libraryHaskellDepends = [ base dejafu exceptions HUnit ];

     

       143282
       143282
       -
              description = "Deja Fu support for the HUnit test framework";

     

       143283
       143283
       -
              license = lib.licenses.mit;

     

       143284
       143284
       -
            }) {};

     

       143285
       143285
       -
       

     

       143286
       143286
       -
         "hunit-dejafu_2_0_0_5" = callPackage

     

       143287
       143287
       -
           ({ mkDerivation, base, dejafu, exceptions, HUnit }:

     

       143288
       143288
       -
            mkDerivation {

     

       143289
       143289
       -
              pname = "hunit-dejafu";

     

       143290
       143302
        
              version = "2.0.0.5";

     

       143291
       143303
        
              sha256 = "0pbsbj70a2m7zvk25wa8mi0ymxv4c49g2vgg8819wpjcrxw8sy64";

     

       143292
       143304
        
              libraryHaskellDepends = [ base dejafu exceptions HUnit ];

     

       143293
       143305
        
              description = "Deja Fu support for the HUnit test framework";

     

       143294
       143306
        
              license = lib.licenses.mit;

     

       143295
       143295
       -
              hydraPlatforms = lib.platforms.none;

     

       143296
       143307
        
            }) {};

     

       143297
       143308
        
       

     

       143298
       143309
        
         "hunit-gui" = callPackage

     
···

       149434
       149445
        
              license = lib.licenses.mit;

     

       149435
       149446
        
            }) {};

     

       149436
       149447
        
       

     

       149448
       149448
       +
         "inspection-testing_0_4_6_0" = callPackage

     

       149449
       149449
       +
           ({ mkDerivation, base, containers, ghc, mtl, template-haskell

     

       149450
       149450
       +
            , transformers

     

       149451
       149451
       +
            }:

     

       149452
       149452
       +
            mkDerivation {

     

       149453
       149453
       +
              pname = "inspection-testing";

     

       149454
       149454
       +
              version = "0.4.6.0";

     

       149455
       149455
       +
              sha256 = "0qz1npyycj4bvyly9xmjbnhw569l52h38gx02rk0r7zhapw83aig";

     

       149456
       149456
       +
              libraryHaskellDepends = [

     

       149457
       149457
       +
                base containers ghc mtl template-haskell transformers

     

       149458
       149458
       +
              ];

     

       149459
       149459
       +
              testHaskellDepends = [ base ];

     

       149460
       149460
       +
              description = "GHC plugin to do inspection testing";

     

       149461
       149461
       +
              license = lib.licenses.mit;

     

       149462
       149462
       +
              hydraPlatforms = lib.platforms.none;

     

       149463
       149463
       +
            }) {};

     

       149464
       149464
       +
       

     

       149437
       149465
        
         "inspector-wrecker" = callPackage

     

       149438
       149466
        
           ({ mkDerivation, aeson, base, bytestring, case-insensitive

     

       149439
       149467
        
            , connection, data-default, http-client, http-client-tls

     
···

       150214
       150242
        
            }) {};

     

       150215
       150243
        
       

     

       150216
       150244
        
         "interpolation" = callPackage

     

       150217
       150217
       -
           ({ mkDerivation, array, base, containers, QuickCheck, utility-ht }:

     

       150218
       150218
       -
            mkDerivation {

     

       150219
       150219
       -
              pname = "interpolation";

     

       150220
       150220
       -
              version = "0.1.1.1";

     

       150221
       150221
       -
              sha256 = "081xlf59xp0j1svigkqfcz5an3yl3p8f5402i6492hz9rpv5qwy5";

     

       150222
       150222
       -
              isLibrary = true;

     

       150223
       150223
       -
              isExecutable = true;

     

       150224
       150224
       -
              libraryHaskellDepends = [ base utility-ht ];

     

       150225
       150225
       -
              testHaskellDepends = [

     

       150226
       150226
       -
                array base containers QuickCheck utility-ht

     

       150227
       150227
       -
              ];

     

       150228
       150228
       -
              description = "piecewise linear and cubic Hermite interpolation";

     

       150229
       150229
       -
              license = lib.licenses.bsd3;

     

       150230
       150230
       -
            }) {};

     

       150231
       150231
       -
       

     

       150232
       150232
       -
         "interpolation_0_1_1_2" = callPackage

     

       150233
       150245
        
           ({ mkDerivation, array, base, containers, doctest-exitcode-stdio

     

       150234
       150246
        
            , doctest-lib, QuickCheck, utility-ht

     

       150235
       150247
        
            }:

     
···

       150246
       150258
        
              ];

     

       150247
       150259
        
              description = "piecewise linear and cubic Hermite interpolation";

     

       150248
       150260
        
              license = lib.licenses.bsd3;

     

       150249
       150249
       -
              hydraPlatforms = lib.platforms.none;

     

       150250
       150261
        
            }) {};

     

       150251
       150262
        
       

     

       150252
       150263
        
         "interpolator" = callPackage

     
···

       150337
       150348
        
            }:

     

       150338
       150349
        
            mkDerivation {

     

       150339
       150350
        
              pname = "interval-algebra";

     

       150340
       150340
       -
              version = "0.10.0";

     

       150341
       150341
       -
              sha256 = "1b1a78rssxaqiw42hbb1zqmlq4lmxkxxkhrm3ybqpmrqk492mckv";

     

       150351
       150351
       +
              version = "0.10.1";

     

       150352
       150352
       +
              sha256 = "1nplznmspji7g51g2xxsr2b5lahhxqnmbs180mm3zmvkam8zizri";

     

       150342
       150353
        
              libraryHaskellDepends = [

     

       150343
       150354
        
                base containers foldl QuickCheck safe time witherable

     

       150344
       150355
        
              ];

     
···

       151389
       151400
        
            }:

     

       151390
       151401
        
            mkDerivation {

     

       151391
       151402
        
              pname = "irc-client";

     

       151392
       151392
       -
              version = "1.1.2.1";

     

       151393
       151393
       -
              sha256 = "1zaa8na730m96flgiyzcwq95v2ianvflsw3abvdavf7xpq4s71ld";

     

       151394
       151394
       -
              libraryHaskellDepends = [

     

       151395
       151395
       -
                base bytestring conduit connection containers contravariant

     

       151396
       151396
       -
                exceptions irc-conduit irc-ctcp mtl network-conduit-tls old-locale

     

       151397
       151397
       -
                profunctors stm stm-chans text time tls transformers x509

     

       151398
       151398
       -
                x509-store x509-validation

     

       151399
       151399
       -
              ];

     

       151400
       151400
       -
              description = "An IRC client library";

     

       151401
       151401
       -
              license = lib.licenses.mit;

     

       151402
       151402
       -
              maintainers = with lib.maintainers; [ sternenseemann ];

     

       151403
       151403
       -
            }) {};

     

       151404
       151404
       -
       

     

       151405
       151405
       -
         "irc-client_1_1_2_2" = callPackage

     

       151406
       151406
       -
           ({ mkDerivation, base, bytestring, conduit, connection, containers

     

       151407
       151407
       -
            , contravariant, exceptions, irc-conduit, irc-ctcp, mtl

     

       151408
       151408
       -
            , network-conduit-tls, old-locale, profunctors, stm, stm-chans

     

       151409
       151409
       -
            , text, time, tls, transformers, x509, x509-store, x509-validation

     

       151410
       151410
       -
            }:

     

       151411
       151411
       -
            mkDerivation {

     

       151412
       151412
       -
              pname = "irc-client";

     

       151413
       151403
        
              version = "1.1.2.2";

     

       151414
       151404
        
              sha256 = "0hhaf7xhy3q48gkp2j01jjiiz0ww9mwwjh8brbqs8phlal03ks70";

     

       151415
       151405
        
              libraryHaskellDepends = [

     
···

       151420
       151410
        
              ];

     

       151421
       151411
        
              description = "An IRC client library";

     

       151422
       151412
        
              license = lib.licenses.mit;

     

       151423
       151423
       -
              hydraPlatforms = lib.platforms.none;

     

       151424
       151413
        
              maintainers = with lib.maintainers; [ sternenseemann ];

     

       151425
       151414
        
            }) {};

     

       151426
       151415
        
       

     
···

       151442
       151431
        
            }:

     

       151443
       151432
        
            mkDerivation {

     

       151444
       151433
        
              pname = "irc-conduit";

     

       151445
       151445
       -
              version = "0.3.0.4";

     

       151446
       151446
       -
              sha256 = "0asaddcbdcnbp0bbhvzaq5514nw2l1cp1gac3jbn4mh7brgfwjc1";

     

       151447
       151447
       -
              libraryHaskellDepends = [

     

       151448
       151448
       -
                async base bytestring conduit conduit-extra connection irc irc-ctcp

     

       151449
       151449
       -
                network-conduit-tls profunctors text time tls transformers

     

       151450
       151450
       -
                x509-validation

     

       151451
       151451
       -
              ];

     

       151452
       151452
       -
              description = "Streaming IRC message library using conduits";

     

       151453
       151453
       -
              license = lib.licenses.mit;

     

       151454
       151454
       -
            }) {};

     

       151455
       151455
       -
       

     

       151456
       151456
       -
         "irc-conduit_0_3_0_5" = callPackage

     

       151457
       151457
       -
           ({ mkDerivation, async, base, bytestring, conduit, conduit-extra

     

       151458
       151458
       -
            , connection, irc, irc-ctcp, network-conduit-tls, profunctors, text

     

       151459
       151459
       -
            , time, tls, transformers, x509-validation

     

       151460
       151460
       -
            }:

     

       151461
       151461
       -
            mkDerivation {

     

       151462
       151462
       -
              pname = "irc-conduit";

     

       151463
       151434
        
              version = "0.3.0.5";

     

       151464
       151435
        
              sha256 = "02ziqjzqdyaizhrrzlbq4ddkfjfjf58jvwqfzrbf0mf0f5scv9cz";

     

       151465
       151436
        
              libraryHaskellDepends = [

     
···

       151469
       151440
        
              ];

     

       151470
       151441
        
              description = "Streaming IRC message library using conduits";

     

       151471
       151442
        
              license = lib.licenses.mit;

     

       151472
       151472
       -
              hydraPlatforms = lib.platforms.none;

     

       151473
       151443
        
            }) {};

     

       151474
       151444
        
       

     

       151475
       151445
        
         "irc-core" = callPackage

     
···

       151494
       151464
        
           ({ mkDerivation, base, bytestring, text }:

     

       151495
       151465
        
            mkDerivation {

     

       151496
       151466
        
              pname = "irc-ctcp";

     

       151497
       151497
       -
              version = "0.1.3.0";

     

       151498
       151498
       -
              sha256 = "16mp9dpp57id760zc932dszd5r1ncskwwxrp0djka5r1alddjz6n";

     

       151499
       151499
       -
              libraryHaskellDepends = [ base bytestring text ];

     

       151500
       151500
       -
              description = "A CTCP encoding and decoding library for IRC clients";

     

       151501
       151501
       -
              license = lib.licenses.mit;

     

       151502
       151502
       -
            }) {};

     

       151503
       151503
       -
       

     

       151504
       151504
       -
         "irc-ctcp_0_1_3_1" = callPackage

     

       151505
       151505
       -
           ({ mkDerivation, base, bytestring, text }:

     

       151506
       151506
       -
            mkDerivation {

     

       151507
       151507
       -
              pname = "irc-ctcp";

     

       151508
       151467
        
              version = "0.1.3.1";

     

       151509
       151468
        
              sha256 = "1ckdbxnjv96bpyhcpdi0vj6pjjq8wm4zyh75fps57wi1j61c4v2n";

     

       151510
       151469
        
              libraryHaskellDepends = [ base bytestring text ];

     

       151511
       151470
        
              description = "A CTCP encoding and decoding library for IRC clients";

     

       151512
       151471
        
              license = lib.licenses.mit;

     

       151513
       151513
       -
              hydraPlatforms = lib.platforms.none;

     

       151514
       151472
        
            }) {};

     

       151515
       151473
        
       

     

       151516
       151474
        
         "irc-dcc" = callPackage

     
···

       152004
       151962
        
              description = "A (bytestring-) builder for the ISO-14496-12 base media file format";

     

       152005
       151963
        
              license = lib.licenses.bsd3;

     

       152006
       151964
        
              hydraPlatforms = lib.platforms.none;

     

       151965
       151965
       +
            }) {};

     

       151966
       151966
       +
       

     

       151967
       151967
       +
         "isocline" = callPackage

     

       151968
       151968
       +
           ({ mkDerivation, base, bytestring, text }:

     

       151969
       151969
       +
            mkDerivation {

     

       151970
       151970
       +
              pname = "isocline";

     

       151971
       151971
       +
              version = "1.0.1";

     

       151972
       151972
       +
              sha256 = "1s57gqzhic1zjc0fn1j8l834cfa24w9q2rvhbxdfkb442qpw4piw";

     

       151973
       151973
       +
              isLibrary = true;

     

       151974
       151974
       +
              isExecutable = true;

     

       151975
       151975
       +
              libraryHaskellDepends = [ base bytestring text ];

     

       151976
       151976
       +
              executableHaskellDepends = [ base bytestring text ];

     

       151977
       151977
       +
              testHaskellDepends = [ base bytestring text ];

     

       151978
       151978
       +
              description = "A portable alternative to GNU Readline";

     

       151979
       151979
       +
              license = lib.licenses.mit;

     

       151980
       151980
       +
              hydraPlatforms = lib.platforms.none;

     

       151981
       151981
       +
              broken = true;

     

       152007
       151982
        
            }) {};

     

       152008
       151983
        
       

     

       152009
       151984
        
         "isohunt" = callPackage

     
···

       158256
       158231
        
              libraryToolDepends = [ c2hs ];

     

       158257
       158232
        
              description = "A binding to the kqueue event library";

     

       158258
       158233
        
              license = lib.licenses.bsd3;

     

       158259
       158259
       -
              platforms = [ "x86_64-darwin" ];

     

       158234
       158234
       +
              platforms = [ "aarch64-darwin" "x86_64-darwin" ];

     

       158260
       158235
        
            }) {};

     

       158261
       158236
        
       

     

       158262
       158237
        
         "kraken" = callPackage

     
···

       158453
       158428
        
              ];

     

       158454
       158429
        
              description = "Client library for Kubernetes";

     

       158455
       158430
        
              license = lib.licenses.asl20;

     

       158456
       158456
       -
              hydraPlatforms = lib.platforms.none;

     

       158457
       158431
        
            }) {};

     

       158458
       158432
        
       

     

       158459
       158433
        
         "kubernetes-client-core" = callPackage

     
···

       158907
       158881
        
              broken = true;

     

       158908
       158882
        
            }) {};

     

       158909
       158883
        
       

     

       158884
       158884
       +
         "lambda-cube" = callPackage

     

       158885
       158885
       +
           ({ mkDerivation, base, hspec, megaparsec, QuickCheck

     

       158886
       158886
       +
            , template-haskell, text

     

       158887
       158887
       +
            }:

     

       158888
       158888
       +
            mkDerivation {

     

       158889
       158889
       +
              pname = "lambda-cube";

     

       158890
       158890
       +
              version = "0.1.0.0";

     

       158891
       158891
       +
              sha256 = "0s5sh4r43r5xhlldxqy2snddc5dgnx2rpawk4pipxp69983xhazi";

     

       158892
       158892
       +
              revision = "3";

     

       158893
       158893
       +
              editedCabalFile = "0ycaf4j9g0zsbw4qjwd6san4vn7h6iiyyf0dqgqwcl0vfv7z2hf0";

     

       158894
       158894
       +
              libraryHaskellDepends = [ base megaparsec template-haskell text ];

     

       158895
       158895
       +
              testHaskellDepends = [ base hspec QuickCheck ];

     

       158896
       158896
       +
              description = "Haskell implementation of (some of) lambda cube calculi";

     

       158897
       158897
       +
              license = lib.licenses.mit;

     

       158898
       158898
       +
            }) {};

     

       158899
       158899
       +
       

     

       158910
       158900
        
         "lambda-devs" = callPackage

     

       158911
       158901
        
           ({ mkDerivation, base, binary, containers, dimensional

     

       158912
       158902
        
            , distributed-process, HUnit, numtype, QuickCheck, test-framework

     
···

       159085
       159075
        
            }:

     

       159086
       159076
        
            mkDerivation {

     

       159087
       159077
        
              pname = "lambdabot-core";

     

       159088
       159088
       -
              version = "5.3.0.1";

     

       159089
       159089
       -
              sha256 = "05xx68f3gpc7s1k8p81pwphmiznf7niradf52p39rss3nx8rr3ay";

     

       159090
       159090
       -
              libraryHaskellDepends = [

     

       159091
       159091
       -
                base binary bytestring containers dependent-map dependent-sum

     

       159092
       159092
       -
                dependent-sum-template directory edit-distance exceptions filepath

     

       159093
       159093
       -
                haskeline hslogger HTTP lifted-base monad-control mtl network

     

       159094
       159094
       -
                network-bsd parsec prim-uniq random random-fu random-source

     

       159095
       159095
       -
                regex-tdfa SafeSemaphore split syb template-haskell time

     

       159096
       159096
       -
                transformers transformers-base unix utf8-string zlib

     

       159097
       159097
       -
              ];

     

       159098
       159098
       -
              description = "Lambdabot core functionality";

     

       159099
       159099
       -
              license = "GPL";

     

       159100
       159100
       -
            }) {};

     

       159101
       159101
       -
       

     

       159102
       159102
       -
         "lambdabot-core_5_3_0_2" = callPackage

     

       159103
       159103
       -
           ({ mkDerivation, base, binary, bytestring, containers

     

       159104
       159104
       -
            , dependent-map, dependent-sum, dependent-sum-template, directory

     

       159105
       159105
       -
            , edit-distance, exceptions, filepath, haskeline, hslogger, HTTP

     

       159106
       159106
       -
            , lifted-base, monad-control, mtl, network, network-bsd, parsec

     

       159107
       159107
       -
            , prim-uniq, random, random-fu, random-source, regex-tdfa

     

       159108
       159108
       -
            , SafeSemaphore, split, syb, template-haskell, time, transformers

     

       159109
       159109
       -
            , transformers-base, unix, utf8-string, zlib

     

       159110
       159110
       -
            }:

     

       159111
       159111
       -
            mkDerivation {

     

       159112
       159112
       -
              pname = "lambdabot-core";

     

       159113
       159078
        
              version = "5.3.0.2";

     

       159114
       159079
        
              sha256 = "1i375kiw98j5gd4pixh59lcqk0lakwmrgxzpkr0431a48kxffq7r";

     

       159115
       159080
        
              libraryHaskellDepends = [

     
···

       159122
       159087
        
              ];

     

       159123
       159088
        
              description = "Lambdabot core functionality";

     

       159124
       159089
        
              license = "GPL";

     

       159125
       159125
       -
              hydraPlatforms = lib.platforms.none;

     

       159126
       159090
        
            }) {};

     

       159127
       159091
        
       

     

       159128
       159092
        
         "lambdabot-haskell-plugins" = callPackage

     
···

       160080
       160044
        
       

     

       160081
       160045
        
         "language-docker" = callPackage

     

       160082
       160046
        
           ({ mkDerivation, base, bytestring, containers, data-default-class

     

       160083
       160083
       -
            , hspec, HUnit, megaparsec, prettyprinter, QuickCheck, split, text

     

       160084
       160084
       -
            , time

     

       160085
       160085
       -
            }:

     

       160086
       160086
       -
            mkDerivation {

     

       160087
       160087
       -
              pname = "language-docker";

     

       160088
       160088
       -
              version = "10.0.1";

     

       160089
       160089
       -
              sha256 = "19pyms0ik37wpzjnlplj2vwikbjdjaw78llpfjp0a0467wlk7na6";

     

       160090
       160090
       -
              libraryHaskellDepends = [

     

       160091
       160091
       -
                base bytestring containers data-default-class megaparsec

     

       160092
       160092
       -
                prettyprinter split text time

     

       160093
       160093
       -
              ];

     

       160094
       160094
       -
              testHaskellDepends = [

     

       160095
       160095
       -
                base bytestring containers data-default-class hspec HUnit

     

       160096
       160096
       -
                megaparsec prettyprinter QuickCheck split text time

     

       160097
       160097
       -
              ];

     

       160098
       160098
       -
              description = "Dockerfile parser, pretty-printer and embedded DSL";

     

       160099
       160099
       -
              license = lib.licenses.gpl3Only;

     

       160100
       160100
       -
            }) {};

     

       160101
       160101
       -
       

     

       160102
       160102
       -
         "language-docker_10_0_2" = callPackage

     

       160103
       160103
       -
           ({ mkDerivation, base, bytestring, containers, data-default-class

     

       160104
       160047
        
            , hspec, hspec-megaparsec, HUnit, megaparsec, prettyprinter

     

       160105
       160048
        
            , QuickCheck, split, text, time

     

       160106
       160049
        
            }:

     
···

       160119
       160062
        
              ];

     

       160120
       160063
        
              description = "Dockerfile parser, pretty-printer and embedded DSL";

     

       160121
       160064
        
              license = lib.licenses.gpl3Only;

     

       160122
       160122
       -
              hydraPlatforms = lib.platforms.none;

     

       160123
       160065
        
            }) {};

     

       160124
       160066
        
       

     

       160125
       160067
        
         "language-dockerfile" = callPackage

     
···

       161159
       161101
        
            }:

     

       161160
       161102
        
            mkDerivation {

     

       161161
       161103
        
              pname = "lapack-comfort-array";

     

       161162
       161162
       -
              version = "0.0.0.1";

     

       161163
       161163
       -
              sha256 = "0kn9bb3q772sbzm54rdqbqrmp21kck2gvc0xagi974dq7b1wilh1";

     

       161164
       161164
       -
              libraryHaskellDepends = [

     

       161165
       161165
       -
                base comfort-array lapack-ffi netlib-comfort-array netlib-ffi

     

       161166
       161166
       -
                storable-complex transformers

     

       161167
       161167
       -
              ];

     

       161168
       161168
       -
              description = "Auto-generated interface to Fortran LAPACK via comfort-array";

     

       161169
       161169
       -
              license = lib.licenses.bsd3;

     

       161170
       161170
       -
              hydraPlatforms = lib.platforms.none;

     

       161171
       161171
       -
            }) {};

     

       161172
       161172
       -
       

     

       161173
       161173
       -
         "lapack-comfort-array_0_0_1" = callPackage

     

       161174
       161174
       -
           ({ mkDerivation, base, comfort-array, lapack-ffi

     

       161175
       161175
       -
            , netlib-comfort-array, netlib-ffi, storable-complex, transformers

     

       161176
       161176
       -
            }:

     

       161177
       161177
       -
            mkDerivation {

     

       161178
       161178
       -
              pname = "lapack-comfort-array";

     

       161179
       161104
        
              version = "0.0.1";

     

       161180
       161105
        
              sha256 = "1p4vfw95qnd48cbizncb7b7fgzkxbv7r3rp3ffw6r11wymhm67q0";

     

       161181
       161106
        
              libraryHaskellDepends = [

     
···

       161271
       161196
        
              description = "Efficiently hash (large) Haskell values";

     

       161272
       161197
        
              license = lib.licenses.bsd3;

     

       161273
       161198
        
              platforms = [

     

       161274
       161274
       -
                "armv7l-linux" "i686-linux" "x86_64-darwin" "x86_64-linux"

     

       161199
       161199
       +
                "aarch64-darwin" "armv7l-linux" "i686-linux" "x86_64-darwin"

     

       161200
       161200
       +
                "x86_64-linux"

     

       161275
       161201
        
              ];

     

       161276
       161202
        
              maintainers = with lib.maintainers; [ sternenseemann ];

     

       161277
       161203
        
            }) {};

     

       161278
       161204
        
       

     

       161205
       161205
       +
         "large-records" = callPackage

     

       161206
       161206
       +
           ({ mkDerivation, aeson, base, containers, generic-deriving

     

       161207
       161207
       +
            , generics-sop, ghc-dump-core, haskell-src-exts, haskell-src-meta

     

       161208
       161208
       +
            , json-sop, microlens, mtl, newtype, QuickCheck

     

       161209
       161209
       +
            , record-dot-preprocessor, record-hasfield, sop-core, syb, tasty

     

       161210
       161210
       +
            , tasty-hunit, tasty-quickcheck, template-haskell, text

     

       161211
       161211
       +
            , transformers, vector

     

       161212
       161212
       +
            }:

     

       161213
       161213
       +
            mkDerivation {

     

       161214
       161214
       +
              pname = "large-records";

     

       161215
       161215
       +
              version = "0.1.0.0";

     

       161216
       161216
       +
              sha256 = "1l4j7vb3lckqn1cvyvcg6g3bnvi8x69nsjmkmmi7666025bxfw61";

     

       161217
       161217
       +
              revision = "1";

     

       161218
       161218
       +
              editedCabalFile = "1j89aypcp97vwb7qyg4n2ffilsp064z1w7kck1wh2rp69wk5r51n";

     

       161219
       161219
       +
              libraryHaskellDepends = [

     

       161220
       161220
       +
                aeson base containers generics-sop haskell-src-exts

     

       161221
       161221
       +
                haskell-src-meta microlens mtl record-hasfield sop-core syb

     

       161222
       161222
       +
                template-haskell text vector

     

       161223
       161223
       +
              ];

     

       161224
       161224
       +
              testHaskellDepends = [

     

       161225
       161225
       +
                aeson base generic-deriving generics-sop ghc-dump-core json-sop

     

       161226
       161226
       +
                microlens mtl newtype QuickCheck record-dot-preprocessor

     

       161227
       161227
       +
                record-hasfield sop-core tasty tasty-hunit tasty-quickcheck

     

       161228
       161228
       +
                template-haskell transformers vector

     

       161229
       161229
       +
              ];

     

       161230
       161230
       +
              testToolDepends = [ record-dot-preprocessor ];

     

       161231
       161231
       +
              description = "Efficient compilation for large records, linear in the size of the record";

     

       161232
       161232
       +
              license = lib.licenses.bsd3;

     

       161233
       161233
       +
            }) {};

     

       161234
       161234
       +
       

     

       161279
       161235
        
         "largeword" = callPackage

     

       161280
       161236
        
           ({ mkDerivation, base, binary, bytestring, HUnit, QuickCheck

     

       161281
       161237
        
            , test-framework, test-framework-hunit, test-framework-quickcheck2

     
···

       165595
       165551
        
              description = "Use SMT solvers to solve linear systems over integers and rationals";

     

       165596
       165552
        
              license = lib.licenses.bsd3;

     

       165597
       165553
        
              platforms = [

     

       165598
       165598
       -
                "armv7l-linux" "i686-linux" "x86_64-darwin" "x86_64-linux"

     

       165554
       165554
       +
                "aarch64-darwin" "armv7l-linux" "i686-linux" "x86_64-darwin"

     

       165555
       165555
       +
                "x86_64-linux"

     

       165599
       165556
        
              ];

     

       165600
       165557
        
            }) {};

     

       165601
       165558
        
       

     
···

       169871
       169828
        
              ];

     

       169872
       169829
        
              description = "Core functionality for LTI 1.3.";

     

       169873
       169830
        
              license = lib.licenses.lgpl3Only;

     

       169874
       169874
       -
              hydraPlatforms = lib.platforms.none;

     

       169875
       169831
        
            }) {};

     

       169876
       169832
        
       

     

       169877
       169833
        
         "ltiv1p1" = callPackage

     
···

       174208
       174164
        
              ];

     

       174209
       174165
        
              description = "Sample from a posterior using Markov chain Monte Carlo";

     

       174210
       174166
        
              license = lib.licenses.gpl3Plus;

     

       174211
       174211
       -
              hydraPlatforms = lib.platforms.none;

     

       174212
       174167
        
            }) {};

     

       174213
       174168
        
       

     

       174214
       174169
        
         "mcmc-samplers" = callPackage

     
···

       177859
       177814
        
            }:

     

       177860
       177815
        
            mkDerivation {

     

       177861
       177816
        
              pname = "mixed-types-num";

     

       177862
       177862
       -
              version = "0.5.8.0";

     

       177863
       177863
       -
              sha256 = "1i40g6kf4my91i7xg54wfi6n2s8ivmx5k08ccqz3iycn6gha8pr7";

     

       177864
       177864
       -
              libraryHaskellDepends = [

     

       177865
       177865
       -
                base collect-errors hspec hspec-smallcheck mtl QuickCheck

     

       177866
       177866
       -
                smallcheck template-haskell

     

       177867
       177867
       -
              ];

     

       177868
       177868
       -
              testHaskellDepends = [

     

       177869
       177869
       -
                base collect-errors hspec hspec-smallcheck QuickCheck smallcheck

     

       177870
       177870
       -
              ];

     

       177871
       177871
       -
              description = "Alternative Prelude with numeric and logic expressions typed bottom-up";

     

       177872
       177872
       -
              license = lib.licenses.bsd3;

     

       177873
       177873
       -
            }) {};

     

       177874
       177874
       -
       

     

       177875
       177875
       -
         "mixed-types-num_0_5_9_1" = callPackage

     

       177876
       177876
       -
           ({ mkDerivation, base, collect-errors, hspec, hspec-smallcheck, mtl

     

       177877
       177877
       -
            , QuickCheck, smallcheck, template-haskell

     

       177878
       177878
       -
            }:

     

       177879
       177879
       -
            mkDerivation {

     

       177880
       177880
       -
              pname = "mixed-types-num";

     

       177881
       177817
        
              version = "0.5.9.1";

     

       177882
       177818
        
              sha256 = "009hsagx0g1myf2jlljqnf96mwnz3a4jbcmrcjs0lizskprzj1n2";

     

       177883
       177819
        
              libraryHaskellDepends = [

     
···

       177889
       177825
        
              ];

     

       177890
       177826
        
              description = "Alternative Prelude with numeric and logic expressions typed bottom-up";

     

       177891
       177827
        
              license = lib.licenses.bsd3;

     

       177892
       177892
       -
              hydraPlatforms = lib.platforms.none;

     

       177893
       177828
        
            }) {};

     

       177894
       177829
        
       

     

       177895
       177830
        
         "mixpanel-client" = callPackage

     
···

       179180
       179115
        
            }:

     

       179181
       179116
        
            mkDerivation {

     

       179182
       179117
        
              pname = "monad-control";

     

       179183
       179183
       -
              version = "1.0.3";

     

       179184
       179184
       -
              sha256 = "16rdv4s85ni1xdbd8nzarm4sh331198jnmakrn5wxla9hrfwg2fi";

     

       179185
       179185
       -
              libraryHaskellDepends = [

     

       179186
       179186
       -
                base stm transformers transformers-base transformers-compat

     

       179187
       179187
       -
              ];

     

       179188
       179188
       -
              description = "Lift control operations, like exception catching, through monad transformers";

     

       179189
       179189
       -
              license = lib.licenses.bsd3;

     

       179190
       179190
       -
            }) {};

     

       179191
       179191
       -
       

     

       179192
       179192
       -
         "monad-control_1_0_3_1" = callPackage

     

       179193
       179193
       -
           ({ mkDerivation, base, stm, transformers, transformers-base

     

       179194
       179194
       -
            , transformers-compat

     

       179195
       179195
       -
            }:

     

       179196
       179196
       -
            mkDerivation {

     

       179197
       179197
       -
              pname = "monad-control";

     

       179198
       179118
        
              version = "1.0.3.1";

     

       179199
       179119
        
              sha256 = "0g3if9km8ik80bcy130a826ig9wlk4bnf0qli3vmwdwr9nhaw2xf";

     

       179200
       179120
        
              libraryHaskellDepends = [

     
···

       179202
       179122
        
              ];

     

       179203
       179123
        
              description = "Lift control operations, like exception catching, through monad transformers";

     

       179204
       179124
        
              license = lib.licenses.bsd3;

     

       179205
       179205
       -
              hydraPlatforms = lib.platforms.none;

     

       179206
       179125
        
            }) {};

     

       179207
       179126
        
       

     

       179208
       179127
        
         "monad-control-aligned" = callPackage

     
···

       179241
       179160
        
            }:

     

       179242
       179161
        
            mkDerivation {

     

       179243
       179162
        
              pname = "monad-coroutine";

     

       179244
       179244
       -
              version = "0.9.1.2";

     

       179245
       179245
       -
              sha256 = "1s4975q1k23b2skyq9mwkkda08f2zxkv96x0yplzhz9n64kchhf3";

     

       179246
       179246
       -
              libraryHaskellDepends = [

     

       179247
       179247
       -
                base monad-parallel transformers transformers-compat

     

       179248
       179248
       -
              ];

     

       179249
       179249
       -
              description = "Coroutine monad transformer for suspending and resuming monadic computations";

     

       179250
       179250
       -
              license = "GPL";

     

       179251
       179251
       -
            }) {};

     

       179252
       179252
       -
       

     

       179253
       179253
       -
         "monad-coroutine_0_9_1_3" = callPackage

     

       179254
       179254
       -
           ({ mkDerivation, base, monad-parallel, transformers

     

       179255
       179255
       -
            , transformers-compat

     

       179256
       179256
       -
            }:

     

       179257
       179257
       -
            mkDerivation {

     

       179258
       179258
       -
              pname = "monad-coroutine";

     

       179259
       179163
        
              version = "0.9.1.3";

     

       179260
       179164
        
              sha256 = "0ns8863695hm4yabd4908znpn1bqc7ayfnzl9bkkqhs70rff2dmh";

     

       179261
       179165
        
              libraryHaskellDepends = [

     
···

       179263
       179167
        
              ];

     

       179264
       179168
        
              description = "Coroutine monad transformer for suspending and resuming monadic computations";

     

       179265
       179169
        
              license = "GPL";

     

       179266
       179266
       -
              hydraPlatforms = lib.platforms.none;

     

       179267
       179170
        
            }) {};

     

       179268
       179171
        
       

     

       179269
       179172
        
         "monad-dijkstra" = callPackage

     
···

       179838
       179741
        
            }:

     

       179839
       179742
        
            mkDerivation {

     

       179840
       179743
        
              pname = "monad-parallel";

     

       179841
       179841
       -
              version = "0.7.2.4";

     

       179842
       179842
       -
              sha256 = "1h36hwbk800v0cq2x8kxf7v3gkr8maws7ijxckvsqp480xr4r5xx";

     

       179843
       179843
       -
              libraryHaskellDepends = [

     

       179844
       179844
       -
                base parallel transformers transformers-compat

     

       179845
       179845
       -
              ];

     

       179846
       179846
       -
              description = "Parallel execution of monadic computations";

     

       179847
       179847
       -
              license = lib.licenses.bsd3;

     

       179848
       179848
       -
            }) {};

     

       179849
       179849
       -
       

     

       179850
       179850
       -
         "monad-parallel_0_7_2_5" = callPackage

     

       179851
       179851
       -
           ({ mkDerivation, base, parallel, transformers, transformers-compat

     

       179852
       179852
       -
            }:

     

       179853
       179853
       -
            mkDerivation {

     

       179854
       179854
       -
              pname = "monad-parallel";

     

       179855
       179744
        
              version = "0.7.2.5";

     

       179856
       179745
        
              sha256 = "0yjn8acn8z8b1v5nnmwrmrcim9lqh942kgi2c03cnnklfdc1cqip";

     

       179857
       179746
        
              libraryHaskellDepends = [

     
···

       179859
       179748
        
              ];

     

       179860
       179749
        
              description = "Parallel execution of monadic computations";

     

       179861
       179750
        
              license = lib.licenses.bsd3;

     

       179862
       179862
       -
              hydraPlatforms = lib.platforms.none;

     

       179863
       179751
        
            }) {};

     

       179864
       179752
        
       

     

       179865
       179753
        
         "monad-parallel-progressbar" = callPackage

     
···

       180163
       180051
        
              broken = true;

     

       180164
       180052
        
            }) {};

     

       180165
       180053
        
       

     

       180054
       180054
       +
         "monad-tree" = callPackage

     

       180055
       180055
       +
           ({ mkDerivation, base }:

     

       180056
       180056
       +
            mkDerivation {

     

       180057
       180057
       +
              pname = "monad-tree";

     

       180058
       180058
       +
              version = "0.1.0";

     

       180059
       180059
       +
              sha256 = "1rjrcai2wqz3qkn3sk1fj6c0vvzk58gmghzwp9w9xvr09kd7zyd2";

     

       180060
       180060
       +
              libraryHaskellDepends = [ base ];

     

       180061
       180061
       +
              description = "Tree data structure for nondeterministic computations";

     

       180062
       180062
       +
              license = lib.licenses.mit;

     

       180063
       180063
       +
            }) {};

     

       180064
       180064
       +
       

     

       180166
       180065
        
         "monad-tx" = callPackage

     

       180167
       180066
        
           ({ mkDerivation, base }:

     

       180168
       180067
        
            mkDerivation {

     
···

       181020
       180919
        
            }:

     

       181021
       180920
        
            mkDerivation {

     

       181022
       180921
        
              pname = "monomer";

     

       181023
       181023
       -
              version = "1.0.0.1";

     

       181024
       181024
       -
              sha256 = "1ns4zm1vny8r49k0iq77b75s17gqmzxjv3kj70a4k5j4jx5s70fr";

     

       180922
       180922
       +
              version = "1.0.0.2";

     

       180923
       180923
       +
              sha256 = "1m0c6ldc5sg2if4b21n7b13f5rpyws0vmw9nn8gjqly7rbq446az";

     

       181025
       180924
        
              isLibrary = true;

     

       181026
       180925
        
              isExecutable = true;

     

       181027
       180926
        
              libraryHaskellDepends = [

     
···

       181048
       180947
        
              ];

     

       181049
       180948
        
              description = "A GUI library for writing native Haskell applications";

     

       181050
       180949
        
              license = lib.licenses.bsd3;

     

       181051
       181051
       -
              hydraPlatforms = lib.platforms.none;

     

       181052
       180950
        
            }) {inherit (pkgs) glew;};

     

       181053
       180951
        
       

     

       181054
       180952
        
         "monomorphic" = callPackage

     
···

       182086
       181984
        
              description = "Save your spot when watching movies with @mplayer@";

     

       182087
       181985
        
              license = lib.licenses.bsd3;

     

       182088
       181986
        
              platforms = [

     

       182089
       182089
       -
                "armv7l-linux" "i686-linux" "x86_64-darwin" "x86_64-linux"

     

       181987
       181987
       +
                "aarch64-darwin" "armv7l-linux" "i686-linux" "x86_64-darwin"

     

       181988
       181988
       +
                "x86_64-linux"

     

       182090
       181989
        
              ];

     

       182091
       181990
        
            }) {};

     

       182092
       181991
        
       

     
···

       184710
       184609
        
            }:

     

       184711
       184610
        
            mkDerivation {

     

       184712
       184611
        
              pname = "mwc-random";

     

       184713
       184713
       -
              version = "0.15.0.1";

     

       184714
       184714
       -
              sha256 = "1p8c5g4hb72k90ai39rgpn6cr942i6636l1y0zfp9xgjb3v0a2q3";

     

       184715
       184715
       -
              revision = "2";

     

       184716
       184716
       -
              editedCabalFile = "0si7d23ycyg1072w10v06zh1xx4yy5jxwmrrs65inrs7fhdb1r28";

     

       184717
       184717
       -
              libraryHaskellDepends = [

     

       184718
       184718
       -
                base math-functions primitive random time vector

     

       184719
       184719
       -
              ];

     

       184720
       184720
       -
              testHaskellDepends = [

     

       184721
       184721
       -
                base bytestring doctest primitive QuickCheck random tasty

     

       184722
       184722
       -
                tasty-hunit tasty-quickcheck vector

     

       184723
       184723
       -
              ];

     

       184724
       184724
       -
              benchmarkHaskellDepends = [

     

       184725
       184725
       -
                base gauge mersenne-random random vector

     

       184726
       184726
       -
              ];

     

       184727
       184727
       -
              doCheck = false;

     

       184728
       184728
       -
              description = "Fast, high quality pseudo random number generation";

     

       184729
       184729
       -
              license = lib.licenses.bsd3;

     

       184730
       184730
       -
            }) {};

     

       184731
       184731
       -
       

     

       184732
       184732
       -
         "mwc-random_0_15_0_2" = callPackage

     

       184733
       184733
       -
           ({ mkDerivation, base, bytestring, doctest, gauge, math-functions

     

       184734
       184734
       -
            , mersenne-random, primitive, QuickCheck, random, tasty

     

       184735
       184735
       -
            , tasty-hunit, tasty-quickcheck, time, vector

     

       184736
       184736
       -
            }:

     

       184737
       184737
       -
            mkDerivation {

     

       184738
       184738
       -
              pname = "mwc-random";

     

       184739
       184612
        
              version = "0.15.0.2";

     

       184740
       184613
        
              sha256 = "0ny2mw4am24d6ykrm8rbcjnrq6p2cjmzjb4m6qfk54wfdxflvmim";

     

       184741
       184614
        
              libraryHaskellDepends = [

     
···

       184751
       184624
        
              doCheck = false;

     

       184752
       184625
        
              description = "Fast, high quality pseudo random number generation";

     

       184753
       184626
        
              license = lib.licenses.bsd3;

     

       184754
       184754
       -
              hydraPlatforms = lib.platforms.none;

     

       184755
       184627
        
            }) {};

     

       184756
       184628
        
       

     

       184757
       184629
        
         "mwc-random-accelerate" = callPackage

     
···

       185847
       185719
        
            }:

     

       185848
       185720
        
            mkDerivation {

     

       185849
       185721
        
              pname = "nanovg";

     

       185850
       185850
       -
              version = "0.7.0.0";

     

       185851
       185851
       -
              sha256 = "1mrn5dy05nl5kkxw5vfgf57wifllq7jnv0akd1wi9wnlgvvqjnqz";

     

       185722
       185722
       +
              version = "0.8.0.0";

     

       185723
       185723
       +
              sha256 = "1il4305wv7f53225jv5s04nf7gf5rw6cfxm8j3v1di2xvhdingz5";

     

       185852
       185724
        
              isLibrary = true;

     

       185853
       185725
        
              isExecutable = true;

     

       185854
       185726
        
              libraryHaskellDepends = [ base bytestring containers text vector ];

     

       185855
       185855
       -
              librarySystemDepends = [ freetype glew libGL libGLU libX11 ];

     

       185856
       185856
       -
              libraryPkgconfigDepends = [ glew ];

     

       185727
       185727
       +
              librarySystemDepends = [ glew libGL libGLU libX11 ];

     

       185728
       185728
       +
              libraryPkgconfigDepends = [ freetype glew ];

     

       185857
       185729
        
              libraryToolDepends = [ c2hs ];

     

       185858
       185730
        
              testHaskellDepends = [ base containers hspec inline-c QuickCheck ];

     

       185859
       185731
        
              description = "Haskell bindings for nanovg";

     

       185860
       185732
        
              license = lib.licenses.isc;

     

       185861
       185861
       -
              hydraPlatforms = lib.platforms.none;

     

       185862
       185862
       -
              broken = true;

     

       185863
       185733
        
            }) {inherit (pkgs) freetype; inherit (pkgs) glew; 

     

       185864
       185734
        
                inherit (pkgs) libGL; inherit (pkgs) libGLU; 

     

       185865
       185735
        
                inherit (pkgs.xorg) libX11;};

     
···

       185879
       185749
        
              ];

     

       185880
       185750
        
              description = "Simple interface to rendering with NanoVG";

     

       185881
       185751
        
              license = lib.licenses.bsd3;

     

       185882
       185882
       -
              hydraPlatforms = lib.platforms.none;

     

       185883
       185752
        
            }) {};

     

       185884
       185753
        
       

     

       185885
       185754
        
         "nanq" = callPackage

     
···

       187052
       186921
        
           ({ mkDerivation, base, comfort-array, netlib-ffi, transformers }:

     

       187053
       186922
        
            mkDerivation {

     

       187054
       186923
        
              pname = "netlib-comfort-array";

     

       187055
       187055
       -
              version = "0.0.0.1";

     

       187056
       187056
       -
              sha256 = "0v4p1l8gjqkxncjrp6bv664x6xs3y6n5h76pvgccsja5rammwbp3";

     

       187057
       187057
       -
              libraryHaskellDepends = [

     

       187058
       187058
       -
                base comfort-array netlib-ffi transformers

     

       187059
       187059
       -
              ];

     

       187060
       187060
       -
              description = "Helper modules for comfort-array wrappers to BLAS and LAPACK";

     

       187061
       187061
       -
              license = lib.licenses.bsd3;

     

       187062
       187062
       -
            }) {};

     

       187063
       187063
       -
       

     

       187064
       187064
       -
         "netlib-comfort-array_0_0_0_2" = callPackage

     

       187065
       187065
       -
           ({ mkDerivation, base, comfort-array, netlib-ffi, transformers }:

     

       187066
       187066
       -
            mkDerivation {

     

       187067
       187067
       -
              pname = "netlib-comfort-array";

     

       187068
       186924
        
              version = "0.0.0.2";

     

       187069
       186925
        
              sha256 = "1mwgdll9m0ryy5y1385sx2asff98kqfkz4bif8s4i0dkrqalsfx4";

     

       187070
       186926
        
              libraryHaskellDepends = [

     
···

       187072
       186928
        
              ];

     

       187073
       186929
        
              description = "Helper modules for comfort-array wrappers to BLAS and LAPACK";

     

       187074
       186930
        
              license = lib.licenses.bsd3;

     

       187075
       187075
       -
              hydraPlatforms = lib.platforms.none;

     

       187076
       186931
        
            }) {};

     

       187077
       186932
        
       

     

       187078
       186933
        
         "netlib-ffi" = callPackage

     
···

       190578
       190433
        
              hydraPlatforms = lib.platforms.none;

     

       190579
       190434
        
            }) {};

     

       190580
       190435
        
       

     

       190436
       190436
       +
         "not-prelude" = callPackage

     

       190437
       190437
       +
           ({ mkDerivation, base-noprelude, data-default, exceptions, failable

     

       190438
       190438
       +
            , mtl, text, transformers

     

       190439
       190439
       +
            }:

     

       190440
       190440
       +
            mkDerivation {

     

       190441
       190441
       +
              pname = "not-prelude";

     

       190442
       190442
       +
              version = "0.1.0.0";

     

       190443
       190443
       +
              sha256 = "0hb3ri6g1v21wi3saaai56b1a2r76g2dgaa7xqqchi31lh004131";

     

       190444
       190444
       +
              libraryHaskellDepends = [

     

       190445
       190445
       +
                base-noprelude data-default exceptions failable mtl text

     

       190446
       190446
       +
                transformers

     

       190447
       190447
       +
              ];

     

       190448
       190448
       +
              description = "An opinionated Prelude replacement library";

     

       190449
       190449
       +
              license = lib.licenses.mit;

     

       190450
       190450
       +
            }) {};

     

       190451
       190451
       +
       

     

       190581
       190452
        
         "notcpp" = callPackage

     

       190582
       190453
        
           ({ mkDerivation, base, template-haskell }:

     

       190583
       190454
        
            mkDerivation {

     
···

       193358
       193229
        
            }:

     

       193359
       193230
        
            mkDerivation {

     

       193360
       193231
        
              pname = "opaleye";

     

       193361
       193361
       -
              version = "0.7.3.0";

     

       193362
       193362
       -
              sha256 = "0ls8hk8iy47hna1y7kbakzv9ihp61lv605f1ap4di95fv03wy288";

     

       193363
       193363
       -
              libraryHaskellDepends = [

     

       193364
       193364
       -
                aeson base base16-bytestring bytestring case-insensitive

     

       193365
       193365
       -
                contravariant postgresql-simple pretty product-profunctors

     

       193366
       193366
       -
                profunctors scientific semigroups text time time-locale-compat

     

       193367
       193367
       -
                transformers uuid void

     

       193368
       193368
       -
              ];

     

       193369
       193369
       -
              testHaskellDepends = [

     

       193370
       193370
       -
                aeson base bytestring containers contravariant dotenv hspec

     

       193371
       193371
       -
                hspec-discover multiset postgresql-simple product-profunctors

     

       193372
       193372
       -
                profunctors QuickCheck semigroups text time transformers uuid

     

       193373
       193373
       -
              ];

     

       193374
       193374
       -
              testToolDepends = [ hspec-discover ];

     

       193375
       193375
       -
              description = "An SQL-generating DSL targeting PostgreSQL";

     

       193376
       193376
       -
              license = lib.licenses.bsd3;

     

       193377
       193377
       -
            }) {};

     

       193378
       193378
       -
       

     

       193379
       193379
       -
         "opaleye_0_7_4_0" = callPackage

     

       193380
       193380
       -
           ({ mkDerivation, aeson, base, base16-bytestring, bytestring

     

       193381
       193381
       -
            , case-insensitive, containers, contravariant, dotenv, hspec

     

       193382
       193382
       -
            , hspec-discover, multiset, postgresql-simple, pretty

     

       193383
       193383
       -
            , product-profunctors, profunctors, QuickCheck, scientific

     

       193384
       193384
       -
            , semigroups, text, time, time-locale-compat, transformers, uuid

     

       193385
       193385
       -
            , void

     

       193386
       193386
       -
            }:

     

       193387
       193387
       -
            mkDerivation {

     

       193388
       193388
       -
              pname = "opaleye";

     

       193389
       193232
        
              version = "0.7.4.0";

     

       193390
       193233
        
              sha256 = "1v4gxqnjacyj7npcvl70dzksgl12qrgwscv4l47kvzmf76i1x6rd";

     

       193391
       193234
        
              libraryHaskellDepends = [

     
···

       193402
       193245
        
              testToolDepends = [ hspec-discover ];

     

       193403
       193246
        
              description = "An SQL-generating DSL targeting PostgreSQL";

     

       193404
       193247
        
              license = lib.licenses.bsd3;

     

       193405
       193405
       -
              hydraPlatforms = lib.platforms.none;

     

       193406
       193248
        
            }) {};

     

       193407
       193249
        
       

     

       193408
       193250
        
         "opaleye-classy" = callPackage

     
···

       197108
       196950
        
              maintainers = with lib.maintainers; [ peti ];

     

       197109
       196951
        
            }) {};

     

       197110
       196952
        
       

     

       197111
       197111
       -
         "pandoc_2_14_1" = callPackage

     

       196953
       196953
       +
         "pandoc_2_14_2" = callPackage

     

       197112
       196954
        
           ({ mkDerivation, aeson, aeson-pretty, array, attoparsec, base

     

       197113
       196955
        
            , base64-bytestring, binary, blaze-html, blaze-markup, bytestring

     

       197114
       196956
        
            , case-insensitive, citeproc, commonmark, commonmark-extensions

     
···

       197116
       196958
        
            , Diff, directory, doclayout, doctemplates, emojis, exceptions

     

       197117
       196959
        
            , file-embed, filepath, Glob, haddock-library, hslua

     

       197118
       196960
        
            , hslua-module-path, hslua-module-system, hslua-module-text, HsYAML

     

       197119
       197119
       -
            , HTTP, http-client, http-client-tls, http-types, ipynb

     

       197120
       197120
       -
            , jira-wiki-markup, JuicyPixels, mtl, network, network-uri

     

       197121
       197121
       -
            , pandoc-types, parsec, process, QuickCheck, random, safe

     

       197122
       197122
       -
            , scientific, SHA, skylighting, skylighting-core, split, syb

     

       197123
       197123
       -
            , tagsoup, tasty, tasty-bench, tasty-golden, tasty-hunit, tasty-lua

     

       197124
       197124
       -
            , tasty-quickcheck, temporary, texmath, text, text-conversions

     

       197125
       197125
       -
            , time, unicode-collation, unicode-transforms, unix

     

       197126
       197126
       -
            , unordered-containers, xml, xml-conduit, zip-archive, zlib

     

       196961
       196961
       +
            , http-client, http-client-tls, http-types, ipynb, jira-wiki-markup

     

       196962
       196962
       +
            , JuicyPixels, mtl, network, network-uri, pandoc-types, parsec

     

       196963
       196963
       +
            , process, QuickCheck, random, safe, scientific, SHA, skylighting

     

       196964
       196964
       +
            , skylighting-core, split, syb, tagsoup, tasty, tasty-bench

     

       196965
       196965
       +
            , tasty-golden, tasty-hunit, tasty-lua, tasty-quickcheck, temporary

     

       196966
       196966
       +
            , texmath, text, text-conversions, time, unicode-collation

     

       196967
       196967
       +
            , unicode-transforms, unix, unordered-containers, xml, xml-conduit

     

       196968
       196968
       +
            , zip-archive, zlib

     

       197127
       196969
        
            }:

     

       197128
       196970
        
            mkDerivation {

     

       197129
       196971
        
              pname = "pandoc";

     

       197130
       197130
       -
              version = "2.14.1";

     

       197131
       197131
       -
              sha256 = "1jj011az45zpd201f3dwb90m22p60nv5bmpbh39li885xwv46qyq";

     

       196972
       196972
       +
              version = "2.14.2";

     

       196973
       196973
       +
              sha256 = "1bjw5di5dwfpnxgkj2qmri8f1nv6yin23cd8s38chwan29vd7xrc";

     

       197132
       196974
        
              configureFlags = [ "-fhttps" "-f-trypandoc" ];

     

       197133
       196975
        
              isLibrary = true;

     

       197134
       196976
        
              isExecutable = true;

     
···

       197139
       196981
        
                commonmark commonmark-extensions commonmark-pandoc connection

     

       197140
       196982
        
                containers data-default deepseq directory doclayout doctemplates

     

       197141
       196983
        
                emojis exceptions file-embed filepath Glob haddock-library hslua

     

       197142
       197142
       -
                hslua-module-path hslua-module-system hslua-module-text HsYAML HTTP

     

       196984
       196984
       +
                hslua-module-path hslua-module-system hslua-module-text HsYAML

     

       197143
       196985
        
                http-client http-client-tls http-types ipynb jira-wiki-markup

     

       197144
       196986
        
                JuicyPixels mtl network network-uri pandoc-types parsec process

     

       197145
       196987
        
                random safe scientific SHA skylighting skylighting-core split syb

     
···

       197573
       197415
        
              ];

     

       197574
       197416
        
              description = "A Pandoc filter to include figures generated from code blocks using your plotting toolkit of choice";

     

       197575
       197417
        
              license = lib.licenses.gpl2Plus;

     

       197418
       197418
       +
            }) {};

     

       197419
       197419
       +
       

     

       197420
       197420
       +
         "pandoc-plot_1_3_0" = callPackage

     

       197421
       197421
       +
           ({ mkDerivation, base, bytestring, containers, criterion

     

       197422
       197422
       +
            , data-default, directory, filepath, gitrev, hashable, hspec

     

       197423
       197423
       +
            , hspec-expectations, lifted-async, lifted-base, mtl

     

       197424
       197424
       +
            , optparse-applicative, pandoc, pandoc-types, shakespeare, tagsoup

     

       197425
       197425
       +
            , tasty, tasty-hspec, tasty-hunit, template-haskell, text

     

       197426
       197426
       +
            , typed-process, unix, yaml

     

       197427
       197427
       +
            }:

     

       197428
       197428
       +
            mkDerivation {

     

       197429
       197429
       +
              pname = "pandoc-plot";

     

       197430
       197430
       +
              version = "1.3.0";

     

       197431
       197431
       +
              sha256 = "0d33cbw0ygsdwh718q7q5gw2s6565dbrjwi3rz0qdf78q14wiayi";

     

       197432
       197432
       +
              isLibrary = true;

     

       197433
       197433
       +
              isExecutable = true;

     

       197434
       197434
       +
              libraryHaskellDepends = [

     

       197435
       197435
       +
                base bytestring containers data-default directory filepath hashable

     

       197436
       197436
       +
                lifted-async lifted-base mtl pandoc pandoc-types shakespeare

     

       197437
       197437
       +
                tagsoup template-haskell text typed-process unix yaml

     

       197438
       197438
       +
              ];

     

       197439
       197439
       +
              executableHaskellDepends = [

     

       197440
       197440
       +
                base containers directory filepath gitrev optparse-applicative

     

       197441
       197441
       +
                pandoc pandoc-types template-haskell text typed-process

     

       197442
       197442
       +
              ];

     

       197443
       197443
       +
              testHaskellDepends = [

     

       197444
       197444
       +
                base containers directory filepath hspec hspec-expectations

     

       197445
       197445
       +
                pandoc-types tasty tasty-hspec tasty-hunit text

     

       197446
       197446
       +
              ];

     

       197447
       197447
       +
              benchmarkHaskellDepends = [

     

       197448
       197448
       +
                base criterion pandoc-types template-haskell text

     

       197449
       197449
       +
              ];

     

       197450
       197450
       +
              description = "A Pandoc filter to include figures generated from code blocks using your plotting toolkit of choice";

     

       197451
       197451
       +
              license = lib.licenses.gpl2Plus;

     

       197452
       197452
       +
              hydraPlatforms = lib.platforms.none;

     

       197576
       197453
        
            }) {};

     

       197577
       197454
        
       

     

       197578
       197455
        
         "pandoc-pyplot" = callPackage

     
···

       199759
       199636
        
              ];

     

       199760
       199637
        
              description = "Hashing and checking of passwords";

     

       199761
       199638
        
              license = lib.licenses.bsd3;

     

       199762
       199762
       -
              platforms = [ "i686-linux" "x86_64-darwin" "x86_64-linux" ];

     

       199639
       199639
       +
              platforms = [

     

       199640
       199640
       +
                "aarch64-darwin" "i686-linux" "x86_64-darwin" "x86_64-linux"

     

       199641
       199641
       +
              ];

     

       199763
       199642
        
              maintainers = with lib.maintainers; [ cdepillabout ];

     

       199764
       199643
        
            }) {};

     

       199765
       199644
        
       

     
···

       199784
       199663
        
              ];

     

       199785
       199664
        
              description = "typeclass instances for password package";

     

       199786
       199665
        
              license = lib.licenses.bsd3;

     

       199787
       199787
       -
              platforms = [ "i686-linux" "x86_64-darwin" "x86_64-linux" ];

     

       199666
       199666
       +
              platforms = [

     

       199667
       199667
       +
                "aarch64-darwin" "i686-linux" "x86_64-darwin" "x86_64-linux"

     

       199668
       199668
       +
              ];

     

       199788
       199669
        
              maintainers = with lib.maintainers; [ cdepillabout ];

     

       199789
       199670
        
            }) {};

     

       199790
       199671
        
       

     
···

       200787
       200668
        
              license = lib.licenses.asl20;

     

       200788
       200669
        
            }) {};

     

       200789
       200670
        
       

     

       200790
       200790
       -
         "pcre2_2_0_0" = callPackage

     

       200791
       200791
       -
           ({ mkDerivation, base, containers, criterion, hspec

     

       200671
       200671
       +
         "pcre2_2_0_1" = callPackage

     

       200672
       200672
       +
           ({ mkDerivation, base, containers, criterion, hspec, microlens

     

       200792
       200673
        
            , microlens-platform, mtl, pcre-light, regex-pcre-builtin

     

       200793
       200674
        
            , template-haskell, text

     

       200794
       200675
        
            }:

     

       200795
       200676
        
            mkDerivation {

     

       200796
       200677
        
              pname = "pcre2";

     

       200797
       200797
       -
              version = "2.0.0";

     

       200798
       200798
       -
              sha256 = "1jkyc2s3x5n7zrw9b78gk8jj262xfmg8cva2gr7mlzzl0hd9r11y";

     

       200678
       200678
       +
              version = "2.0.1";

     

       200679
       200679
       +
              sha256 = "0f93z99qhlhyvq7xsfn0nap9cxpxg2hs7790jqc5hi5kmqxlwvmy";

     

       200799
       200680
        
              libraryHaskellDepends = [

     

       200800
       200800
       -
                base containers mtl template-haskell text

     

       200681
       200681
       +
                base containers microlens mtl template-haskell text

     

       200801
       200682
        
              ];

     

       200802
       200683
        
              testHaskellDepends = [

     

       200803
       200803
       -
                base containers hspec microlens-platform mtl template-haskell text

     

       200684
       200684
       +
                base containers hspec microlens microlens-platform mtl

     

       200685
       200685
       +
                template-haskell text

     

       200804
       200686
        
              ];

     

       200805
       200687
        
              benchmarkHaskellDepends = [

     

       200806
       200806
       -
                base containers criterion microlens-platform mtl pcre-light

     

       200807
       200807
       -
                regex-pcre-builtin template-haskell text

     

       200688
       200688
       +
                base containers criterion microlens microlens-platform mtl

     

       200689
       200689
       +
                pcre-light regex-pcre-builtin template-haskell text

     

       200808
       200690
        
              ];

     

       200809
       200691
        
              description = "Regular expressions via the PCRE2 C library (included)";

     

       200810
       200692
        
              license = lib.licenses.asl20;

     
···

       201959
       201841
        
              ];

     

       201960
       201842
        
              description = "Serialization library with state and leb128 encoding";

     

       201961
       201843
        
              license = lib.licenses.bsd3;

     

       201962
       201962
       -
              platforms = [ "i686-linux" "x86_64-darwin" "x86_64-linux" ];

     

       201844
       201844
       +
              platforms = [

     

       201845
       201845
       +
                "aarch64-darwin" "i686-linux" "x86_64-darwin" "x86_64-linux"

     

       201846
       201846
       +
              ];

     

       201963
       201847
        
            }) {};

     

       201964
       201848
        
       

     

       201965
       201849
        
         "persist2er" = callPackage

     
···

       204517
       204401
        
            }:

     

       204518
       204402
        
            mkDerivation {

     

       204519
       204403
        
              pname = "pinned-warnings";

     

       204520
       204520
       -
              version = "0.1.0.6";

     

       204521
       204521
       -
              sha256 = "1n0h2v71x3j0wn0g2f3zq3xw681s16hl7ffywi83z50hacd8x6kx";

     

       204404
       204404
       +
              version = "0.1.0.8";

     

       204405
       204405
       +
              sha256 = "0ky5lqvf1bfbjzblqgnj47jhkxw4fb7gz7k268hnf41gfnbsy3i4";

     

       204522
       204406
        
              libraryHaskellDepends = [

     

       204523
       204407
        
                base bytestring containers directory ghc time transformers

     

       204524
       204408
        
              ];

     
···

       212008
       211892
        
       

     

       212009
       211893
        
         "primitive" = callPackage

     

       212010
       211894
        
           ({ mkDerivation, base, base-orphans, deepseq, ghc-prim, QuickCheck

     

       212011
       212011
       -
            , quickcheck-classes-base, semigroups, tagged, tasty

     

       212012
       212012
       -
            , tasty-quickcheck, transformers, transformers-compat

     

       212013
       212013
       -
            }:

     

       212014
       212014
       -
            mkDerivation {

     

       212015
       212015
       -
              pname = "primitive";

     

       212016
       212016
       -
              version = "0.7.1.0";

     

       212017
       212017
       -
              sha256 = "1w53i4mk248g58xrffmksznr4nmn2bbbycajzpcqfxx5ybyyrsvb";

     

       212018
       212018
       -
              revision = "3";

     

       212019
       212019
       -
              editedCabalFile = "03vgkhib8w3g0m0zwpz74hsixrf0pvgh6ql0xcy05fpq1kynppi9";

     

       212020
       212020
       -
              libraryHaskellDepends = [ base deepseq transformers ];

     

       212021
       212021
       -
              testHaskellDepends = [

     

       212022
       212022
       -
                base base-orphans ghc-prim QuickCheck quickcheck-classes-base

     

       212023
       212023
       -
                semigroups tagged tasty tasty-quickcheck transformers

     

       212024
       212024
       -
                transformers-compat

     

       212025
       212025
       -
              ];

     

       212026
       212026
       -
              description = "Primitive memory-related operations";

     

       212027
       212027
       -
              license = lib.licenses.bsd3;

     

       212028
       212028
       -
            }) {};

     

       212029
       212029
       -
       

     

       212030
       212030
       -
         "primitive_0_7_2_0" = callPackage

     

       212031
       212031
       -
           ({ mkDerivation, base, base-orphans, deepseq, ghc-prim, QuickCheck

     

       212032
       211895
        
            , quickcheck-classes-base, tagged, tasty, tasty-quickcheck

     

       212033
       211896
        
            , transformers, transformers-compat

     

       212034
       211897
        
            }:

     
···

       212043
       211906
        
              ];

     

       212044
       211907
        
              description = "Primitive memory-related operations";

     

       212045
       211908
        
              license = lib.licenses.bsd3;

     

       212046
       212046
       -
              hydraPlatforms = lib.platforms.none;

     

       212047
       211909
        
            }) {};

     

       212048
       211910
        
       

     

       212049
       211911
        
         "primitive-addr" = callPackage

     
···

       224882
       224744
        
            }:

     

       224883
       224745
        
            mkDerivation {

     

       224884
       224746
        
              pname = "replace-attoparsec";

     

       224885
       224885
       -
              version = "1.4.4.0";

     

       224886
       224886
       -
              sha256 = "06js4adbzvm2qn18vlaaxhav2dq1hqp825lmsvpg69cylp72fzif";

     

       224887
       224887
       -
              libraryHaskellDepends = [ attoparsec base bytestring text ];

     

       224888
       224888
       -
              testHaskellDepends = [

     

       224889
       224889
       -
                attoparsec base bytestring Cabal parsers text

     

       224890
       224890
       -
              ];

     

       224891
       224891
       -
              description = "Find, replace, and split string patterns with Attoparsec parsers (instead of regex)";

     

       224892
       224892
       -
              license = lib.licenses.bsd2;

     

       224893
       224893
       -
            }) {};

     

       224894
       224894
       -
       

     

       224895
       224895
       -
         "replace-attoparsec_1_4_5_0" = callPackage

     

       224896
       224896
       -
           ({ mkDerivation, attoparsec, base, bytestring, Cabal, parsers, text

     

       224897
       224897
       -
            }:

     

       224898
       224898
       -
            mkDerivation {

     

       224899
       224899
       -
              pname = "replace-attoparsec";

     

       224900
       224747
        
              version = "1.4.5.0";

     

       224901
       224748
        
              sha256 = "1mr7d6w5x6igsvl6mccchr2wbxxr5p86kpyxlbk7m17dplvwazcq";

     

       224902
       224749
        
              libraryHaskellDepends = [ attoparsec base bytestring text ];

     
···

       224905
       224752
        
              ];

     

       224906
       224753
        
              description = "Find, replace, and split string patterns with Attoparsec parsers (instead of regex)";

     

       224907
       224754
        
              license = lib.licenses.bsd2;

     

       224908
       224908
       -
              hydraPlatforms = lib.platforms.none;

     

       224909
       224755
        
            }) {};

     

       224910
       224756
        
       

     

       224911
       224757
        
         "replace-megaparsec" = callPackage

     
···

       225198
       225044
        
       

     

       225199
       225045
        
         "req-conduit" = callPackage

     

       225200
       225046
        
           ({ mkDerivation, base, bytestring, conduit, conduit-extra, hspec

     

       225201
       225201
       -
            , http-client, req, resourcet, temporary, transformers, weigh

     

       225202
       225202
       -
            }:

     

       225203
       225203
       -
            mkDerivation {

     

       225204
       225204
       -
              pname = "req-conduit";

     

       225205
       225205
       -
              version = "1.0.0";

     

       225206
       225206
       -
              sha256 = "193bv4jp7rrbpb1i9as9s2l978wz5kbz5kvr7ppllif5ppj699qx";

     

       225207
       225207
       -
              revision = "8";

     

       225208
       225208
       -
              editedCabalFile = "1md7zajmw87qrx6rvs35yrkbjs3s9nm0akg35jmf7a34xccrr7a7";

     

       225209
       225209
       -
              libraryHaskellDepends = [

     

       225210
       225210
       -
                base bytestring conduit http-client req resourcet transformers

     

       225211
       225211
       -
              ];

     

       225212
       225212
       -
              testHaskellDepends = [

     

       225213
       225213
       -
                base bytestring conduit conduit-extra hspec req resourcet temporary

     

       225214
       225214
       -
                transformers

     

       225215
       225215
       -
              ];

     

       225216
       225216
       -
              benchmarkHaskellDepends = [

     

       225217
       225217
       -
                base bytestring conduit conduit-extra req resourcet temporary weigh

     

       225218
       225218
       -
              ];

     

       225219
       225219
       -
              description = "Conduit helpers for the req HTTP client library";

     

       225220
       225220
       -
              license = lib.licenses.bsd3;

     

       225221
       225221
       -
              hydraPlatforms = lib.platforms.none;

     

       225222
       225222
       -
              broken = true;

     

       225223
       225223
       -
            }) {};

     

       225224
       225224
       -
       

     

       225225
       225225
       -
         "req-conduit_1_0_1" = callPackage

     

       225226
       225226
       -
           ({ mkDerivation, base, bytestring, conduit, conduit-extra, hspec

     

       225227
       225047
        
            , hspec-discover, http-client, req, resourcet, temporary

     

       225228
       225048
        
            , transformers, weigh

     

       225229
       225049
        
            }:

     
···

       225730
       225550
        
            }:

     

       225731
       225551
        
            mkDerivation {

     

       225732
       225552
        
              pname = "resourcet";

     

       225733
       225733
       -
              version = "1.2.4.2";

     

       225734
       225734
       -
              sha256 = "11zb4figcs22hjaq6zsknf70kf9k2bxnw6w03ab9kl9s0i10iwhp";

     

       225735
       225735
       -
              libraryHaskellDepends = [

     

       225736
       225736
       -
                base containers exceptions mtl primitive transformers unliftio-core

     

       225737
       225737
       -
              ];

     

       225738
       225738
       -
              testHaskellDepends = [ base exceptions hspec transformers ];

     

       225739
       225739
       -
              description = "Deterministic allocation and freeing of scarce resources";

     

       225740
       225740
       -
              license = lib.licenses.bsd3;

     

       225741
       225741
       -
            }) {};

     

       225742
       225742
       -
       

     

       225743
       225743
       -
         "resourcet_1_2_4_3" = callPackage

     

       225744
       225744
       -
           ({ mkDerivation, base, containers, exceptions, hspec, mtl

     

       225745
       225745
       -
            , primitive, transformers, unliftio-core

     

       225746
       225746
       -
            }:

     

       225747
       225747
       -
            mkDerivation {

     

       225748
       225748
       -
              pname = "resourcet";

     

       225749
       225553
        
              version = "1.2.4.3";

     

       225750
       225554
        
              sha256 = "0zrvnikw1a0r2j59k12fxikyrg0ki5a7xhqhjgfl9h6dqpz54h85";

     

       225751
       225555
        
              libraryHaskellDepends = [

     
···

       225754
       225558
        
              testHaskellDepends = [ base exceptions hspec transformers ];

     

       225755
       225559
        
              description = "Deterministic allocation and freeing of scarce resources";

     

       225756
       225560
        
              license = lib.licenses.bsd3;

     

       225757
       225757
       -
              hydraPlatforms = lib.platforms.none;

     

       225758
       225561
        
            }) {};

     

       225759
       225562
        
       

     

       225760
       225563
        
         "resourcet-pool" = callPackage

     
···

       226221
       226024
        
              license = lib.licenses.mit;

     

       226222
       226025
        
            }) {};

     

       226223
       226026
        
       

     

       226027
       226027
       +
         "retroclash-lib" = callPackage

     

       226028
       226028
       +
           ({ mkDerivation, barbies, base, clash-ghc, clash-lib, clash-prelude

     

       226029
       226029
       +
            , containers, ghc-typelits-extra, ghc-typelits-knownnat

     

       226030
       226030
       +
            , ghc-typelits-natnormalise, lens, lift-type, monoidal-containers

     

       226031
       226031
       +
            , mtl, template-haskell, transformers

     

       226032
       226032
       +
            }:

     

       226033
       226033
       +
            mkDerivation {

     

       226034
       226034
       +
              pname = "retroclash-lib";

     

       226035
       226035
       +
              version = "0.1.0";

     

       226036
       226036
       +
              sha256 = "062pjqhba41d4bb9gb8wxpd87mpsmzj3np8y9ymagjrnv5iyaf5w";

     

       226037
       226037
       +
              libraryHaskellDepends = [

     

       226038
       226038
       +
                barbies base clash-ghc clash-lib clash-prelude containers

     

       226039
       226039
       +
                ghc-typelits-extra ghc-typelits-knownnat ghc-typelits-natnormalise

     

       226040
       226040
       +
                lens lift-type monoidal-containers mtl template-haskell

     

       226041
       226041
       +
                transformers

     

       226042
       226042
       +
              ];

     

       226043
       226043
       +
              description = "Code shared across the code samples in the book \"Retrocomputing with Clash\"";

     

       226044
       226044
       +
              license = lib.licenses.mit;

     

       226045
       226045
       +
              hydraPlatforms = lib.platforms.none;

     

       226046
       226046
       +
            }) {};

     

       226047
       226047
       +
       

     

       226048
       226048
       +
         "retroclash-sim" = callPackage

     

       226049
       226049
       +
           ({ mkDerivation, array, arrows, base, clash-ghc, clash-lib

     

       226050
       226050
       +
            , clash-prelude, ghc-typelits-extra, ghc-typelits-knownnat

     

       226051
       226051
       +
            , ghc-typelits-natnormalise, lens, mtl, retroclash-lib, sdl2, text

     

       226052
       226052
       +
            , transformers

     

       226053
       226053
       +
            }:

     

       226054
       226054
       +
            mkDerivation {

     

       226055
       226055
       +
              pname = "retroclash-sim";

     

       226056
       226056
       +
              version = "0.1.0";

     

       226057
       226057
       +
              sha256 = "1wv8is17ds9y49an832dlgixly9b98h8x6ybc5dj7zzf1jwplyp8";

     

       226058
       226058
       +
              libraryHaskellDepends = [

     

       226059
       226059
       +
                array arrows base clash-ghc clash-lib clash-prelude

     

       226060
       226060
       +
                ghc-typelits-extra ghc-typelits-knownnat ghc-typelits-natnormalise

     

       226061
       226061
       +
                lens mtl retroclash-lib sdl2 text transformers

     

       226062
       226062
       +
              ];

     

       226063
       226063
       +
              description = "High-level simulators from the book \"Retrocomputing with Clash\"";

     

       226064
       226064
       +
              license = lib.licenses.mit;

     

       226065
       226065
       +
              hydraPlatforms = lib.platforms.none;

     

       226066
       226066
       +
            }) {};

     

       226067
       226067
       +
       

     

       226224
       226068
        
         "retry" = callPackage

     

       226225
       226069
        
           ({ mkDerivation, base, exceptions, ghc-prim, hedgehog, HUnit, mtl

     

       226226
       226070
        
            , random, stm, tasty, tasty-hedgehog, tasty-hunit, time

     
···

       227165
       227009
        
       

     

       227166
       227010
        
         "rio" = callPackage

     

       227167
       227011
        
           ({ mkDerivation, base, bytestring, containers, deepseq, directory

     

       227168
       227168
       -
            , exceptions, filepath, hashable, hspec, microlens, microlens-mtl

     

       227169
       227169
       -
            , mtl, primitive, process, QuickCheck, text, time, typed-process

     

       227170
       227170
       -
            , unix, unliftio, unliftio-core, unordered-containers, vector

     

       227171
       227171
       -
            }:

     

       227172
       227172
       -
            mkDerivation {

     

       227173
       227173
       -
              pname = "rio";

     

       227174
       227174
       -
              version = "0.1.20.0";

     

       227175
       227175
       -
              sha256 = "0x5b5c0y97b5n1lvbcsqlkhbv4nbbznx1w1fp3a17a03pz7qf61s";

     

       227176
       227176
       -
              libraryHaskellDepends = [

     

       227177
       227177
       -
                base bytestring containers deepseq directory exceptions filepath

     

       227178
       227178
       -
                hashable microlens microlens-mtl mtl primitive process text time

     

       227179
       227179
       -
                typed-process unix unliftio unliftio-core unordered-containers

     

       227180
       227180
       -
                vector

     

       227181
       227181
       -
              ];

     

       227182
       227182
       -
              testHaskellDepends = [

     

       227183
       227183
       -
                base bytestring containers deepseq directory exceptions filepath

     

       227184
       227184
       -
                hashable hspec microlens microlens-mtl mtl primitive process

     

       227185
       227185
       -
                QuickCheck text time typed-process unix unliftio unliftio-core

     

       227186
       227186
       -
                unordered-containers vector

     

       227187
       227187
       -
              ];

     

       227188
       227188
       -
              description = "A standard library for Haskell";

     

       227189
       227189
       -
              license = lib.licenses.mit;

     

       227190
       227190
       -
            }) {};

     

       227191
       227191
       -
       

     

       227192
       227192
       -
         "rio_0_1_21_0" = callPackage

     

       227193
       227193
       -
           ({ mkDerivation, base, bytestring, containers, deepseq, directory

     

       227194
       227012
        
            , exceptions, filepath, hashable, hspec, hspec-discover, microlens

     

       227195
       227013
        
            , microlens-mtl, mtl, primitive, process, QuickCheck, text, time

     

       227196
       227014
        
            , typed-process, unix, unliftio, unliftio-core

     
···

       227215
       227033
        
              testToolDepends = [ hspec-discover ];

     

       227216
       227034
        
              description = "A standard library for Haskell";

     

       227217
       227035
        
              license = lib.licenses.mit;

     

       227218
       227218
       -
              hydraPlatforms = lib.platforms.none;

     

       227219
       227036
        
            }) {};

     

       227220
       227037
        
       

     

       227221
       227038
        
         "rio-app" = callPackage

     
···

       231350
       231167
        
              description = "SMT Based Verification: Symbolic Haskell theorem prover using SMT solving";

     

       231351
       231168
        
              license = lib.licenses.bsd3;

     

       231352
       231169
        
              platforms = [

     

       231353
       231353
       -
                "armv7l-linux" "i686-linux" "x86_64-darwin" "x86_64-linux"

     

       231170
       231170
       +
                "aarch64-darwin" "armv7l-linux" "i686-linux" "x86_64-darwin"

     

       231171
       231171
       +
                "x86_64-linux"

     

       231354
       231172
        
              ];

     

       231355
       231173
        
              hydraPlatforms = lib.platforms.none;

     

       231356
       231174
        
            }) {inherit (pkgs) z3;};

     
···

       231385
       231203
        
              description = "SMT Based Verification: Symbolic Haskell theorem prover using SMT solving";

     

       231386
       231204
        
              license = lib.licenses.bsd3;

     

       231387
       231205
        
              platforms = [

     

       231388
       231388
       -
                "armv7l-linux" "i686-linux" "x86_64-darwin" "x86_64-linux"

     

       231206
       231206
       +
                "aarch64-darwin" "armv7l-linux" "i686-linux" "x86_64-darwin"

     

       231207
       231207
       +
                "x86_64-linux"

     

       231389
       231208
        
              ];

     

       231390
       231209
        
            }) {inherit (pkgs) z3;};

     

       231391
       231210
        
       

     

       231211
       231211
       +
         "sbv_8_16" = callPackage

     

       231212
       231212
       +
           ({ mkDerivation, array, async, base, bench-show, bytestring

     

       231213
       231213
       +
            , containers, deepseq, directory, doctest, filepath, gauge, Glob

     

       231214
       231214
       +
            , hlint, libBF, mtl, pretty, process, QuickCheck, random, silently

     

       231215
       231215
       +
            , syb, tasty, tasty-golden, tasty-hunit, tasty-quickcheck

     

       231216
       231216
       +
            , template-haskell, text, time, transformers, uniplate, z3

     

       231217
       231217
       +
            }:

     

       231218
       231218
       +
            mkDerivation {

     

       231219
       231219
       +
              pname = "sbv";

     

       231220
       231220
       +
              version = "8.16";

     

       231221
       231221
       +
              sha256 = "1jmcc9qz659my5i3ir6lq34zfbjp9wcnq61fppic1hlwm39qjppd";

     

       231222
       231222
       +
              enableSeparateDataOutput = true;

     

       231223
       231223
       +
              libraryHaskellDepends = [

     

       231224
       231224
       +
                array async base containers deepseq directory filepath libBF mtl

     

       231225
       231225
       +
                pretty process QuickCheck random syb template-haskell text time

     

       231226
       231226
       +
                transformers uniplate

     

       231227
       231227
       +
              ];

     

       231228
       231228
       +
              testHaskellDepends = [

     

       231229
       231229
       +
                base bytestring containers directory doctest filepath Glob hlint

     

       231230
       231230
       +
                mtl QuickCheck random tasty tasty-golden tasty-hunit

     

       231231
       231231
       +
                tasty-quickcheck

     

       231232
       231232
       +
              ];

     

       231233
       231233
       +
              testSystemDepends = [ z3 ];

     

       231234
       231234
       +
              benchmarkHaskellDepends = [

     

       231235
       231235
       +
                base bench-show containers deepseq directory filepath gauge mtl

     

       231236
       231236
       +
                process random silently syb text time

     

       231237
       231237
       +
              ];

     

       231238
       231238
       +
              description = "SMT Based Verification: Symbolic Haskell theorem prover using SMT solving";

     

       231239
       231239
       +
              license = lib.licenses.bsd3;

     

       231240
       231240
       +
              platforms = [

     

       231241
       231241
       +
                "aarch64-darwin" "armv7l-linux" "i686-linux" "x86_64-darwin"

     

       231242
       231242
       +
                "x86_64-linux"

     

       231243
       231243
       +
              ];

     

       231244
       231244
       +
              hydraPlatforms = lib.platforms.none;

     

       231245
       231245
       +
            }) {inherit (pkgs) z3;};

     

       231246
       231246
       +
       

     

       231392
       231247
        
         "sbvPlugin" = callPackage

     

       231393
       231248
        
           ({ mkDerivation, base, containers, directory, filepath, ghc

     

       231394
       231249
        
            , ghc-prim, mtl, process, sbv, tasty, tasty-golden

     
···

       231748
       231603
        
              ];

     

       231749
       231604
        
              description = "Generates unique passwords for various websites from a single password";

     

       231750
       231605
        
              license = lib.licenses.bsd3;

     

       231751
       231751
       -
              platforms = [ "i686-linux" "x86_64-darwin" "x86_64-linux" ];

     

       231606
       231606
       +
              platforms = [

     

       231607
       231607
       +
                "aarch64-darwin" "i686-linux" "x86_64-darwin" "x86_64-linux"

     

       231608
       231608
       +
              ];

     

       231752
       231609
        
            }) {};

     

       231753
       231610
        
       

     

       231754
       231611
        
         "scc" = callPackage

     
···

       232931
       232788
        
              ];

     

       232932
       232789
        
              description = "Stronger password hashing via sequential memory-hard functions";

     

       232933
       232790
        
              license = lib.licenses.bsd3;

     

       232934
       232934
       -
              platforms = [ "i686-linux" "x86_64-darwin" "x86_64-linux" ];

     

       232791
       232791
       +
              platforms = [

     

       232792
       232792
       +
                "aarch64-darwin" "i686-linux" "x86_64-darwin" "x86_64-linux"

     

       232793
       232793
       +
              ];

     

       232935
       232794
        
            }) {};

     

       232936
       232795
        
       

     

       232937
       232796
        
         "scrz" = callPackage

     
···

       240292
       240151
        
              license = lib.licenses.bsd3;

     

       240293
       240152
        
              hydraPlatforms = lib.platforms.none;

     

       240294
       240153
        
              broken = true;

     

       240154
       240154
       +
            }) {};

     

       240155
       240155
       +
       

     

       240156
       240156
       +
         "shortbytestring" = callPackage

     

       240157
       240157
       +
           ({ mkDerivation, base, bytestring, deepseq, exceptions, ghc-prim

     

       240158
       240158
       +
            , primitive, random, tasty, tasty-bench, tasty-quickcheck

     

       240159
       240159
       +
            , template-haskell, text, word16, word8

     

       240160
       240160
       +
            }:

     

       240161
       240161
       +
            mkDerivation {

     

       240162
       240162
       +
              pname = "shortbytestring";

     

       240163
       240163
       +
              version = "0.1.0.0";

     

       240164
       240164
       +
              sha256 = "1wjk73xlrk0qgnn8j53ngnikh034v295mm7w9nqadvwg9y3absfy";

     

       240165
       240165
       +
              libraryHaskellDepends = [

     

       240166
       240166
       +
                base bytestring exceptions primitive template-haskell text word16

     

       240167
       240167
       +
                word8

     

       240168
       240168
       +
              ];

     

       240169
       240169
       +
              testHaskellDepends = [

     

       240170
       240170
       +
                base bytestring deepseq ghc-prim tasty tasty-quickcheck word16

     

       240171
       240171
       +
                word8

     

       240172
       240172
       +
              ];

     

       240173
       240173
       +
              benchmarkHaskellDepends = [

     

       240174
       240174
       +
                base bytestring deepseq random tasty-bench

     

       240175
       240175
       +
              ];

     

       240176
       240176
       +
              description = "Additional ShortByteString API";

     

       240177
       240177
       +
              license = lib.licenses.mit;

     

       240295
       240178
        
            }) {};

     

       240296
       240179
        
       

     

       240297
       240180
        
         "shortcircuit" = callPackage

     
···

       246608
       246491
        
              hydraPlatforms = lib.platforms.none;

     

       246609
       246492
        
            }) {};

     

       246610
       246493
        
       

     

       246494
       246494
       +
         "some-dict-of" = callPackage

     

       246495
       246495
       +
           ({ mkDerivation, base, constraints }:

     

       246496
       246496
       +
            mkDerivation {

     

       246497
       246497
       +
              pname = "some-dict-of";

     

       246498
       246498
       +
              version = "0.1.0.0";

     

       246499
       246499
       +
              sha256 = "0c7gr41fqak777wnh0q81mkpv89j6m1q3qqca5r2mzqhkqli4d4d";

     

       246500
       246500
       +
              libraryHaskellDepends = [ base constraints ];

     

       246501
       246501
       +
              testHaskellDepends = [ base constraints ];

     

       246502
       246502
       +
              description = "Carry evidence of constraints around";

     

       246503
       246503
       +
              license = lib.licenses.bsd3;

     

       246504
       246504
       +
            }) {};

     

       246505
       246505
       +
       

     

       246611
       246506
        
         "sonic-visualiser" = callPackage

     

       246612
       246507
        
           ({ mkDerivation, array, base, bytestring, bzlib, containers, mtl

     

       246613
       246508
        
            , pretty, utf8-string, xml

     
···

       248861
       248756
        
              pname = "srt-dhall";

     

       248862
       248757
        
              version = "0.1.0.0";

     

       248863
       248758
        
              sha256 = "16ygxiqb9d0js3gr4823fdkk8pzsairby6iywnvsafas1qvhm0yp";

     

       248759
       248759
       +
              revision = "1";

     

       248760
       248760
       +
              editedCabalFile = "0y1x65mmhsa78svk19nwf7211fny9c4w3gf9d31d10j9bglyly8f";

     

       248864
       248761
        
              libraryHaskellDepends = [

     

       248865
       248762
        
                attoparsec base dhall either formatting simple-media-timestamp

     

       248866
       248763
        
                simple-media-timestamp-formatting srt srt-attoparsec srt-formatting

     
···

       251928
       251825
        
            }:

     

       251929
       251826
        
            mkDerivation {

     

       251930
       251827
        
              pname = "store";

     

       251931
       251931
       -
              version = "0.7.11";

     

       251932
       251932
       -
              sha256 = "03i9gd18xqbfmj5kmiv4k4sw44gn6mn4faj71r2723abm3qwklwr";

     

       251933
       251933
       -
              libraryHaskellDepends = [

     

       251934
       251934
       -
                array async base base-orphans base64-bytestring bifunctors

     

       251935
       251935
       -
                bytestring containers contravariant cryptohash deepseq directory

     

       251936
       251936
       -
                filepath free ghc-prim hashable hspec hspec-smallcheck integer-gmp

     

       251937
       251937
       -
                lifted-base monad-control mono-traversable nats network primitive

     

       251938
       251938
       -
                resourcet safe smallcheck store-core syb template-haskell text

     

       251939
       251939
       -
                th-lift th-lift-instances th-orphans th-reify-many th-utilities

     

       251940
       251940
       -
                time transformers unordered-containers vector void

     

       251941
       251941
       -
              ];

     

       251942
       251942
       -
              testHaskellDepends = [

     

       251943
       251943
       -
                array async base base-orphans base64-bytestring bifunctors

     

       251944
       251944
       -
                bytestring clock containers contravariant cryptohash deepseq

     

       251945
       251945
       -
                directory filepath free ghc-prim hashable hspec hspec-smallcheck

     

       251946
       251946
       -
                integer-gmp lifted-base monad-control mono-traversable nats network

     

       251947
       251947
       -
                primitive resourcet safe smallcheck store-core syb template-haskell

     

       251948
       251948
       -
                text th-lift th-lift-instances th-orphans th-reify-many

     

       251949
       251949
       -
                th-utilities time transformers unordered-containers vector void

     

       251950
       251950
       -
              ];

     

       251951
       251951
       -
              benchmarkHaskellDepends = [

     

       251952
       251952
       -
                array async base base-orphans base64-bytestring bifunctors

     

       251953
       251953
       -
                bytestring cereal cereal-vector containers contravariant criterion

     

       251954
       251954
       -
                cryptohash deepseq directory filepath free ghc-prim hashable hspec

     

       251955
       251955
       -
                hspec-smallcheck integer-gmp lifted-base monad-control

     

       251956
       251956
       -
                mono-traversable nats network primitive resourcet safe smallcheck

     

       251957
       251957
       -
                store-core syb template-haskell text th-lift th-lift-instances

     

       251958
       251958
       -
                th-orphans th-reify-many th-utilities time transformers

     

       251959
       251959
       -
                unordered-containers vector vector-binary-instances void weigh

     

       251960
       251960
       -
              ];

     

       251961
       251961
       -
              description = "Fast binary serialization";

     

       251962
       251962
       -
              license = lib.licenses.mit;

     

       251963
       251963
       -
            }) {};

     

       251964
       251964
       -
       

     

       251965
       251965
       -
         "store_0_7_12" = callPackage

     

       251966
       251966
       -
           ({ mkDerivation, array, async, base, base-orphans

     

       251967
       251967
       -
            , base64-bytestring, bifunctors, bytestring, cereal, cereal-vector

     

       251968
       251968
       -
            , clock, containers, contravariant, criterion, cryptohash, deepseq

     

       251969
       251969
       -
            , directory, filepath, free, ghc-prim, hashable, hspec

     

       251970
       251970
       -
            , hspec-smallcheck, integer-gmp, lifted-base, monad-control

     

       251971
       251971
       -
            , mono-traversable, nats, network, primitive, resourcet, safe

     

       251972
       251972
       -
            , smallcheck, store-core, syb, template-haskell, text, th-lift

     

       251973
       251973
       -
            , th-lift-instances, th-orphans, th-reify-many, th-utilities, time

     

       251974
       251974
       -
            , transformers, unordered-containers, vector

     

       251975
       251975
       -
            , vector-binary-instances, void, weigh

     

       251976
       251976
       -
            }:

     

       251977
       251977
       -
            mkDerivation {

     

       251978
       251978
       -
              pname = "store";

     

       251979
       251828
        
              version = "0.7.12";

     

       251980
       251829
        
              sha256 = "1r6wajaxjlh38bivzmcdx8p0x89g04p6alddlibpa356drzl3jbp";

     

       251981
       251830
        
              libraryHaskellDepends = [

     
···

       252008
       251857
        
              ];

     

       252009
       251858
        
              description = "Fast binary serialization";

     

       252010
       251859
        
              license = lib.licenses.mit;

     

       252011
       252011
       -
              hydraPlatforms = lib.platforms.none;

     

       252012
       251860
        
            }) {};

     

       252013
       251861
        
       

     

       252014
       251862
        
         "store-core" = callPackage

     
···

       259523
       259371
        
              license = lib.licenses.mit;

     

       259524
       259372
        
            }) {};

     

       259525
       259373
        
       

     

       259374
       259374
       +
         "tasty_1_4_2" = callPackage

     

       259375
       259375
       +
           ({ mkDerivation, ansi-terminal, base, clock, containers, mtl

     

       259376
       259376
       +
            , optparse-applicative, stm, tagged, unbounded-delays, unix

     

       259377
       259377
       +
            , wcwidth

     

       259378
       259378
       +
            }:

     

       259379
       259379
       +
            mkDerivation {

     

       259380
       259380
       +
              pname = "tasty";

     

       259381
       259381
       +
              version = "1.4.2";

     

       259382
       259382
       +
              sha256 = "0574hbqzxzyv6vsk5kzbf04kz58y0iy8x9ydcj4b8fpncgmgy63g";

     

       259383
       259383
       +
              libraryHaskellDepends = [

     

       259384
       259384
       +
                ansi-terminal base clock containers mtl optparse-applicative stm

     

       259385
       259385
       +
                tagged unbounded-delays unix wcwidth

     

       259386
       259386
       +
              ];

     

       259387
       259387
       +
              description = "Modern and extensible testing framework";

     

       259388
       259388
       +
              license = lib.licenses.mit;

     

       259389
       259389
       +
              hydraPlatforms = lib.platforms.none;

     

       259390
       259390
       +
            }) {};

     

       259391
       259391
       +
       

     

       259526
       259392
        
         "tasty-ant-xml" = callPackage

     

       259527
       259393
        
           ({ mkDerivation, base, containers, directory, filepath

     

       259528
       259394
        
            , generic-deriving, ghc-prim, mtl, stm, tagged, tasty, transformers

     
···

       259639
       259505
        
           ({ mkDerivation, base, dejafu, random, tagged, tasty }:

     

       259640
       259506
        
            mkDerivation {

     

       259641
       259507
        
              pname = "tasty-dejafu";

     

       259642
       259642
       -
              version = "2.0.0.7";

     

       259643
       259643
       -
              sha256 = "0jzaqra7gsrvy33j1g6bnrwg7x5pyg5p50l5mgvpz71kd946725l";

     

       259644
       259644
       -
              libraryHaskellDepends = [ base dejafu random tagged tasty ];

     

       259645
       259645
       -
              description = "Deja Fu support for the Tasty test framework";

     

       259646
       259646
       -
              license = lib.licenses.mit;

     

       259647
       259647
       -
            }) {};

     

       259648
       259648
       -
       

     

       259649
       259649
       -
         "tasty-dejafu_2_0_0_8" = callPackage

     

       259650
       259650
       -
           ({ mkDerivation, base, dejafu, random, tagged, tasty }:

     

       259651
       259651
       -
            mkDerivation {

     

       259652
       259652
       -
              pname = "tasty-dejafu";

     

       259653
       259508
        
              version = "2.0.0.8";

     

       259654
       259509
        
              sha256 = "0v0vkbj8nr4jg62a5c0qygj1pjkz1vnssiicafv87qis02j36myx";

     

       259655
       259510
        
              libraryHaskellDepends = [ base dejafu random tagged tasty ];

     

       259656
       259511
        
              description = "Deja Fu support for the Tasty test framework";

     

       259657
       259512
        
              license = lib.licenses.mit;

     

       259658
       259658
       -
              hydraPlatforms = lib.platforms.none;

     

       259659
       259513
        
            }) {};

     

       259660
       259514
        
       

     

       259661
       259515
        
         "tasty-discover" = callPackage

     
···

       262916
       262770
        
            }:

     

       262917
       262771
        
            mkDerivation {

     

       262918
       262772
        
              pname = "texmath";

     

       262919
       262919
       -
              version = "0.12.3";

     

       262920
       262920
       -
              sha256 = "0lhbgnswhss56lrp25i70hvmn6zg6xcfwdigfmwjggmhz0h5q88x";

     

       262921
       262921
       -
              isLibrary = true;

     

       262922
       262922
       -
              isExecutable = true;

     

       262923
       262923
       -
              libraryHaskellDepends = [

     

       262924
       262924
       -
                base containers mtl pandoc-types parsec split syb text xml

     

       262925
       262925
       -
              ];

     

       262926
       262926
       -
              testHaskellDepends = [

     

       262927
       262927
       -
                base bytestring directory filepath process temporary text

     

       262928
       262928
       -
                utf8-string xml

     

       262929
       262929
       -
              ];

     

       262930
       262930
       -
              description = "Conversion between formats used to represent mathematics";

     

       262931
       262931
       -
              license = lib.licenses.gpl2Only;

     

       262932
       262932
       -
            }) {};

     

       262933
       262933
       -
       

     

       262934
       262934
       -
         "texmath_0_12_3_1" = callPackage

     

       262935
       262935
       -
           ({ mkDerivation, base, bytestring, containers, directory, filepath

     

       262936
       262936
       -
            , mtl, pandoc-types, parsec, process, split, syb, temporary, text

     

       262937
       262937
       -
            , utf8-string, xml

     

       262938
       262938
       -
            }:

     

       262939
       262939
       -
            mkDerivation {

     

       262940
       262940
       -
              pname = "texmath";

     

       262941
       262773
        
              version = "0.12.3.1";

     

       262942
       262774
        
              sha256 = "1qyiihb9h7w7074p495yd4s8dj9adz0dy865gyp822z69jvmkcki";

     

       262943
       262775
        
              isLibrary = true;

     
···

       262951
       262783
        
              ];

     

       262952
       262784
        
              description = "Conversion between formats used to represent mathematics";

     

       262953
       262785
        
              license = lib.licenses.gpl2Only;

     

       262954
       262954
       -
              hydraPlatforms = lib.platforms.none;

     

       262955
       262786
        
            }) {};

     

       262956
       262787
        
       

     

       262957
       262788
        
         "texrunner" = callPackage

     
···

       263455
       263286
        
              benchmarkHaskellDepends = [ base criterion deepseq text weigh ];

     

       263456
       263287
        
              description = "Calculate various string metrics efficiently";

     

       263457
       263288
        
              license = lib.licenses.bsd3;

     

       263289
       263289
       +
            }) {};

     

       263290
       263290
       +
       

     

       263291
       263291
       +
         "text-metrics_0_3_1" = callPackage

     

       263292
       263292
       +
           ({ mkDerivation, base, containers, criterion, deepseq, hspec

     

       263293
       263293
       +
            , QuickCheck, text, vector, weigh

     

       263294
       263294
       +
            }:

     

       263295
       263295
       +
            mkDerivation {

     

       263296
       263296
       +
              pname = "text-metrics";

     

       263297
       263297
       +
              version = "0.3.1";

     

       263298
       263298
       +
              sha256 = "17bp1lnbkqr5ykrcd6v5sqv0fhljck7hky8zrrpw7rlkb1f3sdc2";

     

       263299
       263299
       +
              libraryHaskellDepends = [ base containers text vector ];

     

       263300
       263300
       +
              testHaskellDepends = [ base hspec QuickCheck text ];

     

       263301
       263301
       +
              benchmarkHaskellDepends = [ base criterion deepseq text weigh ];

     

       263302
       263302
       +
              description = "Calculate various string metrics efficiently";

     

       263303
       263303
       +
              license = lib.licenses.bsd3;

     

       263304
       263304
       +
              hydraPlatforms = lib.platforms.none;

     

       263458
       263305
        
            }) {};

     

       263459
       263306
        
       

     

       263460
       263307
        
         "text-normal" = callPackage

     
···

       265577
       265424
        
              license = lib.licenses.bsd3;

     

       265578
       265425
        
            }) {};

     

       265579
       265426
        
       

     

       265427
       265427
       +
         "ticket-management" = callPackage

     

       265428
       265428
       +
           ({ mkDerivation, base, bytestring, cereal, containers, directory

     

       265429
       265429
       +
            , optparse-applicative, QuickCheck, text, time, unliftio

     

       265430
       265430
       +
            }:

     

       265431
       265431
       +
            mkDerivation {

     

       265432
       265432
       +
              pname = "ticket-management";

     

       265433
       265433
       +
              version = "0.2.0.0";

     

       265434
       265434
       +
              sha256 = "0cbdkjjh2sfsj4cjgxvxjrva6rb0gli36q3g8idhwf7wa2llyz4w";

     

       265435
       265435
       +
              isLibrary = true;

     

       265436
       265436
       +
              isExecutable = true;

     

       265437
       265437
       +
              libraryHaskellDepends = [

     

       265438
       265438
       +
                base bytestring cereal containers directory optparse-applicative

     

       265439
       265439
       +
                QuickCheck text time unliftio

     

       265440
       265440
       +
              ];

     

       265441
       265441
       +
              executableHaskellDepends = [ base ];

     

       265442
       265442
       +
              testHaskellDepends = [ base QuickCheck text ];

     

       265443
       265443
       +
              description = "A basic implementation of a personal ticket management system";

     

       265444
       265444
       +
              license = lib.licenses.mit;

     

       265445
       265445
       +
              hydraPlatforms = lib.platforms.none;

     

       265446
       265446
       +
              broken = true;

     

       265447
       265447
       +
            }) {};

     

       265448
       265448
       +
       

     

       265580
       265449
        
         "tickle" = callPackage

     

       265581
       265450
        
           ({ mkDerivation, base, bifunctors, bytestring, checkers, filepath

     

       265582
       265451
        
            , lens, mtl, papa, QuickCheck, semigroupoids, semigroups, tasty

     
···

       267094
       266963
        
            }:

     

       267095
       266964
        
            mkDerivation {

     

       267096
       266965
        
              pname = "tldr";

     

       267097
       267097
       -
              version = "0.9.0";

     

       267098
       267098
       -
              sha256 = "0dixx8i6ka3ksfcr6bjybs1i3ry0wpiffsmskh56cxxcys0jgm5h";

     

       267099
       267099
       -
              isLibrary = true;

     

       267100
       267100
       -
              isExecutable = true;

     

       267101
       267101
       -
              libraryHaskellDepends = [

     

       267102
       267102
       -
                ansi-terminal base bytestring cmark containers directory filepath

     

       267103
       267103
       -
                http-conduit optparse-applicative semigroups text time zip-archive

     

       267104
       267104
       -
              ];

     

       267105
       267105
       -
              executableHaskellDepends = [ base ];

     

       267106
       267106
       -
              testHaskellDepends = [ base tasty tasty-golden ];

     

       267107
       267107
       -
              description = "Haskell tldr client";

     

       267108
       267108
       -
              license = lib.licenses.bsd3;

     

       267109
       267109
       -
            }) {};

     

       267110
       267110
       -
       

     

       267111
       267111
       -
         "tldr_0_9_1" = callPackage

     

       267112
       267112
       -
           ({ mkDerivation, ansi-terminal, base, bytestring, cmark, containers

     

       267113
       267113
       -
            , directory, filepath, http-conduit, optparse-applicative

     

       267114
       267114
       -
            , semigroups, tasty, tasty-golden, text, time, zip-archive

     

       267115
       267115
       -
            }:

     

       267116
       267116
       -
            mkDerivation {

     

       267117
       267117
       -
              pname = "tldr";

     

       267118
       266966
        
              version = "0.9.1";

     

       267119
       266967
        
              sha256 = "0xgj3mf51iv68fhgyrjvxfmzrbcwnk7siaynm213x0kgcyvkwbz0";

     

       267120
       266968
        
              isLibrary = true;

     
···

       267127
       266975
        
              testHaskellDepends = [ base tasty tasty-golden ];

     

       267128
       266976
        
              description = "Haskell tldr client";

     

       267129
       266977
        
              license = lib.licenses.bsd3;

     

       267130
       267130
       -
              hydraPlatforms = lib.platforms.none;

     

       267131
       266978
        
            }) {};

     

       267132
       266979
        
       

     

       267133
       266980
        
         "tlex" = callPackage

     
···

       269125
       268972
        
            }:

     

       269126
       268973
        
            mkDerivation {

     

       269127
       268974
        
              pname = "transformers-base";

     

       269128
       269128
       -
              version = "0.4.5.2";

     

       269129
       269129
       -
              sha256 = "1s256bi0yh0x2hp2gwd30f3mg1cv53zz397dv1yhfsnfzmihrj6h";

     

       269130
       269130
       -
              revision = "1";

     

       269131
       269131
       -
              editedCabalFile = "18j122ypx12rbl9bbf622fvj8nif4rsci8z4qw2llmznbvfl09s0";

     

       269132
       269132
       -
              libraryHaskellDepends = [

     

       269133
       269133
       -
                base base-orphans stm transformers transformers-compat

     

       269134
       269134
       -
              ];

     

       269135
       269135
       -
              description = "Lift computations from the bottom of a transformer stack";

     

       269136
       269136
       -
              license = lib.licenses.bsd3;

     

       269137
       269137
       -
            }) {};

     

       269138
       269138
       -
       

     

       269139
       269139
       -
         "transformers-base_0_4_6" = callPackage

     

       269140
       269140
       -
           ({ mkDerivation, base, base-orphans, stm, transformers

     

       269141
       269141
       -
            , transformers-compat

     

       269142
       269142
       -
            }:

     

       269143
       269143
       -
            mkDerivation {

     

       269144
       269144
       -
              pname = "transformers-base";

     

       269145
       268975
        
              version = "0.4.6";

     

       269146
       268976
        
              sha256 = "146g69yxmlrmvqnzwcw4frxfl3z04lda9zqwcqib34dnkrlghfrj";

     

       269147
       268977
        
              libraryHaskellDepends = [

     
···

       269149
       268979
        
              ];

     

       269150
       268980
        
              description = "Lift computations from the bottom of a transformer stack";

     

       269151
       268981
        
              license = lib.licenses.bsd3;

     

       269152
       269152
       -
              hydraPlatforms = lib.platforms.none;

     

       269153
       268982
        
            }) {};

     

       269154
       268983
        
       

     

       269155
       268984
        
         "transformers-bifunctors" = callPackage

     
···

       270833
       270662
        
              license = lib.licenses.mit;

     

       270834
       270663
        
            }) {};

     

       270835
       270664
        
       

     

       270665
       270665
       +
         "ttc_1_1_0_2" = callPackage

     

       270666
       270666
       +
           ({ mkDerivation, base, bytestring, tasty, tasty-hunit

     

       270667
       270667
       +
            , template-haskell, text

     

       270668
       270668
       +
            }:

     

       270669
       270669
       +
            mkDerivation {

     

       270670
       270670
       +
              pname = "ttc";

     

       270671
       270671
       +
              version = "1.1.0.2";

     

       270672
       270672
       +
              sha256 = "0i1jnign6xb0i4y5rkwz2rp2lj7q3r50i4bkjghz8i2djw2sd1cw";

     

       270673
       270673
       +
              libraryHaskellDepends = [ base bytestring template-haskell text ];

     

       270674
       270674
       +
              testHaskellDepends = [

     

       270675
       270675
       +
                base bytestring tasty tasty-hunit template-haskell text

     

       270676
       270676
       +
              ];

     

       270677
       270677
       +
              description = "Textual Type Classes";

     

       270678
       270678
       +
              license = lib.licenses.mit;

     

       270679
       270679
       +
              hydraPlatforms = lib.platforms.none;

     

       270680
       270680
       +
            }) {};

     

       270681
       270681
       +
       

     

       270836
       270682
        
         "ttl-hashtables" = callPackage

     

       270837
       270683
        
           ({ mkDerivation, base, clock, containers, data-default, failable

     

       270838
       270684
        
            , hashable, hashtables, hspec, mtl, transformers

     
···

       272214
       272060
        
           ({ mkDerivation, base, doctest, Glob }:

     

       272215
       272061
        
            mkDerivation {

     

       272216
       272062
        
              pname = "type-errors-pretty";

     

       272217
       272217
       -
              version = "0.0.1.1";

     

       272218
       272218
       -
              sha256 = "1z6rqah3qnvnlckcw3xhsp4yyfd21harw6kzqbz20y6k7a22jlf0";

     

       272219
       272219
       -
              revision = "1";

     

       272220
       272220
       -
              editedCabalFile = "1qfm0018ids9s7kdwf6d3r1cwnb5aqn55in4vdwklas3ydi8mmrx";

     

       272221
       272221
       -
              libraryHaskellDepends = [ base ];

     

       272222
       272222
       -
              testHaskellDepends = [ base doctest Glob ];

     

       272223
       272223
       -
              description = "Combinators for writing pretty type errors easily";

     

       272224
       272224
       -
              license = lib.licenses.mpl20;

     

       272225
       272225
       -
            }) {};

     

       272226
       272226
       -
       

     

       272227
       272227
       -
         "type-errors-pretty_0_0_1_2" = callPackage

     

       272228
       272228
       -
           ({ mkDerivation, base, doctest, Glob }:

     

       272229
       272229
       -
            mkDerivation {

     

       272230
       272230
       -
              pname = "type-errors-pretty";

     

       272231
       272063
        
              version = "0.0.1.2";

     

       272232
       272064
        
              sha256 = "01zdb5mw77d5rj3yvabqdch132mjw49awpjnjvms20hdhwjgqb6b";

     

       272233
       272065
        
              libraryHaskellDepends = [ base ];

     

       272234
       272066
        
              testHaskellDepends = [ base doctest Glob ];

     

       272235
       272067
        
              description = "Combinators for writing pretty type errors easily";

     

       272236
       272068
        
              license = lib.licenses.mpl20;

     

       272237
       272237
       -
              hydraPlatforms = lib.platforms.none;

     

       272238
       272069
        
            }) {};

     

       272239
       272070
        
       

     

       272240
       272071
        
         "type-fun" = callPackage

     
···

       272906
       272737
        
            }:

     

       272907
       272738
        
            mkDerivation {

     

       272908
       272739
        
              pname = "typed-process";

     

       272909
       272909
       -
              version = "0.2.6.0";

     

       272910
       272910
       -
              sha256 = "1cf2pfym8zdxvvy7xv72ixj7wy3rjrdss6f57k1ysgs66cgsi8ii";

     

       272911
       272911
       -
              libraryHaskellDepends = [

     

       272912
       272912
       -
                async base bytestring process stm transformers unliftio-core

     

       272913
       272913
       -
              ];

     

       272914
       272914
       -
              testHaskellDepends = [

     

       272915
       272915
       -
                async base base64-bytestring bytestring hspec process stm temporary

     

       272916
       272916
       -
                transformers unliftio-core

     

       272917
       272917
       -
              ];

     

       272918
       272918
       -
              description = "Run external processes, with strong typing of streams";

     

       272919
       272919
       -
              license = lib.licenses.mit;

     

       272920
       272920
       -
            }) {};

     

       272921
       272921
       -
       

     

       272922
       272922
       -
         "typed-process_0_2_6_1" = callPackage

     

       272923
       272923
       -
           ({ mkDerivation, async, base, base64-bytestring, bytestring, hspec

     

       272924
       272924
       -
            , process, stm, temporary, transformers, unliftio-core

     

       272925
       272925
       -
            }:

     

       272926
       272926
       -
            mkDerivation {

     

       272927
       272927
       -
              pname = "typed-process";

     

       272928
       272740
        
              version = "0.2.6.1";

     

       272929
       272741
        
              sha256 = "0w4c76qln49967nnhf7f1zj3gbdfqp2qgf5ym8svhqyhp5gh61ws";

     

       272930
       272742
        
              libraryHaskellDepends = [

     
···

       272936
       272748
        
              ];

     

       272937
       272749
        
              description = "Run external processes, with strong typing of streams";

     

       272938
       272750
        
              license = lib.licenses.mit;

     

       272939
       272939
       -
              hydraPlatforms = lib.platforms.none;

     

       272940
       272751
        
            }) {};

     

       272941
       272752
        
       

     

       272942
       272753
        
         "typed-spreadsheet" = callPackage

     
···

       278219
       278030
        
              broken = true;

     

       278220
       278031
        
            }) {};

     

       278221
       278032
        
       

     

       278033
       278033
       +
         "valida" = callPackage

     

       278034
       278034
       +
           ({ mkDerivation, base, smallcheck, tasty, tasty-hunit

     

       278035
       278035
       +
            , tasty-quickcheck, tasty-smallcheck

     

       278036
       278036
       +
            }:

     

       278037
       278037
       +
            mkDerivation {

     

       278038
       278038
       +
              pname = "valida";

     

       278039
       278039
       +
              version = "0.1.0";

     

       278040
       278040
       +
              sha256 = "1spdf40jcm9b6ah18m5nw550x2mlq4bjmqvscf4cnjpc7izdmdng";

     

       278041
       278041
       +
              libraryHaskellDepends = [ base ];

     

       278042
       278042
       +
              testHaskellDepends = [

     

       278043
       278043
       +
                base smallcheck tasty tasty-hunit tasty-quickcheck tasty-smallcheck

     

       278044
       278044
       +
              ];

     

       278045
       278045
       +
              description = "Simple applicative validation for product types, batteries included!";

     

       278046
       278046
       +
              license = lib.licenses.mit;

     

       278047
       278047
       +
            }) {};

     

       278048
       278048
       +
       

     

       278222
       278049
        
         "validate" = callPackage

     

       278223
       278050
        
           ({ mkDerivation }:

     

       278224
       278051
        
            mkDerivation {

     
···

       279814
       279641
        
              description = "An intermediate language for Hoare logic style verification";

     

       279815
       279642
        
              license = lib.licenses.asl20;

     

       279816
       279643
        
              platforms = [

     

       279817
       279817
       -
                "armv7l-linux" "i686-linux" "x86_64-darwin" "x86_64-linux"

     

       279644
       279644
       +
                "aarch64-darwin" "armv7l-linux" "i686-linux" "x86_64-darwin"

     

       279645
       279645
       +
                "x86_64-linux"

     

       279818
       279646
        
              ];

     

       279819
       279647
        
            }) {};

     

       279820
       279648
        
       

     
···

       281116
       280944
        
            }:

     

       281117
       280945
        
            mkDerivation {

     

       281118
       280946
        
              pname = "vulkan";

     

       281119
       281119
       -
              version = "3.12.1";

     

       281120
       281120
       -
              sha256 = "0y9ykv0dx5hvh2683yyn8mdl3jxqk9zaf2a1rkyr5zgc43wsbm05";

     

       280947
       280947
       +
              version = "3.12.2";

     

       280948
       280948
       +
              sha256 = "1vypjnwvvvd0rw99qsb00jnwpq792s9x1wi62zdyzq9cwlf47ici";

     

       281121
       280949
        
              libraryHaskellDepends = [ base bytestring transformers vector ];

     

       281122
       280950
        
              libraryPkgconfigDepends = [ vulkan ];

     

       281123
       280951
        
              testHaskellDepends = [

     
···

       281979
       281807
        
            }) {};

     

       281980
       281808
        
       

     

       281981
       281809
        
         "wai-middleware-auth" = callPackage

     

       281982
       281982
       -
           ({ mkDerivation, aeson, base, base64-bytestring, binary

     

       281983
       281983
       -
            , blaze-builder, blaze-html, bytestring, case-insensitive, cereal

     

       281984
       281984
       -
            , clientsession, cookie, exceptions, hedgehog, hoauth2, http-client

     

       281985
       281985
       -
            , http-client-tls, http-conduit, http-reverse-proxy, http-types

     

       281986
       281986
       -
            , jose, microlens, mtl, optparse-applicative, optparse-simple

     

       281987
       281987
       -
            , regex-posix, safe-exceptions, shakespeare, tasty, tasty-hedgehog

     

       281988
       281988
       -
            , tasty-hunit, text, time, unix-compat, unordered-containers

     

       281989
       281989
       -
            , uri-bytestring, vault, wai, wai-app-static, wai-extra, warp, yaml

     

       281990
       281990
       -
            }:

     

       281991
       281991
       -
            mkDerivation {

     

       281992
       281992
       -
              pname = "wai-middleware-auth";

     

       281993
       281993
       -
              version = "0.2.5.0";

     

       281994
       281994
       -
              sha256 = "12yv8rcybd7saflfcyjy08p1m6il07nk831pkj0isxk8mwjq64l4";

     

       281995
       281995
       -
              isLibrary = true;

     

       281996
       281996
       -
              isExecutable = true;

     

       281997
       281997
       -
              libraryHaskellDepends = [

     

       281998
       281998
       -
                aeson base base64-bytestring binary blaze-builder blaze-html

     

       281999
       281999
       -
                bytestring case-insensitive cereal clientsession cookie exceptions

     

       282000
       282000
       -
                hoauth2 http-client http-client-tls http-conduit http-reverse-proxy

     

       282001
       282001
       -
                http-types jose microlens mtl regex-posix safe-exceptions

     

       282002
       282002
       -
                shakespeare text time unix-compat unordered-containers

     

       282003
       282003
       -
                uri-bytestring vault wai wai-app-static wai-extra yaml

     

       282004
       282004
       -
              ];

     

       282005
       282005
       -
              executableHaskellDepends = [

     

       282006
       282006
       -
                base bytestring cereal clientsession optparse-applicative

     

       282007
       282007
       -
                optparse-simple wai-extra warp

     

       282008
       282008
       -
              ];

     

       282009
       282009
       -
              testHaskellDepends = [

     

       282010
       282010
       -
                aeson base binary bytestring clientsession cookie hedgehog hoauth2

     

       282011
       282011
       -
                http-types jose microlens mtl tasty tasty-hedgehog tasty-hunit text

     

       282012
       282012
       -
                time uri-bytestring wai wai-extra warp

     

       282013
       282013
       -
              ];

     

       282014
       282014
       -
              description = "Authentication middleware that secures WAI application";

     

       282015
       282015
       -
              license = lib.licenses.mit;

     

       282016
       282016
       -
            }) {};

     

       282017
       282017
       -
       

     

       282018
       282018
       -
         "wai-middleware-auth_0_2_5_1" = callPackage

     

       282019
       281810
        
           ({ mkDerivation, aeson, base, base64-bytestring, binary

     

       282020
       281811
        
            , blaze-builder, blaze-html, bytestring, case-insensitive, cereal

     

       282021
       281812
        
            , clientsession, cookie, exceptions, hedgehog, hoauth2, http-client

     
···

       282050
       281841
        
              ];

     

       282051
       281842
        
              description = "Authentication middleware that secures WAI application";

     

       282052
       281843
        
              license = lib.licenses.mit;

     

       282053
       282053
       -
              hydraPlatforms = lib.platforms.none;

     

       282054
       281844
        
            }) {};

     

       282055
       281845
        
       

     

       282056
       281846
        
         "wai-middleware-brotli" = callPackage

     
···

       285217
       285007
        
              hydraPlatforms = lib.platforms.none;

     

       285218
       285008
        
            }) {};

     

       285219
       285009
        
       

     

       285010
       285010
       +
         "wgpu-hs" = callPackage

     

       285011
       285011
       +
           ({ mkDerivation, base, bytestring, data-default, GLFW-b, text

     

       285012
       285012
       +
            , transformers, vector, wgpu-raw-hs

     

       285013
       285013
       +
            }:

     

       285014
       285014
       +
            mkDerivation {

     

       285015
       285015
       +
              pname = "wgpu-hs";

     

       285016
       285016
       +
              version = "0.2.0.0";

     

       285017
       285017
       +
              sha256 = "1kc5xmknfhh9dmn90rbnplmx8n7f07xwvrvz7dcybjpiw8pr2dml";

     

       285018
       285018
       +
              isLibrary = true;

     

       285019
       285019
       +
              isExecutable = true;

     

       285020
       285020
       +
              libraryHaskellDepends = [

     

       285021
       285021
       +
                base bytestring data-default GLFW-b text transformers vector

     

       285022
       285022
       +
                wgpu-raw-hs

     

       285023
       285023
       +
              ];

     

       285024
       285024
       +
              executableHaskellDepends = [

     

       285025
       285025
       +
                base data-default GLFW-b text transformers

     

       285026
       285026
       +
              ];

     

       285027
       285027
       +
              doHaddock = false;

     

       285028
       285028
       +
              description = "WGPU";

     

       285029
       285029
       +
              license = lib.licenses.bsd3;

     

       285030
       285030
       +
            }) {};

     

       285031
       285031
       +
       

     

       285220
       285032
        
         "wgpu-raw-hs" = callPackage

     

       285221
       285033
        
           ({ mkDerivation, base, GLFW-b, unix }:

     

       285222
       285034
        
            mkDerivation {

     

       285223
       285035
        
              pname = "wgpu-raw-hs";

     

       285224
       285224
       -
              version = "0.1.0.2";

     

       285225
       285225
       -
              sha256 = "1hagn99jdmwjcyz2afmmd9ws31dncas9fssv6lx75kshar6x4rah";

     

       285226
       285226
       -
              isLibrary = true;

     

       285227
       285227
       -
              isExecutable = true;

     

       285036
       285036
       +
              version = "0.2.0.0";

     

       285037
       285037
       +
              sha256 = "05dzz6q5laxw7wwhly7v5i4bppfqz4yahh8qq6qc0h2c8v0qmdzp";

     

       285228
       285038
        
              libraryHaskellDepends = [ base GLFW-b unix ];

     

       285229
       285229
       -
              executableHaskellDepends = [ base GLFW-b ];

     

       285230
       285039
        
              description = "WGPU Raw";

     

       285231
       285040
        
              license = lib.licenses.bsd3;

     

       285232
       285041
        
            }) {};

     
···

       286365
       286174
        
              license = lib.licenses.bsd3;

     

       286366
       286175
        
            }) {};

     

       286367
       286176
        
       

     

       286177
       286177
       +
         "word16" = callPackage

     

       286178
       286178
       +
           ({ mkDerivation, base, bytestring, criterion, hspec, hspec-discover

     

       286179
       286179
       +
            , template-haskell, text

     

       286180
       286180
       +
            }:

     

       286181
       286181
       +
            mkDerivation {

     

       286182
       286182
       +
              pname = "word16";

     

       286183
       286183
       +
              version = "0.1.0.0";

     

       286184
       286184
       +
              sha256 = "0z2nabnh7b42bl7hqy2iw68a1gxay26pgsid7m4hs8s2d7cghndx";

     

       286185
       286185
       +
              libraryHaskellDepends = [ base bytestring template-haskell text ];

     

       286186
       286186
       +
              testHaskellDepends = [ base hspec ];

     

       286187
       286187
       +
              testToolDepends = [ hspec-discover ];

     

       286188
       286188
       +
              benchmarkHaskellDepends = [ base bytestring criterion ];

     

       286189
       286189
       +
              description = "Word16 library";

     

       286190
       286190
       +
              license = lib.licenses.mit;

     

       286191
       286191
       +
            }) {};

     

       286192
       286192
       +
       

     

       286368
       286193
        
         "word24" = callPackage

     

       286369
       286194
        
           ({ mkDerivation, base, criterion, deepseq, QuickCheck

     

       286370
       286195
        
            , test-framework, test-framework-quickcheck2

     
···

       288182
       288007
        
              executableSystemDepends = [ xgboost ];

     

       288183
       288008
        
              description = "XGBoost library for Haskell";

     

       288184
       288009
        
              license = lib.licenses.mit;

     

       288185
       288185
       -
              platforms = [ "i686-linux" "x86_64-darwin" "x86_64-linux" ];

     

       288010
       288010
       +
              platforms = [

     

       288011
       288011
       +
                "aarch64-darwin" "i686-linux" "x86_64-darwin" "x86_64-linux"

     

       288012
       288012
       +
              ];

     

       288186
       288013
        
            }) {inherit (pkgs) xgboost;};

     

       288187
       288014
        
       

     

       288188
       288015
        
         "xhaskell-library" = callPackage

     
···

       291012
       290839
        
            }) {};

     

       291013
       290840
        
       

     

       291014
       290841
        
         "yapb" = callPackage

     

       291015
       291015
       -
           ({ mkDerivation, base, bytestring, directory, hashable, network

     

       291016
       291016
       -
            , process, regex-tdfa

     

       290842
       290842
       +
           ({ mkDerivation, base, bytestring, directory, hashable, hspec

     

       290843
       290843
       +
            , network, process, regex-tdfa

     

       291017
       290844
        
            }:

     

       291018
       290845
        
            mkDerivation {

     

       291019
       290846
        
              pname = "yapb";

     

       291020
       291020
       -
              version = "0.1.1";

     

       291021
       291021
       -
              sha256 = "1zbk2whfi09wzx9ql4dhkbg50s7v45y309avxljypg7z9i9pvx3x";

     

       290847
       290847
       +
              version = "0.1.3";

     

       290848
       290848
       +
              sha256 = "11p3ygnfpsh9dqlnpppi02baa5bk86pw6w6f1gawdd848qh7q9if";

     

       291022
       290849
        
              isLibrary = true;

     

       291023
       290850
        
              isExecutable = true;

     

       291024
       290851
        
              libraryHaskellDepends = [

     

       291025
       291025
       -
                base bytestring directory hashable network process regex-tdfa

     

       290852
       290852
       +
                base bytestring directory hashable hspec network process regex-tdfa

     

       291026
       290853
        
              ];

     

       291027
       291027
       -
              executableHaskellDepends = [ base regex-tdfa ];

     

       291028
       291028
       -
              testHaskellDepends = [ base ];

     

       290854
       290854
       +
              executableHaskellDepends = [ base hspec regex-tdfa ];

     

       290855
       290855
       +
              testHaskellDepends = [ base hspec process ];

     

       291029
       290856
        
              description = "Yet Another Parser Builder (YAPB)";

     

       291030
       290857
        
              license = lib.licenses.bsd3;

     

       290858
       290858
       +
              hydraPlatforms = lib.platforms.none;

     

       290859
       290859
       +
              broken = true;

     

       291031
       290860
        
            }) {};

     

       291032
       290861
        
       

     

       291033
       290862
        
         "yarn-lock" = callPackage

     
···

       291857
       291686
        
              ];

     

       291858
       291687
        
              description = "A yesod-auth plugin for LTI 1.3";

     

       291859
       291688
        
              license = lib.licenses.lgpl3Only;

     

       291860
       291860
       -
              hydraPlatforms = lib.platforms.none;

     

       291861
       291689
        
            }) {};

     

       291862
       291690
        
       

     

       291863
       291691
        
         "yesod-auth-nopassword" = callPackage

+1 -1

pkgs/development/tools/haskell/haskell-language-server/withWrapper.nix

···

       1
       1
       -
       { lib, supportedGhcVersions ? [ "884" "8106" ], stdenv, haskellPackages

     

       1
       1
       +
       { lib, supportedGhcVersions ? [ "884" "8107" ], stdenv, haskellPackages

     

       2
       2
        
       , haskell }:

     

       3
       3
        
       #

     

       4
       4
        
       # The recommended way to override this package is

+4 -4

pkgs/top-level/all-packages.nix

···

       1029
       1029
        
         };

     

       1030
       1030
        
         termite-unwrapped = callPackage ../applications/terminal-emulators/termite { };

     

       1031
       1031
        
       

     

       1032
       1032
       -
         termonad-with-packages = callPackage ../applications/terminal-emulators/termonad {

     

       1033
       1033
       -
           inherit (haskellPackages) ghcWithPackages;

     

       1034
       1034
       -
         };

     

       1032
       1032
       +
         termonad-with-packages = callPackage ../applications/terminal-emulators/termonad { };

     

       1033
       1033
       +
       

     

       1034
       1034
       +
         termonad = termonad-with-packages;

     

       1035
       1035
        
       

     

       1036
       1036
        
         termsyn = callPackage ../data/fonts/termsyn { };

     

       1037
       1037
        
       

     
···

       11480
       11480
        
       

     

       11481
       11481
        
         # Please update doc/languages-frameworks/haskell.section.md, “Our

     

       11482
       11482
        
         # current default compiler is”, if you bump this:

     

       11483
       11483
       -
         haskellPackages = dontRecurseIntoAttrs haskell.packages.ghc8106;

     

       11483
       11483
       +
         haskellPackages = dontRecurseIntoAttrs haskell.packages.ghc8107;

     

       11484
       11484
        
       

     

       11485
       11485
        
         inherit (haskellPackages) ghc;

     

       11486
       11486

+40 -17

pkgs/top-level/haskell-packages.nix

···

       6
       6
        
           "ghc865Binary"

     

       7
       7
        
           "ghc8102Binary"

     

       8
       8
        
           "ghc8102BinaryMinimal"

     

       9
       9
       -
           "ghc8105Binary"

     

       10
       10
       -
           "ghc8105BinaryMinimal"

     

       9
       9
       +
           "ghc8107Binary"

     

       10
       10
       +
           "ghc8107BinaryMinimal"

     

       11
       11
        
           "integer-simple"

     

       12
       12
        
           "native-bignum"

     

       13
       13
        
           "ghcHEAD"

     
···

       59
       59
        
             minimal = true;

     

       60
       60
        
           };

     

       61
       61
        
       

     

       62
       62
       -
           ghc8105Binary = callPackage ../development/compilers/ghc/8.10.5-binary.nix {

     

       62
       62
       +
           ghc8107Binary = callPackage ../development/compilers/ghc/8.10.7-binary.nix {

     

       63
       63
        
             llvmPackages = pkgs.llvmPackages_11;

     

       64
       64
        
           };

     

       65
       65
        
       

     

       66
       66
       -
           ghc8105BinaryMinimal = callPackage ../development/compilers/ghc/8.10.5-binary.nix {

     

       66
       66
       +
           ghc8107BinaryMinimal = callPackage ../development/compilers/ghc/8.10.7-binary.nix {

     

       67
       67
        
             llvmPackages = pkgs.llvmPackages_11;

     

       68
       68
        
             minimal = true;

     

       69
       69
        
           };

     
···

       71
       71
        
           ghc884 = callPackage ../development/compilers/ghc/8.8.4.nix {

     

       72
       72
        
             # the oldest ghc with aarch64-darwin support is 8.10.5

     

       73
       73
        
             bootPkgs = if stdenv.isDarwin && stdenv.isAarch64 then

     

       74
       74
       -
                 packages.ghc8105BinaryMinimal

     

       74
       74
       +
                 packages.ghc8107BinaryMinimal

     

       75
       75
        
               # aarch64 ghc865Binary gets SEGVs due to haskell#15449 or similar

     

       76
       76
        
               # Musl bindists do not exist for ghc 8.6.5, so we use 8.10.* for them

     

       77
       77
        
               else if stdenv.isAarch64 || stdenv.targetPlatform.isMusl then

     
···

       82
       82
        
             buildLlvmPackages = buildPackages.llvmPackages_7;

     

       83
       83
        
             llvmPackages = pkgs.llvmPackages_7;

     

       84
       84
        
           };

     

       85
       85
       -
           ghc8106 = callPackage ../development/compilers/ghc/8.10.6.nix {

     

       85
       85
       +
           ghc8107 = callPackage ../development/compilers/ghc/8.10.7.nix {

     

       86
       86
        
             # the oldest ghc with aarch64-darwin support is 8.10.5

     

       87
       87
        
             bootPkgs = if stdenv.isDarwin && stdenv.isAarch64 then

     

       88
       88
       -
                 packages.ghc8105BinaryMinimal

     

       88
       88
       +
                 packages.ghc8107BinaryMinimal

     

       89
       89
        
               # aarch64 ghc865Binary gets SEGVs due to haskell#15449 or similar

     

       90
       90
        
               # Musl bindists do not exist for ghc 8.6.5, so we use 8.10.* for them

     

       91
       91
        
               else if stdenv.isAarch64 || stdenv.isAarch32 || stdenv.targetPlatform.isMusl then

     
···

       103
       103
        
           ghc901 = callPackage ../development/compilers/ghc/9.0.1.nix {

     

       104
       104
        
             # the oldest ghc with aarch64-darwin support is 8.10.5

     

       105
       105
        
             bootPkgs = if stdenv.isDarwin && stdenv.isAarch64 then

     

       106
       106
       -
                 packages.ghc8105BinaryMinimal

     

       106
       106
       +
                 packages.ghc8107BinaryMinimal

     

       107
       107
        
               # aarch64 ghc8102Binary exceeds max output size on hydra

     

       108
       108
        
               else if stdenv.isAarch64 || stdenv.isAarch32 then

     

       109
       109
        
                 packages.ghc8102BinaryMinimal

     
···

       113
       113
        
             buildLlvmPackages = buildPackages.llvmPackages_10;

     

       114
       114
        
             llvmPackages = pkgs.llvmPackages_10;

     

       115
       115
        
           };

     

       116
       116
       +
           ghc921 = callPackage ../development/compilers/ghc/9.2.1.nix {

     

       117
       117
       +
             # aarch64 ghc8102Binary exceeds max output size on hydra

     

       118
       118
       +
             bootPkgs = if stdenv.isAarch64 || stdenv.isAarch32 then

     

       119
       119
       +
                 packages.ghc8102BinaryMinimal

     

       120
       120
       +
               else

     

       121
       121
       +
                 packages.ghc8102Binary;

     

       122
       122
       +
             inherit (buildPackages.python3Packages) sphinx;

     

       123
       123
       +
             # Need to use apple's patched xattr until

     

       124
       124
       +
             # https://github.com/xattr/xattr/issues/44 and

     

       125
       125
       +
             # https://github.com/xattr/xattr/issues/55 are solved.

     

       126
       126
       +
             inherit (buildPackages.darwin) xattr;

     

       127
       127
       +
             buildLlvmPackages = buildPackages.llvmPackages_10;

     

       128
       128
       +
             llvmPackages = pkgs.llvmPackages_10;

     

       129
       129
       +
           };

     

       116
       130
        
           ghcHEAD = callPackage ../development/compilers/ghc/head.nix {

     

       117
       131
        
             bootPkgs = packages.ghc901; # no binary yet

     

       118
       132
        
             inherit (buildPackages.python3Packages) sphinx;

     

       133
       133
       +
             # Need to use apple's patched xattr until

     

       134
       134
       +
             # https://github.com/xattr/xattr/issues/44 and

     

       135
       135
       +
             # https://github.com/xattr/xattr/issues/55 are solved.

     

       136
       136
       +
             inherit (buildPackages.darwin) xattr;

     

       119
       137
        
             buildLlvmPackages = buildPackages.llvmPackages_10;

     

       120
       138
        
             llvmPackages = pkgs.llvmPackages_10;

     

       121
       139
        
             libffi = pkgs.libffi;

     
···

       166
       184
        
             compilerConfig = callPackage ../development/haskell-modules/configuration-ghc-8.10.x.nix { };

     

       167
       185
        
             packageSetConfig = bootstrapPackageSet;

     

       168
       186
        
           };

     

       169
       169
       -
           ghc8105Binary = callPackage ../development/haskell-modules {

     

       170
       170
       -
             buildHaskellPackages = bh.packages.ghc8105Binary;

     

       171
       171
       -
             ghc = bh.compiler.ghc8105Binary;

     

       187
       187
       +
           ghc8107Binary = callPackage ../development/haskell-modules {

     

       188
       188
       +
             buildHaskellPackages = bh.packages.ghc8107Binary;

     

       189
       189
       +
             ghc = bh.compiler.ghc8107Binary;

     

       172
       190
        
             compilerConfig = callPackage ../development/haskell-modules/configuration-ghc-8.10.x.nix { };

     

       173
       191
        
             packageSetConfig = bootstrapPackageSet;

     

       174
       192
        
           };

     

       175
       175
       -
           ghc8105BinaryMinimal = callPackage ../development/haskell-modules {

     

       176
       176
       -
             buildHaskellPackages = bh.packages.ghc8105BinaryMinimal;

     

       177
       177
       -
             ghc = bh.compiler.ghc8105BinaryMinimal;

     

       193
       193
       +
           ghc8107BinaryMinimal = callPackage ../development/haskell-modules {

     

       194
       194
       +
             buildHaskellPackages = bh.packages.ghc8107BinaryMinimal;

     

       195
       195
       +
             ghc = bh.compiler.ghc8107BinaryMinimal;

     

       178
       196
        
             compilerConfig = callPackage ../development/haskell-modules/configuration-ghc-8.10.x.nix { };

     

       179
       197
        
             packageSetConfig = bootstrapPackageSet;

     

       180
       198
        
           };

     
···

       183
       201
        
             ghc = bh.compiler.ghc884;

     

       184
       202
        
             compilerConfig = callPackage ../development/haskell-modules/configuration-ghc-8.8.x.nix { };

     

       185
       203
        
           };

     

       186
       186
       -
           ghc8106 = callPackage ../development/haskell-modules {

     

       187
       187
       -
             buildHaskellPackages = bh.packages.ghc8106;

     

       188
       188
       -
             ghc = bh.compiler.ghc8106;

     

       204
       204
       +
           ghc8107 = callPackage ../development/haskell-modules {

     

       205
       205
       +
             buildHaskellPackages = bh.packages.ghc8107;

     

       206
       206
       +
             ghc = bh.compiler.ghc8107;

     

       189
       207
        
             compilerConfig = callPackage ../development/haskell-modules/configuration-ghc-8.10.x.nix { };

     

       190
       208
        
           };

     

       191
       209
        
           ghc901 = callPackage ../development/haskell-modules {

     

       192
       210
        
             buildHaskellPackages = bh.packages.ghc901;

     

       193
       211
        
             ghc = bh.compiler.ghc901;

     

       194
       212
        
             compilerConfig = callPackage ../development/haskell-modules/configuration-ghc-9.0.x.nix { };

     

       213
       213
       +
           };

     

       214
       214
       +
           ghc921 = callPackage ../development/haskell-modules {

     

       215
       215
       +
             buildHaskellPackages = bh.packages.ghc921;

     

       216
       216
       +
             ghc = bh.compiler.ghc921;

     

       217
       217
       +
             compilerConfig = callPackage ../development/haskell-modules/configuration-ghc-9.2.x.nix { };

     

       195
       218
        
           };

     

       196
       219
        
           ghcHEAD = callPackage ../development/haskell-modules {

     

       197
       220
        
             buildHaskellPackages = bh.packages.ghcHEAD;

+9 -9

pkgs/top-level/release-haskell.nix

···

       50
       50
        
         # list of all compilers to test specific packages on

     

       51
       51
        
         all = with compilerNames; [

     

       52
       52
        
           ghc884

     

       53
       53
       -
           ghc8106

     

       53
       53
       +
           ghc8107

     

       54
       54
        
           ghc901

     

       55
       55
        
         ];

     

       56
       56
        
       

     
···

       278
       278
        
             # Test some statically linked packages to catch regressions

     

       279
       279
        
             # and get some cache going for static compilation with GHC.

     

       280
       280
        
             # Use integer-simple to avoid GMP linking problems (LGPL)

     

       281
       281
       -
             pkgsStatic.haskell.packages.integer-simple.ghc8106 =

     

       281
       281
       +
             pkgsStatic.haskell.packages.integer-simple.ghc8107 =

     

       282
       282
        
               removePlatforms

     

       283
       283
        
                 [

     

       284
       284
        
                   "aarch64-linux" # times out on Hydra

     

       285
       285
        
                   "x86_64-darwin" # TODO: reenable when static libiconv works on darwin

     

       286
       286
        
                 ]

     

       287
       287
        
                 {

     

       288
       288
       -
                   inherit (packagePlatforms pkgs.pkgsStatic.haskell.packages.integer-simple.ghc8106)

     

       288
       288
       +
                   inherit (packagePlatforms pkgs.pkgsStatic.haskell.packages.integer-simple.ghc8107)

     

       289
       289
        
                     hello

     

       290
       290
        
                     lens

     

       291
       291
        
                     random

     
···

       300
       300
        
             # package sets (like Cabal, jailbreak-cabal) are

     

       301
       301
        
             # working as expected.

     

       302
       302
        
             cabal-install = all;

     

       303
       303
       -
             Cabal_3_6_0_0 = with compilerNames; [ ghc884 ghc8106 ];

     

       303
       303
       +
             Cabal_3_6_0_0 = with compilerNames; [ ghc884 ghc8107 ];

     

       304
       304
        
             cabal2nix-unstable = all;

     

       305
       305
        
             funcmp = all;

     

       306
       306
        
             # Doesn't currently work on ghc-9.0:

     

       307
       307
        
             # https://github.com/haskell/haskell-language-server/issues/297

     

       308
       308
       -
             haskell-language-server = with compilerNames; [ ghc884 ghc8106 ];

     

       308
       308
       +
             haskell-language-server = with compilerNames; [ ghc884 ghc8107 ];

     

       309
       309
        
             hoogle = all;

     

       310
       310
        
             hsdns = all;

     

       311
       311
        
             jailbreak-cabal = all;

     
···

       379
       379
        
               constituents = accumulateDerivations [

     

       380
       380
        
                 jobs.pkgsMusl.haskell.compiler.ghc8102Binary

     

       381
       381
        
                 jobs.pkgsMusl.haskell.compiler.ghc884

     

       382
       382
       -
                 jobs.pkgsMusl.haskell.compiler.ghc8106

     

       382
       382
       +
                 jobs.pkgsMusl.haskell.compiler.ghc8107

     

       383
       383
        
                 jobs.pkgsMusl.haskell.compiler.ghc901

     

       384
       384
        
               ];

     

       385
       385
        
             };

     
···

       394
       394
        
                 ];

     

       395
       395
        
               };

     

       396
       396
        
               constituents = accumulateDerivations [

     

       397
       397
       -
                 jobs.pkgsStatic.haskell.packages.integer-simple.ghc8106.hello

     

       398
       398
       -
                 jobs.pkgsStatic.haskell.packages.integer-simple.ghc8106.lens

     

       399
       399
       -
                 jobs.pkgsStatic.haskell.packages.integer-simple.ghc8106.random

     

       397
       397
       +
                 jobs.pkgsStatic.haskell.packages.integer-simple.ghc8107.hello

     

       398
       398
       +
                 jobs.pkgsStatic.haskell.packages.integer-simple.ghc8107.lens

     

       399
       399
       +
                 jobs.pkgsStatic.haskell.packages.integer-simple.ghc8107.random

     

       400
       400
        
               ];

     

       401
       401
        
             };

     

       402
       402
        
           }