commit 016913f3da0bac999d312f24e28427d838257e33 · pyrox.dev/nixpkgs

+4 -4

pkgs/data/misc/hackage/pin.json

···

       1
       1
        
       {

     

       2
       2
       -
         "commit": "155a57bcfc019c9972a44be54a407d0329dfb436",

     

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

     

       4
       4
       -
         "sha256": "17pqq15b936gf8vm1lb1kmnnlmjd61a5bfld9v3cs7ydz764kg8w",

     

       5
       5
       -
         "msg": "Update from Hackage at 2022-07-21T21:13:45Z"

     

       2
       2
       +
         "commit": "c58387b71e19d6dd43bbade8f84d6a44b6418e24",

     

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

     

       4
       4
       +
         "sha256": "0xdvqn4392l65ns4wm47c8nyp1s7al4i506927dmkzz85m3hvyn0",

     

       5
       5
       +
         "msg": "Update from Hackage at 2022-07-26T16:57:53Z"

     

       6
       6
        
       }

+381

pkgs/development/compilers/ghc/9.4.1.nix

···

       1
       1
       +
       # Preliminary GHC 9.4.1 expression using the make build system.

     

       2
       2
       +
       # TODO(@sternenseemann): port to hadrian, so we are prepared for 9.6

     

       3
       3
       +
       # where make support will be dropped.

     

       4
       4
       +
       { lib, stdenv, pkgsBuildTarget, pkgsHostTarget, targetPackages

     

       5
       5
       +
       

     

       6
       6
       +
       # build-tools

     

       7
       7
       +
       , bootPkgs

     

       8
       8
       +
       , autoconf, automake, coreutils, fetchpatch, fetchurl, perl, python3, m4, sphinx

     

       9
       9
       +
       , xattr, autoSignDarwinBinariesHook

     

       10
       10
       +
       , bash

     

       11
       11
       +
       

     

       12
       12
       +
       , libiconv ? null, ncurses

     

       13
       13
       +
       , glibcLocales ? null

     

       14
       14
       +
       

     

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

     

       16
       16
       +
         libffi ? null

     

       17
       17
       +
       

     

       18
       18
       +
       , useLLVM ? !(stdenv.targetPlatform.isx86

     

       19
       19
       +
                     || stdenv.targetPlatform.isPower

     

       20
       20
       +
                     || stdenv.targetPlatform.isSparc

     

       21
       21
       +
                     || (stdenv.targetPlatform.isAarch64 && stdenv.targetPlatform.isDarwin))

     

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

     

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

     

       24
       24
       +
         # build-time dependency too.

     

       25
       25
       +
         buildTargetLlvmPackages, llvmPackages

     

       26
       26
       +
       

     

       27
       27
       +
       , # If enabled, GHC will be built with the GPL-free but slightly slower native

     

       28
       28
       +
         # bignum backend instead of the faster but GPLed gmp backend.

     

       29
       29
       +
         enableNativeBignum ? !(lib.meta.availableOn stdenv.hostPlatform gmp)

     

       30
       30
       +
       , gmp

     

       31
       31
       +
       

     

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

     

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

     

       34
       34
       +
       

     

       35
       35
       +
         # aarch64 outputs otherwise exceed 2GB limit

     

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

     

       37
       37
       +
       

     

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

     

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

     

       40
       40
       +
         enableShared ? with stdenv.targetPlatform; !isWindows && !useiOSPrebuilt && !isStatic

     

       41
       41
       +
       

     

       42
       42
       +
       , # Whether to build terminfo.

     

       43
       43
       +
         enableTerminfo ? !stdenv.targetPlatform.isWindows

     

       44
       44
       +
       

     

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

     

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

     

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

     

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

     

       49
       49
       +
       

     

       50
       50
       +
       , #  Whether to build sphinx documentation.

     

       51
       51
       +
         enableDocs ? (

     

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

     

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

     

       54
       54
       +
           # `sphinx` pulls in among others:

     

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

     

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

     

       57
       57
       +
           && !stdenv.hostPlatform.isMusl

     

       58
       58
       +
         )

     

       59
       59
       +
       

     

       60
       60
       +
       , enableHaddockProgram ?

     

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

     

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

     

       63
       63
       +
       

     

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

     

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

     

       66
       66
       +
         disableLargeAddressSpace ? stdenv.targetPlatform.isiOS

     

       67
       67
       +
       }:

     

       68
       68
       +
       

     

       69
       69
       +
       assert !enableNativeBignum -> gmp != null;

     

       70
       70
       +
       

     

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

     

       72
       72
       +
       # see note [HADDOCK_DOCS].

     

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

     

       74
       74
       +
       

     

       75
       75
       +
       let

     

       76
       76
       +
         inherit (stdenv) buildPlatform hostPlatform targetPlatform;

     

       77
       77
       +
       

     

       78
       78
       +
         inherit (bootPkgs) ghc;

     

       79
       79
       +
       

     

       80
       80
       +
         # TODO(@Ericson2314) Make unconditional

     

       81
       81
       +
         targetPrefix = lib.optionalString

     

       82
       82
       +
           (targetPlatform != hostPlatform)

     

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

     

       84
       84
       +
       

     

       85
       85
       +
         buildMK = ''

     

       86
       86
       +
           BuildFlavour = ${ghcFlavour}

     

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

     

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

     

       89
       89
       +
           endif

     

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

     

       91
       91
       +
           BUILD_SPHINX_PDF = NO

     

       92
       92
       +
         '' +

     

       93
       93
       +
         # Note [HADDOCK_DOCS]:

     

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

     

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

     

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

     

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

     

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

     

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

     

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

     

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

     

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

     

       103
       103
       +
         ''

     

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

     

       105
       105
       +
           # Build haddocks for boot packages with hyperlinking

     

       106
       106
       +
           EXTRA_HADDOCK_OPTS += --hyperlinked-source --quickjump

     

       107
       107
       +
       

     

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

     

       109
       109
       +
           BIGNUM_BACKEND = ${if enableNativeBignum then "native" else "gmp"}

     

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

     

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

     

       112
       112
       +
           CrossCompilePrefix = ${targetPrefix}

     

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

     

       114
       114
       +
           GhcLibWays = "v dyn"

     

       115
       115
       +
         '' +

     

       116
       116
       +
         # -fexternal-dynamic-refs apparently (because it's not clear from the documentation)

     

       117
       117
       +
         # makes the GHC RTS able to load static libraries, which may be needed for TemplateHaskell.

     

       118
       118
       +
         # This solution was described in https://www.tweag.io/blog/2020-09-30-bazel-static-haskell

     

       119
       119
       +
         lib.optionalString enableRelocatedStaticLibs ''

     

       120
       120
       +
           GhcLibHcOpts += -fPIC -fexternal-dynamic-refs

     

       121
       121
       +
           GhcRtsHcOpts += -fPIC -fexternal-dynamic-refs

     

       122
       122
       +
         '' + lib.optionalString targetPlatform.useAndroidPrebuilt ''

     

       123
       123
       +
           EXTRA_CC_OPTS += -std=gnu99

     

       124
       124
       +
         '';

     

       125
       125
       +
       

     

       126
       126
       +
         # Splicer will pull out correct variations

     

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

     

       128
       128
       +
           ++ [libffi]

     

       129
       129
       +
           ++ lib.optional (!enableNativeBignum) gmp

     

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

     

       131
       131
       +
       

     

       132
       132
       +
         # TODO(@sternenseemann): is buildTarget LLVM unnecessary?

     

       133
       133
       +
         # GHC doesn't seem to have {LLC,OPT}_HOST

     

       134
       134
       +
         toolsForTarget = [

     

       135
       135
       +
           pkgsBuildTarget.targetPackages.stdenv.cc

     

       136
       136
       +
         ] ++ lib.optional useLLVM buildTargetLlvmPackages.llvm;

     

       137
       137
       +
       

     

       138
       138
       +
         targetCC = builtins.head toolsForTarget;

     

       139
       139
       +
       

     

       140
       140
       +
         # Sometimes we have to dispatch between the bintools wrapper and the unwrapped

     

       141
       141
       +
         # derivation for certain tools depending on the platform.

     

       142
       142
       +
         bintoolsFor = {

     

       143
       143
       +
           # GHC needs install_name_tool on all darwin platforms. On aarch64-darwin it is

     

       144
       144
       +
           # part of the bintools wrapper (due to codesigning requirements), but not on

     

       145
       145
       +
           # x86_64-darwin.

     

       146
       146
       +
           install_name_tool =

     

       147
       147
       +
             if stdenv.targetPlatform.isAarch64

     

       148
       148
       +
             then targetCC.bintools

     

       149
       149
       +
             else targetCC.bintools.bintools;

     

       150
       150
       +
           # Same goes for strip.

     

       151
       151
       +
           strip =

     

       152
       152
       +
             # TODO(@sternenseemann): also use wrapper if linker == "bfd" or "gold"

     

       153
       153
       +
             if stdenv.targetPlatform.isAarch64 && stdenv.targetPlatform.isDarwin

     

       154
       154
       +
             then targetCC.bintools

     

       155
       155
       +
             else targetCC.bintools.bintools;

     

       156
       156
       +
         };

     

       157
       157
       +
       

     

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

     

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

     

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

     

       161
       161
       +
         useLdGold = targetPlatform.linker == "gold" ||

     

       162
       162
       +
           (targetPlatform.linker == "bfd" && (targetCC.bintools.bintools.hasGold or false) && !targetPlatform.isMusl);

     

       163
       163
       +
       

     

       164
       164
       +
         # Makes debugging easier to see which variant is at play in `nix-store -q --tree`.

     

       165
       165
       +
         variantSuffix = lib.concatStrings [

     

       166
       166
       +
           (lib.optionalString stdenv.hostPlatform.isMusl "-musl")

     

       167
       167
       +
           (lib.optionalString enableNativeBignum "-native-bignum")

     

       168
       168
       +
         ];

     

       169
       169
       +
       

     

       170
       170
       +
       in

     

       171
       171
       +
       

     

       172
       172
       +
       # C compiler, bintools and LLVM are used at build time, but will also leak into

     

       173
       173
       +
       # the resulting GHC's settings file and used at runtime. This means that we are

     

       174
       174
       +
       # currently only able to build GHC if hostPlatform == buildPlatform.

     

       175
       175
       +
       assert targetCC == pkgsHostTarget.targetPackages.stdenv.cc;

     

       176
       176
       +
       assert buildTargetLlvmPackages.llvm == llvmPackages.llvm;

     

       177
       177
       +
       assert stdenv.targetPlatform.isDarwin -> buildTargetLlvmPackages.clang == llvmPackages.clang;

     

       178
       178
       +
       

     

       179
       179
       +
       stdenv.mkDerivation (rec {

     

       180
       180
       +
         version = "9.4.0.20220721";

     

       181
       181
       +
         pname = "${targetPrefix}ghc${variantSuffix}";

     

       182
       182
       +
       

     

       183
       183
       +
         src = fetchurl {

     

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

     

       185
       185
       +
           sha256 = "bca8c52f76d8747a66291181de2de7bdf9ff80093808fe39bf5cbff0f116c426";

     

       186
       186
       +
         };

     

       187
       187
       +
       

     

       188
       188
       +
         enableParallelBuilding = true;

     

       189
       189
       +
       

     

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

     

       191
       191
       +
       

     

       192
       192
       +
         patches = [

     

       193
       193
       +
           # fix hyperlinked haddock sources: https://github.com/haskell/haddock/pull/1482

     

       194
       194
       +
           (fetchpatch {

     

       195
       195
       +
             url = "https://patch-diff.githubusercontent.com/raw/haskell/haddock/pull/1482.patch";

     

       196
       196
       +
             sha256 = "sha256-8w8QUCsODaTvknCDGgTfFNZa8ZmvIKaKS+2ZJZ9foYk=";

     

       197
       197
       +
             extraPrefix = "utils/haddock/";

     

       198
       198
       +
             stripLen = 1;

     

       199
       199
       +
           })

     

       200
       200
       +
         ];

     

       201
       201
       +
       

     

       202
       202
       +
         postPatch = "patchShebangs .";

     

       203
       203
       +
       

     

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

     

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

     

       206
       206
       +
       

     

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

     

       208
       208
       +
         # TODO(@sternenseemann): investigate coreutils dependencies and pass absolute paths

     

       209
       209
       +
         preConfigure = ''

     

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

     

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

     

       212
       212
       +
           done

     

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

     

       214
       214
       +
           # the *host* tools.

     

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

     

       216
       216
       +
           export CXX="${targetCC}/bin/${targetCC.targetPrefix}c++"

     

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

     

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

     

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

     

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

     

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

     

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

     

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

     

       224
       224
       +
           export STRIP="${bintoolsFor.strip}/bin/${bintoolsFor.strip.targetPrefix}strip"

     

       225
       225
       +
         '' + lib.optionalString (stdenv.targetPlatform.linker == "cctools") ''

     

       226
       226
       +
           export OTOOL="${targetCC.bintools.bintools}/bin/${targetCC.bintools.targetPrefix}otool"

     

       227
       227
       +
           export INSTALL_NAME_TOOL="${bintoolsFor.install_name_tool}/bin/${bintoolsFor.install_name_tool.targetPrefix}install_name_tool"

     

       228
       228
       +
         '' + lib.optionalString useLLVM ''

     

       229
       229
       +
           export LLC="${lib.getBin buildTargetLlvmPackages.llvm}/bin/llc"

     

       230
       230
       +
           export OPT="${lib.getBin buildTargetLlvmPackages.llvm}/bin/opt"

     

       231
       231
       +
         '' + lib.optionalString (useLLVM && stdenv.targetPlatform.isDarwin) ''

     

       232
       232
       +
           # LLVM backend on Darwin needs clang: https://downloads.haskell.org/~ghc/latest/docs/html/users_guide/codegens.html#llvm-code-generator-fllvm

     

       233
       233
       +
           export CLANG="${buildTargetLlvmPackages.clang}/bin/${buildTargetLlvmPackages.clang.targetPrefix}clang"

     

       234
       234
       +
         '' + ''

     

       235
       235
       +
       

     

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

     

       237
       237
       +
           # GHC 9.4.1-rc1 tarball is not properly prepared, also the boot script has been renamed

     

       238
       238
       +
           # https://gitlab.haskell.org/ghc/ghc/-/issues/21626#note_444654

     

       239
       239
       +
           # TODO(@sternenseemann): make source-dist rules include all boot-generated files

     

       240
       240
       +
           ./boot.source

     

       241
       241
       +
       

     

       242
       242
       +
           # Too restrictive upper bound on Cabal the make build system chokes on

     

       243
       243
       +
           # XXX(@sternenseemann): this should be upstreamed

     

       244
       244
       +
           substituteInPlace utils/ghc-cabal/ghc-cabal.cabal --replace "3.8" "3.9"

     

       245
       245
       +
       

     

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

     

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

     

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

     

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

     

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

     

       251
       251
       +
         '' + lib.optionalString stdenv.isDarwin ''

     

       252
       252
       +
           export NIX_LDFLAGS+=" -no_dtrace_dof"

     

       253
       253
       +
       

     

       254
       254
       +
           # GHC tries the host xattr /usr/bin/xattr by default which fails since it expects python to be 2.7

     

       255
       255
       +
           export XATTR=${lib.getBin xattr}/bin/xattr

     

       256
       256
       +
         '' + lib.optionalString targetPlatform.useAndroidPrebuilt ''

     

       257
       257
       +
           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

     

       258
       258
       +
         '' + lib.optionalString targetPlatform.isMusl ''

     

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

     

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

     

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

     

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

     

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

     

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

     

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

     

       266
       266
       +
       

     

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

     

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

     

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

     

       270
       270
       +
               substituteInPlace $x \

     

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

     

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

     

       273
       273
       +
             done

     

       274
       274
       +
         '';

     

       275
       275
       +
       

     

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

     

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

     

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

     

       279
       279
       +
       

     

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

     

       281
       281
       +
         configureFlags = [

     

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

     

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

     

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

     

       285
       285
       +
           "--with-system-libffi"

     

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

     

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

     

       288
       288
       +
         ] ++ lib.optionals (targetPlatform == hostPlatform && !enableNativeBignum) [

     

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

     

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

     

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

     

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

     

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

     

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

     

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

     

       296
       296
       +
         ] ++ lib.optionals useLdGold [

     

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

     

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

     

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

     

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

     

       301
       301
       +
           "--disable-large-address-space"

     

       302
       302
       +
         ];

     

       303
       303
       +
       

     

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

     

       305
       305
       +
         strictDeps = true;

     

       306
       306
       +
       

     

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

     

       308
       308
       +
         dontAddExtraLibs = true;

     

       309
       309
       +
       

     

       310
       310
       +
         nativeBuildInputs = [

     

       311
       311
       +
           perl autoconf automake m4 python3

     

       312
       312
       +
           ghc bootPkgs.alex bootPkgs.happy bootPkgs.hscolour

     

       313
       313
       +
         ] ++ lib.optionals (stdenv.isDarwin && stdenv.isAarch64) [

     

       314
       314
       +
           autoSignDarwinBinariesHook

     

       315
       315
       +
         ] ++ lib.optionals enableDocs [

     

       316
       316
       +
           sphinx

     

       317
       317
       +
         ];

     

       318
       318
       +
       

     

       319
       319
       +
         # For building runtime libs

     

       320
       320
       +
         depsBuildTarget = toolsForTarget;

     

       321
       321
       +
       

     

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

     

       323
       323
       +
       

     

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

     

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

     

       326
       326
       +
       

     

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

     

       328
       328
       +
         # that in turn causes GHCi to abort

     

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

     

       330
       330
       +
       

     

       331
       331
       +
         checkTarget = "test";

     

       332
       332
       +
       

     

       333
       333
       +
         hardeningDisable =

     

       334
       334
       +
           [ "format" ]

     

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

     

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

     

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

     

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

     

       339
       339
       +
           # See:

     

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

     

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

     

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

     

       343
       343
       +
       

     

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

     

       345
       345
       +
         # Hydra which already warrants a significant speedup

     

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

     

       347
       347
       +
       

     

       348
       348
       +
         postInstall = ''

     

       349
       349
       +
           # Install the bash completion file.

     

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

     

       351
       351
       +
         '';

     

       352
       352
       +
       

     

       353
       353
       +
         passthru = {

     

       354
       354
       +
           inherit bootPkgs targetPrefix;

     

       355
       355
       +
       

     

       356
       356
       +
           inherit llvmPackages;

     

       357
       357
       +
           inherit enableShared;

     

       358
       358
       +
       

     

       359
       359
       +
           # This is used by the haskell builder to query

     

       360
       360
       +
           # the presence of the haddock program.

     

       361
       361
       +
           hasHaddock = enableHaddockProgram;

     

       362
       362
       +
       

     

       363
       363
       +
           # Our Cabal compiler name

     

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

     

       365
       365
       +
         };

     

       366
       366
       +
       

     

       367
       367
       +
         meta = {

     

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

     

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

     

       370
       370
       +
           maintainers = with lib.maintainers; [

     

       371
       371
       +
             guibou

     

       372
       372
       +
           ] ++ lib.teams.haskell.members;

     

       373
       373
       +
           timeout = 24 * 3600;

     

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

     

       375
       375
       +
         };

     

       376
       376
       +
       

     

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

     

       378
       378
       +
         dontStrip = true;

     

       379
       379
       +
         dontPatchELF = true;

     

       380
       380
       +
         noAuditTmpdir = true;

     

       381
       381
       +
       })

+3 -3

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

···

       8
       8
        
       }:

     

       9
       9
        
       mkDerivation {

     

       10
       10
        
         pname = "cabal2nix";

     

       11
       11
       -
         version = "unstable-2022-07-17";

     

       11
       11
       +
         version = "unstable-2022-07-22";

     

       12
       12
        
         src = fetchzip {

     

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

     

       14
       14
       -
           sha256 = "19dagxhj1aflhf19xab8yss5mia6kfpghn4h0na8zshqab8xxgrd";

     

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

     

       14
       14
       +
           sha256 = "11a5l0fdj67bpqv30af4v5zxr3c7n9p81pfs4c0d3w65bmr9sa1y";

     

       15
       15
        
         };

     

       16
       16
        
         isLibrary = true;

     

       17
       17
        
         isExecutable = true;

+5 -18

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

···

       99
       99
        
             name = "git-annex-${super.git-annex.version}-src";

     

       100
       100
        
             url = "git://git-annex.branchable.com/";

     

       101
       101
        
             rev = "refs/tags/" + super.git-annex.version;

     

       102
       102
       -
             sha256 = "0pr2fnaq3fa6lcly39xssl89v65h0wa26ikv5g30fm8y6z5rkqqd";

     

       102
       102
       +
             sha256 = "0p9qd7yasdji5kwxn4d0hrv9hnxbzfsczknldh8jav3ynhg8k6c9";

     

       103
       103
        
             # delete android and Android directories which cause issues on

     

       104
       104
        
             # darwin (case insensitive directory). Since we don't need them

     

       105
       105
        
             # during the build process, we can delete it to prevent a hash

     
···

       2404
       2404
        
         # https://github.com/system-f/validation/issues/57

     

       2405
       2405
        
         validation = doJailbreak super.validation;

     

       2406
       2406
        
       

     

       2407
       2407
       -
         # aws upstream seems to lack the necessary maintenance at the moment, luckily

     

       2408
       2408
       -
         # Joey Hess seems to have already looked into building git-annex with aeson 2.0

     

       2409
       2409
       -
         # https://github.com/aristidb/aws/issues/275

     

       2410
       2410
       -
         aws = overrideCabal (drv: {

     

       2411
       2411
       -
           patches = drv.patches or [] ++ [

     

       2412
       2412
       -
             (fetchpatch {

     

       2413
       2413
       -
               name = "aws-aeson-2.0-compat.patch";

     

       2414
       2414
       -
               url = "https://github.com/aristidb/aws/pull/277/commits/7af7586c5d244d07f77d49e5fdc739e6e8e54816.patch";

     

       2415
       2415
       -
               sha256 = "1bsiyk1k671rwlyflka2whq972h72cwscrxkr9n2wzhxp70ap3g3";

     

       2416
       2416
       -
               excludes = [ "aws.cabal" ];

     

       2417
       2417
       -
             })

     

       2418
       2418
       -
           ];

     

       2419
       2419
       -
           # needs aws credentials, jailbreak for base16-bytestring

     

       2420
       2420
       -
           doCheck = false;

     

       2421
       2421
       -
           jailbreak = true;

     

       2422
       2422
       -
         }) super.aws;

     

       2423
       2423
       -
       

     

       2424
       2407
        
         # 2022-03-16: strict upper bounds https://github.com/monadfix/shower/issues/18

     

       2425
       2408
        
         shower = doJailbreak (dontCheck super.shower);

     

       2409
       2409
       +
       

     

       2410
       2410
       +
         # Doesn't compile with HTF 0.15

     

       2411
       2411
       +
         # https://github.com/andrewufrank/uniform-error/issues/1

     

       2412
       2412
       +
         uniform-error = dontCheck super.uniform-error;

     

       2426
       2413
        
       

     

       2427
       2414
        
         # The shipped Setup.hs file is broken.

     

       2428
       2415
        
         csv = overrideCabal (drv: { preCompileBuildDriver = "rm Setup.hs"; }) super.csv;

+51

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

···

       1
       1
       +
       { pkgs, haskellLib }:

     

       2
       2
       +
       

     

       3
       3
       +
       let

     

       4
       4
       +
         inherit (pkgs) fetchpatch lib;

     

       5
       5
       +
         inherit (lib) throwIfNot versionOlder;

     

       6
       6
       +
       in

     

       7
       7
       +
       

     

       8
       8
       +
       self: super: {

     

       9
       9
       +
         llvmPackages = lib.dontRecurseIntoAttrs self.ghc.llvmPackages;

     

       10
       10
       +
       

     

       11
       11
       +
         # Disable GHC core libraries.

     

       12
       12
       +
         array = null;

     

       13
       13
       +
         base = null;

     

       14
       14
       +
         binary = null;

     

       15
       15
       +
         bytestring = null;

     

       16
       16
       +
         Cabal = null;

     

       17
       17
       +
         Cabal-syntax = null;

     

       18
       18
       +
         containers = null;

     

       19
       19
       +
         deepseq = null;

     

       20
       20
       +
         directory = null;

     

       21
       21
       +
         exceptions = null;

     

       22
       22
       +
         filepath = null;

     

       23
       23
       +
         ghc-bignum = null;

     

       24
       24
       +
         ghc-boot = null;

     

       25
       25
       +
         ghc-boot-th = null;

     

       26
       26
       +
         ghc-compact = null;

     

       27
       27
       +
         ghc-heap = null;

     

       28
       28
       +
         ghc-prim = null;

     

       29
       29
       +
         ghci = null;

     

       30
       30
       +
         haskeline = null;

     

       31
       31
       +
         hpc = null;

     

       32
       32
       +
         integer-gmp = null;

     

       33
       33
       +
         libiserv = null;

     

       34
       34
       +
         mtl = null;

     

       35
       35
       +
         parsec = null;

     

       36
       36
       +
         pretty = null;

     

       37
       37
       +
         process = null;

     

       38
       38
       +
         rts = null;

     

       39
       39
       +
         stm = null;

     

       40
       40
       +
         system-cxx-std-lib = null;

     

       41
       41
       +
         template-haskell = null;

     

       42
       42
       +
         # GHC only builds terminfo if it is a native compiler

     

       43
       43
       +
         terminfo = if pkgs.stdenv.hostPlatform == pkgs.stdenv.buildPlatform then null else self.terminfo_0_4_1_5;

     

       44
       44
       +
         text = null;

     

       45
       45
       +
         time = null;

     

       46
       46
       +
         transformers = null;

     

       47
       47
       +
         unix = null;

     

       48
       48
       +
         # GHC only bundles the xhtml library if haddock is enabled, check if this is

     

       49
       49
       +
         # still the case when updating: https://gitlab.haskell.org/ghc/ghc/-/blob/0198841877f6f04269d6050892b98b5c3807ce4c/ghc.mk#L463

     

       50
       50
       +
         xhtml = if self.ghc.hasHaddock or true then null else self.xhtml_3000_2_2_1;

     

       51
       51
       +
       }

+6 -2

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

···

       543
       543
        
         - cabalgraph

     

       544
       544
        
         - cabal-graphdeps

     

       545
       545
        
         - cabal-helper

     

       546
       546
       +
         - cabal-hoogle

     

       546
       547
        
         - Cabal-ide-backend

     

       547
       548
        
         - cabal-info

     

       548
       549
        
         - cabal-install-bundle

     
···

       1259
       1260
        
         - ebnf-bff

     

       1260
       1261
        
         - eccrypto

     

       1261
       1262
        
         - ecma262

     

       1263
       1263
       +
         - ecta

     

       1262
       1264
        
         - ecu

     

       1263
       1265
        
         - eddie

     

       1264
       1266
        
         - ede

     
···

       1304
       1306
        
         - emailaddress

     

       1305
       1307
        
         - email-header

     

       1306
       1308
        
         - email-postmark

     

       1309
       1309
       +
         - embed-config

     

       1307
       1310
        
         - embla

     

       1308
       1311
        
         - emgm

     

       1309
       1312
        
         - Emping

     
···

       1502
       1505
        
         - fix-symbols-gitit

     

       1503
       1506
        
         - fizzbuzz

     

       1504
       1507
        
         - fizzbuzz-as-a-service

     

       1505
       1505
       -
         - flac

     

       1506
       1508
        
         - flaccuraterip

     

       1507
       1509
        
         - flamethrower

     

       1508
       1510
        
         - flamingra

     
···

       2867
       2869
        
         - koellner-phonetic

     

       2868
       2870
        
         - koneko

     

       2869
       2871
        
         - Konf

     

       2872
       2872
       +
         - konnakol

     

       2870
       2873
        
         - kontra-config

     

       2871
       2874
        
         - koofr-client

     

       2872
       2875
        
         - korea-holidays

     
···

       3537
       3540
        
         - newtype-th

     

       3538
       3541
        
         - next-ref

     

       3539
       3542
        
         - nextstep-plist

     

       3540
       3540
       -
         - nfc

     

       3541
       3543
        
         - NGrams

     

       3542
       3544
        
         - niagra

     

       3543
       3545
        
         - nibblestring

     
···

       4015
       4017
        
         - postgres-embedded

     

       4016
       4018
        
         - PostgreSQL

     

       4017
       4019
        
         - postgresql-lo-stream

     

       4020
       4020
       +
         - postgresql-ltree

     

       4018
       4021
        
         - postgresql-named

     

       4019
       4022
        
         - postgresql-query

     

       4020
       4023
        
         - postgresql-resilient

     
···

       5492
       5495
        
         - validated-types

     

       5493
       5496
        
         - Validation

     

       5494
       5497
        
         - validations

     

       5498
       5498
       +
         - validity-network-uri

     

       5495
       5499
        
         - valid-names

     

       5496
       5500
        
         - value-supply

     

       5497
       5501
        
         - vampire

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

···

       165
       165
        
           - spago

     

       166
       166
        
           - stack

     

       167
       167
        
           - termonad

     

       168
       168
       +
         centromere:

     

       169
       169
       +
           - nfc

     

       168
       170
        
         dalpd:

     

       169
       171
        
           - ghc-vis

     

       170
       172
        
           - svgcairo

+6 -1

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

···

       304
       304
        
        - PlslTools

     

       305
       305
        
        - Printf-TH

     

       306
       306
        
        - ProbabilityMonads

     

       307
       307
       +
        - PropaFP

     

       307
       308
        
        - Pugs

     

       308
       309
        
        - Pup-Events

     

       309
       310
        
        - Pup-Events-Demo

     
···

       844
       845
        
        - bricks-rendering

     

       845
       846
        
        - bricks-syntax

     

       846
       847
        
        - bronyradiogermany-streaming

     

       848
       848
       +
        - btc-lsp

     

       847
       849
        
        - btree

     

       848
       850
        
        - buchhaltung

     

       849
       851
        
        - buildbox-tools

     
···

       1316
       1318
        
        - ekg-carbon

     

       1317
       1319
        
        - ekg-cloudwatch

     

       1318
       1320
        
        - ekg-wai

     

       1321
       1321
       +
        - electrs-client

     

       1319
       1322
        
        - elerea-examples

     

       1320
       1323
        
        - elliptic-curve

     

       1321
       1324
        
        - elsa

     
···

       1452
       1455
        
        - fixed-point-vector-space

     

       1453
       1456
        
        - fixed-precision

     

       1454
       1457
        
        - fixhs

     

       1455
       1455
       -
        - flac-picture

     

       1456
       1458
        
        - flashblast

     

       1457
       1459
        
        - flatbuffers

     

       1458
       1460
        
        - flexiwrap

     
···

       1550
       1552
        
        - geniconvert

     

       1551
       1553
        
        - geniserver

     

       1552
       1554
        
        - genvalidity-mergeful

     

       1555
       1555
       +
        - genvalidity-network-uri

     

       1553
       1556
        
        - genvalidity-sydtest

     

       1554
       1557
        
        - genvalidity-sydtest-aeson

     

       1555
       1558
        
        - genvalidity-sydtest-hashable

     
···

       3120
       3123
        
        - poseidon

     

       3121
       3124
        
        - poseidon-postgis

     

       3122
       3125
        
        - postgresql-pure

     

       3126
       3126
       +
        - postgresql-simple-ltree

     

       3123
       3127
        
        - postgresql-simple-queue

     

       3124
       3128
        
        - postgresql-simple-typed

     

       3125
       3129
        
        - postgresql-tx-query

     
···

       3194
       3198
        
        - pvd

     

       3195
       3199
        
        - qd-vec

     

       3196
       3200
        
        - qhs

     

       3201
       3201
       +
        - qhull

     

       3197
       3202
        
        - qr-imager

     

       3198
       3203
        
        - qr-repa

     

       3199
       3204
        
        - qtah-examples

+11

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

···

       948
       948
        
           ] ++ (drv.patches or []);

     

       949
       949
        
         }) super.graphviz;

     

       950
       950
        
       

     

       951
       951
       +
         # Test suite requires AWS access which requires both a network

     

       952
       952
       +
         # connection and payment.

     

       953
       953
       +
         aws = dontCheck super.aws;

     

       954
       954
       +
       

     

       951
       955
        
         # Test case tries to contact the network

     

       952
       956
        
         http-api-data-qq = overrideCabal (drv: {

     

       953
       957
        
           testFlags = [

     
···

       972
       976
        
             install -Dm644 test/examples/*.jac -t "$docDir/examples"

     

       973
       977
        
           '';

     

       974
       978
        
         }) super.jacinda;

     

       979
       979
       +
       

     

       980
       980
       +
         nfc = overrideCabal (drv: {

     

       981
       981
       +
           isExecutable = true;

     

       982
       982
       +
           executableHaskellDepends = with self; drv.executableHaskellDepends or [] ++ [ base base16-bytestring bytestring ];

     

       983
       983
       +
           configureFlags = drv.configureFlags or [] ++ [ "-fbuild-examples" ];

     

       984
       984
       +
           enableSeparateBinOutput = true;

     

       985
       985
       +
         }) super.nfc;

     

       975
       986
        
       

     

       976
       987
        
       # haskell-language-server plugins all use the same test harness so we give them what we want in this loop.

     

       977
       988
        
       } // pkgs.lib.mapAttrs

+820 -213

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

···

       16683
       16683
        
              mainProgram = "program";

     

       16684
       16684
        
            }) {};

     

       16685
       16685
        
       

     

       16686
       16686
       +
         "PropaFP" = callPackage

     

       16687
       16687
       +
           ({ mkDerivation, aern2-mfun, aern2-mp, base, binary, bytestring

     

       16688
       16688
       +
            , collect-errors, containers, directory, extra, ghc

     

       16689
       16689
       +
            , mixed-types-num, optparse-applicative, process, QuickCheck

     

       16690
       16690
       +
            , regex-tdfa, scientific, temporary

     

       16691
       16691
       +
            }:

     

       16692
       16692
       +
            mkDerivation {

     

       16693
       16693
       +
              pname = "PropaFP";

     

       16694
       16694
       +
              version = "0.1.0.0";

     

       16695
       16695
       +
              sha256 = "1rq39yciyqrzc2ky9w0phg6m00m106mng6vf586rl3yd9v83makg";

     

       16696
       16696
       +
              isLibrary = true;

     

       16697
       16697
       +
              isExecutable = true;

     

       16698
       16698
       +
              libraryHaskellDepends = [

     

       16699
       16699
       +
                aern2-mfun aern2-mp base binary bytestring collect-errors

     

       16700
       16700
       +
                containers directory extra ghc mixed-types-num optparse-applicative

     

       16701
       16701
       +
                process QuickCheck regex-tdfa scientific temporary

     

       16702
       16702
       +
              ];

     

       16703
       16703
       +
              executableHaskellDepends = [

     

       16704
       16704
       +
                aern2-mfun aern2-mp base binary bytestring collect-errors

     

       16705
       16705
       +
                containers directory extra ghc mixed-types-num optparse-applicative

     

       16706
       16706
       +
                process QuickCheck regex-tdfa scientific temporary

     

       16707
       16707
       +
              ];

     

       16708
       16708
       +
              testHaskellDepends = [

     

       16709
       16709
       +
                aern2-mfun aern2-mp base binary bytestring collect-errors

     

       16710
       16710
       +
                containers directory extra ghc mixed-types-num optparse-applicative

     

       16711
       16711
       +
                process QuickCheck regex-tdfa scientific temporary

     

       16712
       16712
       +
              ];

     

       16713
       16713
       +
              description = "Auto-active verification of floating-point programs";

     

       16714
       16714
       +
              license = lib.licenses.mpl20;

     

       16715
       16715
       +
              hydraPlatforms = lib.platforms.none;

     

       16716
       16716
       +
            }) {};

     

       16717
       16717
       +
       

     

       16686
       16718
        
         "Proper" = callPackage

     

       16687
       16719
        
           ({ mkDerivation, base, containers, HUnit, parsec, syb }:

     

       16688
       16720
        
            mkDerivation {

     
···

       21638
       21670
        
           ({ mkDerivation, base }:

     

       21639
       21671
        
            mkDerivation {

     

       21640
       21672
        
              pname = "WeakSets";

     

       21641
       21641
       -
              version = "1.2.0.0";

     

       21642
       21642
       -
              sha256 = "0zq7dxw050bj13mb7ayz144lxpwwhd424wzafnypn5i3vpmgldd6";

     

       21673
       21673
       +
              version = "1.2.3.0";

     

       21674
       21674
       +
              sha256 = "0skz318p0irm8nld2raqh61s127mav7cppbwi1iyjm7mwiw3x22g";

     

       21643
       21675
        
              libraryHaskellDepends = [ base ];

     

       21644
       21676
        
              testHaskellDepends = [ base ];

     

       21645
       21677
        
              description = "Simple set types. Useful to create sets of arbitrary types and nested sets.";

     
···

       25714
       25746
        
           ({ mkDerivation, aeson, base, inspection-testing }:

     

       25715
       25747
        
            mkDerivation {

     

       25716
       25748
        
              pname = "aeson-modern-tojson";

     

       25717
       25717
       -
              version = "0.1.1.0";

     

       25718
       25718
       -
              sha256 = "0x1798k4kyndilnm7fpkl8cc4fgn2f3jc1f9x8j2dc8kjkhv1fv7";

     

       25749
       25749
       +
              version = "0.2.0.0";

     

       25750
       25750
       +
              sha256 = "00jpkmij67xamzdg71gsiykx24x51ksphmprqxzbm5q7ifqfmfah";

     

       25719
       25751
        
              libraryHaskellDepends = [ aeson base ];

     

       25720
       25752
        
              testHaskellDepends = [ aeson base inspection-testing ];

     

       25721
       25753
        
              description = "Provide a handy way for derving ToJSON proprely";

     
···

       26085
       26117
        
            }:

     

       26086
       26118
        
            mkDerivation {

     

       26087
       26119
        
              pname = "aeson-tiled";

     

       26088
       26088
       -
              version = "0.0.1.0";

     

       26089
       26089
       -
              sha256 = "1szlwkww2sbqrz6d8mbq20nzkba70a41if33bcka0vhfq5lrp224";

     

       26120
       26120
       +
              version = "0.0.2.0";

     

       26121
       26121
       +
              sha256 = "1akmvr6638rwmyqfs43clxbswdnpwrwb94zzq8whs4j01hkcly7w";

     

       26090
       26122
        
              libraryHaskellDepends = [

     

       26091
       26123
        
                aeson base bytestring containers text vector

     

       26092
       26124
        
              ];

     
···

       37328
       37360
        
            }:

     

       37329
       37361
        
            mkDerivation {

     

       37330
       37362
        
              pname = "autodocodec";

     

       37331
       37331
       -
              version = "0.1.0.3";

     

       37332
       37332
       -
              sha256 = "1vj4klvkzh0ahvpwjgcsvxmcgnbcy0z06fpjbgpl0g9g54pv8fhj";

     

       37363
       37363
       +
              version = "0.2.0.0";

     

       37364
       37364
       +
              sha256 = "0dxn8p0r3qbpym809rbl75bclrkrqbfs8d57gkz9r5r4g4bvwfmg";

     

       37333
       37365
        
              libraryHaskellDepends = [

     

       37334
       37366
        
                aeson base bytestring containers hashable mtl scientific text time

     

       37335
       37367
        
                unordered-containers validity validity-scientific vector

     
···

       37345
       37377
        
            }:

     

       37346
       37378
        
            mkDerivation {

     

       37347
       37379
        
              pname = "autodocodec-openapi3";

     

       37348
       37348
       -
              version = "0.2.1.0";

     

       37349
       37349
       -
              sha256 = "1nd1r7r258dxhrdjwc7m8byrv99b1zqapvj8021yq8j1nad8mjvg";

     

       37380
       37380
       +
              version = "0.2.1.1";

     

       37381
       37381
       +
              sha256 = "0klk2xxj4mwlfg4irxsc98av5grp5g1jv1qkivlzfhxrnviyfkqw";

     

       37350
       37382
        
              libraryHaskellDepends = [

     

       37351
       37383
        
                aeson autodocodec base insert-ordered-containers lens mtl openapi3

     

       37352
       37384
        
                scientific text unordered-containers

     
···

       37362
       37394
        
            }:

     

       37363
       37395
        
            mkDerivation {

     

       37364
       37396
        
              pname = "autodocodec-schema";

     

       37365
       37365
       -
              version = "0.1.0.1";

     

       37366
       37366
       -
              sha256 = "1nzwbj3r5gps2lnriig38h1y51m4pd997z65kpsmxzcbyakdxjnd";

     

       37397
       37397
       +
              version = "0.1.0.2";

     

       37398
       37398
       +
              sha256 = "0vvwjz8abn6qmk2801p7vyrbjkqcxdqjlc82ha8l9xvb6mmvqy3i";

     

       37367
       37399
        
              libraryHaskellDepends = [

     

       37368
       37400
        
                aeson autodocodec base containers mtl text unordered-containers

     

       37369
       37401
        
                validity validity-aeson validity-containers validity-text

     
···

       37375
       37407
        
         "autodocodec-swagger2" = callPackage

     

       37376
       37408
        
           ({ mkDerivation, aeson, autodocodec, base

     

       37377
       37409
        
            , insert-ordered-containers, scientific, swagger2, text

     

       37410
       37410
       +
            , unordered-containers

     

       37378
       37411
        
            }:

     

       37379
       37412
        
            mkDerivation {

     

       37380
       37413
        
              pname = "autodocodec-swagger2";

     

       37381
       37381
       -
              version = "0.0.1.0";

     

       37382
       37382
       -
              sha256 = "1h5866568wksnj8khpn50v8c2pysri668l0y4x1pawn92cq5brn4";

     

       37414
       37414
       +
              version = "0.0.1.1";

     

       37415
       37415
       +
              sha256 = "1a8nfacp23v943hz7n3vi4viglqj128z22yq64lb7mk46rd2zlm6";

     

       37383
       37416
        
              libraryHaskellDepends = [

     

       37384
       37417
        
                aeson autodocodec base insert-ordered-containers scientific

     

       37385
       37385
       -
                swagger2 text

     

       37418
       37418
       +
                swagger2 text unordered-containers

     

       37386
       37419
        
              ];

     

       37387
       37420
        
              description = "Autodocodec interpreters for swagger2";

     

       37388
       37421
        
              license = lib.licenses.mit;

     
···

       37395
       37428
        
            }:

     

       37396
       37429
        
            mkDerivation {

     

       37397
       37430
        
              pname = "autodocodec-yaml";

     

       37398
       37398
       -
              version = "0.2.0.0";

     

       37399
       37399
       -
              sha256 = "0wqc0gxyakz5vqa99kj684mnxfdgr3qz2prwabynr1lqs08krw1i";

     

       37431
       37431
       +
              version = "0.2.0.2";

     

       37432
       37432
       +
              sha256 = "164nrmpxrwyr49f0gczi2sixzrs3sv2pn8j293s9avw684aq2prx";

     

       37400
       37433
        
              libraryHaskellDepends = [

     

       37401
       37434
        
                autodocodec autodocodec-schema base bytestring containers path

     

       37402
       37435
        
                path-io safe-coloured-text scientific text unordered-containers

     
···

       37992
       38025
        
            }:

     

       37993
       38026
        
            mkDerivation {

     

       37994
       38027
        
              pname = "aws";

     

       37995
       37995
       -
              version = "0.22";

     

       37996
       37996
       -
              sha256 = "1l3f94mpih7slz37ikyjkyrwvlf110w87997d8sbnbd8glwlcb8r";

     

       37997
       37997
       -
              revision = "3";

     

       37998
       37998
       -
              editedCabalFile = "0k9xk07mviyvh5cxri7z923f5wfylmbrg63l1hqrnkd8hxk9w14y";

     

       38028
       38028
       +
              version = "0.22.1";

     

       38029
       38029
       +
              sha256 = "0zz8f144rsd7bpl4xfxw3wbp9s1a300c8i6vifh2yfhi798j76n4";

     

       37999
       38030
        
              isLibrary = true;

     

       38000
       38031
        
              isExecutable = true;

     

       38001
       38032
        
              libraryHaskellDepends = [

     
···

       42189
       42220
        
              pname = "bifunctors";

     

       42190
       42221
        
              version = "5.5.12";

     

       42191
       42222
        
              sha256 = "0pbidsv1w3bvzs8w6sv8g1iqf0l9r1y0b1fmvd67cwlp01r7f1n6";

     

       42223
       42223
       +
              revision = "1";

     

       42224
       42224
       +
              editedCabalFile = "1sf3nbcsbj5m5gw26kv036a1v4zmn91rw7x2iamxwx1ji668a3xy";

     

       42192
       42225
        
              libraryHaskellDepends = [

     

       42193
       42226
        
                base base-orphans comonad containers tagged template-haskell

     

       42194
       42227
        
                th-abstraction transformers

     
···

       42667
       42700
        
              pname = "binary-instances";

     

       42668
       42701
        
              version = "1.0.2";

     

       42669
       42702
        
              sha256 = "10z29k35clq74ma2f0yrkbyf14wdax1zzgb6mn26ja4vp9f5wc14";

     

       42670
       42670
       -
              revision = "3";

     

       42671
       42671
       -
              editedCabalFile = "1jfhn6nqqg8hz3d2j7zyhpqv74165jf69dycjr6vzbxmvvn03wil";

     

       42703
       42703
       +
              revision = "4";

     

       42704
       42704
       +
              editedCabalFile = "157519fj5900sylbx8m38w5gy9la1795529wpsfj21ak1qfv74gn";

     

       42672
       42705
        
              libraryHaskellDepends = [

     

       42673
       42706
        
                aeson base binary binary-orphans case-insensitive hashable

     

       42674
       42707
        
                scientific tagged text text-binary time-compat unordered-containers

     
···

       46151
       46184
        
            }) {};

     

       46152
       46185
        
       

     

       46153
       46186
        
         "blizzard-html" = callPackage

     

       46154
       46154
       -
           ({ mkDerivation, base, blaze-html, clay, text }:

     

       46187
       46187
       +
           ({ mkDerivation, base, blaze-html, text }:

     

       46155
       46188
        
            mkDerivation {

     

       46156
       46189
        
              pname = "blizzard-html";

     

       46157
       46157
       -
              version = "0.1.0.0";

     

       46158
       46158
       -
              sha256 = "0q77g1apkjy6vfks1734cx6y11v5l7qksfs1g2axp2lmsymkd28v";

     

       46159
       46159
       -
              libraryHaskellDepends = [ base blaze-html clay text ];

     

       46160
       46160
       -
              description = "An HTML and CSS renderer for Haskell";

     

       46190
       46190
       +
              version = "0.4.0.1";

     

       46191
       46191
       +
              sha256 = "11k9pdr5f8vxypk05c2aysqkl3199ywvkh2dk9jf5rgkpf2j221p";

     

       46192
       46192
       +
              libraryHaskellDepends = [ base blaze-html text ];

     

       46193
       46193
       +
              description = "An HTML renderer for Haskell";

     

       46161
       46194
        
              license = lib.licenses.mit;

     

       46162
       46195
        
              hydraPlatforms = lib.platforms.none;

     

       46163
       46196
        
              broken = true;

     
···

       48736
       48769
        
              broken = true;

     

       48737
       48770
        
            }) {};

     

       48738
       48771
        
       

     

       48772
       48772
       +
         "btc-lsp" = callPackage

     

       48773
       48773
       +
           ({ mkDerivation, aeson, async, base, base16-bytestring

     

       48774
       48774
       +
            , base64-bytestring, binary, bytestring, case-insensitive, casing

     

       48775
       48775
       +
            , chronos, classy-prelude-yesod, containers, cryptonite, envparse

     

       48776
       48776
       +
            , errors, esqueleto, extra, fast-logger, file-embed, format-numbers

     

       48777
       48777
       +
            , generic-pretty-instances, GenericPretty, hjsmin, hspec

     

       48778
       48778
       +
            , http-client-tls, http2, http2-client, http2-client-grpc

     

       48779
       48779
       +
            , http2-grpc-proto-lens, http2-grpc-types, iso8601-time, katip

     

       48780
       48780
       +
            , lnd-client, memory, microlens, monad-logger, network-bitcoin

     

       48781
       48781
       +
            , persistent, persistent-migration, persistent-postgresql, pretty

     

       48782
       48782
       +
            , proto-lens, proto-lens-runtime, qrcode-core, qrcode-juicypixels

     

       48783
       48783
       +
            , QuickCheck, resource-pool, scientific, secp256k1-haskell, SHA

     

       48784
       48784
       +
            , shakespeare, stm, template-haskell, text, time, transformers

     

       48785
       48785
       +
            , unbounded-delays, universum, unliftio, uuid, vector, wai

     

       48786
       48786
       +
            , wai-extra, warp, warp-grpc, warp-tls, witch, yaml, yesod

     

       48787
       48787
       +
            , yesod-auth, yesod-core, yesod-form, yesod-static

     

       48788
       48788
       +
            }:

     

       48789
       48789
       +
            mkDerivation {

     

       48790
       48790
       +
              pname = "btc-lsp";

     

       48791
       48791
       +
              version = "0.1.0.0";

     

       48792
       48792
       +
              sha256 = "08lwm518gysncw2wa9b1b3fsdfy5mk6g1fgzjskd73j03xa5zvq3";

     

       48793
       48793
       +
              isLibrary = true;

     

       48794
       48794
       +
              isExecutable = true;

     

       48795
       48795
       +
              libraryHaskellDepends = [

     

       48796
       48796
       +
                aeson async base base16-bytestring base64-bytestring binary

     

       48797
       48797
       +
                bytestring case-insensitive casing chronos classy-prelude-yesod

     

       48798
       48798
       +
                containers cryptonite envparse errors esqueleto extra fast-logger

     

       48799
       48799
       +
                file-embed format-numbers generic-pretty-instances GenericPretty

     

       48800
       48800
       +
                hjsmin http-client-tls http2 http2-client http2-client-grpc

     

       48801
       48801
       +
                http2-grpc-proto-lens http2-grpc-types iso8601-time katip

     

       48802
       48802
       +
                lnd-client memory microlens monad-logger network-bitcoin persistent

     

       48803
       48803
       +
                persistent-migration persistent-postgresql pretty proto-lens

     

       48804
       48804
       +
                proto-lens-runtime qrcode-core qrcode-juicypixels resource-pool

     

       48805
       48805
       +
                scientific secp256k1-haskell SHA shakespeare stm template-haskell

     

       48806
       48806
       +
                text time transformers unbounded-delays universum unliftio uuid

     

       48807
       48807
       +
                vector wai wai-extra warp warp-grpc warp-tls witch yaml yesod

     

       48808
       48808
       +
                yesod-auth yesod-core yesod-form yesod-static

     

       48809
       48809
       +
              ];

     

       48810
       48810
       +
              executableHaskellDepends = [

     

       48811
       48811
       +
                aeson base bytestring envparse hspec lnd-client network-bitcoin

     

       48812
       48812
       +
                proto-lens QuickCheck unliftio vector witch

     

       48813
       48813
       +
              ];

     

       48814
       48814
       +
              testHaskellDepends = [

     

       48815
       48815
       +
                aeson base bytestring envparse hspec lnd-client network-bitcoin

     

       48816
       48816
       +
                proto-lens QuickCheck unliftio vector witch

     

       48817
       48817
       +
              ];

     

       48818
       48818
       +
              description = "Lightning service provider";

     

       48819
       48819
       +
              license = lib.licenses.bsd3;

     

       48820
       48820
       +
              hydraPlatforms = lib.platforms.none;

     

       48821
       48821
       +
            }) {};

     

       48822
       48822
       +
       

     

       48739
       48823
        
         "btree" = callPackage

     

       48740
       48824
        
           ({ mkDerivation, base, clock, containers, ghc-prim, hashable

     

       48741
       48825
        
            , initialize, MonadRandom, primitive, smallcheck, tasty

     
···

       50037
       50121
        
              pname = "bytesmith";

     

       50038
       50122
        
              version = "0.3.9.0";

     

       50039
       50123
        
              sha256 = "0jmx4flf3j5a4gyrw79cxiybp6f7y0rm9ifmrxypxpwrwc220zjg";

     

       50124
       50124
       +
              revision = "1";

     

       50125
       50125
       +
              editedCabalFile = "0ly247yj2ay0fpj5v3dqp0hava1wrllqhphf7k3hcifpi5zfr8i0";

     

       50040
       50126
        
              libraryHaskellDepends = [

     

       50041
       50127
        
                base byteslice bytestring contiguous primitive run-st text-short

     

       50042
       50128
        
                wide-word

     
···

       51248
       51334
        
            }:

     

       51249
       51335
        
            mkDerivation {

     

       51250
       51336
        
              pname = "cabal-debian";

     

       51251
       51251
       -
              version = "5.1";

     

       51252
       51252
       -
              sha256 = "14kh2s61m7wm9h0ms4dlpfvqr2gd8fv0w44ar3c3dg5053hwrvny";

     

       51337
       51337
       +
              version = "5.2";

     

       51338
       51338
       +
              sha256 = "0vin5nj673l5gyg2q3jjz8vxh6ajja5mh6k81j1ppihwscwmmz4p";

     

       51253
       51339
        
              isLibrary = true;

     

       51254
       51340
        
              isExecutable = true;

     

       51255
       51341
        
              libraryHaskellDepends = [

     
···

       51553
       51639
        
              broken = true;

     

       51554
       51640
        
            }) {};

     

       51555
       51641
        
       

     

       51642
       51642
       +
         "cabal-hoogle" = callPackage

     

       51643
       51643
       +
           ({ mkDerivation, base, Cabal, containers, directory, extra

     

       51644
       51644
       +
            , filepath, hoogle, optparse-applicative, regex-tdfa, silently

     

       51645
       51645
       +
            , string-interpolate, tasty, tasty-discover, tasty-hunit, text

     

       51646
       51646
       +
            , transformers, typed-process

     

       51647
       51647
       +
            }:

     

       51648
       51648
       +
            mkDerivation {

     

       51649
       51649
       +
              pname = "cabal-hoogle";

     

       51650
       51650
       +
              version = "0.1.0.0";

     

       51651
       51651
       +
              sha256 = "0k37r2wismimnj10cclvs1aikzz1c90d40l19hkrk0a47k274yi1";

     

       51652
       51652
       +
              revision = "2";

     

       51653
       51653
       +
              editedCabalFile = "0a46rwql5r9iv42n32vzpmlci2zchkr93c23yg69k82q90j0zw2h";

     

       51654
       51654
       +
              isLibrary = true;

     

       51655
       51655
       +
              isExecutable = true;

     

       51656
       51656
       +
              libraryHaskellDepends = [

     

       51657
       51657
       +
                base Cabal containers directory extra filepath optparse-applicative

     

       51658
       51658
       +
                regex-tdfa string-interpolate text transformers typed-process

     

       51659
       51659
       +
              ];

     

       51660
       51660
       +
              executableHaskellDepends = [ base ];

     

       51661
       51661
       +
              testHaskellDepends = [ base silently tasty tasty-hunit ];

     

       51662
       51662
       +
              testToolDepends = [ hoogle tasty-discover ];

     

       51663
       51663
       +
              description = "generate hoogle database for cabal project and dependencies";

     

       51664
       51664
       +
              license = lib.licenses.bsd3;

     

       51665
       51665
       +
              hydraPlatforms = lib.platforms.none;

     

       51666
       51666
       +
              mainProgram = "cabal-hoogle";

     

       51667
       51667
       +
              broken = true;

     

       51668
       51668
       +
            }) {};

     

       51669
       51669
       +
       

     

       51556
       51670
        
         "cabal-info" = callPackage

     

       51557
       51671
        
           ({ mkDerivation, base, Cabal, directory, filepath

     

       51558
       51672
        
            , optparse-applicative

     
···

       53175
       53289
        
              broken = true;

     

       53176
       53290
        
            }) {};

     

       53177
       53291
        
       

     

       53292
       53292
       +
         "call-alloy_0_3_0_3" = callPackage

     

       53293
       53293
       +
           ({ mkDerivation, base, bytestring, containers, directory, extra

     

       53294
       53294
       +
            , file-embed, filepath, hashable, hspec, mtl, process, split

     

       53295
       53295
       +
            , trifecta, unix

     

       53296
       53296
       +
            }:

     

       53297
       53297
       +
            mkDerivation {

     

       53298
       53298
       +
              pname = "call-alloy";

     

       53299
       53299
       +
              version = "0.3.0.3";

     

       53300
       53300
       +
              sha256 = "1clzw0sk13gzwk2ikxlz7p0f70pb2246pnd01ggjm0nrfykri18p";

     

       53301
       53301
       +
              libraryHaskellDepends = [

     

       53302
       53302
       +
                base bytestring containers directory extra file-embed filepath

     

       53303
       53303
       +
                hashable mtl process split trifecta unix

     

       53304
       53304
       +
              ];

     

       53305
       53305
       +
              testHaskellDepends = [

     

       53306
       53306
       +
                base bytestring containers directory extra file-embed filepath

     

       53307
       53307
       +
                hashable hspec mtl process split trifecta unix

     

       53308
       53308
       +
              ];

     

       53309
       53309
       +
              description = "A simple library to call Alloy given a specification";

     

       53310
       53310
       +
              license = lib.licenses.mit;

     

       53311
       53311
       +
              hydraPlatforms = lib.platforms.none;

     

       53312
       53312
       +
              broken = true;

     

       53313
       53313
       +
            }) {};

     

       53314
       53314
       +
       

     

       53178
       53315
        
         "call-haskell-from-anything" = callPackage

     

       53179
       53316
        
           ({ mkDerivation, base, bytestring, data-msgpack, mtl

     

       53180
       53317
        
            , storable-endian, template-haskell

     
···

       57447
       57584
        
              pname = "chronos";

     

       57448
       57585
        
              version = "1.1.4";

     

       57449
       57586
        
              sha256 = "1v7h0qlckliid2zd3ff2l9l4xrdxacaw8my8bjj8grysj4vvyn5q";

     

       57450
       57450
       -
              revision = "1";

     

       57451
       57451
       -
              editedCabalFile = "1238mgjk7v0qf7n3c9qrzp7c6gmdcmx80x1ndgsy2nvzsdn5xklg";

     

       57587
       57587
       +
              revision = "2";

     

       57588
       57588
       +
              editedCabalFile = "0ixc0ng425lgsrj95zfnm2jazk19b8py845s3b02dfz7zid9q7n5";

     

       57452
       57589
        
              libraryHaskellDepends = [

     

       57453
       57590
        
                aeson attoparsec base bytebuild byteslice bytesmith bytestring

     

       57454
       57591
        
                deepseq hashable natural-arithmetic primitive semigroups text

     
···

       59513
       59650
        
         "cli-extras" = callPackage

     

       59514
       59651
        
           ({ mkDerivation, aeson, ansi-terminal, base, bytestring, containers

     

       59515
       59652
        
            , exceptions, io-streams, lens, logging-effect, monad-logger

     

       59516
       59516
       -
            , monad-loops, mtl, process, terminal-size, text, time

     

       59517
       59517
       -
            , transformers, which

     

       59653
       59653
       +
            , monad-loops, mtl, process, shell-escape, terminal-size, text

     

       59654
       59654
       +
            , time, transformers, utf8-string, which

     

       59518
       59655
        
            }:

     

       59519
       59656
        
            mkDerivation {

     

       59520
       59657
        
              pname = "cli-extras";

     

       59521
       59521
       -
              version = "0.1.0.2";

     

       59522
       59522
       -
              sha256 = "1qcvphbimcclvy7qkqrz9djg4650axwqjfyq6nlbvmpivh14m9vq";

     

       59523
       59523
       -
              revision = "1";

     

       59524
       59524
       -
              editedCabalFile = "1zf7win72j7gmr8srvmn8y23636z5ga817cg3lkfsm5mwhi9k0zw";

     

       59658
       59658
       +
              version = "0.2.0.0";

     

       59659
       59659
       +
              sha256 = "1xzpg8i06jix4dnbjanp85dgjhf4xf7am50k550d88nsnxi93byn";

     

       59525
       59660
        
              libraryHaskellDepends = [

     

       59526
       59661
        
                aeson ansi-terminal base bytestring containers exceptions

     

       59527
       59662
        
                io-streams lens logging-effect monad-logger monad-loops mtl process

     

       59528
       59528
       -
                terminal-size text time transformers which

     

       59663
       59663
       +
                shell-escape terminal-size text time transformers utf8-string which

     

       59529
       59664
        
              ];

     

       59530
       59665
        
              description = "Miscellaneous utilities for building and working with command line interfaces";

     

       59531
       59666
        
              license = lib.licenses.bsd3;

     
···

       66594
       66729
        
              license = lib.licenses.bsd3;

     

       66595
       66730
        
            }) {};

     

       66596
       66731
        
       

     

       66597
       66597
       -
         "containers_0_6_5_1" = callPackage

     

       66598
       66598
       -
           ({ mkDerivation, array, base, deepseq }:

     

       66732
       66732
       +
         "containers_0_6_6" = callPackage

     

       66733
       66733
       +
           ({ mkDerivation, array, base, deepseq, template-haskell }:

     

       66599
       66734
        
            mkDerivation {

     

       66600
       66735
        
              pname = "containers";

     

       66601
       66601
       -
              version = "0.6.5.1";

     

       66602
       66602
       -
              sha256 = "1zlyvkamzc87hr7r3ckyvgwhszdk9i18jrsv2cmkh9v093gvl7ni";

     

       66603
       66603
       -
              libraryHaskellDepends = [ array base deepseq ];

     

       66736
       66736
       +
              version = "0.6.6";

     

       66737
       66737
       +
              sha256 = "1s1a1d8hvlgarmajf3p8ars1cqxyaw1ncmw0793g7m82y78hw6dq";

     

       66738
       66738
       +
              libraryHaskellDepends = [ array base deepseq template-haskell ];

     

       66604
       66739
        
              description = "Assorted concrete container types";

     

       66605
       66740
        
              license = lib.licenses.bsd3;

     

       66606
       66741
        
              hydraPlatforms = lib.platforms.none;

     
···

       67872
       68007
        
              license = lib.licenses.mit;

     

       67873
       68008
        
            }) {};

     

       67874
       68009
        
       

     

       67875
       67875
       -
         "core-program_0_5_1_0" = callPackage

     

       68010
       68010
       +
         "core-program_0_5_1_1" = callPackage

     

       67876
       68011
        
           ({ mkDerivation, async, base, bytestring, core-data, core-text

     

       67877
       68012
        
            , directory, exceptions, filepath, fsnotify, hashable, hourglass

     

       67878
       68013
        
            , mtl, prettyprinter, safe-exceptions, stm, template-haskell

     
···

       67881
       68016
        
            }:

     

       67882
       68017
        
            mkDerivation {

     

       67883
       68018
        
              pname = "core-program";

     

       67884
       67884
       -
              version = "0.5.1.0";

     

       67885
       67885
       -
              sha256 = "0h9iw9kdj947zlzjd9gi4xlnldrqpgw80vla31c0zhl4dmib6a22";

     

       67886
       67886
       -
              revision = "1";

     

       67887
       67887
       -
              editedCabalFile = "1920jl5yxwgj64wacgx929b054icq7bz73p06rqfm38wkj87bqa3";

     

       68019
       68019
       +
              version = "0.5.1.1";

     

       68020
       68020
       +
              sha256 = "08hnal9lv92aigivfcz25rap64bl8zbpin1ln61irp0zw13sq6s8";

     

       67888
       68021
        
              libraryHaskellDepends = [

     

       67889
       68022
        
                async base bytestring core-data core-text directory exceptions

     

       67890
       68023
        
                filepath fsnotify hashable hourglass mtl prettyprinter

     
···

       70954
       71087
        
              license = lib.licenses.bsd3;

     

       70955
       71088
        
              hydraPlatforms = lib.platforms.none;

     

       70956
       71089
        
              broken = true;

     

       71090
       71090
       +
            }) {};

     

       71091
       71091
       +
       

     

       71092
       71092
       +
         "css-simple" = callPackage

     

       71093
       71093
       +
           ({ mkDerivation, base, criterion, mtl, text, text-builder }:

     

       71094
       71094
       +
            mkDerivation {

     

       71095
       71095
       +
              pname = "css-simple";

     

       71096
       71096
       +
              version = "0.1.0.1";

     

       71097
       71097
       +
              sha256 = "0s51i9g6kz9lrn5a2ngdv0sh2rc61ynipp5ksbbsxrqpzslbm7jv";

     

       71098
       71098
       +
              libraryHaskellDepends = [ base mtl text text-builder ];

     

       71099
       71099
       +
              testHaskellDepends = [ base mtl text text-builder ];

     

       71100
       71100
       +
              benchmarkHaskellDepends = [ base criterion mtl text text-builder ];

     

       71101
       71101
       +
              description = "eDSL for CSS";

     

       71102
       71102
       +
              license = lib.licenses.gpl3Only;

     

       70957
       71103
        
            }) {};

     

       70958
       71104
        
       

     

       70959
       71105
        
         "css-syntax" = callPackage

     
···

       75913
       76059
        
            }:

     

       75914
       76060
        
            mkDerivation {

     

       75915
       76061
        
              pname = "dear-imgui";

     

       75916
       75916
       -
              version = "2.0.0";

     

       75917
       75917
       -
              sha256 = "0x1lx34zdgaga6xgq1axdf39wxz6av7h8vna1d702v09n67hpac3";

     

       76062
       76062
       +
              version = "2.1.0";

     

       76063
       76063
       +
              sha256 = "1nj0796zy10q29w5f0f3fjyf6hvhdv12yv96lg0rdlyl1mfpgm4d";

     

       75918
       76064
        
              isLibrary = true;

     

       75919
       76065
        
              isExecutable = true;

     

       75920
       76066
        
              libraryHaskellDepends = [

     
···

       75958
       76104
        
              license = lib.licenses.bsd3;

     

       75959
       76105
        
            }) {};

     

       75960
       76106
        
       

     

       76107
       76107
       +
         "debian_4_0_4" = callPackage

     

       76108
       76108
       +
           ({ mkDerivation, base, bytestring, bz2, Cabal, containers

     

       76109
       76109
       +
            , directory, either, exceptions, filepath, hostname, HUnit, lens

     

       76110
       76110
       +
            , ListLike, mtl, network-uri, old-locale, parsec, pretty, process

     

       76111
       76111
       +
            , process-extras, pureMD5, QuickCheck, regex-compat, regex-tdfa

     

       76112
       76112
       +
            , SHA, syb, template-haskell, temporary, text, th-lift, th-orphans

     

       76113
       76113
       +
            , time, unix, utf8-string, zlib

     

       76114
       76114
       +
            }:

     

       76115
       76115
       +
            mkDerivation {

     

       76116
       76116
       +
              pname = "debian";

     

       76117
       76117
       +
              version = "4.0.4";

     

       76118
       76118
       +
              sha256 = "11510xb7a9nlvaygrmwbx9imagj8517iz2am6jv88934m0l5iy1n";

     

       76119
       76119
       +
              isLibrary = true;

     

       76120
       76120
       +
              isExecutable = true;

     

       76121
       76121
       +
              libraryHaskellDepends = [

     

       76122
       76122
       +
                base bytestring bz2 Cabal containers directory either exceptions

     

       76123
       76123
       +
                filepath hostname HUnit lens ListLike mtl network-uri old-locale

     

       76124
       76124
       +
                parsec pretty process process-extras pureMD5 QuickCheck

     

       76125
       76125
       +
                regex-compat regex-tdfa SHA syb template-haskell temporary text

     

       76126
       76126
       +
                th-lift th-orphans time unix utf8-string zlib

     

       76127
       76127
       +
              ];

     

       76128
       76128
       +
              executableHaskellDepends = [ base directory filepath process ];

     

       76129
       76129
       +
              testHaskellDepends = [

     

       76130
       76130
       +
                base Cabal HUnit parsec pretty regex-tdfa text

     

       76131
       76131
       +
              ];

     

       76132
       76132
       +
              description = "Modules for working with the Debian package system";

     

       76133
       76133
       +
              license = lib.licenses.bsd3;

     

       76134
       76134
       +
              hydraPlatforms = lib.platforms.none;

     

       76135
       76135
       +
            }) {};

     

       76136
       76136
       +
       

     

       75961
       76137
        
         "debian-binary" = callPackage

     

       75962
       76138
        
           ({ mkDerivation, base, directory, filepath, HSH }:

     

       75963
       76139
        
            mkDerivation {

     
···

       77664
       77840
        
              pname = "deriving-compat";

     

       77665
       77841
        
              version = "0.6.1";

     

       77666
       77842
        
              sha256 = "09lxms6220saycra4kpxihwa7zh253zmv1zpa41dbnhgffxs3zbb";

     

       77843
       77843
       +
              revision = "1";

     

       77844
       77844
       +
              editedCabalFile = "0m3ywfvj96yqrdyv6mgnmdhlsvjjn89wl0n1n7v2m60zaan14cgh";

     

       77667
       77845
        
              libraryHaskellDepends = [

     

       77668
       77846
        
                base containers ghc-boot-th ghc-prim template-haskell

     

       77669
       77847
        
                th-abstraction transformers transformers-compat

     
···

       77695
       77873
        
            }:

     

       77696
       77874
        
            mkDerivation {

     

       77697
       77875
        
              pname = "deriving-trans";

     

       77698
       77698
       -
              version = "0.4.0.0";

     

       77699
       77699
       -
              sha256 = "1d7p7np8jadiynih2a271q67hxbd352lvf4pzspd4nvr6npa1ipc";

     

       77876
       77876
       +
              version = "0.5.0.0";

     

       77877
       77877
       +
              sha256 = "0gbrlq02pyrjlsnpb96y5rv9zvip33zfqv865hmjzyj3ig938i1r";

     

       77700
       77878
        
              libraryHaskellDepends = [

     

       77701
       77879
        
                base monad-control monad-control-identity mtl transformers

     

       77702
       77880
        
                transformers-base

     
···

       80901
       81079
        
              broken = true;

     

       80902
       81080
        
            }) {};

     

       80903
       81081
        
       

     

       80904
       80904
       -
         "directory_1_3_7_0" = callPackage

     

       81082
       81082
       +
         "directory_1_3_7_1" = callPackage

     

       80905
       81083
        
           ({ mkDerivation, base, filepath, time, unix }:

     

       80906
       81084
        
            mkDerivation {

     

       80907
       81085
        
              pname = "directory";

     

       80908
       80908
       -
              version = "1.3.7.0";

     

       80909
       80909
       -
              sha256 = "041dnqqnc1dadasqyhivpa7rnhw3i08gq5bwj1kfz7lhlihbv1lz";

     

       80910
       80910
       -
              revision = "2";

     

       80911
       80911
       -
              editedCabalFile = "13krvs6zfswr3xndysq1bg7mz9n8mm1w7p4zcx8xjs0jqkm8hiyl";

     

       81086
       81086
       +
              version = "1.3.7.1";

     

       81087
       81087
       +
              sha256 = "1z8frwbr0kdk47x3xasq7ifzcrwl7ryh1aqgf202xv4cakb8a9yw";

     

       80912
       81088
        
              libraryHaskellDepends = [ base filepath time unix ];

     

       80913
       81089
        
              testHaskellDepends = [ base filepath time unix ];

     

       80914
       81090
        
              description = "Platform-agnostic library for filesystem operations";

     
···

       85355
       85531
        
              pname = "dual-game";

     

       85356
       85532
        
              version = "0.1.0.1";

     

       85357
       85533
        
              sha256 = "1w69d7d2xbpi82n41gq08qdmldh834ka7qwvy159vsac556wwcfg";

     

       85358
       85358
       -
              revision = "7";

     

       85359
       85359
       -
              editedCabalFile = "04hi455i82y7nf30chnkbvgfz5fzn050nb3r916abr7s205jfzkq";

     

       85534
       85534
       +
              revision = "8";

     

       85535
       85535
       +
              editedCabalFile = "1c4m2nwmnrjs8rinfa9p9vynmdr56i5ggydgnjs3d8szpbbbbrml";

     

       85360
       85536
        
              isLibrary = false;

     

       85361
       85537
        
              isExecutable = true;

     

       85362
       85538
        
              executableHaskellDepends = [

     
···

       86842
       87018
        
              license = lib.licenses.bsd3;

     

       86843
       87019
        
            }) {};

     

       86844
       87020
        
       

     

       87021
       87021
       +
         "ecta" = callPackage

     

       87022
       87022
       +
           ({ mkDerivation, array, base, cmdargs, containers, criterion

     

       87023
       87023
       +
            , equivalence, extra, fgl, hashable, hashtables, hspec

     

       87024
       87024
       +
            , hspec-discover, ilist, intern, language-dot, lens, mtl, pipes

     

       87025
       87025
       +
            , pretty-simple, QuickCheck, raw-strings-qq, text, time

     

       87026
       87026
       +
            , unordered-containers, vector, vector-instances

     

       87027
       87027
       +
            }:

     

       87028
       87028
       +
            mkDerivation {

     

       87029
       87029
       +
              pname = "ecta";

     

       87030
       87030
       +
              version = "1.0.0.2";

     

       87031
       87031
       +
              sha256 = "10d0dvwd5lrla509ncx7f9i72ak4b7g4z3459nlxba904qhr0gnm";

     

       87032
       87032
       +
              isLibrary = true;

     

       87033
       87033
       +
              isExecutable = true;

     

       87034
       87034
       +
              libraryHaskellDepends = [

     

       87035
       87035
       +
                array base cmdargs containers equivalence extra fgl hashable

     

       87036
       87036
       +
                hashtables ilist intern language-dot lens mtl pipes pretty-simple

     

       87037
       87037
       +
                raw-strings-qq text time unordered-containers vector

     

       87038
       87038
       +
                vector-instances

     

       87039
       87039
       +
              ];

     

       87040
       87040
       +
              executableHaskellDepends = [

     

       87041
       87041
       +
                base cmdargs containers hashable language-dot mtl pipes

     

       87042
       87042
       +
                pretty-simple text time unordered-containers vector

     

       87043
       87043
       +
              ];

     

       87044
       87044
       +
              testHaskellDepends = [

     

       87045
       87045
       +
                base cmdargs containers equivalence hashable hspec language-dot mtl

     

       87046
       87046
       +
                pipes pretty-simple QuickCheck text time unordered-containers

     

       87047
       87047
       +
                vector

     

       87048
       87048
       +
              ];

     

       87049
       87049
       +
              testToolDepends = [ hspec-discover ];

     

       87050
       87050
       +
              benchmarkHaskellDepends = [

     

       87051
       87051
       +
                base cmdargs containers criterion hashable language-dot mtl pipes

     

       87052
       87052
       +
                pretty-simple text time unordered-containers vector

     

       87053
       87053
       +
              ];

     

       87054
       87054
       +
              license = lib.licenses.bsd3;

     

       87055
       87055
       +
              hydraPlatforms = lib.platforms.none;

     

       87056
       87056
       +
              mainProgram = "hectare";

     

       87057
       87057
       +
              broken = true;

     

       87058
       87058
       +
            }) {};

     

       87059
       87059
       +
       

     

       86845
       87060
        
         "ecu" = callPackage

     

       86846
       87061
        
           ({ mkDerivation, base, bytestring, canlib, digest, directory

     

       86847
       87062
        
            , process, vcd

     
···

       88144
       88359
        
              libraryHaskellDepends = [ base hmatrix safe ];

     

       88145
       88360
        
              description = "Find the elbow point";

     

       88146
       88361
        
              license = lib.licenses.gpl3Only;

     

       88362
       88362
       +
            }) {};

     

       88363
       88363
       +
       

     

       88364
       88364
       +
         "electrs-client" = callPackage

     

       88365
       88365
       +
           ({ mkDerivation, aeson, base, bytestring, envparse

     

       88366
       88366
       +
            , generic-pretty-instances, GenericPretty, hex-text, hspec, network

     

       88367
       88367
       +
            , network-bitcoin, SHA, text, transformers, unbounded-delays

     

       88368
       88368
       +
            , universum, unliftio

     

       88369
       88369
       +
            }:

     

       88370
       88370
       +
            mkDerivation {

     

       88371
       88371
       +
              pname = "electrs-client";

     

       88372
       88372
       +
              version = "0.1.0.0";

     

       88373
       88373
       +
              sha256 = "1ywmxc4x5p108hv7l5ymr60alk01mmgnz6dn8h4xcnfnrck6p9b1";

     

       88374
       88374
       +
              libraryHaskellDepends = [

     

       88375
       88375
       +
                aeson base bytestring envparse generic-pretty-instances

     

       88376
       88376
       +
                GenericPretty hex-text network network-bitcoin SHA text

     

       88377
       88377
       +
                transformers unbounded-delays universum unliftio

     

       88378
       88378
       +
              ];

     

       88379
       88379
       +
              testHaskellDepends = [ base hspec network-bitcoin ];

     

       88380
       88380
       +
              description = "Electrs client library for Haskell";

     

       88381
       88381
       +
              license = lib.licenses.bsd3;

     

       88382
       88382
       +
              hydraPlatforms = lib.platforms.none;

     

       88147
       88383
        
            }) {};

     

       88148
       88384
        
       

     

       88149
       88385
        
         "electrum-mnemonic" = callPackage

     
···

       89290
       89526
        
              hydraPlatforms = lib.platforms.none;

     

       89291
       89527
        
            }) {};

     

       89292
       89528
        
       

     

       89529
       89529
       +
         "embed-config" = callPackage

     

       89530
       89530
       +
           ({ mkDerivation, aeson, base, bytestring, file-embed, hspec

     

       89531
       89531
       +
            , template-haskell, yaml

     

       89532
       89532
       +
            }:

     

       89533
       89533
       +
            mkDerivation {

     

       89534
       89534
       +
              pname = "embed-config";

     

       89535
       89535
       +
              version = "0.0.0.0";

     

       89536
       89536
       +
              sha256 = "1nbr9946agi4nyignn4x5x19660v66f3lr3m0l8xk2jxikrqlw49";

     

       89537
       89537
       +
              libraryHaskellDepends = [

     

       89538
       89538
       +
                aeson base bytestring file-embed template-haskell yaml

     

       89539
       89539
       +
              ];

     

       89540
       89540
       +
              testHaskellDepends = [ aeson base hspec ];

     

       89541
       89541
       +
              description = "Reasonable conventions for embedding YAML configuration with Template Haskell";

     

       89542
       89542
       +
              license = lib.licenses.bsd3;

     

       89543
       89543
       +
              hydraPlatforms = lib.platforms.none;

     

       89544
       89544
       +
              broken = true;

     

       89545
       89545
       +
            }) {};

     

       89546
       89546
       +
       

     

       89293
       89547
        
         "embeddock" = callPackage

     

       89294
       89548
        
           ({ mkDerivation, base, filepath, her-lexer, MissingH, process }:

     

       89295
       89549
        
            mkDerivation {

     
···

       90540
       90794
        
              license = lib.licenses.bsd3;

     

       90541
       90795
        
            }) {};

     

       90542
       90796
        
       

     

       90797
       90797
       +
         "equivalence_0_4_1" = callPackage

     

       90798
       90798
       +
           ({ mkDerivation, base, containers, mtl, QuickCheck, STMonadTrans

     

       90799
       90799
       +
            , template-haskell, transformers, transformers-compat

     

       90800
       90800
       +
            }:

     

       90801
       90801
       +
            mkDerivation {

     

       90802
       90802
       +
              pname = "equivalence";

     

       90803
       90803
       +
              version = "0.4.1";

     

       90804
       90804
       +
              sha256 = "13q0lklm58n0l7bx0d4k1cw1i2il8hpdjp76lb79ix8lv7cxd2jr";

     

       90805
       90805
       +
              libraryHaskellDepends = [

     

       90806
       90806
       +
                base containers mtl STMonadTrans transformers transformers-compat

     

       90807
       90807
       +
              ];

     

       90808
       90808
       +
              testHaskellDepends = [

     

       90809
       90809
       +
                base containers mtl QuickCheck STMonadTrans template-haskell

     

       90810
       90810
       +
                transformers transformers-compat

     

       90811
       90811
       +
              ];

     

       90812
       90812
       +
              description = "Maintaining an equivalence relation implemented as union-find using STT";

     

       90813
       90813
       +
              license = lib.licenses.bsd3;

     

       90814
       90814
       +
              hydraPlatforms = lib.platforms.none;

     

       90815
       90815
       +
            }) {};

     

       90816
       90816
       +
       

     

       90543
       90817
        
         "erd" = callPackage

     

       90544
       90818
        
           ({ mkDerivation, base, bytestring, containers, directory, filepath

     

       90545
       90819
        
            , gitrev, graphviz, parsec, raw-strings-qq, tasty, tasty-hunit

     
···

       97226
       97500
        
              license = lib.licenses.bsd3;

     

       97227
       97501
        
            }) {};

     

       97228
       97502
        
       

     

       97229
       97229
       -
         "filepath-bytestring_1_4_2_1_10" = callPackage

     

       97503
       97503
       +
         "filepath-bytestring_1_4_2_1_11" = callPackage

     

       97230
       97504
        
           ({ mkDerivation, base, bytestring, criterion, filepath, QuickCheck

     

       97231
       97505
        
            , unix

     

       97232
       97506
        
            }:

     

       97233
       97507
        
            mkDerivation {

     

       97234
       97508
        
              pname = "filepath-bytestring";

     

       97235
       97235
       -
              version = "1.4.2.1.10";

     

       97236
       97236
       -
              sha256 = "0nwfyld4ajikiinppkc0a92bbjnr1bcnpb6llg6k7av61xrv72ar";

     

       97509
       97509
       +
              version = "1.4.2.1.11";

     

       97510
       97510
       +
              sha256 = "1y906vb9p51awzgd5s1bq718kw03gpw7z8i8bdznlw7i9r40shbk";

     

       97237
       97511
        
              libraryHaskellDepends = [ base bytestring unix ];

     

       97238
       97512
        
              testHaskellDepends = [ base bytestring filepath QuickCheck ];

     

       97239
       97513
        
              benchmarkHaskellDepends = [ base criterion filepath ];

     
···

       98618
       98892
        
       

     

       98619
       98893
        
         "flac" = callPackage

     

       98620
       98894
        
           ({ mkDerivation, base, bytestring, containers, directory

     

       98621
       98621
       -
            , exceptions, filepath, FLAC, hspec, hspec-discover, mtl, temporary

     

       98895
       98895
       +
            , exceptions, filepath, flac, hspec, hspec-discover, mtl, temporary

     

       98622
       98896
        
            , text, transformers, vector, wave

     

       98623
       98897
        
            }:

     

       98624
       98898
        
            mkDerivation {

     
···

       98632
       98906
        
                base bytestring containers directory exceptions filepath mtl text

     

       98633
       98907
        
                transformers vector wave

     

       98634
       98908
        
              ];

     

       98635
       98635
       -
              librarySystemDepends = [ FLAC ];

     

       98909
       98909
       +
              librarySystemDepends = [ flac ];

     

       98636
       98910
        
              testHaskellDepends = [

     

       98637
       98911
        
                base bytestring directory filepath hspec temporary transformers

     

       98638
       98912
        
                vector wave

     
···

       98640
       98914
        
              testToolDepends = [ hspec-discover ];

     

       98641
       98915
        
              description = "Complete high-level binding to libFLAC";

     

       98642
       98916
        
              license = lib.licenses.bsd3;

     

       98643
       98643
       -
              hydraPlatforms = lib.platforms.none;

     

       98644
       98644
       -
              broken = true;

     

       98645
       98645
       -
            }) {FLAC = null;};

     

       98917
       98917
       +
            }) {inherit (pkgs) flac;};

     

       98646
       98918
        
       

     

       98647
       98919
        
         "flac-picture" = callPackage

     

       98648
       98920
        
           ({ mkDerivation, base, bytestring, directory, flac, hspec

     
···

       98662
       98934
        
              testToolDepends = [ hspec-discover ];

     

       98663
       98935
        
              description = "Support for writing picture to FLAC metadata blocks with JuicyPixels";

     

       98664
       98936
        
              license = lib.licenses.bsd3;

     

       98665
       98665
       -
              hydraPlatforms = lib.platforms.none;

     

       98666
       98937
        
            }) {};

     

       98667
       98938
        
       

     

       98668
       98939
        
         "flaccuraterip" = callPackage

     
···

       101644
       101915
        
              pname = "free";

     

       101645
       101916
        
              version = "5.1.9";

     

       101646
       101917
        
              sha256 = "1vlzis9sqxh7xrmh3habbgiw3skkhkn710bhqb6fnl45804i6x9f";

     

       101918
       101918
       +
              revision = "1";

     

       101919
       101919
       +
              editedCabalFile = "133nycxnzy7sgp2vib8hpp2jgzm8pxp31ljf7b4v91jn1gqg3kpl";

     

       101647
       101920
        
              libraryHaskellDepends = [

     

       101648
       101921
        
                base comonad containers distributive exceptions indexed-traversable

     

       101649
       101922
        
                mtl profunctors semigroupoids template-haskell th-abstraction

     
···

       105712
       105985
        
              license = lib.licenses.bsd3;

     

       105713
       105986
        
            }) {};

     

       105714
       105987
        
       

     

       105988
       105988
       +
         "generic-deriving_1_14_2" = callPackage

     

       105989
       105989
       +
           ({ mkDerivation, base, containers, ghc-prim, hspec, hspec-discover

     

       105990
       105990
       +
            , template-haskell, th-abstraction

     

       105991
       105991
       +
            }:

     

       105992
       105992
       +
            mkDerivation {

     

       105993
       105993
       +
              pname = "generic-deriving";

     

       105994
       105994
       +
              version = "1.14.2";

     

       105995
       105995
       +
              sha256 = "0bxacg6b1vz135x93vf7jk6129m08hdyj7426ymaylfl2w8kapi6";

     

       105996
       105996
       +
              libraryHaskellDepends = [

     

       105997
       105997
       +
                base containers ghc-prim template-haskell th-abstraction

     

       105998
       105998
       +
              ];

     

       105999
       105999
       +
              testHaskellDepends = [ base hspec template-haskell ];

     

       106000
       106000
       +
              testToolDepends = [ hspec-discover ];

     

       106001
       106001
       +
              description = "Generic programming library for generalised deriving";

     

       106002
       106002
       +
              license = lib.licenses.bsd3;

     

       106003
       106003
       +
              hydraPlatforms = lib.platforms.none;

     

       106004
       106004
       +
            }) {};

     

       106005
       106005
       +
       

     

       105715
       106006
        
         "generic-enum" = callPackage

     

       105716
       106007
        
           ({ mkDerivation, array, base, bytestring, hspec }:

     

       105717
       106008
        
            mkDerivation {

     
···

       105981
       106272
        
              license = lib.licenses.mit;

     

       105982
       106273
        
              hydraPlatforms = lib.platforms.none;

     

       105983
       106274
        
              broken = true;

     

       106275
       106275
       +
            }) {};

     

       106276
       106276
       +
       

     

       106277
       106277
       +
         "generic-pretty-instances" = callPackage

     

       106278
       106278
       +
           ({ mkDerivation, base, base16-bytestring, bytestring

     

       106279
       106279
       +
            , case-insensitive, GenericPretty, hspec, persistent, pretty

     

       106280
       106280
       +
            , pretty-simple, proto-lens, proto-lens-runtime, secp256k1-haskell

     

       106281
       106281
       +
            , text, time, universum, vector

     

       106282
       106282
       +
            }:

     

       106283
       106283
       +
            mkDerivation {

     

       106284
       106284
       +
              pname = "generic-pretty-instances";

     

       106285
       106285
       +
              version = "0.1.0.0";

     

       106286
       106286
       +
              sha256 = "01apps8kn71xbyclasra4zmk321fphj0bs2hw9j6yb5hxlldj34s";

     

       106287
       106287
       +
              libraryHaskellDepends = [

     

       106288
       106288
       +
                base base16-bytestring bytestring case-insensitive GenericPretty

     

       106289
       106289
       +
                persistent pretty pretty-simple proto-lens proto-lens-runtime

     

       106290
       106290
       +
                secp256k1-haskell text time universum vector

     

       106291
       106291
       +
              ];

     

       106292
       106292
       +
              testHaskellDepends = [

     

       106293
       106293
       +
                base base16-bytestring bytestring case-insensitive GenericPretty

     

       106294
       106294
       +
                hspec persistent pretty pretty-simple proto-lens proto-lens-runtime

     

       106295
       106295
       +
                secp256k1-haskell text time universum vector

     

       106296
       106296
       +
              ];

     

       106297
       106297
       +
              description = "GenericPretty canonical instances";

     

       106298
       106298
       +
              license = lib.licenses.bsd3;

     

       105984
       106299
        
            }) {};

     

       105985
       106300
        
       

     

       105986
       106301
        
         "generic-random" = callPackage

     
···

       106767
       107082
        
              license = lib.licenses.mit;

     

       106768
       107083
        
            }) {};

     

       106769
       107084
        
       

     

       107085
       107085
       +
         "genvalidity-network-uri" = callPackage

     

       107086
       107086
       +
           ({ mkDerivation, base, criterion, genvalidity

     

       107087
       107087
       +
            , genvalidity-criterion, genvalidity-sydtest, iproute, network-uri

     

       107088
       107088
       +
            , QuickCheck, sydtest, sydtest-discover, validity

     

       107089
       107089
       +
            , validity-network-uri

     

       107090
       107090
       +
            }:

     

       107091
       107091
       +
            mkDerivation {

     

       107092
       107092
       +
              pname = "genvalidity-network-uri";

     

       107093
       107093
       +
              version = "0.0.0.0";

     

       107094
       107094
       +
              sha256 = "0nq5qlk8c6kv6y67p01db0i0n5gsfphl1rl75dy8iwmnc0ii2mks";

     

       107095
       107095
       +
              libraryHaskellDepends = [

     

       107096
       107096
       +
                base genvalidity iproute network-uri QuickCheck validity

     

       107097
       107097
       +
                validity-network-uri

     

       107098
       107098
       +
              ];

     

       107099
       107099
       +
              testHaskellDepends = [

     

       107100
       107100
       +
                base genvalidity genvalidity-sydtest network-uri QuickCheck sydtest

     

       107101
       107101
       +
                validity-network-uri

     

       107102
       107102
       +
              ];

     

       107103
       107103
       +
              testToolDepends = [ sydtest-discover ];

     

       107104
       107104
       +
              benchmarkHaskellDepends = [

     

       107105
       107105
       +
                base criterion genvalidity genvalidity-criterion network-uri

     

       107106
       107106
       +
                QuickCheck

     

       107107
       107107
       +
              ];

     

       107108
       107108
       +
              description = "GenValidity support for URI";

     

       107109
       107109
       +
              license = lib.licenses.mit;

     

       107110
       107110
       +
              hydraPlatforms = lib.platforms.none;

     

       107111
       107111
       +
            }) {};

     

       107112
       107112
       +
       

     

       106770
       107113
        
         "genvalidity-path" = callPackage

     

       106771
       107114
        
           ({ mkDerivation, base, criterion, genvalidity

     

       106772
       107115
        
            , genvalidity-criterion, genvalidity-hspec, hspec, path, QuickCheck

     
···

       111494
       111837
        
            }:

     

       111495
       111838
        
            mkDerivation {

     

       111496
       111839
        
              pname = "git-annex";

     

       111497
       111497
       -
              version = "10.20220624";

     

       111498
       111498
       -
              sha256 = "0a17ph8w620fmbwhm4yhdz2pwp0z8g5d4qsw2bg8k1par2n8rnmz";

     

       111840
       111840
       +
              version = "10.20220724";

     

       111841
       111841
       +
              sha256 = "0890xsfhk5k7xddqgq4qppbr169vjja76cd5cz1cslj20lmz5f28";

     

       111499
       111842
        
              configureFlags = [

     

       111500
       111843
        
                "-fassistant" "-f-benchmark" "-fdbus" "-f-debuglocks" "-fmagicmime"

     

       111501
       111844
        
                "-fnetworkbsd" "-fpairing" "-fproduction" "-fs3" "-ftorrentparser"

     
···

       112059
       112402
        
              license = lib.licenses.bsd3;

     

       112060
       112403
        
            }) {};

     

       112061
       112404
        
       

     

       112062
       112062
       -
         "github_0_28" = callPackage

     

       112405
       112405
       +
         "github_0_28_0_1" = callPackage

     

       112063
       112406
        
           ({ mkDerivation, aeson, base, base-compat, base16-bytestring

     

       112064
       112407
        
            , binary, binary-instances, bytestring, containers, cryptohash-sha1

     

       112065
       112408
        
            , deepseq, deepseq-generics, exceptions, file-embed, hashable

     

       112066
       112409
        
            , hspec, hspec-discover, http-client, http-client-tls

     

       112067
       112410
        
            , http-link-header, http-types, iso8601-time, mtl, network-uri

     

       112068
       112411
        
            , tagged, text, time-compat, tls, transformers, transformers-compat

     

       112069
       112069
       -
            , unordered-containers, vector, vector-instances

     

       112412
       112412
       +
            , unordered-containers, vector

     

       112070
       112413
        
            }:

     

       112071
       112414
        
            mkDerivation {

     

       112072
       112415
        
              pname = "github";

     

       112073
       112073
       -
              version = "0.28";

     

       112074
       112074
       -
              sha256 = "142l0zff852606hkpvkhvagp6h3ziq2z2x7x2pa77q5ymyq48089";

     

       112075
       112075
       -
              revision = "4";

     

       112076
       112076
       -
              editedCabalFile = "063plc1v50fww3kar571czk2brqdb82zm33jsfnbcfal5i2w1v73";

     

       112416
       112416
       +
              version = "0.28.0.1";

     

       112417
       112417
       +
              sha256 = "16ahq2ng52ypkkgqbbmizr486px3dh709hw3jdn7jzglgvn20712";

     

       112077
       112418
        
              libraryHaskellDepends = [

     

       112078
       112419
        
                aeson base base-compat base16-bytestring binary binary-instances

     

       112079
       112420
        
                bytestring containers cryptohash-sha1 deepseq deepseq-generics

     

       112080
       112421
        
                exceptions hashable http-client http-client-tls http-link-header

     

       112081
       112422
        
                http-types iso8601-time mtl network-uri tagged text time-compat tls

     

       112082
       112423
        
                transformers transformers-compat unordered-containers vector

     

       112083
       112083
       -
                vector-instances

     

       112084
       112424
        
              ];

     

       112085
       112425
        
              testHaskellDepends = [

     

       112086
       112426
        
                aeson base base-compat bytestring file-embed hspec tagged text

     
···

       121780
       122120
        
            }:

     

       121781
       122121
        
            mkDerivation {

     

       121782
       122122
        
              pname = "hackport";

     

       121783
       121783
       -
              version = "0.7.1.2";

     

       121784
       121784
       -
              sha256 = "0fyrbm5c0yi7a8pgrq2sgr2hml0yyklb4pcszigx4k8fhvgzqprb";

     

       122123
       122123
       +
              version = "0.7.2.1";

     

       122124
       122124
       +
              sha256 = "0b109c9m52j0idlcp5w7aqnryb2bmghf4g33jhhd3dsrr0xx6ah0";

     

       121785
       122125
        
              isLibrary = false;

     

       121786
       122126
        
              isExecutable = true;

     

       121787
       122127
        
              libraryHaskellDepends = [

     
···

       124490
       124830
        
              license = lib.licenses.bsd3;

     

       124491
       124831
        
            }) {};

     

       124492
       124832
        
       

     

       124833
       124833
       +
         "happstack-server_7_8_0" = callPackage

     

       124834
       124834
       +
           ({ mkDerivation, base, base64-bytestring, blaze-html, bytestring

     

       124835
       124835
       +
            , containers, directory, exceptions, extensible-exceptions

     

       124836
       124836
       +
            , filepath, hslogger, html, HUnit, monad-control, mtl, network

     

       124837
       124837
       +
            , network-uri, old-locale, parsec, process, semigroups, sendfile

     

       124838
       124838
       +
            , syb, system-filepath, text, threads, time, transformers

     

       124839
       124839
       +
            , transformers-base, transformers-compat, unix, utf8-string, xhtml

     

       124840
       124840
       +
            , zlib

     

       124841
       124841
       +
            }:

     

       124842
       124842
       +
            mkDerivation {

     

       124843
       124843
       +
              pname = "happstack-server";

     

       124844
       124844
       +
              version = "7.8.0";

     

       124845
       124845
       +
              sha256 = "1d8fmxh5v4n5fqksprz1j374cibwihljr0515ngr5jh77lbplsim";

     

       124846
       124846
       +
              libraryHaskellDepends = [

     

       124847
       124847
       +
                base base64-bytestring blaze-html bytestring containers directory

     

       124848
       124848
       +
                exceptions extensible-exceptions filepath hslogger html

     

       124849
       124849
       +
                monad-control mtl network network-uri old-locale parsec process

     

       124850
       124850
       +
                semigroups sendfile syb system-filepath text threads time

     

       124851
       124851
       +
                transformers transformers-base transformers-compat unix utf8-string

     

       124852
       124852
       +
                xhtml zlib

     

       124853
       124853
       +
              ];

     

       124854
       124854
       +
              testHaskellDepends = [

     

       124855
       124855
       +
                base bytestring containers HUnit parsec zlib

     

       124856
       124856
       +
              ];

     

       124857
       124857
       +
              description = "Web related tools and services";

     

       124858
       124858
       +
              license = lib.licenses.bsd3;

     

       124859
       124859
       +
              hydraPlatforms = lib.platforms.none;

     

       124860
       124860
       +
            }) {};

     

       124861
       124861
       +
       

     

       124493
       124862
        
         "happstack-server-tls" = callPackage

     

       124494
       124863
        
           ({ mkDerivation, base, bytestring, extensible-exceptions

     

       124495
       124864
        
            , happstack-server, hslogger, HsOpenSSL, network, openssl, sendfile

     
···

       138025
       138394
        
              broken = true;

     

       138026
       138395
        
            }) {};

     

       138027
       138396
        
       

     

       138397
       138397
       +
         "hkd-records" = callPackage

     

       138398
       138398
       +
           ({ mkDerivation, base, hkd, text }:

     

       138399
       138399
       +
            mkDerivation {

     

       138400
       138400
       +
              pname = "hkd-records";

     

       138401
       138401
       +
              version = "0.0.2";

     

       138402
       138402
       +
              sha256 = "1404c3gqrk2i0ab67v12h5khcghbkad7cyphfmp6kkn8d5smpz1m";

     

       138403
       138403
       +
              libraryHaskellDepends = [ base hkd text ];

     

       138404
       138404
       +
              description = "higher kinded record operations";

     

       138405
       138405
       +
              license = lib.licenses.bsd3;

     

       138406
       138406
       +
            }) {};

     

       138407
       138407
       +
       

     

       138028
       138408
        
         "hkdf" = callPackage

     

       138029
       138409
        
           ({ mkDerivation, base, byteable, bytestring, cryptohash, hspec }:

     

       138030
       138410
        
            mkDerivation {

     
···

       150414
       150794
        
              license = lib.licenses.mit;

     

       150415
       150795
        
            }) {};

     

       150416
       150796
        
       

     

       150797
       150797
       +
         "http-client_0_7_12" = callPackage

     

       150798
       150798
       +
           ({ mkDerivation, array, async, base, base64-bytestring

     

       150799
       150799
       +
            , blaze-builder, bytestring, case-insensitive, containers, cookie

     

       150800
       150800
       +
            , deepseq, directory, exceptions, filepath, ghc-prim, hspec

     

       150801
       150801
       +
            , hspec-discover, http-types, iproute, mime-types, monad-control

     

       150802
       150802
       +
            , network, network-uri, random, stm, streaming-commons, text, time

     

       150803
       150803
       +
            , transformers, zlib

     

       150804
       150804
       +
            }:

     

       150805
       150805
       +
            mkDerivation {

     

       150806
       150806
       +
              pname = "http-client";

     

       150807
       150807
       +
              version = "0.7.12";

     

       150808
       150808
       +
              sha256 = "03mfkrf2zl3jga2hihx7aq7qymzgnk31ldvbk66y70c3i1jpgxb2";

     

       150809
       150809
       +
              libraryHaskellDepends = [

     

       150810
       150810
       +
                array async base base64-bytestring blaze-builder bytestring

     

       150811
       150811
       +
                case-insensitive containers cookie deepseq exceptions filepath

     

       150812
       150812
       +
                ghc-prim http-types iproute mime-types network network-uri random

     

       150813
       150813
       +
                stm streaming-commons text time transformers

     

       150814
       150814
       +
              ];

     

       150815
       150815
       +
              testHaskellDepends = [

     

       150816
       150816
       +
                async base blaze-builder bytestring case-insensitive containers

     

       150817
       150817
       +
                cookie deepseq directory hspec http-types monad-control network

     

       150818
       150818
       +
                network-uri streaming-commons text time transformers zlib

     

       150819
       150819
       +
              ];

     

       150820
       150820
       +
              testToolDepends = [ hspec-discover ];

     

       150821
       150821
       +
              doCheck = false;

     

       150822
       150822
       +
              description = "An HTTP client engine";

     

       150823
       150823
       +
              license = lib.licenses.mit;

     

       150824
       150824
       +
              hydraPlatforms = lib.platforms.none;

     

       150825
       150825
       +
            }) {};

     

       150826
       150826
       +
       

     

       150417
       150827
        
         "http-client-auth" = callPackage

     

       150418
       150828
        
           ({ mkDerivation, base, base64-string, blaze-builder, bytestring

     

       150419
       150829
        
            , case-insensitive, conduit, crypto-conduit, http-client

     
···

       155608
       156018
        
              pname = "identicon-style-squares";

     

       155609
       156019
        
              version = "0.1.0.1";

     

       155610
       156020
        
              sha256 = "1x456v7fb211f7ciipp2bfn9fvh5w4i34bl5mjw7bkn7hgsaa3x6";

     

       155611
       155611
       -
              revision = "3";

     

       155612
       155612
       -
              editedCabalFile = "0jri78n8xggipikhp6p4l4i2zwjn4fdydbv730w01linfg1h6w68";

     

       156021
       156021
       +
              revision = "4";

     

       156022
       156022
       +
              editedCabalFile = "0s38fp9wkzgbgd7mb4lrc4x1c3panc5sac7wrgdjqymw7339yz0b";

     

       155613
       156023
        
              libraryHaskellDepends = [

     

       155614
       156024
        
                base identicon JuicyPixels polyvariadic

     

       155615
       156025
        
              ];

     
···

       158057
       158467
        
              license = lib.licenses.bsd3;

     

       158058
       158468
        
            }) {};

     

       158059
       158469
        
       

     

       158470
       158470
       +
         "ini_0_4_2" = callPackage

     

       158471
       158471
       +
           ({ mkDerivation, attoparsec, base, hspec, text

     

       158472
       158472
       +
            , unordered-containers

     

       158473
       158473
       +
            }:

     

       158474
       158474
       +
            mkDerivation {

     

       158475
       158475
       +
              pname = "ini";

     

       158476
       158476
       +
              version = "0.4.2";

     

       158477
       158477
       +
              sha256 = "0dp9c48vli8z6058yajnqg9hyf9swglk8ga4wcwl03aal7n8r7gp";

     

       158478
       158478
       +
              libraryHaskellDepends = [

     

       158479
       158479
       +
                attoparsec base text unordered-containers

     

       158480
       158480
       +
              ];

     

       158481
       158481
       +
              testHaskellDepends = [ base hspec unordered-containers ];

     

       158482
       158482
       +
              description = "Configuration files in the INI format";

     

       158483
       158483
       +
              license = lib.licenses.bsd3;

     

       158484
       158484
       +
              hydraPlatforms = lib.platforms.none;

     

       158485
       158485
       +
            }) {};

     

       158486
       158486
       +
       

     

       158060
       158487
        
         "ini-qq" = callPackage

     

       158061
       158488
        
           ({ mkDerivation, base, HUnit, ini, raw-strings-qq, template-haskell

     

       158062
       158489
        
            , text

     
···

       159701
       160128
        
              pname = "invariant";

     

       159702
       160129
        
              version = "0.6";

     

       159703
       160130
        
              sha256 = "07ffgcfpacsdihcmcmx2m1gp8czlg28657bxncxjykjiiiwjlaxm";

     

       160131
       160131
       +
              revision = "1";

     

       160132
       160132
       +
              editedCabalFile = "0551ll1swnrmq09j89jqnxl4qnirbbpdpsdym23adaf36qdd7v37";

     

       159704
       160133
        
              libraryHaskellDepends = [

     

       159705
       160134
        
                array base bifunctors comonad containers contravariant ghc-prim

     

       159706
       160135
        
                profunctors StateVar stm tagged template-haskell th-abstraction

     
···

       164811
       165240
        
              license = lib.licenses.bsd3;

     

       164812
       165241
        
            }) {};

     

       164813
       165242
        
       

     

       165243
       165243
       +
         "jsonpath_0_3_0_0" = callPackage

     

       165244
       165244
       +
           ({ mkDerivation, aeson, aeson-casing, base, bytestring, file-embed

     

       165245
       165245
       +
            , hspec, hspec-discover, hspec-megaparsec, megaparsec, scientific

     

       165246
       165246
       +
            , text, unordered-containers, vector

     

       165247
       165247
       +
            }:

     

       165248
       165248
       +
            mkDerivation {

     

       165249
       165249
       +
              pname = "jsonpath";

     

       165250
       165250
       +
              version = "0.3.0.0";

     

       165251
       165251
       +
              sha256 = "10a2wbkhdg2x61qpfvb4cl89plhvwy5nc5qqqs5jnll7kg4cabyi";

     

       165252
       165252
       +
              libraryHaskellDepends = [

     

       165253
       165253
       +
                aeson base megaparsec scientific text unordered-containers vector

     

       165254
       165254
       +
              ];

     

       165255
       165255
       +
              testHaskellDepends = [

     

       165256
       165256
       +
                aeson aeson-casing base bytestring file-embed hspec

     

       165257
       165257
       +
                hspec-megaparsec megaparsec text unordered-containers vector

     

       165258
       165258
       +
              ];

     

       165259
       165259
       +
              testToolDepends = [ hspec-discover ];

     

       165260
       165260
       +
              description = "Library to parse and execute JSONPath";

     

       165261
       165261
       +
              license = lib.licenses.bsd3;

     

       165262
       165262
       +
              hydraPlatforms = lib.platforms.none;

     

       165263
       165263
       +
            }) {};

     

       165264
       165264
       +
       

     

       164814
       165265
        
         "jsonresume" = callPackage

     

       164815
       165266
        
           ({ mkDerivation, aeson, base, bytestring, old-locale, text, time

     

       164816
       165267
        
            , unordered-containers

     
···

       167203
       167654
        
              pname = "keycode";

     

       167204
       167655
        
              version = "0.2.2";

     

       167205
       167656
        
              sha256 = "046k8d1h5wwadf5z4pppjkc3g7v2zxlzb06s1xgixc42y5y41yan";

     

       167206
       167206
       -
              revision = "7";

     

       167207
       167207
       -
              editedCabalFile = "1xfhm486mgkf744nbx94aw0b1lraj1yv29c57rbx1c2b84v2z8k2";

     

       167657
       167657
       +
              revision = "8";

     

       167658
       167658
       +
              editedCabalFile = "1a8a51sz670cfh73q9l2dckfqgv59lpxk8dg5xd9fnvi2ba7wdf1";

     

       167208
       167659
        
              libraryHaskellDepends = [

     

       167209
       167660
        
                base containers ghc-prim template-haskell

     

       167210
       167661
        
              ];

     
···

       167973
       168424
        
              broken = true;

     

       167974
       168425
        
            }) {};

     

       167975
       168426
        
       

     

       168427
       168427
       +
         "konnakol" = callPackage

     

       168428
       168428
       +
           ({ mkDerivation, base, colour, containers, diagrams-lib

     

       168429
       168429
       +
            , diagrams-svg, random, split, tidal

     

       168430
       168430
       +
            }:

     

       168431
       168431
       +
            mkDerivation {

     

       168432
       168432
       +
              pname = "konnakol";

     

       168433
       168433
       +
              version = "0.1.0.0";

     

       168434
       168434
       +
              sha256 = "10hykji062b54q95yv1f0l8pxapxzyhk1l872nyjahn0ph0bkx1n";

     

       168435
       168435
       +
              libraryHaskellDepends = [

     

       168436
       168436
       +
                base colour containers diagrams-lib diagrams-svg random split tidal

     

       168437
       168437
       +
              ];

     

       168438
       168438
       +
              testHaskellDepends = [ base ];

     

       168439
       168439
       +
              description = "Formalising the rules of Konnakol, an Indian percussional art form";

     

       168440
       168440
       +
              license = lib.licenses.gpl3Only;

     

       168441
       168441
       +
              hydraPlatforms = lib.platforms.none;

     

       168442
       168442
       +
              broken = true;

     

       168443
       168443
       +
            }) {};

     

       168444
       168444
       +
       

     

       167976
       168445
        
         "kontra-config" = callPackage

     

       167977
       168446
        
           ({ mkDerivation, base, bytestring, data-default, exceptions, text

     

       167978
       168447
        
            , transformers-base, unjson, utf8-string, yaml

     
···

       171167
       171636
        
            }:

     

       171168
       171637
        
            mkDerivation {

     

       171169
       171638
        
              pname = "large-anon";

     

       171170
       171170
       -
              version = "0.1.0.0";

     

       171171
       171171
       -
              sha256 = "15rrqpfd7jmm391lxhz2ag1sa17nw8x3wjqm0f9naidgmyv9x1z2";

     

       171172
       171172
       -
              revision = "1";

     

       171173
       171173
       -
              editedCabalFile = "1541ak37yk8431wiwjmcn0yp12f07wjhr8vsjs1hgmh124dm9295";

     

       171639
       171639
       +
              version = "0.1.1";

     

       171640
       171640
       +
              sha256 = "15fgmh1nnm3xc04sw0gk7a456fa1j8gij8av4h22g98pp4dap4wb";

     

       171174
       171641
        
              libraryHaskellDepends = [

     

       171175
       171642
        
                aeson base containers ghc ghc-tcplugin-api hashable large-generics

     

       171176
       171643
        
                mtl optics-core primitive record-hasfield sop-core syb tagged

     
···

       171196
       171663
        
              pname = "large-generics";

     

       171197
       171664
        
              version = "0.2.0.0";

     

       171198
       171665
        
              sha256 = "0pyydzwybccwaliajzaddgirrffv0sskkyf5zp84rs8kp2yqz9z1";

     

       171666
       171666
       +
              revision = "1";

     

       171667
       171667
       +
              editedCabalFile = "07hr73lv367ga0m3knrhwcafr6g7sa7p24689zfn4n1z4ja1cm8q";

     

       171199
       171668
        
              libraryHaskellDepends = [

     

       171200
       171669
        
                aeson base generics-sop primitive sop-core

     

       171201
       171670
        
              ];

     
···

       171247
       171716
        
            }:

     

       171248
       171717
        
            mkDerivation {

     

       171249
       171718
        
              pname = "large-records";

     

       171250
       171250
       -
              version = "0.2.1.0";

     

       171251
       171251
       -
              sha256 = "0gmgrkh9fsyy6ww64l4warsilxkxwfzfl43d36d8a5dcgvn49ip2";

     

       171252
       171252
       -
              revision = "1";

     

       171253
       171253
       -
              editedCabalFile = "1j366mm61j7xxy5lhppc0an8249iskhd3dqxazfwmc3vi23a044k";

     

       171719
       171719
       +
              version = "0.3";

     

       171720
       171720
       +
              sha256 = "1s11zk2bgi85q18hp01pkjvp8l3f1plb78cblyi4j0cvs6ra4q4w";

     

       171254
       171721
        
              libraryHaskellDepends = [

     

       171255
       171722
        
                base containers ghc large-generics mtl primitive record-hasfield

     

       171256
       171723
        
                syb template-haskell transformers

     
···

       174949
       175416
        
              pname = "lift-generics";

     

       174950
       175417
        
              version = "0.2.1";

     

       174951
       175418
        
              sha256 = "1qkzq8hcb6j15cslv577bmhjcxmljzsrryysdgd7r99kr3q445b4";

     

       174952
       174952
       -
              revision = "2";

     

       174953
       174953
       -
              editedCabalFile = "1q6lviqfvyis3ss9w6r6j5d35is50r2favj9lkdagcmczw9c4706";

     

       175419
       175419
       +
              revision = "3";

     

       175420
       175420
       +
              editedCabalFile = "0birp7ibzvil7m9ra0ixgaz9z0liixbw9z1j22x4r8x5r6hyaqik";

     

       174954
       175421
        
              libraryHaskellDepends = [

     

       174955
       175422
        
                base generic-deriving ghc-prim template-haskell th-compat

     

       174956
       175423
        
              ];

     
···

       178061
       178528
        
            }) {};

     

       178062
       178529
        
       

     

       178063
       178530
        
         "lnd-client" = callPackage

     

       178064
       178064
       -
           ({ mkDerivation, aeson, asn1-encoding, asn1-types, async, base

     

       178065
       178065
       -
            , base16-bytestring, base64-bytestring, bytestring, chronos

     

       178066
       178066
       -
            , containers, cryptohash-sha256, cryptonite, deepseq, envparse

     

       178067
       178067
       -
            , extra, hspec, http2, http2-client, http2-client-grpc

     

       178068
       178068
       -
            , http2-grpc-proto-lens, http2-grpc-types, JuicyPixels, katip

     

       178069
       178069
       -
            , microlens, network-bitcoin, pem, persistent, proto-lens

     

       178070
       178070
       -
            , proto-lens-runtime, qrcode-core, qrcode-juicypixels, scientific

     

       178071
       178071
       -
            , stm, template-haskell, text, unbounded-delays, universum

     

       178072
       178072
       -
            , unliftio, x509

     

       178531
       178531
       +
           ({ mkDerivation, aeson, async, base, base16-bytestring

     

       178532
       178532
       +
            , base64-bytestring, bytestring, chronos, containers

     

       178533
       178533
       +
            , cryptohash-sha256, cryptonite, envparse, extra

     

       178534
       178534
       +
            , generic-pretty-instances, GenericPretty, hspec, http2

     

       178535
       178535
       +
            , http2-client, http2-client-grpc, http2-grpc-proto-lens

     

       178536
       178536
       +
            , http2-grpc-types, JuicyPixels, katip, microlens, network-bitcoin

     

       178537
       178537
       +
            , pem, persistent, proto-lens, proto-lens-runtime, qrcode-core

     

       178538
       178538
       +
            , qrcode-juicypixels, scientific, stm, template-haskell, text, time

     

       178539
       178539
       +
            , tls, unbounded-delays, universum, unliftio, x509, x509-store

     

       178073
       178540
        
            }:

     

       178074
       178541
        
            mkDerivation {

     

       178075
       178542
        
              pname = "lnd-client";

     

       178076
       178076
       -
              version = "0.1.0.0";

     

       178077
       178077
       -
              sha256 = "0fjjm9gamj50scd9m55mv587klhn8xpj35x8abvms5pmpf0npzgq";

     

       178543
       178543
       +
              version = "0.1.0.1";

     

       178544
       178544
       +
              sha256 = "1bfkb4ryi79cxsyq7d16mgy634wq9azyganpf5ahyjfnfhsbb6ra";

     

       178545
       178545
       +
              isLibrary = true;

     

       178546
       178546
       +
              isExecutable = true;

     

       178078
       178547
        
              libraryHaskellDepends = [

     

       178079
       178079
       -
                aeson asn1-encoding asn1-types async base base16-bytestring

     

       178080
       178080
       -
                base64-bytestring bytestring chronos containers cryptohash-sha256

     

       178081
       178081
       -
                cryptonite deepseq envparse extra hspec http2 http2-client

     

       178082
       178082
       -
                http2-client-grpc http2-grpc-proto-lens http2-grpc-types

     

       178083
       178083
       -
                JuicyPixels katip microlens network-bitcoin pem persistent

     

       178084
       178084
       -
                proto-lens proto-lens-runtime qrcode-core qrcode-juicypixels

     

       178085
       178085
       -
                scientific stm template-haskell text unbounded-delays universum

     

       178086
       178086
       -
                unliftio x509

     

       178087
       178087
       -
              ];

     

       178088
       178088
       -
              testHaskellDepends = [

     

       178089
       178089
       -
                aeson asn1-encoding asn1-types async base base16-bytestring

     

       178090
       178090
       -
                base64-bytestring bytestring chronos containers cryptohash-sha256

     

       178091
       178091
       -
                cryptonite deepseq envparse extra hspec http2 http2-client

     

       178548
       178548
       +
                aeson async base base16-bytestring base64-bytestring bytestring

     

       178549
       178549
       +
                chronos containers cryptohash-sha256 cryptonite envparse extra

     

       178550
       178550
       +
                generic-pretty-instances GenericPretty http2 http2-client

     

       178092
       178551
        
                http2-client-grpc http2-grpc-proto-lens http2-grpc-types

     

       178093
       178552
        
                JuicyPixels katip microlens network-bitcoin pem persistent

     

       178094
       178553
        
                proto-lens proto-lens-runtime qrcode-core qrcode-juicypixels

     

       178095
       178095
       -
                scientific stm template-haskell text unbounded-delays universum

     

       178096
       178096
       -
                unliftio x509

     

       178554
       178554
       +
                scientific stm template-haskell text time tls unbounded-delays

     

       178555
       178555
       +
                universum unliftio x509 x509-store

     

       178097
       178556
        
              ];

     

       178557
       178557
       +
              executableHaskellDepends = [ async base ];

     

       178558
       178558
       +
              testHaskellDepends = [ async base containers hspec unliftio ];

     

       178559
       178559
       +
              doHaddock = false;

     

       178098
       178560
        
              description = "Lightning Network Daemon (LND) client library for Haskell";

     

       178099
       178561
        
              license = lib.licenses.bsd3;

     

       178100
       178562
        
              hydraPlatforms = lib.platforms.none;

     

       178563
       178563
       +
              mainProgram = "lnd-client-prof";

     

       178101
       178564
        
            }) {};

     

       178102
       178565
        
       

     

       178103
       178566
        
         "lnurl" = callPackage

     
···

       188424
       188887
        
       

     

       188425
       188888
        
         "mit-3qvpPyAi6mH" = callPackage

     

       188426
       188889
        
           ({ mkDerivation, base, base64, containers, directory, ki

     

       188427
       188427
       -
            , optparse-applicative, parsec, process, text, text-ansi, unix

     

       188890
       188890
       +
            , optparse-applicative, parsec, process, stm, text, text-ansi, unix

     

       188428
       188891
        
            }:

     

       188429
       188892
        
            mkDerivation {

     

       188430
       188893
        
              pname = "mit-3qvpPyAi6mH";

     

       188431
       188431
       -
              version = "8";

     

       188432
       188432
       -
              sha256 = "0rknwwfysmic2x8apwah99d0lmjlgyn6wnxrvviv22903bnjlcn9";

     

       188894
       188894
       +
              version = "9";

     

       188895
       188895
       +
              sha256 = "1p0kpfpzsnp6zyhvx8mqh3lrmgl19q15lfs8q32yk08bqk63pbj9";

     

       188433
       188896
        
              isLibrary = true;

     

       188434
       188897
        
              isExecutable = true;

     

       188435
       188898
        
              libraryHaskellDepends = [

     

       188436
       188899
        
                base base64 containers directory ki optparse-applicative parsec

     

       188437
       188437
       -
                process text text-ansi unix

     

       188900
       188900
       +
                process stm text text-ansi unix

     

       188438
       188901
        
              ];

     

       188439
       188902
        
              executableHaskellDepends = [ base ];

     

       188440
       188903
        
              description = "A git wrapper with a streamlined UX";

     
···

       197103
       197566
        
           ({ mkDerivation, base, hspec, optics-core, text }:

     

       197104
       197567
        
            mkDerivation {

     

       197105
       197568
        
              pname = "nat-optics";

     

       197106
       197106
       -
              version = "1.0.0.3";

     

       197107
       197107
       -
              sha256 = "1anvn1p4zp8qwc7pasvx1xvglncjbz7p45x4i7rzj2zdz7qcs4nq";

     

       197569
       197569
       +
              version = "1.0.0.4";

     

       197570
       197570
       +
              sha256 = "0r9disaj26f17k84zkkfxj1glin2vdgfk8ss5fyag6xr6imzp17s";

     

       197108
       197571
        
              libraryHaskellDepends = [ base optics-core text ];

     

       197109
       197572
        
              testHaskellDepends = [ base hspec optics-core text ];

     

       197110
       197573
        
              description = "Refinement types for natural numbers with an optics interface";

     
···

       200178
       200641
        
              libraryToolDepends = [ c2hs ];

     

       200179
       200642
        
              description = "libnfc bindings";

     

       200180
       200643
        
              license = lib.licenses.publicDomain;

     

       200181
       200181
       -
              hydraPlatforms = lib.platforms.none;

     

       200182
       200182
       -
              broken = true;

     

       200644
       200644
       +
              maintainers = [ lib.maintainers.centromere ];

     

       200183
       200645
        
            }) {inherit (pkgs) libnfc;};

     

       200184
       200646
        
       

     

       200185
       200647
        
         "ngram" = callPackage

     
···

       200592
       201054
        
              pname = "nix-derivation";

     

       200593
       201055
        
              version = "1.1.2";

     

       200594
       201056
        
              sha256 = "0248xbxq4889hc3qp9z0yr21f97j3lxrjjx2isxdf8ah4hpidzy7";

     

       200595
       200595
       -
              revision = "1";

     

       200596
       200596
       -
              editedCabalFile = "06fj7rqj8g3xhwm0x0cyxp7f8k8gasm4y2ccnm8zq9bhli1hw4b0";

     

       201057
       201057
       +
              revision = "2";

     

       201058
       201058
       +
              editedCabalFile = "1n2yqwpj6n4djb9gjv2dsvbx8xp5vff5qxhaivmglwqh8v55sf9x";

     

       200597
       201059
        
              isLibrary = true;

     

       200598
       201060
        
              isExecutable = true;

     

       200599
       201061
        
              libraryHaskellDepends = [

     
···

       201975
       202437
        
            }:

     

       201976
       202438
        
            mkDerivation {

     

       201977
       202439
        
              pname = "notmuch";

     

       201978
       201978
       -
              version = "0.3.0.1";

     

       201979
       201979
       -
              sha256 = "0dns7h8fh5ddd77wysys5x9qialz7bqj9h76qj3fy34145d7wlq4";

     

       202440
       202440
       +
              version = "0.3.1";

     

       202441
       202441
       +
              sha256 = "1lvxrljzgpc1rgdgrb6x35k3syc9wnnh3acr8dbfj7n2giq5ganr";

     

       201980
       202442
        
              isLibrary = true;

     

       201981
       202443
        
              isExecutable = true;

     

       201982
       202444
        
              libraryHaskellDepends = [

     
···

       204826
       205288
        
              license = lib.licenses.bsd3;

     

       204827
       205289
        
            }) {};

     

       204828
       205290
        
       

     

       204829
       204829
       -
         "opaleye_0_9_3_1" = callPackage

     

       205291
       205291
       +
         "opaleye_0_9_3_2" = callPackage

     

       204830
       205292
        
           ({ mkDerivation, aeson, base, base16-bytestring, bytestring

     

       204831
       205293
        
            , case-insensitive, containers, contravariant, dotenv, hspec

     

       204832
       205294
        
            , hspec-discover, multiset, postgresql-simple, pretty

     
···

       204836
       205298
        
            }:

     

       204837
       205299
        
            mkDerivation {

     

       204838
       205300
        
              pname = "opaleye";

     

       204839
       204839
       -
              version = "0.9.3.1";

     

       204840
       204840
       -
              sha256 = "1mgyjg2gzs2l6941561bhk29wqv9fj81g7q4wlkkaxszg9w2lkww";

     

       205301
       205301
       +
              version = "0.9.3.2";

     

       205302
       205302
       +
              sha256 = "0lkdi2svbv64z4rnsfxbr7ijb3a5rmsx4c6igzql7ajrlwha49rx";

     

       204841
       205303
        
              libraryHaskellDepends = [

     

       204842
       205304
        
                aeson base base16-bytestring bytestring case-insensitive

     

       204843
       205305
        
                contravariant postgresql-simple pretty product-profunctors

     
···

       208121
       208583
        
            }) {};

     

       208122
       208584
        
       

     

       208123
       208585
        
         "package-version" = callPackage

     

       208124
       208124
       -
           ({ mkDerivation, base, deepseq, doctest, hedgehog, prettyprinter

     

       208125
       208125
       -
            , safe-exceptions, tagged, tasty, tasty-hedgehog, tasty-hunit

     

       208126
       208126
       -
            , template-haskell, text

     

       208586
       208586
       +
           ({ mkDerivation, base, bytestring, deepseq, doctest, env-guard

     

       208587
       208587
       +
            , hedgehog, prettyprinter, safe-exceptions, tagged, tasty

     

       208588
       208588
       +
            , tasty-hedgehog, tasty-hunit, template-haskell, text

     

       208127
       208589
        
            }:

     

       208128
       208590
        
            mkDerivation {

     

       208129
       208591
        
              pname = "package-version";

     

       208130
       208130
       -
              version = "0.1.0.0";

     

       208131
       208131
       -
              sha256 = "1r1rw412f40ylnyhxjb04f2ch52wqqblm8979x92n8fd9jj3lr84";

     

       208132
       208132
       -
              revision = "1";

     

       208133
       208133
       -
              editedCabalFile = "165bhn0fv5ip5vcrnxv33i4a8mi7r0nhry1j3f7alh2mj0zck7xv";

     

       208592
       208592
       +
              version = "0.2";

     

       208593
       208593
       +
              sha256 = "0381k1s0gc5wqxx21fg3nk7cgg821qlszdnwp1gl9jrykbfqak44";

     

       208134
       208594
        
              libraryHaskellDepends = [

     

       208135
       208135
       -
                base deepseq prettyprinter safe-exceptions template-haskell text

     

       208595
       208595
       +
                base bytestring deepseq prettyprinter safe-exceptions

     

       208596
       208596
       +
                template-haskell text

     

       208136
       208597
        
              ];

     

       208137
       208598
        
              testHaskellDepends = [

     

       208138
       208138
       -
                base doctest hedgehog safe-exceptions tagged tasty tasty-hedgehog

     

       208139
       208139
       -
                tasty-hunit text

     

       208599
       208599
       +
                base doctest env-guard hedgehog safe-exceptions tagged tasty

     

       208600
       208600
       +
                tasty-hedgehog tasty-hunit text

     

       208140
       208601
        
              ];

     

       208141
       208602
        
              description = "A package for retrieving a package's version number";

     

       208142
       208603
        
              license = lib.licenses.bsd3;

     
···

       218364
       218825
        
       

     

       218365
       218826
        
         "pixiv" = callPackage

     

       218366
       218827
        
           ({ mkDerivation, aeson, base, base16-bytestring, bytestring

     

       218367
       218367
       -
            , cryptohash-md5, directory, exceptions, filepath, http-client

     

       218828
       218828
       +
            , cryptohash-md5, exceptions, filepath, http-client

     

       218368
       218829
        
            , http-client-tls, lens, monad-control, mtl, process, servant

     

       218369
       218830
        
            , servant-client, servant-client-core, template-haskell, temporary

     

       218370
       218831
        
            , text, time, transformers, transformers-base, zip-archive

     

       218371
       218832
        
            }:

     

       218372
       218833
        
            mkDerivation {

     

       218373
       218834
        
              pname = "pixiv";

     

       218374
       218374
       -
              version = "0.1.0";

     

       218375
       218375
       -
              sha256 = "001pfzijh7ibcyinmw0l8yvw0kxsvmniw993qx9b6zlzf689cpp6";

     

       218376
       218376
       -
              revision = "1";

     

       218377
       218377
       -
              editedCabalFile = "03wfjj0a074n02mpa02gncfy35m53qdmij465dk8g6qjnjah8a01";

     

       218835
       218835
       +
              version = "0.1.1";

     

       218836
       218836
       +
              sha256 = "1mzcnm1y0fsx66lk09j49mdw9hv4l0zsq4wqi9jcamr0jf5ffq0y";

     

       218378
       218837
        
              libraryHaskellDepends = [

     

       218379
       218379
       -
                aeson base base16-bytestring bytestring cryptohash-md5 directory

     

       218380
       218380
       -
                exceptions filepath http-client http-client-tls lens monad-control

     

       218381
       218381
       -
                mtl process servant servant-client servant-client-core

     

       218382
       218382
       -
                template-haskell temporary text time transformers transformers-base

     

       218383
       218383
       -
                zip-archive

     

       218838
       218838
       +
                aeson base base16-bytestring bytestring cryptohash-md5 exceptions

     

       218839
       218839
       +
                filepath http-client http-client-tls lens monad-control mtl process

     

       218840
       218840
       +
                servant servant-client servant-client-core template-haskell

     

       218841
       218841
       +
                temporary text time transformers transformers-base zip-archive

     

       218384
       218842
        
              ];

     

       218385
       218843
        
              testHaskellDepends = [

     

       218386
       218844
        
                aeson base bytestring http-client http-client-tls

     
···

       222260
       222718
        
              broken = true;

     

       222261
       222719
        
            }) {};

     

       222262
       222720
        
       

     

       222721
       222721
       +
         "postgresql-ltree" = callPackage

     

       222722
       222722
       +
           ({ mkDerivation, aeson, attoparsec, base, containers, hspec

     

       222723
       222723
       +
            , QuickCheck, text, uuid

     

       222724
       222724
       +
            }:

     

       222725
       222725
       +
            mkDerivation {

     

       222726
       222726
       +
              pname = "postgresql-ltree";

     

       222727
       222727
       +
              version = "0.0.0.0";

     

       222728
       222728
       +
              sha256 = "0i3zh6bnkxfqvphyssxg8brzq20v7ladsqsq5j1m99g29bs5x77q";

     

       222729
       222729
       +
              libraryHaskellDepends = [

     

       222730
       222730
       +
                aeson attoparsec base containers text uuid

     

       222731
       222731
       +
              ];

     

       222732
       222732
       +
              testHaskellDepends = [ base hspec QuickCheck text ];

     

       222733
       222733
       +
              description = "Types and functions for representing PostgreSQL's ltree";

     

       222734
       222734
       +
              license = lib.licenses.bsd3;

     

       222735
       222735
       +
              hydraPlatforms = lib.platforms.none;

     

       222736
       222736
       +
              broken = true;

     

       222737
       222737
       +
            }) {};

     

       222738
       222738
       +
       

     

       222263
       222739
        
         "postgresql-migration" = callPackage

     

       222264
       222740
        
           ({ mkDerivation, base, base64-bytestring, bytestring, cryptohash

     

       222265
       222741
        
            , directory, filepath, hspec, postgresql-simple, text, time

     
···

       222551
       223027
        
              ];

     

       222552
       223028
        
              description = "Interpolated SQL queries via quasiquotation";

     

       222553
       223029
        
              license = lib.licenses.bsd3;

     

       223030
       223030
       +
            }) {};

     

       223031
       223031
       +
       

     

       223032
       223032
       +
         "postgresql-simple-ltree" = callPackage

     

       223033
       223033
       +
           ({ mkDerivation, aeson, base, bytestring, hspec, monad-logger

     

       223034
       223034
       +
            , postgresql-ltree, postgresql-simple, QuickCheck, text

     

       223035
       223035
       +
            , tmp-postgres

     

       223036
       223036
       +
            }:

     

       223037
       223037
       +
            mkDerivation {

     

       223038
       223038
       +
              pname = "postgresql-simple-ltree";

     

       223039
       223039
       +
              version = "0.0.0.0";

     

       223040
       223040
       +
              sha256 = "1pm0xl7d71gvr57v15kjr7yw9v1bd4marfqi8c920jm58jh07z8m";

     

       223041
       223041
       +
              revision = "1";

     

       223042
       223042
       +
              editedCabalFile = "1csmfcgvbcjq4fssivqk5fjyv517ffar9fvwpbcax9dzpfg4his5";

     

       223043
       223043
       +
              libraryHaskellDepends = [

     

       223044
       223044
       +
                aeson base postgresql-ltree postgresql-simple text

     

       223045
       223045
       +
              ];

     

       223046
       223046
       +
              testHaskellDepends = [

     

       223047
       223047
       +
                base bytestring hspec monad-logger postgresql-ltree

     

       223048
       223048
       +
                postgresql-simple QuickCheck text tmp-postgres

     

       223049
       223049
       +
              ];

     

       223050
       223050
       +
              description = "Instances for using ltree with postgresql-simple";

     

       223051
       223051
       +
              license = lib.licenses.bsd3;

     

       223052
       223052
       +
              hydraPlatforms = lib.platforms.none;

     

       222554
       223053
        
            }) {};

     

       222555
       223054
        
       

     

       222556
       223055
        
         "postgresql-simple-migration" = callPackage

     
···

       229441
       229940
        
              license = lib.licenses.mit;

     

       229442
       229941
        
              hydraPlatforms = lib.platforms.none;

     

       229443
       229942
        
              mainProgram = "qhs";

     

       229943
       229943
       +
            }) {};

     

       229944
       229944
       +
       

     

       229945
       229945
       +
         "qhull" = callPackage

     

       229946
       229946
       +
           ({ mkDerivation, base, combinat, containers, data-default-class

     

       229947
       229947
       +
            , extra, hashable, ilist, insert-ordered-containers

     

       229948
       229948
       +
            , optparse-applicative, pretty-show, random, regex-base

     

       229949
       229949
       +
            , regex-compat, regex-posix, split, toysolver, Unique

     

       229950
       229950
       +
            , vector-algorithms, vector-space

     

       229951
       229951
       +
            }:

     

       229952
       229952
       +
            mkDerivation {

     

       229953
       229953
       +
              pname = "qhull";

     

       229954
       229954
       +
              version = "0.1.0.1";

     

       229955
       229955
       +
              sha256 = "0r34w9v73zly7kz4ib70m2kpm16k1ngcx36ccfzz1agqjkbcva5l";

     

       229956
       229956
       +
              isLibrary = true;

     

       229957
       229957
       +
              isExecutable = true;

     

       229958
       229958
       +
              libraryHaskellDepends = [

     

       229959
       229959
       +
                base combinat containers data-default-class extra hashable ilist

     

       229960
       229960
       +
                insert-ordered-containers pretty-show random regex-base

     

       229961
       229961
       +
                regex-compat regex-posix split toysolver Unique vector-algorithms

     

       229962
       229962
       +
                vector-space

     

       229963
       229963
       +
              ];

     

       229964
       229964
       +
              executableHaskellDepends = [

     

       229965
       229965
       +
                base combinat containers extra ilist insert-ordered-containers

     

       229966
       229966
       +
                optparse-applicative pretty-show regex-base regex-compat

     

       229967
       229967
       +
                regex-posix

     

       229968
       229968
       +
              ];

     

       229969
       229969
       +
              description = "Delaunay triangulation, Voronoi diagrams and convex hulls";

     

       229970
       229970
       +
              license = lib.licenses.gpl3Only;

     

       229971
       229971
       +
              hydraPlatforms = lib.platforms.none;

     

       229444
       229972
        
            }) {};

     

       229445
       229973
        
       

     

       229446
       229974
        
         "qhull-simple" = callPackage

     
···

       250814
       251342
        
              pname = "servant-iCalendar";

     

       250815
       251343
        
              version = "0.1.0.1";

     

       250816
       251344
        
              sha256 = "15gqlb60r8msn3k1j8wjxq89qg6d790lnb751wabg2lsxybmdzas";

     

       250817
       250817
       -
              revision = "8";

     

       250818
       250818
       -
              editedCabalFile = "10ka19ga7slcv4cb2f0ncfbkz52bbrm8jkxma8qksz6hm48wxjya";

     

       251345
       251345
       +
              revision = "9";

     

       251346
       251346
       +
              editedCabalFile = "10r7kbil264vv090vhinhbb263zckjwdvp1sn1hx238yp5dzxlq0";

     

       250819
       251347
        
              libraryHaskellDepends = [

     

       250820
       251348
        
                base data-default http-media iCalendar servant

     

       250821
       251349
        
              ];

     
···

       252630
       253158
        
            }:

     

       252631
       253159
        
            mkDerivation {

     

       252632
       253160
        
              pname = "serversession-backend-persistent";

     

       252633
       252633
       -
              version = "2.0.0";

     

       252634
       252634
       -
              sha256 = "11zcncppswgx7cd9ihr6nm91574f7azsqbdcra9p2c2fqm191dvg";

     

       253161
       253161
       +
              version = "2.0.1";

     

       253162
       253162
       +
              sha256 = "1x08a5xhg2f48hjj651gchn17k7fg1n4a64vmyzy2ps2xrgqr2sy";

     

       252635
       253163
        
              libraryHaskellDepends = [

     

       252636
       253164
        
                aeson base base64-bytestring bytestring cereal path-pieces

     

       252637
       253165
        
                persistent serversession tagged text time transformers

     
···

       252731
       253259
        
            }:

     

       252732
       253260
        
            mkDerivation {

     

       252733
       253261
        
              pname = "serversession-frontend-yesod";

     

       252734
       252734
       -
              version = "1.0";

     

       252735
       252735
       -
              sha256 = "0lv7gkj4inks98g44n5kqvx5s4c66lmxf7gqfdly54znggglcf86";

     

       253262
       253262
       +
              version = "1.0.1";

     

       253263
       253263
       +
              sha256 = "0wq33480mv4sjbmf7rh1yzz65apy29ap8rypwhif1f2fd6byi5m9";

     

       252736
       253264
        
              libraryHaskellDepends = [

     

       252737
       253265
        
                base bytestring containers cookie data-default path-pieces

     

       252738
       253266
        
                serversession text time transformers unordered-containers wai

     
···

       259480
       260008
        
              pname = "snap-core";

     

       259481
       260009
        
              version = "1.0.5.0";

     

       259482
       260010
        
              sha256 = "0hf671g7h4nikfvi05q3mmcxhfcsh874dkansssn0mc68k9fsak4";

     

       259483
       259483
       -
              revision = "1";

     

       259484
       259484
       -
              editedCabalFile = "17ls02j8lxk0ml3pikxqkpmivzi49n2x5xh14gnrk2j1f8g06zk5";

     

       260011
       260011
       +
              revision = "2";

     

       260012
       260012
       +
              editedCabalFile = "14cvxfyq4d0sjyyj1qxphzywgq63kxmc4bcgwfd6hphqd60h2p35";

     

       259485
       260013
        
              libraryHaskellDepends = [

     

       259486
       260014
        
                attoparsec base bytestring bytestring-builder case-insensitive

     

       259487
       260015
        
                containers directory filepath hashable HUnit io-streams lifted-base

     
···

       269383
       269911
        
              pname = "structs";

     

       269384
       269912
        
              version = "0.1.6";

     

       269385
       269913
        
              sha256 = "0wzbhsvix46aans0hdm11pvsigk1lxpdaha2sxslx0ip1xsdg0gk";

     

       269914
       269914
       +
              revision = "1";

     

       269915
       269915
       +
              editedCabalFile = "1vpi14bc8x53dxzcyya39zr287kyfrjxiy5z5lwfkf63dmsrbd28";

     

       269386
       269916
        
              libraryHaskellDepends = [

     

       269387
       269917
        
                base deepseq ghc-prim primitive template-haskell th-abstraction

     

       269388
       269918
        
              ];

     
···

       269438
       269968
        
              pname = "structured";

     

       269439
       269969
        
              version = "0.1.1";

     

       269440
       269970
        
              sha256 = "1mz02ys85z79nj24ylsmgh8v2m7zv2rixf7w0iqnwc49lax52w4q";

     

       269441
       269441
       -
              revision = "3";

     

       269442
       269442
       -
              editedCabalFile = "188vz6j28ir7c6qrch3i95p9dd98b9f4hk9yvilnwpzd5v86dm3x";

     

       269971
       269971
       +
              revision = "4";

     

       269972
       269972
       +
              editedCabalFile = "1ayq9nf0bxx960qmdckxjsyhrz4xd6ymp0cf6v3qih13k8ld74hd";

     

       269443
       269973
        
              libraryHaskellDepends = [

     

       269444
       269974
        
                aeson array base base16-bytestring binary bytestring containers

     

       269445
       269975
        
                hashable scientific tagged text time-compat transformers

     
···

       270811
       271341
        
            }:

     

       270812
       271342
        
            mkDerivation {

     

       270813
       271343
        
              pname = "sv2v";

     

       270814
       270814
       -
              version = "0.0.9";

     

       270815
       270815
       -
              sha256 = "1pb7fwq7nbwliznw14y2hw1rwg8y78kiyv41cdwcz0vlwcp0cqd9";

     

       271344
       271344
       +
              version = "0.0.10";

     

       271345
       271345
       +
              sha256 = "00h7f8dmi17r4bcyzm25d6avvxdi8fqfxmvh7ssg9kqcbbix9xkd";

     

       270816
       271346
        
              isLibrary = false;

     

       270817
       271347
        
              isExecutable = true;

     

       270818
       271348
        
              executableHaskellDepends = [

     
···

       273768
       274298
        
              pname = "tagged";

     

       273769
       274299
        
              version = "0.8.6.1";

     

       273770
       274300
        
              sha256 = "00kcc6lmj7v3xm2r3wzw5jja27m4alcw1wi8yiismd0bbzwzrq7m";

     

       273771
       273771
       -
              revision = "2";

     

       273772
       273772
       -
              editedCabalFile = "0qi63c3z40i9qm44r571yjzcpb8d473vj2km4kq0fij0ljc7vii9";

     

       274301
       274301
       +
              revision = "3";

     

       274302
       274302
       +
              editedCabalFile = "19klgkhkca9qgq2ylc41z85x7piagjh8wranriy48dcfkgraw94a";

     

       273773
       274303
        
              libraryHaskellDepends = [

     

       273774
       274304
        
                base deepseq template-haskell transformers

     

       273775
       274305
        
              ];

     
···

       278919
       279449
        
              license = lib.licenses.bsd3;

     

       278920
       279450
        
            }) {inherit (pkgs) icu;};

     

       278921
       279451
        
       

     

       278922
       278922
       -
         "text-icu_0_8_0_1" = callPackage

     

       279452
       279452
       +
         "text-icu_0_8_0_2" = callPackage

     

       278923
       279453
        
           ({ mkDerivation, array, base, bytestring, deepseq, directory

     

       278924
       279454
        
            , ghc-prim, HUnit, icu, icu-i18n, QuickCheck, random

     

       278925
       279455
        
            , test-framework, test-framework-hunit, test-framework-quickcheck2

     
···

       278927
       279457
        
            }:

     

       278928
       279458
        
            mkDerivation {

     

       278929
       279459
        
              pname = "text-icu";

     

       278930
       278930
       -
              version = "0.8.0.1";

     

       278931
       278931
       -
              sha256 = "1bxhaxyvhag26airz870lc6rjlf14xigdx3cml13kp7bshwgl7wi";

     

       278932
       278932
       -
              revision = "2";

     

       278933
       278933
       -
              editedCabalFile = "0j9l87xg5xp33n31ln16qj6gzw4xzvs0cd3bfvjiw7x8wy8irli2";

     

       279460
       279460
       +
              version = "0.8.0.2";

     

       279461
       279461
       +
              sha256 = "0frxrsj580ipgb3pdvw1msdz8d63j02vvrqhzjja3ixlq24am69d";

     

       278934
       279462
        
              libraryHaskellDepends = [ base bytestring deepseq text time ];

     

       278935
       279463
        
              librarySystemDepends = [ icu ];

     

       278936
       279464
        
              libraryPkgconfigDepends = [ icu-i18n ];

     
···

       279393
       279921
        
              pname = "text-show";

     

       279394
       279922
        
              version = "3.9.7";

     

       279395
       279923
        
              sha256 = "1zc47qh38jmg19fdki9isjcq4v115w2q61dnmxkypahhgiaqgkb3";

     

       279924
       279924
       +
              revision = "1";

     

       279925
       279925
       +
              editedCabalFile = "0dm0ziv02wcwlgzp58kfa4i05xbq9v82ay6kjnzrf0n3z3pdpxbm";

     

       279396
       279926
        
              libraryHaskellDepends = [

     

       279397
       279927
        
                array base base-compat-batteries bifunctors bytestring

     

       279398
       279928
        
                bytestring-builder containers generic-deriving ghc-boot-th ghc-prim

     
···

       279459
       279989
        
              pname = "text-show-instances";

     

       279460
       279990
        
              version = "3.9";

     

       279461
       279991
        
              sha256 = "1bfangk4ys6pvhrv3j7i2c29xnhgin5lma2ndw051hnmmc7v2j7l";

     

       279462
       279462
       -
              revision = "1";

     

       279463
       279463
       -
              editedCabalFile = "1radrshv4flxlqsv36bz06pvw1l7nanqimfrx9rzspxcnldzv5q7";

     

       279992
       279992
       +
              revision = "2";

     

       279993
       279993
       +
              editedCabalFile = "0jmyq3pcxgwhqvhk16p7hz960f09ap2ym5iz2acnnc8ynyq6vvrf";

     

       279464
       279994
        
              libraryHaskellDepends = [

     

       279465
       279995
        
                base base-compat-batteries bifunctors binary containers directory

     

       279466
       279996
        
                ghc-boot-th haskeline hpc old-locale old-time pretty random

     
···

       279859
       280389
        
              license = lib.licenses.isc;

     

       279860
       280390
        
            }) {};

     

       279861
       280391
        
       

     

       280392
       280392
       +
         "th-abstraction_0_4_4_0" = callPackage

     

       280393
       280393
       +
           ({ mkDerivation, base, containers, ghc-prim, template-haskell }:

     

       280394
       280394
       +
            mkDerivation {

     

       280395
       280395
       +
              pname = "th-abstraction";

     

       280396
       280396
       +
              version = "0.4.4.0";

     

       280397
       280397
       +
              sha256 = "1nmgylmxgqc2hxjqcxqiws2qm8cimvc859b1fr341hn60an1d829";

     

       280398
       280398
       +
              libraryHaskellDepends = [

     

       280399
       280399
       +
                base containers ghc-prim template-haskell

     

       280400
       280400
       +
              ];

     

       280401
       280401
       +
              testHaskellDepends = [ base containers template-haskell ];

     

       280402
       280402
       +
              description = "Nicer interface for reified information about data types";

     

       280403
       280403
       +
              license = lib.licenses.isc;

     

       280404
       280404
       +
              hydraPlatforms = lib.platforms.none;

     

       280405
       280405
       +
            }) {};

     

       280406
       280406
       +
       

     

       279862
       280407
        
         "th-alpha" = callPackage

     

       279863
       280408
        
           ({ mkDerivation, base, containers, derive, mmorph, mtl, tasty

     

       279864
       280409
        
            , tasty-hunit, tasty-quickcheck, template-haskell, th-desugar

     
···

       279934
       280479
        
              license = lib.licenses.bsd3;

     

       279935
       280480
        
            }) {};

     

       279936
       280481
        
       

     

       280482
       280482
       +
         "th-compat_0_1_4" = callPackage

     

       280483
       280483
       +
           ({ mkDerivation, base, base-compat, directory, filepath, hspec

     

       280484
       280484
       +
            , hspec-discover, mtl, template-haskell

     

       280485
       280485
       +
            }:

     

       280486
       280486
       +
            mkDerivation {

     

       280487
       280487
       +
              pname = "th-compat";

     

       280488
       280488
       +
              version = "0.1.4";

     

       280489
       280489
       +
              sha256 = "1f5ssi24mnhmmi91dl5ddg2jwci6akwlznqggf56nyxl9b0pmyfq";

     

       280490
       280490
       +
              libraryHaskellDepends = [

     

       280491
       280491
       +
                base directory filepath template-haskell

     

       280492
       280492
       +
              ];

     

       280493
       280493
       +
              testHaskellDepends = [

     

       280494
       280494
       +
                base base-compat hspec mtl template-haskell

     

       280495
       280495
       +
              ];

     

       280496
       280496
       +
              testToolDepends = [ hspec-discover ];

     

       280497
       280497
       +
              description = "Backward- (and forward-)compatible Quote and Code types";

     

       280498
       280498
       +
              license = lib.licenses.bsd3;

     

       280499
       280499
       +
              hydraPlatforms = lib.platforms.none;

     

       280500
       280500
       +
            }) {};

     

       280501
       280501
       +
       

     

       279937
       280502
        
         "th-constraint-compat" = callPackage

     

       279938
       280503
        
           ({ mkDerivation, base, containers, template-haskell }:

     

       279939
       280504
        
            mkDerivation {

     
···

       280070
       280635
        
              testHaskellDepends = [ base template-haskell th-abstraction ];

     

       280071
       280636
        
              description = "Expands type synonyms in Template Haskell ASTs";

     

       280072
       280637
        
              license = lib.licenses.bsd3;

     

       280638
       280638
       +
            }) {};

     

       280639
       280639
       +
       

     

       280640
       280640
       +
         "th-expand-syns_0_4_10_0" = callPackage

     

       280641
       280641
       +
           ({ mkDerivation, base, containers, syb, template-haskell

     

       280642
       280642
       +
            , th-abstraction

     

       280643
       280643
       +
            }:

     

       280644
       280644
       +
            mkDerivation {

     

       280645
       280645
       +
              pname = "th-expand-syns";

     

       280646
       280646
       +
              version = "0.4.10.0";

     

       280647
       280647
       +
              sha256 = "044h1hv4b0ihpwr9wndj55fa843cbzqp1difgj9wyy3mw925higm";

     

       280648
       280648
       +
              libraryHaskellDepends = [

     

       280649
       280649
       +
                base containers syb template-haskell th-abstraction

     

       280650
       280650
       +
              ];

     

       280651
       280651
       +
              testHaskellDepends = [ base template-haskell th-abstraction ];

     

       280652
       280652
       +
              description = "Expands type synonyms in Template Haskell ASTs";

     

       280653
       280653
       +
              license = lib.licenses.bsd3;

     

       280654
       280654
       +
              hydraPlatforms = lib.platforms.none;

     

       280073
       280655
        
            }) {};

     

       280074
       280656
        
       

     

       280075
       280657
        
         "th-extras" = callPackage

     
···

       280238
       280820
        
              pname = "th-lift";

     

       280239
       280821
        
              version = "0.8.2";

     

       280240
       280822
        
              sha256 = "1r2wrnrn6qwy6ysyfnlqn6xbfckw0b22h8n00pk67bhhg81jfn9s";

     

       280241
       280241
       -
              revision = "1";

     

       280242
       280242
       -
              editedCabalFile = "1l8fsxbxfsgcy6qxlgn6qxwhiqwwmmaj2vb1gbrjyb905gb3lpwm";

     

       280823
       280823
       +
              revision = "2";

     

       280824
       280824
       +
              editedCabalFile = "1s95i774zy3q8yzk18ygdzhzky6wfcr7g55hd2g8h8lc05xzcdgi";

     

       280243
       280825
        
              libraryHaskellDepends = [

     

       280244
       280826
        
                base ghc-prim template-haskell th-abstraction

     

       280245
       280827
        
              ];

     
···

       289408
       289990
        
            }) {};

     

       289409
       289991
        
       

     

       289410
       289992
        
         "typelet" = callPackage

     

       289411
       289411
       -
           ({ mkDerivation, base, cabal-doctest, containers, ghc

     

       289412
       289412
       -
            , ghc-tcplugin-api, tasty, tasty-hunit, tasty-quickcheck

     

       289993
       289993
       +
           ({ mkDerivation, base, containers, ghc, ghc-tcplugin-api, tasty

     

       289994
       289994
       +
            , tasty-hunit, tasty-quickcheck

     

       289413
       289995
        
            }:

     

       289414
       289996
        
            mkDerivation {

     

       289415
       289997
        
              pname = "typelet";

     

       289416
       289416
       -
              version = "0.1.1.0";

     

       289417
       289417
       -
              sha256 = "1mgmlly0whdgbpjqa3smjgxhrlwqq971kka36i61ldkppb6ic2kj";

     

       289418
       289418
       -
              isLibrary = true;

     

       289419
       289419
       -
              isExecutable = true;

     

       289420
       289420
       -
              setupHaskellDepends = [ base cabal-doctest ];

     

       289998
       289998
       +
              version = "0.1.2";

     

       289999
       289999
       +
              sha256 = "09vxpwiz3hf876a5ymwvcq2n5dcxkzpna5srdk817051m715ys99";

     

       289421
       290000
        
              libraryHaskellDepends = [ base containers ghc ghc-tcplugin-api ];

     

       289422
       290001
        
              testHaskellDepends = [ base tasty tasty-hunit tasty-quickcheck ];

     

       289423
       290002
        
              description = "Plugin to faciliate type-level let";

     
···

       291227
       291806
        
           ({ mkDerivation, base, numeric-prelude, test-invariant }:

     

       291228
       291807
        
            mkDerivation {

     

       291229
       291808
        
              pname = "uniform-algebras";

     

       291230
       291230
       -
              version = "0.1.2";

     

       291231
       291231
       -
              sha256 = "16dpdhgzyxvi80h6wl68ggwi5msag6l8jasn8nxa4jky4nki50x4";

     

       291809
       291809
       +
              version = "0.1.3";

     

       291810
       291810
       +
              sha256 = "0y5x89qkbmzda4xxmg9zdk573vjz89h8iqia8p555cmachf18lf7";

     

       291232
       291811
        
              libraryHaskellDepends = [ base numeric-prelude test-invariant ];

     

       291233
       291812
        
              description = "Pointless functions and a simplistic zero and monoid";

     

       291234
       291813
        
              license = lib.licenses.gpl2Only;

     

       291235
       291814
        
            }) {};

     

       291236
       291815
        
       

     

       291237
       291816
        
         "uniform-error" = callPackage

     

       291238
       291238
       -
           ({ mkDerivation, base, monads-tf, safe, uniform-strings }:

     

       291817
       291817
       +
           ({ mkDerivation, base, HTF, safe, transformers, uniform-strings }:

     

       291239
       291818
        
            mkDerivation {

     

       291240
       291819
        
              pname = "uniform-error";

     

       291241
       291241
       -
              version = "0.1.0";

     

       291242
       291242
       -
              sha256 = "1ap8wrnh08yvv9hwd92mp1g5fz4g7l0aij1h0hfl3j7ijd028pmx";

     

       291243
       291243
       -
              libraryHaskellDepends = [ base monads-tf safe uniform-strings ];

     

       291820
       291820
       +
              version = "0.1.3";

     

       291821
       291821
       +
              sha256 = "0p9gplvnhfly0whdl0b0ydjpiyg7v5r5flkg4c02yqzsdxfp7sjf";

     

       291822
       291822
       +
              libraryHaskellDepends = [ base safe transformers uniform-strings ];

     

       291823
       291823
       +
              testHaskellDepends = [

     

       291824
       291824
       +
                base HTF safe transformers uniform-strings

     

       291825
       291825
       +
              ];

     

       291244
       291826
        
              description = "Handling errors in the uniform framework";

     

       291245
       291827
        
              license = lib.licenses.gpl2Only;

     

       291246
       291828
        
            }) {};

     

       291247
       291829
        
       

     

       291248
       291830
        
         "uniform-fileio" = callPackage

     

       291249
       291831
        
           ({ mkDerivation, base, bytestring, deepseq, directory, exceptions

     

       291250
       291250
       -
            , filepath, monads-tf, path, path-io, pipes, pureMD5, safe, text

     

       291251
       291251
       -
            , uniform-algebras, uniform-error, uniform-strings, uniform-time

     

       291252
       291252
       -
            , unix, zlib

     

       291832
       291832
       +
            , filepath, HTF, monads-tf, path, path-io, pipes, pureMD5

     

       291833
       291833
       +
            , quickcheck-text, safe, test-invariant, text, uniform-algebras

     

       291834
       291834
       +
            , uniform-error, uniform-strings, uniform-time, unix, zlib

     

       291253
       291835
        
            }:

     

       291254
       291836
        
            mkDerivation {

     

       291255
       291837
        
              pname = "uniform-fileio";

     

       291256
       291256
       -
              version = "0.1.2";

     

       291257
       291257
       -
              sha256 = "0i9lq07k9v7s119rj2xv5nz5zi7jq60bndvb9v5n6gvrn2zqfm3s";

     

       291838
       291838
       +
              version = "0.1.3";

     

       291839
       291839
       +
              sha256 = "08drclzs1g7w2cqsa16izs2nxa4pdkz5v1c2qbkwl03in9ga9v1v";

     

       291258
       291840
        
              libraryHaskellDepends = [

     

       291259
       291841
        
                base bytestring deepseq directory exceptions filepath monads-tf

     

       291260
       291842
        
                path path-io pipes pureMD5 safe text uniform-algebras uniform-error

     

       291261
       291843
        
                uniform-strings uniform-time unix zlib

     

       291844
       291844
       +
              ];

     

       291845
       291845
       +
              testHaskellDepends = [

     

       291846
       291846
       +
                base bytestring deepseq directory exceptions filepath HTF monads-tf

     

       291847
       291847
       +
                path path-io pipes pureMD5 quickcheck-text safe test-invariant text

     

       291848
       291848
       +
                uniform-algebras uniform-error uniform-strings uniform-time unix

     

       291849
       291849
       +
                zlib

     

       291262
       291850
        
              ];

     

       291263
       291851
        
              description = "Uniform file handling operations";

     

       291264
       291852
        
              license = lib.licenses.gpl2Only;

     
···

       291301
       291889
        
            }) {};

     

       291302
       291890
        
       

     

       291303
       291891
        
         "uniform-strings" = callPackage

     

       291304
       291304
       -
           ({ mkDerivation, base, bytestring, MissingH, monads-tf, network-uri

     

       291305
       291305
       -
            , pretty-show, safe, split, text, text-icu, uniform-algebras

     

       291892
       291892
       +
           ({ mkDerivation, base, bytestring, HTF, MissingH, monads-tf

     

       291893
       291893
       +
            , network-uri, pretty-show, quickcheck-text, safe, snap-core, split

     

       291894
       291894
       +
            , test-invariant, text, uniform-algebras

     

       291306
       291895
        
            }:

     

       291307
       291896
        
            mkDerivation {

     

       291308
       291897
        
              pname = "uniform-strings";

     

       291309
       291309
       -
              version = "0.1.2";

     

       291310
       291310
       -
              sha256 = "05x74a4mkyrpvbi4w3i0m1lj26d7mdcszdfdz4sixm69fg8jjh33";

     

       291898
       291898
       +
              version = "0.1.3.1";

     

       291899
       291899
       +
              sha256 = "1bh0n41sn0sgss85r890n2lysnb33xkf1qqxhs9498pd7gjzk5q7";

     

       291311
       291900
        
              libraryHaskellDepends = [

     

       291312
       291901
        
                base bytestring MissingH monads-tf network-uri pretty-show safe

     

       291313
       291313
       -
                split text text-icu uniform-algebras

     

       291902
       291902
       +
                snap-core split text uniform-algebras

     

       291903
       291903
       +
              ];

     

       291904
       291904
       +
              testHaskellDepends = [

     

       291905
       291905
       +
                base bytestring HTF MissingH monads-tf network-uri pretty-show

     

       291906
       291906
       +
                quickcheck-text safe snap-core split test-invariant text

     

       291907
       291907
       +
                uniform-algebras

     

       291314
       291908
        
              ];

     

       291315
       291909
        
              description = "Manipulate and convert strings of characters uniformly and consistently";

     

       291316
       291910
        
              license = lib.licenses.gpl2Only;

     
···

       291322
       291916
        
            }:

     

       291323
       291917
        
            mkDerivation {

     

       291324
       291918
        
              pname = "uniform-time";

     

       291325
       291325
       -
              version = "0.1.0";

     

       291326
       291326
       -
              sha256 = "08p40xl4zzswhax3i6j4ps0zy2m9qsbcpj4b00xvizc3g9fxnzsh";

     

       291919
       291919
       +
              version = "0.1.3";

     

       291920
       291920
       +
              sha256 = "0lygmp71933gdnydqg6p8gdnwvzh25p8dkx3jwvc3c0nh4jb1j9d";

     

       291327
       291921
        
              libraryHaskellDepends = [

     

       291328
       291922
        
                base convertible monads-tf time uniform-algebras uniform-error

     

       291329
       291923
        
                uniform-strings

     
···

       291333
       291927
        
            }) {};

     

       291334
       291928
        
       

     

       291335
       291929
        
         "uniformBase" = callPackage

     

       291336
       291336
       -
           ({ mkDerivation, base, uniform-algebras, uniform-error

     

       291337
       291337
       -
            , uniform-fileio, uniform-strings, uniform-time

     

       291930
       291930
       +
           ({ mkDerivation, base, data-default, uniform-algebras

     

       291931
       291931
       +
            , uniform-error, uniform-fileio, uniform-strings, uniform-time

     

       291338
       291932
        
            }:

     

       291339
       291933
        
            mkDerivation {

     

       291340
       291934
        
              pname = "uniformBase";

     

       291341
       291341
       -
              version = "0.1.3";

     

       291342
       291342
       -
              sha256 = "0gsms5zs28dhhn6jqdd5chb3liyp398kcyjb8z6hmyaprlc73pyl";

     

       291935
       291935
       +
              version = "0.1.4";

     

       291936
       291936
       +
              sha256 = "1j2fra8p5svb2g9fl86innfghvkvcdqa7dy2w0nszi0lvn5hf86h";

     

       291343
       291937
        
              libraryHaskellDepends = [

     

       291344
       291344
       -
                base uniform-algebras uniform-error uniform-fileio uniform-strings

     

       291345
       291345
       -
                uniform-time

     

       291938
       291938
       +
                base data-default uniform-algebras uniform-error uniform-fileio

     

       291939
       291939
       +
                uniform-strings uniform-time

     

       291346
       291940
        
              ];

     

       291347
       291941
        
              description = "A uniform base to build apps on";

     

       291348
       291942
        
              license = lib.licenses.gpl2Only;

     
···

       293591
       294185
        
              pname = "urlencoded";

     

       293592
       294186
        
              version = "0.5.0.0";

     

       293593
       294187
        
              sha256 = "0d1vj7w297cf9sk9x942za00f7ihqzcgbgjdbn7r9g0hz7qyl6nn";

     

       293594
       293594
       -
              revision = "1";

     

       293595
       293595
       -
              editedCabalFile = "0yskpdn6k4xj5qvgvqjblm6abg247ximk2kv7lswpkngbavlvyiq";

     

       294188
       294188
       +
              revision = "3";

     

       294189
       294189
       +
              editedCabalFile = "05vdcb1ffy1i2xl87w3079ckkj5l7bw1bqj25308pkw8b85amhv6";

     

       293596
       294190
        
              libraryHaskellDepends = [ base mtl network network-uri split ];

     

       293597
       294191
        
              testHaskellDepends = [ base network network-uri QuickCheck ];

     

       293598
       294192
        
              description = "Generate or process x-www-urlencoded data";

     
···

       295017
       295611
        
              license = lib.licenses.mit;

     

       295018
       295612
        
            }) {};

     

       295019
       295613
        
       

     

       295614
       295614
       +
         "validity-network-uri" = callPackage

     

       295615
       295615
       +
           ({ mkDerivation, base, network-uri, validity }:

     

       295616
       295616
       +
            mkDerivation {

     

       295617
       295617
       +
              pname = "validity-network-uri";

     

       295618
       295618
       +
              version = "0.0.0.0";

     

       295619
       295619
       +
              sha256 = "01ni4i1i16p20s2yx5pqlk4yw1byki04wb4vafx57n84fyd629mp";

     

       295620
       295620
       +
              libraryHaskellDepends = [ base network-uri validity ];

     

       295621
       295621
       +
              description = "Validity instances for URI";

     

       295622
       295622
       +
              license = lib.licenses.mit;

     

       295623
       295623
       +
              hydraPlatforms = lib.platforms.none;

     

       295624
       295624
       +
              broken = true;

     

       295625
       295625
       +
            }) {};

     

       295626
       295626
       +
       

     

       295020
       295627
        
         "validity-path" = callPackage

     

       295021
       295628
        
           ({ mkDerivation, base, filepath, genvalidity-hspec, hspec, path

     

       295022
       295629
        
            , validity

     
···

       295829
       296436
        
              pname = "vector-binary-instances";

     

       295830
       296437
        
              version = "0.2.5.2";

     

       295831
       296438
        
              sha256 = "0kgmlb4rf89b18d348cf2k06xfhdpamhmvq7iz5pab5014hknbmp";

     

       295832
       295832
       -
              revision = "1";

     

       295833
       295833
       -
              editedCabalFile = "0rbjskq11wlfa97h8bidzk145lkqrv00kx1rgwgdcfbgz1l73iha";

     

       296439
       296439
       +
              revision = "2";

     

       296440
       296440
       +
              editedCabalFile = "149gn5n722r2skj5w46av3944fbw3882qkaydq7asm6zx5kc0nj6";

     

       295834
       296441
        
              libraryHaskellDepends = [ base binary vector ];

     

       295835
       296442
        
              testHaskellDepends = [ base binary tasty tasty-quickcheck vector ];

     

       295836
       296443
        
              benchmarkHaskellDepends = [

+22

pkgs/top-level/haskell-packages.nix

···

       16
       16
        
           "native-bignum"

     

       17
       17
        
           "ghc902"

     

       18
       18
        
           "ghc923"

     

       19
       19
       +
           "ghc941"

     

       19
       20
        
           "ghcHEAD"

     

       20
       21
        
         ];

     

       21
       22
        
       

     

       22
       23
        
         nativeBignumIncludes = [

     

       23
       24
        
           "ghc902"

     

       24
       25
        
           "ghc923"

     

       26
       26
       +
           "ghc941"

     

       25
       27
        
           "ghcHEAD"

     

       26
       28
        
         ];

     

       27
       29
        
       

     
···

       153
       155
        
             buildTargetLlvmPackages = pkgsBuildTarget.llvmPackages_12;

     

       154
       156
        
             llvmPackages = pkgs.llvmPackages_12;

     

       155
       157
        
           };

     

       158
       158
       +
           ghc941 = callPackage ../development/compilers/ghc/9.4.1.nix {

     

       159
       159
       +
             bootPkgs =

     

       160
       160
       +
               # TODO(@sternenseemann): Package 9.0.2 bindist or wait for upstream fix

     

       161
       161
       +
               # Need to use 902 due to

     

       162
       162
       +
               # https://gitlab.haskell.org/ghc/ghc/-/issues/21914

     

       163
       163
       +
                 packages.ghc902;

     

       164
       164
       +
             inherit (buildPackages.python3Packages) sphinx;

     

       165
       165
       +
             # Need to use apple's patched xattr until

     

       166
       166
       +
             # https://github.com/xattr/xattr/issues/44 and

     

       167
       167
       +
             # https://github.com/xattr/xattr/issues/55 are solved.

     

       168
       168
       +
             inherit (buildPackages.darwin) xattr autoSignDarwinBinariesHook;

     

       169
       169
       +
             # Support range >= 10 && < 14

     

       170
       170
       +
             buildTargetLlvmPackages = pkgsBuildTarget.llvmPackages_12;

     

       171
       171
       +
             llvmPackages = pkgs.llvmPackages_12;

     

       172
       172
       +
           };

     

       156
       173
        
           ghcHEAD = callPackage ../development/compilers/ghc/head.nix {

     

       157
       174
        
             bootPkgs =

     

       158
       175
        
               if stdenv.hostPlatform.isPower64 && stdenv.hostPlatform.isLittleEndian then

     
···

       264
       281
        
             buildHaskellPackages = bh.packages.ghc923;

     

       265
       282
        
             ghc = bh.compiler.ghc923;

     

       266
       283
        
             compilerConfig = callPackage ../development/haskell-modules/configuration-ghc-9.2.x.nix { };

     

       284
       284
       +
           };

     

       285
       285
       +
           ghc941 = callPackage ../development/haskell-modules {

     

       286
       286
       +
             buildHaskellPackages = bh.packages.ghc941;

     

       287
       287
       +
             ghc = bh.compiler.ghc941;

     

       288
       288
       +
             compilerConfig = callPackage ../development/haskell-modules/configuration-ghc-9.4.x.nix { };

     

       267
       289
        
           };

     

       268
       290
        
           ghcHEAD = callPackage ../development/haskell-modules {

     

       269
       291
        
             buildHaskellPackages = bh.packages.ghcHEAD;