diff options
28 files changed, 2325 insertions, 726 deletions
diff --git a/doc/languages-frameworks/haskell.section.md b/doc/languages-frameworks/haskell.section.md index e8970b2d03354..247daf8d1dbe8 100644 --- a/doc/languages-frameworks/haskell.section.md +++ b/doc/languages-frameworks/haskell.section.md @@ -1076,6 +1076,9 @@ benchmark component. `disableLibraryProfiling drv` : Sets the `enableLibraryProfiling` argument to `false` for `drv`. +`disableParallelBuilding drv` +: Sets the `enableParallelBuilding` argument to `false` for `drv`. + #### Library functions in the Haskell package sets {#haskell-package-set-lib-functions} Some library functions depend on packages from the Haskell package sets. Thus they are diff --git a/pkgs/data/misc/hackage/pin.json b/pkgs/data/misc/hackage/pin.json index 6449d77aee043..97532fab180f9 100644 --- a/pkgs/data/misc/hackage/pin.json +++ b/pkgs/data/misc/hackage/pin.json @@ -1,6 +1,6 @@ { - "commit": "4670ba3f52eae6737137ddcb817182f3daad4f26", - "url": "https://github.com/commercialhaskell/all-cabal-hashes/archive/4670ba3f52eae6737137ddcb817182f3daad4f26.tar.gz", - "sha256": "18q5shdmh12147502135q6132rmzp29qfjhwrcjwidl0pi9ki70i", - "msg": "Update from Hackage at 2024-08-19T17:17:03Z" + "commit": "5d97d9c05e76d8cecb68f1e9063afb39ca0fb26b", + "url": "https://github.com/commercialhaskell/all-cabal-hashes/archive/5d97d9c05e76d8cecb68f1e9063afb39ca0fb26b.tar.gz", + "sha256": "1ic4wn5immv06m1m2cq6mzrrgrxbidxmj39licxlkmnm9jlwzjwr", + "msg": "Update from Hackage at 2024-09-03T10:29:19Z" } diff --git a/pkgs/development/compilers/ghc/8.10.7.nix b/pkgs/development/compilers/ghc/8.10.7.nix index d0f9130ff3feb..b769f55839b3e 100644 --- a/pkgs/development/compilers/ghc/8.10.7.nix +++ b/pkgs/development/compilers/ghc/8.10.7.nix @@ -1,4 +1,4 @@ -{ lib, stdenv, pkgsBuildTarget, pkgsHostTarget, targetPackages +{ lib, stdenv, pkgsBuildTarget, pkgsHostTarget, buildPackages, targetPackages # build-tools , bootPkgs @@ -39,7 +39,10 @@ enableShared ? !stdenv.targetPlatform.isWindows && !stdenv.targetPlatform.useiOSPrebuilt , # Whether to build terminfo. - enableTerminfo ? !stdenv.targetPlatform.isWindows + enableTerminfo ? !(stdenv.targetPlatform.isWindows + # terminfo can't be built for cross + || (stdenv.buildPlatform != stdenv.hostPlatform) + || (stdenv.hostPlatform != stdenv.targetPlatform)) , # What flavour to build. An empty string indicates no # specific flavour and falls back to ghc default values. @@ -55,25 +58,31 @@ , enableHaddockProgram ? # Disabled for cross; see note [HADDOCK_DOCS]. - (stdenv.targetPlatform == stdenv.hostPlatform) + (stdenv.buildPlatform == stdenv.hostPlatform && stdenv.targetPlatform == stdenv.hostPlatform) , # Whether to disable the large address space allocator # necessary fix for iOS: https://www.reddit.com/r/haskell/comments/4ttdz1/building_an_osxi386_to_iosarm64_cross_compiler/d5qvd67/ disableLargeAddressSpace ? stdenv.targetPlatform.isiOS + +, # Whether to build an unregisterised version of GHC. + # GHC will normally auto-detect whether it can do a registered build, but this + # option will force it to do an unregistered build when set to true. + # See https://gitlab.haskell.org/ghc/ghc/-/wikis/building/unregisterised + enableUnregisterised ? false }@args: assert !enableIntegerSimple -> gmp != null; # Cross cannot currently build the `haddock` program for silly reasons, # see note [HADDOCK_DOCS]. -assert (stdenv.targetPlatform != stdenv.hostPlatform) -> !enableHaddockProgram; +assert (stdenv.buildPlatform != stdenv.hostPlatform || stdenv.targetPlatform != stdenv.hostPlatform) -> !enableHaddockProgram; + +# GHC does not support building when all 3 platforms are different. +assert stdenv.buildPlatform == stdenv.hostPlatform || stdenv.hostPlatform == stdenv.targetPlatform; let - libffi_name = if stdenv.hostPlatform.isDarwin && stdenv.hostPlatform.isAarch64 then "libffi" else "libffi_3_3"; inherit (stdenv) buildPlatform hostPlatform targetPlatform; - inherit (bootPkgs) ghc; - # TODO(@Ericson2314) Make unconditional targetPrefix = lib.optionalString (targetPlatform != hostPlatform) @@ -86,6 +95,8 @@ let endif BUILD_SPHINX_HTML = ${if enableDocs then "YES" else "NO"} BUILD_SPHINX_PDF = NO + + WITH_TERMINFO = ${if enableTerminfo then "YES" else "NO"} '' + # Note [HADDOCK_DOCS]: # Unfortunately currently `HADDOCK_DOCS` controls both whether the `haddock` @@ -134,7 +145,9 @@ let pkgsBuildTarget.targetPackages.stdenv.cc ] ++ lib.optional useLLVM buildTargetLlvmPackages.llvm; + buildCC = buildPackages.stdenv.cc; targetCC = builtins.head toolsForTarget; + installCC = pkgsHostTarget.targetPackages.stdenv.cc; # toolPath calculates the absolute path to the name tool associated with a # given `stdenv.cc` derivation, i.e. it picks the correct derivation to take @@ -145,12 +158,13 @@ let tools = { "cc" = cc; "c++" = cc; - as = cc.bintools.bintools; + as = cc.bintools; - ar = cc.bintools.bintools; - ranlib = cc.bintools.bintools; - nm = cc.bintools.bintools; - readelf = cc.bintools.bintools; + ar = cc.bintools; + ranlib = cc.bintools; + nm = cc.bintools; + readelf = cc.bintools; + objdump = cc.bintools; ld = cc.bintools; "ld.gold" = cc.bintools; @@ -169,6 +183,9 @@ let if stdenv.targetPlatform.isDarwin then cc.bintools else cc.bintools.bintools; + + # clang is used as an assembler on darwin with the LLVM backend + clang = cc; }.${name}; in "${tools}/bin/${tools.targetPrefix}${name}"; @@ -185,14 +202,40 @@ let (lib.optionalString enableIntegerSimple "-integer-simple") ]; -in + libffi_name = + if stdenv.hostPlatform.isDarwin && stdenv.hostPlatform.isAarch64 + then "libffi" + else "libffi_3_3"; + + # These libraries are library dependencies of the standard libraries bundled + # by GHC (core libs) users will link their compiled artifacts again. Thus, + # they should be taken from targetPackages. + # + # We need to use pkgsHostTarget if we are cross compiling a native GHC compiler, + # though (when native compiling GHC, pkgsHostTarget == targetPackages): + # + # 1. targetPackages would be empty(-ish) in this situation since we can't + # execute cross compiled compilers in order to obtain the libraries + # that would be in targetPackages. + # 2. pkgsHostTarget is fine to use since hostPlatform == targetPlatform in this + # situation. + # 3. The core libs used by the final GHC (stage 2) for user artifacts are also + # used to build stage 2 GHC itself, i.e. the core libs are both host and + # target. + targetLibs = + let + basePackageSet = + if hostPlatform != targetPlatform + then targetPackages + else pkgsHostTarget; + in + { + inherit (basePackageSet) gmp ncurses; + # dynamic inherits are not possible in Nix + libffi = basePackageSet.${libffi_name}; + }; -# C compiler, bintools and LLVM are used at build time, but will also leak into -# the resulting GHC's settings file and used at runtime. This means that we are -# currently only able to build GHC if hostPlatform == buildPlatform. -assert targetCC == pkgsHostTarget.targetPackages.stdenv.cc; -assert buildTargetLlvmPackages.llvm == llvmPackages.llvm; -assert stdenv.targetPlatform.isDarwin -> buildTargetLlvmPackages.clang == llvmPackages.clang; +in stdenv.mkDerivation (rec { version = "8.10.7"; @@ -277,6 +320,8 @@ stdenv.mkDerivation (rec { for env in $(env | grep '^TARGET_' | sed -E 's|\+?=.*||'); do export "''${env#TARGET_}=''${!env}" done + # Stage0 (build->build) which builds stage 1 + export GHC="${bootPkgs.ghc}/bin/ghc" # GHC is a bit confused on its cross terminology, as these would normally be # the *host* tools. export CC="${toolPath "cc" targetCC}" @@ -289,6 +334,7 @@ stdenv.mkDerivation (rec { export RANLIB="${toolPath "ranlib" targetCC}" export READELF="${toolPath "readelf" targetCC}" export STRIP="${toolPath "strip" targetCC}" + export OBJDUMP="${toolPath "objdump" targetCC}" '' + lib.optionalString (stdenv.targetPlatform.linker == "cctools") '' export OTOOL="${toolPath "otool" targetCC}" export INSTALL_NAME_TOOL="${toolPath "install_name_tool" targetCC}" @@ -297,8 +343,22 @@ stdenv.mkDerivation (rec { export OPT="${lib.getBin buildTargetLlvmPackages.llvm}/bin/opt" '' + lib.optionalString (useLLVM && stdenv.targetPlatform.isDarwin) '' # LLVM backend on Darwin needs clang: https://downloads.haskell.org/~ghc/latest/docs/html/users_guide/codegens.html#llvm-code-generator-fllvm - export CLANG="${buildTargetLlvmPackages.clang}/bin/${buildTargetLlvmPackages.clang.targetPrefix}clang" + # The executable we specify via $CLANG is used as an assembler (exclusively, it seems, but this isn't + # clarified in any user facing documentation). As such, it'll be called on assembly produced by $CC + # which usually comes from the darwin stdenv. To prevent a situation where $CLANG doesn't understand + # the assembly it is given, we need to make sure that it matches the LLVM version of $CC if possible. + # It is unclear (at the time of writing 2024-09-01) whether $CC should match the LLVM version we use + # for llc and opt which would require using a custom darwin stdenv for targetCC. + export CLANG="${ + if targetCC.isClang + then toolPath "clang" targetCC + else "${buildTargetLlvmPackages.clang}/bin/${buildTargetLlvmPackages.clang.targetPrefix}clang" + }" '' + '' + # No need for absolute paths since these tools only need to work during the build + export CC_STAGE0="$CC_FOR_BUILD" + export LD_STAGE0="$LD_FOR_BUILD" + export AR_STAGE0="$AR_FOR_BUILD" echo -n "${buildMK}" > mk/build.mk sed -i -e 's|-isysroot /Developer/SDKs/MacOSX10.5.sdk||' configure @@ -329,21 +389,26 @@ stdenv.mkDerivation (rec { done ''; + # Although it is usually correct to pass --host, we don't do that here because + # GHC's usage of build, host, and target is non-standard. + # See https://gitlab.haskell.org/ghc/ghc/-/wikis/building/cross-compiling # TODO(@Ericson2314): Always pass "--target" and always prefix. - configurePlatforms = [ "build" "host" ] - ++ lib.optional (targetPlatform != hostPlatform) "target"; + configurePlatforms = [ "build" ] + ++ lib.optional (buildPlatform != hostPlatform || targetPlatform != hostPlatform) "target"; # `--with` flags for libraries needed for RTS linker configureFlags = [ "--datadir=$doc/share/doc/ghc" - "--with-curses-includes=${ncurses.dev}/include" "--with-curses-libraries=${ncurses.out}/lib" + ] ++ lib.optionals enableTerminfo [ + "--with-curses-includes=${lib.getDev targetLibs.ncurses}/include" + "--with-curses-libraries=${lib.getLib targetLibs.ncurses}/lib" ] ++ lib.optionals (args.${libffi_name} != null) [ "--with-system-libffi" - "--with-ffi-includes=${targetPackages.${libffi_name}.dev}/include" - "--with-ffi-libraries=${targetPackages.${libffi_name}.out}/lib" + "--with-ffi-includes=${targetLibs.libffi.dev}/include" + "--with-ffi-libraries=${targetLibs.libffi.out}/lib" ] ++ lib.optionals (targetPlatform == hostPlatform && !enableIntegerSimple) [ - "--with-gmp-includes=${targetPackages.gmp.dev}/include" - "--with-gmp-libraries=${targetPackages.gmp.out}/lib" + "--with-gmp-includes=${targetLibs.gmp.dev}/include" + "--with-gmp-libraries=${targetLibs.gmp.out}/lib" ] ++ lib.optionals (targetPlatform == hostPlatform && hostPlatform.libc != "glibc" && !targetPlatform.isWindows) [ "--with-iconv-includes=${libiconv}/include" "--with-iconv-libraries=${libiconv}/lib" @@ -355,6 +420,8 @@ stdenv.mkDerivation (rec { "CONF_GCC_LINKER_OPTS_STAGE2=-fuse-ld=gold" ] ++ lib.optionals (disableLargeAddressSpace) [ "--disable-large-address-space" + ] ++ lib.optionals enableUnregisterised [ + "--enable-unregisterised" ]; # Make sure we never relax`$PATH` and hooks support for compatibility. @@ -365,17 +432,35 @@ stdenv.mkDerivation (rec { nativeBuildInputs = [ perl autoreconfHook autoconf automake m4 python3 - ghc bootPkgs.alex bootPkgs.happy bootPkgs.hscolour + bootPkgs.alex bootPkgs.happy bootPkgs.hscolour + bootPkgs.ghc-settings-edit ] ++ lib.optionals (stdenv.hostPlatform.isDarwin && stdenv.hostPlatform.isAarch64) [ autoSignDarwinBinariesHook ] ++ lib.optionals enableDocs [ sphinx ]; + # Everything the stage0 compiler needs to build stage1: CC, bintools, extra libs. + # See also GHC, {CC,LD,AR}_STAGE0 in preConfigure. + depsBuildBuild = [ + # N.B. We do not declare bootPkgs.ghc in any of the stdenv.mkDerivation + # dependency lists to prevent the bintools setup hook from adding ghc's + # lib directory to the linker flags. Instead we tell configure about it + # via the GHC environment variable. + buildCC + # stage0 builds terminfo unconditionally, so we always need ncurses + ncurses + ]; # For building runtime libs depsBuildTarget = toolsForTarget; - buildInputs = [ perl bash ] ++ (libDeps hostPlatform); + # Prevent stage0 ghc from leaking into the final result. This was an issue + # with GHC 9.6. + disallowedReferences = [ + bootPkgs.ghc + ]; + + buildInputs = [ bash ] ++ (libDeps hostPlatform); depsTargetTarget = map lib.getDev (libDeps targetPlatform); depsTargetTargetPropagated = map (lib.getOutput "out") (libDeps targetPlatform); @@ -402,6 +487,39 @@ stdenv.mkDerivation (rec { requiredSystemFeatures = [ "big-parallel" ]; postInstall = '' + settingsFile="$out/lib/${targetPrefix}${passthru.haskellCompilerName}/settings" + + # Make the installed GHC use the host->target tools. + ghc-settings-edit "$settingsFile" \ + "C compiler command" "${toolPath "cc" installCC}" \ + "Haskell CPP command" "${toolPath "cc" installCC}" \ + "C++ compiler command" "${toolPath "c++" installCC}" \ + "ld command" "${toolPath "ld${lib.optionalString useLdGold ".gold"}" installCC}" \ + "Merge objects command" "${toolPath "ld${lib.optionalString useLdGold ".gold"}" installCC}" \ + "ar command" "${toolPath "ar" installCC}" \ + "ranlib command" "${toolPath "ranlib" installCC}" + '' + + lib.optionalString (stdenv.targetPlatform.linker == "cctools") '' + ghc-settings-edit "$settingsFile" \ + "otool command" "${toolPath "otool" installCC}" \ + "install_name_tool command" "${toolPath "install_name_tool" installCC}" + '' + + lib.optionalString useLLVM '' + ghc-settings-edit "$settingsFile" \ + "LLVM llc command" "${lib.getBin llvmPackages.llvm}/bin/llc" \ + "LLVM opt command" "${lib.getBin llvmPackages.llvm}/bin/opt" + '' + + lib.optionalString (useLLVM && stdenv.targetPlatform.isDarwin) '' + ghc-settings-edit "$settingsFile" \ + "LLVM clang command" "${ + # See comment for CLANG in preConfigure + if installCC.isClang + then toolPath "clang" installCC + else "${llvmPackages.clang}/bin/${llvmPackages.clang.targetPrefix}clang" + }" + '' + + '' + # Install the bash completion file. install -D -m 444 utils/completion/ghc.bash $out/share/bash-completion/completions/${targetPrefix}ghc ''; @@ -427,7 +545,8 @@ stdenv.mkDerivation (rec { guibou ] ++ lib.teams.haskell.members; timeout = 24 * 3600; - inherit (ghc.meta) license platforms; + platforms = lib.platforms.all; + inherit (bootPkgs.ghc.meta) license; }; } // lib.optionalAttrs targetPlatform.useAndroidPrebuilt { diff --git a/pkgs/development/compilers/ghc/common-hadrian.nix b/pkgs/development/compilers/ghc/common-hadrian.nix index 31d1e52ea95bb..dd7ffaa532d75 100644 --- a/pkgs/development/compilers/ghc/common-hadrian.nix +++ b/pkgs/development/compilers/ghc/common-hadrian.nix @@ -12,6 +12,7 @@ , stdenv , pkgsBuildTarget , pkgsHostTarget +, buildPackages , targetPackages , fetchpatch @@ -65,8 +66,14 @@ enableShared ? with stdenv.targetPlatform; !isWindows && !useiOSPrebuilt && !isStatic && !isGhcjs , # Whether to build terminfo. + # FIXME(@sternenseemann): This actually doesn't influence what hadrian does, + # just what buildInputs etc. looks like. It would be best if we could actually + # tell it what to do like it was possible with make. enableTerminfo ? !(stdenv.targetPlatform.isWindows - || stdenv.targetPlatform.isGhcjs) + || stdenv.targetPlatform.isGhcjs + # terminfo can't be built for cross + || (stdenv.buildPlatform != stdenv.hostPlatform) + || (stdenv.hostPlatform != stdenv.targetPlatform)) , # Libdw.c only supports x86_64, i686 and s390x as of 2022-08-04 enableDwarf ? (stdenv.targetPlatform.isx86 || @@ -117,9 +124,8 @@ -- no way to set this via the command line finalStage :: Stage finalStage = ${ - # Always build the stage 2 compiler if possible. Note we can currently - # assume hostPlatform == buildPlatform. - # TODO(@sternenseemann): improve this condition when we can cross-compile GHC + # Always build the stage 2 compiler if possible. + # TODO(@sternensemann): unify condition with make-built GHCs if stdenv.hostPlatform.canExecute stdenv.targetPlatform then "Stage2" # native compiler or “native” cross e.g. pkgsStatic else "Stage1" # cross compiler @@ -178,6 +184,15 @@ hash = "sha256-MpvTmFFsNiPDoOp9BhZyWeapeibQ77zgEV+xzZ1UAXs="; }) ] + ++ lib.optionals (lib.versionAtLeast version "9.6" && lib.versionOlder version "9.8") [ + # Fix unlit being installed under a different name than is used in the + # settings file: https://gitlab.haskell.org/ghc/ghc/-/issues/23317 + (fetchpatch { + name = "ghc-9.6-fix-unlit-path.patch"; + url = "https://gitlab.haskell.org/ghc/ghc/-/commit/8fde4ac84ec7b1ead238cb158bbef48555d12af9.patch"; + hash = "sha256-3+CyRBpebEZi8YpS22SsdGQHqi0drR7cCKPtKbR3zyE="; + }) + ] ++ lib.optionals (stdenv.targetPlatform.isDarwin && stdenv.targetPlatform.isAarch64) [ # Prevent the paths module from emitting symbols that we don't use # when building with separate outputs. @@ -222,15 +237,25 @@ , # Whether to disable the large address space allocator # necessary fix for iOS: https://www.reddit.com/r/haskell/comments/4ttdz1/building_an_osxi386_to_iosarm64_cross_compiler/d5qvd67/ disableLargeAddressSpace ? stdenv.targetPlatform.isiOS + +, # Whether to build an unregisterised version of GHC. + # GHC will normally auto-detect whether it can do a registered build, but this + # option will force it to do an unregistered build when set to true. + # See https://gitlab.haskell.org/ghc/ghc/-/wikis/building/unregisterised + enableUnregisterised ? false }: assert !enableNativeBignum -> gmp != null; +# GHC does not support building when all 3 platforms are different. +assert stdenv.buildPlatform == stdenv.hostPlatform || stdenv.hostPlatform == stdenv.targetPlatform; + +# It is currently impossible to cross-compile GHC with Hadrian. +assert stdenv.buildPlatform == stdenv.hostPlatform; + let inherit (stdenv) buildPlatform hostPlatform targetPlatform; - inherit (bootPkgs) ghc; - # TODO(@Ericson2314) Make unconditional targetPrefix = lib.optionalString (targetPlatform != hostPlatform) @@ -265,7 +290,12 @@ let else pkgsBuildTarget.targetPackages.stdenv.cc) ] ++ lib.optional useLLVM buildTargetLlvmPackages.llvm; + buildCC = buildPackages.stdenv.cc; targetCC = builtins.head toolsForTarget; + installCC = + if targetPlatform.isGhcjs + then pkgsHostTarget.emscripten + else pkgsHostTarget.targetPackages.stdenv.cc; # toolPath calculates the absolute path to the name tool associated with a # given `stdenv.cc` derivation, i.e. it picks the correct derivation to take @@ -276,12 +306,13 @@ let tools = { "cc" = cc; "c++" = cc; - as = cc.bintools.bintools; + as = cc.bintools; - ar = cc.bintools.bintools; - ranlib = cc.bintools.bintools; - nm = cc.bintools.bintools; - readelf = cc.bintools.bintools; + ar = cc.bintools; + ranlib = cc.bintools; + nm = cc.bintools; + readelf = cc.bintools; + objdump = cc.bintools; ld = cc.bintools; "ld.gold" = cc.bintools; @@ -300,6 +331,9 @@ let if stdenv.targetPlatform.isDarwin then cc.bintools else cc.bintools.bintools; + + # clang is used as an assembler on darwin with the LLVM backend + clang = cc; }.${name}; in "${tools}/bin/${tools.targetPrefix}${name}"; @@ -316,14 +350,34 @@ let (lib.optionalString enableNativeBignum "-native-bignum") ]; -in + # These libraries are library dependencies of the standard libraries bundled + # by GHC (core libs) users will link their compiled artifacts again. Thus, + # they should be taken from targetPackages. + # + # We need to use pkgsHostTarget if we are cross compiling a native GHC compiler, + # though (when native compiling GHC, pkgsHostTarget == targetPackages): + # + # 1. targetPackages would be empty(-ish) in this situation since we can't + # execute cross compiled compilers in order to obtain the libraries + # that would be in targetPackages. + # 2. pkgsHostTarget is fine to use since hostPlatform == targetPlatform in this + # situation. + # 3. The core libs used by the final GHC (stage 2) for user artifacts are also + # used to build stage 2 GHC itself, i.e. the core libs are both host and + # target. + targetLibs = { + inherit + (if hostPlatform != targetPlatform then targetPackages else pkgsHostTarget) + elfutils + gmp + libffi + ncurses; + }; + + # Our Cabal compiler name + haskellCompilerName = "ghc-${version}"; -# C compiler, bintools and LLVM are used at build time, but will also leak into -# the resulting GHC's settings file and used at runtime. This means that we are -# currently only able to build GHC if hostPlatform == buildPlatform. -assert !targetPlatform.isGhcjs -> targetCC == pkgsHostTarget.targetPackages.stdenv.cc; -assert buildTargetLlvmPackages.llvm == llvmPackages.llvm; -assert stdenv.targetPlatform.isDarwin -> buildTargetLlvmPackages.clang == llvmPackages.clang; +in stdenv.mkDerivation ({ pname = "${targetPrefix}ghc${variantSuffix}"; @@ -346,6 +400,13 @@ stdenv.mkDerivation ({ for env in $(env | grep '^TARGET_' | sed -E 's|\+?=.*||'); do export "''${env#TARGET_}=''${!env}" done + # No need for absolute paths since these tools only need to work during the build + export CC_STAGE0="$CC_FOR_BUILD" + export LD_STAGE0="$LD_FOR_BUILD" + export AR_STAGE0="$AR_FOR_BUILD" + + # Stage0 (build->build) which builds stage 1 + export GHC="${bootPkgs.ghc}/bin/ghc" # GHC is a bit confused on its cross terminology, as these would normally be # the *host* tools. export CC="${toolPath "cc" targetCC}" @@ -358,6 +419,7 @@ stdenv.mkDerivation ({ export RANLIB="${toolPath "ranlib" targetCC}" export READELF="${toolPath "readelf" targetCC}" export STRIP="${toolPath "strip" targetCC}" + export OBJDUMP="${toolPath "objdump" targetCC}" '' + lib.optionalString (stdenv.targetPlatform.linker == "cctools") '' export OTOOL="${toolPath "otool" targetCC}" export INSTALL_NAME_TOOL="${toolPath "install_name_tool" targetCC}" @@ -366,7 +428,17 @@ stdenv.mkDerivation ({ export OPT="${lib.getBin buildTargetLlvmPackages.llvm}/bin/opt" '' + lib.optionalString (useLLVM && stdenv.targetPlatform.isDarwin) '' # LLVM backend on Darwin needs clang: https://downloads.haskell.org/~ghc/latest/docs/html/users_guide/codegens.html#llvm-code-generator-fllvm - export CLANG="${buildTargetLlvmPackages.clang}/bin/${buildTargetLlvmPackages.clang.targetPrefix}clang" + # The executable we specify via $CLANG is used as an assembler (exclusively, it seems, but this isn't + # clarified in any user facing documentation). As such, it'll be called on assembly produced by $CC + # which usually comes from the darwin stdenv. To prevent a situation where $CLANG doesn't understand + # the assembly it is given, we need to make sure that it matches the LLVM version of $CC if possible. + # It is unclear (at the time of writing 2024-09-01) whether $CC should match the LLVM version we use + # for llc and opt which would require using a custom darwin stdenv for targetCC. + export CLANG="${ + if targetCC.isClang + then toolPath "clang" targetCC + else "${buildTargetLlvmPackages.clang}/bin/${buildTargetLlvmPackages.clang.targetPrefix}clang" + }" '' + lib.optionalString (stdenv.hostPlatform.isLinux && hostPlatform.libc == "glibc") '' export LOCALE_ARCHIVE="${glibcLocales}/lib/locale/locale-archive" @@ -433,14 +505,16 @@ stdenv.mkDerivation ({ # `--with` flags for libraries needed for RTS linker configureFlags = [ "--datadir=$doc/share/doc/ghc" - "--with-curses-includes=${ncurses.dev}/include" "--with-curses-libraries=${ncurses.out}/lib" + ] ++ lib.optionals enableTerminfo [ + "--with-curses-includes=${lib.getDev targetLibs.ncurses}/include" + "--with-curses-libraries=${lib.getLib targetLibs.ncurses}/lib" ] ++ lib.optionals (libffi != null && !targetPlatform.isGhcjs) [ "--with-system-libffi" - "--with-ffi-includes=${targetPackages.libffi.dev}/include" - "--with-ffi-libraries=${targetPackages.libffi.out}/lib" + "--with-ffi-includes=${targetLibs.libffi.dev}/include" + "--with-ffi-libraries=${targetLibs.libffi.out}/lib" ] ++ lib.optionals (targetPlatform == hostPlatform && !enableNativeBignum) [ - "--with-gmp-includes=${targetPackages.gmp.dev}/include" - "--with-gmp-libraries=${targetPackages.gmp.out}/lib" + "--with-gmp-includes=${targetLibs.gmp.dev}/include" + "--with-gmp-libraries=${targetLibs.gmp.out}/lib" ] ++ lib.optionals (targetPlatform == hostPlatform && hostPlatform.libc != "glibc" && !targetPlatform.isWindows) [ "--with-iconv-includes=${libiconv}/include" "--with-iconv-libraries=${libiconv}/lib" @@ -454,14 +528,16 @@ stdenv.mkDerivation ({ "--disable-large-address-space" ] ++ lib.optionals enableDwarf [ "--enable-dwarf-unwind" - "--with-libdw-includes=${lib.getDev targetPackages.elfutils}/include" - "--with-libdw-libraries=${lib.getLib targetPackages.elfutils}/lib" + "--with-libdw-includes=${lib.getDev targetLibs.elfutils}/include" + "--with-libdw-libraries=${lib.getLib targetLibs.elfutils}/lib" ] ++ lib.optionals targetPlatform.isDarwin [ # Darwin uses llvm-ar. GHC will try to use `-L` with `ar` when it is `llvm-ar` # but it doesn’t currently work because Cabal never uses `-L` on Darwin. See: # https://gitlab.haskell.org/ghc/ghc/-/issues/23188 # https://github.com/haskell/cabal/issues/8882 "fp_cv_prog_ar_supports_dash_l=no" + ] ++ lib.optionals enableUnregisterised [ + "--enable-unregisterised" ]; # Make sure we never relax`$PATH` and hooks support for compatibility. @@ -471,11 +547,13 @@ stdenv.mkDerivation ({ dontAddExtraLibs = true; nativeBuildInputs = [ - perl ghc hadrian bootPkgs.alex bootPkgs.happy bootPkgs.hscolour + perl hadrian bootPkgs.alex bootPkgs.happy bootPkgs.hscolour # autoconf and friends are necessary for hadrian to create the bindist autoconf automake m4 # Python is used in a few scripts invoked by hadrian to generate e.g. rts headers. python3 + # Tool used to update GHC's settings file in postInstall + bootPkgs.ghc-settings-edit ] ++ lib.optionals (stdenv.hostPlatform.isDarwin && stdenv.hostPlatform.isAarch64) [ autoSignDarwinBinariesHook ] ++ lib.optionals enableDocs [ @@ -484,8 +562,25 @@ stdenv.mkDerivation ({ # For building runtime libs depsBuildTarget = toolsForTarget; + # Everything the stage0 compiler needs to build stage1: CC, bintools, extra libs. + # See also GHC, {CC,LD,AR}_STAGE0 in preConfigure. + depsBuildBuild = [ + # N.B. We do not declare bootPkgs.ghc in any of the stdenv.mkDerivation + # dependency lists to prevent the bintools setup hook from adding ghc's + # lib directory to the linker flags. Instead we tell configure about it + # via the GHC environment variable. + buildCC + # stage0 builds terminfo unconditionally, so we always need ncurses + ncurses + ]; + + # Prevent stage0 ghc from leaking into the final result. This was an issue + # with GHC 9.6. + disallowedReferences = [ + bootPkgs.ghc + ]; - buildInputs = [ perl bash ] ++ (libDeps hostPlatform); + buildInputs = [ bash ] ++ (libDeps hostPlatform); depsTargetTarget = map lib.getDev (libDeps targetPlatform); depsTargetTargetPropagated = map (lib.getOutput "out") (libDeps targetPlatform); @@ -553,19 +648,49 @@ stdenv.mkDerivation ({ # leave bindist directory popd + settingsFile="$out/lib/${targetPrefix}${haskellCompilerName}/lib/settings" + + # Make the installed GHC use the host->target tools. + ghc-settings-edit "$settingsFile" \ + "C compiler command" "${toolPath "cc" installCC}" \ + "Haskell CPP command" "${toolPath "cc" installCC}" \ + "C++ compiler command" "${toolPath "c++" installCC}" \ + "ld command" "${toolPath "ld${lib.optionalString useLdGold ".gold"}" installCC}" \ + "Merge objects command" "${toolPath "ld${lib.optionalString useLdGold ".gold"}" installCC}" \ + "ar command" "${toolPath "ar" installCC}" \ + "ranlib command" "${toolPath "ranlib" installCC}" + '' + + lib.optionalString (stdenv.targetPlatform.linker == "cctools") '' + ghc-settings-edit "$settingsFile" \ + "otool command" "${toolPath "otool" installCC}" \ + "install_name_tool command" "${toolPath "install_name_tool" installCC}" + '' + + lib.optionalString useLLVM '' + ghc-settings-edit "$settingsFile" \ + "LLVM llc command" "${lib.getBin llvmPackages.llvm}/bin/llc" \ + "LLVM opt command" "${lib.getBin llvmPackages.llvm}/bin/opt" + '' + + lib.optionalString (useLLVM && stdenv.targetPlatform.isDarwin) '' + ghc-settings-edit "$settingsFile" \ + "LLVM clang command" "${ + # See comment for CLANG in preConfigure + if installCC.isClang + then toolPath "clang" installCC + else "${llvmPackages.clang}/bin/${llvmPackages.clang.targetPrefix}clang" + }" + '' + + '' + # Install the bash completion file. install -Dm 644 utils/completion/ghc.bash $out/share/bash-completion/completions/${targetPrefix}ghc ''; passthru = { - inherit bootPkgs targetPrefix; + inherit bootPkgs targetPrefix haskellCompilerName; inherit llvmPackages; inherit enableShared; - # Our Cabal compiler name - haskellCompilerName = "ghc-${version}"; - # Expose hadrian used for bootstrapping, for debugging purposes inherit hadrian; @@ -581,7 +706,8 @@ stdenv.mkDerivation ({ guibou ] ++ lib.teams.haskell.members; timeout = 24 * 3600; - inherit (ghc.meta) license platforms; + platforms = lib.platforms.all; + inherit (bootPkgs.ghc.meta) license; }; dontStrip = targetPlatform.useAndroidPrebuilt || targetPlatform.isWasm; diff --git a/pkgs/development/compilers/ghc/common-make-native-bignum.nix b/pkgs/development/compilers/ghc/common-make-native-bignum.nix index f6b6c33e9f9fd..223b9d8244ff9 100644 --- a/pkgs/development/compilers/ghc/common-make-native-bignum.nix +++ b/pkgs/development/compilers/ghc/common-make-native-bignum.nix @@ -3,7 +3,7 @@ , url ? "https://downloads.haskell.org/ghc/${version}/ghc-${version}-src.tar.xz" }: -{ lib, stdenv, pkgsBuildTarget, pkgsHostTarget, targetPackages +{ lib, stdenv, pkgsBuildTarget, pkgsHostTarget, buildPackages, targetPackages # build-tools , bootPkgs @@ -42,7 +42,10 @@ enableShared ? with stdenv.targetPlatform; !isWindows && !useiOSPrebuilt && !isStatic , # Whether to build terminfo. - enableTerminfo ? !stdenv.targetPlatform.isWindows + enableTerminfo ? !(stdenv.targetPlatform.isWindows + # terminfo can't be built for cross + || (stdenv.buildPlatform != stdenv.hostPlatform) + || (stdenv.hostPlatform != stdenv.targetPlatform)) , # What flavour to build. An empty string indicates no # specific flavour and falls back to ghc default values. @@ -58,24 +61,33 @@ , enableHaddockProgram ? # Disabled for cross; see note [HADDOCK_DOCS]. - (stdenv.targetPlatform == stdenv.hostPlatform) + (stdenv.buildPlatform == stdenv.hostPlatform && stdenv.targetPlatform == stdenv.hostPlatform) , # Whether to disable the large address space allocator # necessary fix for iOS: https://www.reddit.com/r/haskell/comments/4ttdz1/building_an_osxi386_to_iosarm64_cross_compiler/d5qvd67/ disableLargeAddressSpace ? stdenv.targetPlatform.isiOS + +, # Whether to build an unregisterised version of GHC. + # GHC will normally auto-detect whether it can do a registered build, but this + # option will force it to do an unregistered build when set to true. + # See https://gitlab.haskell.org/ghc/ghc/-/wikis/building/unregisterised + # Registerised RV64 compiler produces programs that segfault + # See https://gitlab.haskell.org/ghc/ghc/-/issues/23957 + enableUnregisterised ? stdenv.hostPlatform.isRiscV64 || stdenv.targetPlatform.isRiscV64 }: assert !enableNativeBignum -> gmp != null; # Cross cannot currently build the `haddock` program for silly reasons, # see note [HADDOCK_DOCS]. -assert (stdenv.targetPlatform != stdenv.hostPlatform) -> !enableHaddockProgram; +assert (stdenv.buildPlatform != stdenv.hostPlatform || stdenv.targetPlatform != stdenv.hostPlatform) -> !enableHaddockProgram; + +# GHC does not support building when all 3 platforms are different. +assert stdenv.buildPlatform == stdenv.hostPlatform || stdenv.hostPlatform == stdenv.targetPlatform; let inherit (stdenv) buildPlatform hostPlatform targetPlatform; - inherit (bootPkgs) ghc; - # TODO(@Ericson2314) Make unconditional targetPrefix = lib.optionalString (targetPlatform != hostPlatform) @@ -88,6 +100,8 @@ let endif BUILD_SPHINX_HTML = ${if enableDocs then "YES" else "NO"} BUILD_SPHINX_PDF = NO + + WITH_TERMINFO = ${if enableTerminfo then "YES" else "NO"} '' + # Note [HADDOCK_DOCS]: # Unfortunately currently `HADDOCK_DOCS` controls both whether the `haddock` @@ -134,7 +148,9 @@ let pkgsBuildTarget.targetPackages.stdenv.cc ] ++ lib.optional useLLVM buildTargetLlvmPackages.llvm; + buildCC = buildPackages.stdenv.cc; targetCC = builtins.head toolsForTarget; + installCC = pkgsHostTarget.targetPackages.stdenv.cc; # toolPath calculates the absolute path to the name tool associated with a # given `stdenv.cc` derivation, i.e. it picks the correct derivation to take @@ -145,12 +161,13 @@ let tools = { "cc" = cc; "c++" = cc; - as = cc.bintools.bintools; + as = cc.bintools; - ar = cc.bintools.bintools; - ranlib = cc.bintools.bintools; - nm = cc.bintools.bintools; - readelf = cc.bintools.bintools; + ar = cc.bintools; + ranlib = cc.bintools; + nm = cc.bintools; + readelf = cc.bintools; + objdump = cc.bintools; ld = cc.bintools; "ld.gold" = cc.bintools; @@ -169,6 +186,9 @@ let if stdenv.targetPlatform.isDarwin then cc.bintools else cc.bintools.bintools; + + # clang is used as an assembler on darwin with the LLVM backend + clang = cc; }.${name}; in "${tools}/bin/${tools.targetPrefix}${name}"; @@ -185,14 +205,30 @@ let (lib.optionalString enableNativeBignum "-native-bignum") ]; -in + # These libraries are library dependencies of the standard libraries bundled + # by GHC (core libs) users will link their compiled artifacts again. Thus, + # they should be taken from targetPackages. + # + # We need to use pkgsHostTarget if we are cross compiling a native GHC compiler, + # though (when native compiling GHC, pkgsHostTarget == targetPackages): + # + # 1. targetPackages would be empty(-ish) in this situation since we can't + # execute cross compiled compilers in order to obtain the libraries + # that would be in targetPackages. + # 2. pkgsHostTarget is fine to use since hostPlatform == targetPlatform in this + # situation. + # 3. The core libs used by the final GHC (stage 2) for user artifacts are also + # used to build stage 2 GHC itself, i.e. the core libs are both host and + # target. + targetLibs = { + inherit + (if hostPlatform != targetPlatform then targetPackages else pkgsHostTarget) + gmp + libffi + ncurses; + }; -# C compiler, bintools and LLVM are used at build time, but will also leak into -# the resulting GHC's settings file and used at runtime. This means that we are -# currently only able to build GHC if hostPlatform == buildPlatform. -assert targetCC == pkgsHostTarget.targetPackages.stdenv.cc; -assert buildTargetLlvmPackages.llvm == llvmPackages.llvm; -assert stdenv.targetPlatform.isDarwin -> buildTargetLlvmPackages.clang == llvmPackages.clang; +in stdenv.mkDerivation (rec { pname = "${targetPrefix}ghc${variantSuffix}"; @@ -282,6 +318,8 @@ stdenv.mkDerivation (rec { for env in $(env | grep '^TARGET_' | sed -E 's|\+?=.*||'); do export "''${env#TARGET_}=''${!env}" done + # Stage0 (build->build) which builds stage 1 + export GHC="${bootPkgs.ghc}/bin/ghc" # GHC is a bit confused on its cross terminology, as these would normally be # the *host* tools. export CC="${toolPath "cc" targetCC}" @@ -294,6 +332,7 @@ stdenv.mkDerivation (rec { export RANLIB="${toolPath "ranlib" targetCC}" export READELF="${toolPath "readelf" targetCC}" export STRIP="${toolPath "strip" targetCC}" + export OBJDUMP="${toolPath "objdump" targetCC}" '' + lib.optionalString (stdenv.targetPlatform.linker == "cctools") '' export OTOOL="${toolPath "otool" targetCC}" export INSTALL_NAME_TOOL="${toolPath "install_name_tool" targetCC}" @@ -302,9 +341,24 @@ stdenv.mkDerivation (rec { export OPT="${lib.getBin buildTargetLlvmPackages.llvm}/bin/opt" '' + lib.optionalString (useLLVM && stdenv.targetPlatform.isDarwin) '' # LLVM backend on Darwin needs clang: https://downloads.haskell.org/~ghc/latest/docs/html/users_guide/codegens.html#llvm-code-generator-fllvm - export CLANG="${buildTargetLlvmPackages.clang}/bin/${buildTargetLlvmPackages.clang.targetPrefix}clang" + # The executable we specify via $CLANG is used as an assembler (exclusively, it seems, but this isn't + # clarified in any user facing documentation). As such, it'll be called on assembly produced by $CC + # which usually comes from the darwin stdenv. To prevent a situation where $CLANG doesn't understand + # the assembly it is given, we need to make sure that it matches the LLVM version of $CC if possible. + # It is unclear (at the time of writing 2024-09-01) whether $CC should match the LLVM version we use + # for llc and opt which would require using a custom darwin stdenv for targetCC. + export CLANG="${ + if targetCC.isClang + then toolPath "clang" targetCC + else "${buildTargetLlvmPackages.clang}/bin/${buildTargetLlvmPackages.clang.targetPrefix}clang" + }" '' + '' + # No need for absolute paths since these tools only need to work during the build + export CC_STAGE0="$CC_FOR_BUILD" + export LD_STAGE0="$LD_FOR_BUILD" + export AR_STAGE0="$AR_FOR_BUILD" + echo -n "${buildMK}" > mk/build.mk '' + lib.optionalString (lib.versionOlder version "9.2" || lib.versionAtLeast version "9.4") '' @@ -346,21 +400,26 @@ stdenv.mkDerivation (rec { 'MinBootGhcVersion="8.10"' ''; + # Although it is usually correct to pass --host, we don't do that here because + # GHC's usage of build, host, and target is non-standard. + # See https://gitlab.haskell.org/ghc/ghc/-/wikis/building/cross-compiling # TODO(@Ericson2314): Always pass "--target" and always prefix. - configurePlatforms = [ "build" "host" ] - ++ lib.optional (targetPlatform != hostPlatform) "target"; + configurePlatforms = [ "build" ] + ++ lib.optional (buildPlatform != hostPlatform || targetPlatform != hostPlatform) "target"; # `--with` flags for libraries needed for RTS linker configureFlags = [ "--datadir=$doc/share/doc/ghc" - "--with-curses-includes=${ncurses.dev}/include" "--with-curses-libraries=${ncurses.out}/lib" + ] ++ lib.optionals enableTerminfo [ + "--with-curses-includes=${lib.getDev targetLibs.ncurses}/include" + "--with-curses-libraries=${lib.getLib targetLibs.ncurses}/lib" ] ++ lib.optionals (libffi != null) [ "--with-system-libffi" - "--with-ffi-includes=${targetPackages.libffi.dev}/include" - "--with-ffi-libraries=${targetPackages.libffi.out}/lib" + "--with-ffi-includes=${targetLibs.libffi.dev}/include" + "--with-ffi-libraries=${targetLibs.libffi.out}/lib" ] ++ lib.optionals (targetPlatform == hostPlatform && !enableNativeBignum) [ - "--with-gmp-includes=${targetPackages.gmp.dev}/include" - "--with-gmp-libraries=${targetPackages.gmp.out}/lib" + "--with-gmp-includes=${targetLibs.gmp.dev}/include" + "--with-gmp-libraries=${targetLibs.gmp.out}/lib" ] ++ lib.optionals (targetPlatform == hostPlatform && hostPlatform.libc != "glibc" && !targetPlatform.isWindows) [ "--with-iconv-includes=${libiconv}/include" "--with-iconv-libraries=${libiconv}/lib" @@ -372,6 +431,8 @@ stdenv.mkDerivation (rec { "CONF_GCC_LINKER_OPTS_STAGE2=-fuse-ld=gold" ] ++ lib.optionals (disableLargeAddressSpace) [ "--disable-large-address-space" + ] ++ lib.optionals enableUnregisterised [ + "--enable-unregisterised" ]; # Make sure we never relax`$PATH` and hooks support for compatibility. @@ -382,7 +443,8 @@ stdenv.mkDerivation (rec { nativeBuildInputs = [ perl autoconf automake m4 python3 - ghc bootPkgs.alex bootPkgs.happy bootPkgs.hscolour + bootPkgs.alex bootPkgs.happy bootPkgs.hscolour + bootPkgs.ghc-settings-edit ] ++ lib.optionals (stdenv.hostPlatform.isDarwin && stdenv.hostPlatform.isAarch64) [ autoSignDarwinBinariesHook ] ++ lib.optionals enableDocs [ @@ -393,10 +455,27 @@ stdenv.mkDerivation (rec { xattr ]; + # Everything the stage0 compiler needs to build stage1: CC, bintools, extra libs. + # See also GHC, {CC,LD,AR}_STAGE0 in preConfigure. + depsBuildBuild = [ + # N.B. We do not declare bootPkgs.ghc in any of the stdenv.mkDerivation + # dependency lists to prevent the bintools setup hook from adding ghc's + # lib directory to the linker flags. Instead we tell configure about it + # via the GHC environment variable. + buildCC + # stage0 builds terminfo unconditionally, so we always need ncurses + ncurses + ]; # For building runtime libs depsBuildTarget = toolsForTarget; - buildInputs = [ perl bash ] ++ (libDeps hostPlatform); + # Prevent stage0 ghc from leaking into the final result. This was an issue + # with GHC 9.6. + disallowedReferences = [ + bootPkgs.ghc + ]; + + buildInputs = [ bash ] ++ (libDeps hostPlatform); depsTargetTarget = map lib.getDev (libDeps targetPlatform); depsTargetTargetPropagated = map (lib.getOutput "out") (libDeps targetPlatform); @@ -423,6 +502,39 @@ stdenv.mkDerivation (rec { requiredSystemFeatures = [ "big-parallel" ]; postInstall = '' + settingsFile="$out/lib/${targetPrefix}${passthru.haskellCompilerName}/settings" + + # Make the installed GHC use the host->target tools. + ghc-settings-edit "$settingsFile" \ + "C compiler command" "${toolPath "cc" installCC}" \ + "Haskell CPP command" "${toolPath "cc" installCC}" \ + "C++ compiler command" "${toolPath "c++" installCC}" \ + "ld command" "${toolPath "ld${lib.optionalString useLdGold ".gold"}" installCC}" \ + "Merge objects command" "${toolPath "ld${lib.optionalString useLdGold ".gold"}" installCC}" \ + "ar command" "${toolPath "ar" installCC}" \ + "ranlib command" "${toolPath "ranlib" installCC}" + '' + + lib.optionalString (stdenv.targetPlatform.linker == "cctools") '' + ghc-settings-edit "$settingsFile" \ + "otool command" "${toolPath "otool" installCC}" \ + "install_name_tool command" "${toolPath "install_name_tool" installCC}" + '' + + lib.optionalString useLLVM '' + ghc-settings-edit "$settingsFile" \ + "LLVM llc command" "${lib.getBin llvmPackages.llvm}/bin/llc" \ + "LLVM opt command" "${lib.getBin llvmPackages.llvm}/bin/opt" + '' + + lib.optionalString (useLLVM && stdenv.targetPlatform.isDarwin) '' + ghc-settings-edit "$settingsFile" \ + "LLVM clang command" "${ + # See comment for CLANG in preConfigure + if installCC.isClang + then toolPath "clang" installCC + else "${llvmPackages.clang}/bin/${llvmPackages.clang.targetPrefix}clang" + }" + '' + + '' + # Install the bash completion file. install -D -m 444 utils/completion/ghc.bash $out/share/bash-completion/completions/${targetPrefix}ghc ''; @@ -448,7 +560,8 @@ stdenv.mkDerivation (rec { guibou ] ++ lib.teams.haskell.members; timeout = 24 * 3600; - inherit (ghc.meta) license platforms; + platforms = lib.platforms.all; + inherit (bootPkgs.ghc.meta) license; }; } // lib.optionalAttrs targetPlatform.useAndroidPrebuilt { diff --git a/pkgs/development/haskell-modules/configuration-common.nix b/pkgs/development/haskell-modules/configuration-common.nix index e1d70248acfbc..9be73651d4575 100644 --- a/pkgs/development/haskell-modules/configuration-common.nix +++ b/pkgs/development/haskell-modules/configuration-common.nix @@ -185,6 +185,13 @@ self: super: { http-api-data = doJailbreak super.http-api-data; tasty-discover = doJailbreak super.tasty-discover; + # Out of date test data: https://github.com/ocharles/weeder/issues/176 + weeder = appendPatch (pkgs.fetchpatch { + name = "weeder-2.9.0-test-fix-expected.patch"; + url = "https://github.com/ocharles/weeder/commit/56028d0c80fe89d4f2ae25275aedb72714fec7da.patch"; + sha256 = "10zkvclyir3zf21v41zdsvg68vrkq89n64kv9k54742am2i4aygf"; + }) super.weeder; + # Allow aeson == 2.1.* # https://github.com/hdgarrood/aeson-better-errors/issues/23 aeson-better-errors = lib.pipe super.aeson-better-errors [ @@ -404,7 +411,7 @@ self: super: { name = "git-annex-${super.git-annex.version}-src"; url = "git://git-annex.branchable.com/"; rev = "refs/tags/" + super.git-annex.version; - sha256 = "1h0vbz95jgj8c380rpy688frnbwind5c2y3ylaw06l2l3j6gdaq3"; + sha256 = "0j037sis64gnrll7ajg48cvzzvxqsrhj7vnhiwcqv8wbmbfv0avn"; # delete android and Android directories which cause issues on # darwin (case insensitive directory). Since we don't need them # during the build process, we can delete it to prevent a hash @@ -1457,6 +1464,11 @@ self: super: { ''; }) super.hledger-flow; + # xmonad-contrib >= 0.18.1 for latest XMonad + xmonad-contrib_0_18_1 = super.xmonad-contrib_0_18_1.override { + xmonad = self.xmonad_0_18_0; + }; + # Chart-tests needs and compiles some modules from Chart itself Chart-tests = overrideCabal (old: { # https://github.com/timbod7/haskell-chart/issues/233 @@ -2044,6 +2056,11 @@ self: super: { tls = self.tls_2_0_6; }); + # Requests version 2 of tls, can be removed once it's the default + diohsc = super.diohsc.overrideScope (self: super: { + tls = self.tls_2_0_6; + }); + # Need https://github.com/obsidiansystems/cli-extras/pull/12 and more cli-extras = doJailbreak super.cli-extras; @@ -2441,9 +2458,7 @@ self: super: { # See: https://gitlab.haskell.org/ghc/ghc/-/issues/17188 # # Overwrite the build cores - raaz = overrideCabal (drv: { - enableParallelBuilding = false; - }) super.raaz; + raaz = disableParallelBuilding super.raaz; # https://github.com/andreymulik/sdp/issues/3 sdp = disableLibraryProfiling super.sdp; @@ -2548,8 +2563,9 @@ self: super: { relative = "dependent-sum-template"; }) super.dependent-sum-template; - # Too strict bounds on chell: https://github.com/fpco/haskell-filesystem/issues/24 - system-fileio = doJailbreak super.system-fileio; + # doJailbreak: too strict bounds on chell: https://github.com/fpco/haskell-filesystem/issues/24 + # dontCheck: tests don't typecheck after ghc 8.4 (possibly introduced by api change of unix library) + system-fileio = doJailbreak (dontCheck super.system-fileio); # Bounds too strict on base and ghc-prim: https://github.com/tibbe/ekg-core/pull/43 (merged); waiting on hackage release ekg-core = assert super.ekg-core.version == "0.1.1.7"; doJailbreak super.ekg-core; diff --git a/pkgs/development/haskell-modules/configuration-darwin.nix b/pkgs/development/haskell-modules/configuration-darwin.nix index 0c5b9106643e8..6e7f7ef47b879 100644 --- a/pkgs/development/haskell-modules/configuration-darwin.nix +++ b/pkgs/development/haskell-modules/configuration-darwin.nix @@ -83,9 +83,6 @@ self: super: ({ with-utf8 = addExtraLibrary pkgs.libiconv super.with-utf8; with-utf8_1_1_0_0 = addExtraLibrary pkgs.libiconv super.with-utf8_1_1_0_0; - # the system-fileio tests use canonicalizePath, which fails in the sandbox - system-fileio = dontCheck super.system-fileio; - git-annex = overrideCabal (drv: { # We can't use testFlags since git-annex side steps the Cabal test mechanism preCheck = drv.preCheck or "" + '' diff --git a/pkgs/development/haskell-modules/configuration-ghc-8.6.x.nix b/pkgs/development/haskell-modules/configuration-ghc-8.6.x.nix index 4a194192ee4b4..4272012f27a32 100644 --- a/pkgs/development/haskell-modules/configuration-ghc-8.6.x.nix +++ b/pkgs/development/haskell-modules/configuration-ghc-8.6.x.nix @@ -69,7 +69,6 @@ self: super: { hpc-coveralls = doJailbreak super.hpc-coveralls; # https://github.com/guillaume-nargeot/hpc-coveralls/issues/82 http-api-data = doJailbreak super.http-api-data; persistent-sqlite = dontCheck super.persistent-sqlite; - system-fileio = dontCheck super.system-fileio; # avoid dependency on broken "patience" unicode-transforms = dontCheck super.unicode-transforms; wl-pprint-extras = doJailbreak super.wl-pprint-extras; # containers >=0.4 && <0.6 is too tight; https://github.com/ekmett/wl-pprint-extras/issues/17 RSA = dontCheck super.RSA; # https://github.com/GaloisInc/RSA/issues/14 diff --git a/pkgs/development/haskell-modules/configuration-ghc-9.10.x.nix b/pkgs/development/haskell-modules/configuration-ghc-9.10.x.nix index 0dd47690b4dc2..972cbc4c7e03b 100644 --- a/pkgs/development/haskell-modules/configuration-ghc-9.10.x.nix +++ b/pkgs/development/haskell-modules/configuration-ghc-9.10.x.nix @@ -5,7 +5,6 @@ with haskellLib; let inherit (pkgs) lib; - disableParallelBuilding = haskellLib.overrideCabal (drv: { enableParallelBuilding = false; }); in self: super: { @@ -55,9 +54,6 @@ self: super: { unix = null; xhtml = null; - # https://gitlab.haskell.org/ghc/ghc/-/issues/23392 - gi-gtk = disableParallelBuilding super.gi-gtk; - # # Version upgrades # @@ -67,14 +63,18 @@ self: super: { aeson = doDistribute self.aeson_2_2_3_0; apply-refact = doDistribute self.apply-refact_0_14_0_0; attoparsec-aeson = doDistribute self.attoparsec-aeson_2_2_2_0; + auto-update = super.auto-update_0_2_1; extensions = doDistribute self.extensions_0_1_0_2; fourmolu = doDistribute self.fourmolu_0_16_2_0; hashable = doDistribute self.hashable_1_4_7_0; integer-conversion = doDistribute self.integer-conversion_0_1_1; ghc-lib-parser = doDistribute self.ghc-lib-parser_9_10_1_20240511; ghc-lib-parser-ex = doDistribute self.ghc-lib-parser-ex_9_10_0_0; + http2 = super.http2_5_3_4; lens = doDistribute self.lens_5_3_2; lukko = doDistribute self.lukko_0_1_2; + network-control = super.network-control_0_1_3; + network-run = super.network-run_0_4_0; ormolu = doDistribute self.ormolu_0_7_7_0; primitive = doDistribute (dontCheck self.primitive_0_9_0_0); # tests introduce a recursive dependency via hspec quickcheck-instances = doDistribute self.quickcheck-instances_0_3_31; @@ -82,6 +82,7 @@ self: super: { rerebase = doDistribute self.rerebase_1_21_1; scientific = doDistribute self.scientific_0_3_8_0; semirings = doDistribute self.semirings_0_7; + time-manager = super.time-manager_0_1_0; th-abstraction = doDistribute self.th-abstraction_0_7_0_0; uuid-types = doDistribute self.uuid-types_1_0_6; @@ -101,9 +102,11 @@ self: super: { # base64 = doJailbreak super.base64; # base <4.20 commutative-semigroups = doJailbreak super.commutative-semigroups; # base <4.20 + dejafu = doJailbreak super.dejafu; # containers <0.7 floskell = doJailbreak super.floskell; # base <4.20 lucid = doJailbreak super.lucid; # base <4.20 tar = doJailbreak super.tar; # base <4.20 + tasty-coverage = doJailbreak super.tasty-coverage; # base <4.20, filepath <1.5 tree-diff = doJailbreak super.tree-diff; # base <4.20 time-compat = doJailbreak super.time-compat; # base <4.20 @@ -123,6 +126,9 @@ self: super: { lukko_0_1_2 = dontCheck super.lukko_0_1_2; # doesn't compile with tasty ==1.4.* resolv = dontCheck super.resolv; # doesn't compile with filepath ==1.5.* primitive-unlifted = dontCheck super.primitive-unlifted; # doesn't compile with primitive ==0.9.* + bsb-http-chunked = pkgs.haskell.lib.dontCheck super.bsb-http-chunked; # https://github.com/sjakobi/bsb-http-chunked/issues/45 + hinotify = pkgs.haskell.lib.dontCheck super.hinotify; # https://github.com/kolmodin/hinotify/issues/38 + warp = pkgs.haskell.lib.dontCheck super.warp_3_4_1; # test suite assumes it can freely call curl haskell-language-server = disableCabalFlag "retrie" (disableCabalFlag "hlint" (disableCabalFlag "stylishhaskel" (super.haskell-language-server.override {stylish-haskell = null;retrie = null;apply-refact=null;hlint = null;}))); diff --git a/pkgs/development/haskell-modules/configuration-ghc-9.12.x.nix b/pkgs/development/haskell-modules/configuration-ghc-9.12.x.nix index 98a8cb4d49b80..adc1896306202 100644 --- a/pkgs/development/haskell-modules/configuration-ghc-9.12.x.nix +++ b/pkgs/development/haskell-modules/configuration-ghc-9.12.x.nix @@ -3,7 +3,6 @@ let inherit (pkgs) lib; - disableParallelBuilding = haskellLib.overrideCabal (drv: { enableParallelBuilding = false; }); in self: super: { @@ -53,6 +52,4 @@ self: super: { unix = null; xhtml = null; - # https://gitlab.haskell.org/ghc/ghc/-/issues/23392 - gi-gtk = disableParallelBuilding super.gi-gtk; } diff --git a/pkgs/development/haskell-modules/configuration-ghc-9.6.x.nix b/pkgs/development/haskell-modules/configuration-ghc-9.6.x.nix index 90d8bc7ff0346..b6485a111b20e 100644 --- a/pkgs/development/haskell-modules/configuration-ghc-9.6.x.nix +++ b/pkgs/development/haskell-modules/configuration-ghc-9.6.x.nix @@ -15,8 +15,6 @@ let builtins.throw "Check if '${msg}' was resolved in ${pkg.pname} ${pkg.version} and update or remove this"; jailbreakForCurrentVersion = p: v: checkAgainAfter p v "bad bounds" (doJailbreak p); - # Workaround for a ghc-9.6 issue: https://gitlab.haskell.org/ghc/ghc/-/issues/23392 - disableParallelBuilding = overrideCabal (drv: { enableParallelBuilding = false; }); in self: super: { @@ -109,9 +107,6 @@ self: super: { package-version # doctest <0.21, tasty-hedgehog <1.4 ; - # Avoid triggering an issue in ghc-9.6.2 - gi-gtk = disableParallelBuilding super.gi-gtk; - # Pending text-2.0 support https://github.com/gtk2hs/gtk2hs/issues/327 gtk = doJailbreak super.gtk; diff --git a/pkgs/development/haskell-modules/configuration-ghc-9.8.x.nix b/pkgs/development/haskell-modules/configuration-ghc-9.8.x.nix index 9094f1f8e9eaf..7e89ea668e028 100644 --- a/pkgs/development/haskell-modules/configuration-ghc-9.8.x.nix +++ b/pkgs/development/haskell-modules/configuration-ghc-9.8.x.nix @@ -5,7 +5,6 @@ with haskellLib; let inherit (pkgs.stdenv.hostPlatform) isDarwin; - disableParallelBuilding = haskellLib.overrideCabal (drv: { enableParallelBuilding = false; }); in self: super: { @@ -146,7 +145,4 @@ self: super: { sha256 = "sha256-umjwgdSKebJdRrXjwHhsi8HBqotx1vFibY9ttLkyT/0="; }) super.reflex; - # https://gitlab.haskell.org/ghc/ghc/-/issues/23392 - gi-gtk = disableParallelBuilding super.gi-gtk; - } diff --git a/pkgs/development/haskell-modules/configuration-ghcjs-9.x.nix b/pkgs/development/haskell-modules/configuration-ghcjs-9.x.nix index 044a3a8f69d8e..448f04228bec2 100644 --- a/pkgs/development/haskell-modules/configuration-ghcjs-9.x.nix +++ b/pkgs/development/haskell-modules/configuration-ghcjs-9.x.nix @@ -2,12 +2,6 @@ with haskellLib; -let - disableParallelBuilding = overrideCabal (drv: { - enableParallelBuilding = false; - }); -in - # cabal2nix doesn't properly add dependencies conditional on arch(javascript) (self: super: { diff --git a/pkgs/development/haskell-modules/configuration-hackage2nix/broken.yaml b/pkgs/development/haskell-modules/configuration-hackage2nix/broken.yaml index f76679137c904..f354cf1433f89 100644 --- a/pkgs/development/haskell-modules/configuration-hackage2nix/broken.yaml +++ b/pkgs/development/haskell-modules/configuration-hackage2nix/broken.yaml @@ -799,7 +799,6 @@ broken-packages: - clanki # failure in job https://hydra.nixos.org/build/233196970 at 2023-09-02 - clarifai # failure in job https://hydra.nixos.org/build/233229480 at 2023-09-02 - CLASE # failure in job https://hydra.nixos.org/build/233234459 at 2023-09-02 - - clash-prelude # failure in job https://hydra.nixos.org/build/233252128 at 2023-09-02 - Clash-Royale-Hack-Cheats # failure in job https://hydra.nixos.org/build/233216034 at 2023-09-02 - ClasshSS # failure in job https://hydra.nixos.org/build/255688076 at 2024-04-16 - ClassLaws # failure in job https://hydra.nixos.org/build/233243019 at 2023-09-02 @@ -1319,7 +1318,6 @@ broken-packages: - dijkstra-simple # failure in job https://hydra.nixos.org/build/233218373 at 2023-09-02 - DimensionalHash # failure in job https://hydra.nixos.org/build/233230945 at 2023-09-02 - dino # failure in job https://hydra.nixos.org/build/252725815 at 2024-03-16 - - diohsc # failure in job https://hydra.nixos.org/build/259625302 at 2024-05-15 - diophantine # failure in job https://hydra.nixos.org/build/233229215 at 2023-09-02 - diplomacy # failure in job https://hydra.nixos.org/build/233207895 at 2023-09-02 - direct-binary-files # failure in job https://hydra.nixos.org/build/233246387 at 2023-09-02 @@ -5888,7 +5886,6 @@ broken-packages: - system-command # failure in job https://hydra.nixos.org/build/233239356 at 2023-09-02 - systemd-ntfy # failure in job https://hydra.nixos.org/build/236686880 at 2023-10-04 - system-extra # failure in job https://hydra.nixos.org/build/233203137 at 2023-09-02 - - system-fileio # failure in job https://hydra.nixos.org/build/252731084 at 2024-03-16 - system-inotify # failure in job https://hydra.nixos.org/build/233206871 at 2023-09-02 - system-lifted # failure in job https://hydra.nixos.org/build/233236013 at 2023-09-02 - system-linux-proc # failure in job https://hydra.nixos.org/build/233209447 at 2023-09-02 diff --git a/pkgs/development/haskell-modules/configuration-hackage2nix/main.yaml b/pkgs/development/haskell-modules/configuration-hackage2nix/main.yaml index cb0e9538c9017..15bb0c4217820 100644 --- a/pkgs/development/haskell-modules/configuration-hackage2nix/main.yaml +++ b/pkgs/development/haskell-modules/configuration-hackage2nix/main.yaml @@ -34,8 +34,8 @@ default-package-overrides: - chs-cabal < 0.1.1.2 # Incompatible with Cabal < 3.12 # 2024-08-17: Stackage doesn't contain hnix-store-core >= 0.8 yet, so we need to restrict hnix-store-remote - hnix-store-remote < 0.7 - # 2024-08-26: test failure for >= 2.9 https://github.com/ocharles/weeder/issues/176 - - weeder < 2.9.0 + # 2024-09-12: match xmonad 0.17.* from Stackage LTS + - xmonad-contrib < 0.18.1 extra-packages: diff --git a/pkgs/development/haskell-modules/configuration-hackage2nix/transitive-broken.yaml b/pkgs/development/haskell-modules/configuration-hackage2nix/transitive-broken.yaml index 2471fca15bfef..de9e5924c7856 100644 --- a/pkgs/development/haskell-modules/configuration-hackage2nix/transitive-broken.yaml +++ b/pkgs/development/haskell-modules/configuration-hackage2nix/transitive-broken.yaml @@ -483,8 +483,6 @@ dont-distribute-packages: - ampersand - amqp-streamly - analyze-client - - anansi - - anansi-hscolour - anatomy - animate-example - animate-frames @@ -572,6 +570,7 @@ dont-distribute-packages: - aviation-weight-balance - awesomium - awesomium-glut + - aws-arn - aws-configuration-tools - aws-dynamodb-conduit - aws-dynamodb-streams @@ -673,7 +672,6 @@ dont-distribute-packages: - bitmaps - bittorrent - bla - - blacktip - blakesum-demo - blastxml - blatex @@ -824,7 +822,6 @@ dont-distribute-packages: - chu2 - chuchu - chunks - - circuit-notation - citation-resolve - citeproc-hs-pandoc-filter - clac @@ -832,17 +829,7 @@ dont-distribute-packages: - claferIG - claferwiki - clash - - clash-ghc - - clash-lib - clash-lib-hedgehog - - clash-multisignal - - clash-prelude-hedgehog - - clash-prelude-quickcheck - - clash-shake - - clash-systemverilog - - clash-verilog - - clash-vhdl - - clashilator - classify-frog - classy-effects - classy-effects-th @@ -1124,7 +1111,6 @@ dont-distribute-packages: - devtools - dewdrop - dfinity-radix-tree - - dhall-lex - dhall-secret - dia-functions - diagrams-reflex @@ -1144,7 +1130,6 @@ dont-distribute-packages: - direct-rocksdb - directory-contents - dirfiles - - dirstream - discogs-haskell - discord-gateway - discord-hs @@ -1440,6 +1425,8 @@ dont-distribute-packages: - frpnow-gtk - frpnow-gtk3 - frpnow-vty + - fs-api + - fs-sim - ftdi - ftp-client-conduit - ftree @@ -2165,7 +2152,6 @@ dont-distribute-packages: - hs-pkpass - hs-profunctors - hs-sdl-term-emulator - - hs2ats - hs2dot - hsbackup - hsbencher-codespeed @@ -2187,7 +2173,6 @@ dont-distribute-packages: - hsinspect-lsp - hslogstash - hsparql - - hspec-dirstream - hspec-expectations-pretty - hspec-pg-transact - hspec-setup @@ -2280,7 +2265,6 @@ dont-distribute-packages: - hyperpublic - i - iException - - ice40-prim - ide-backend - ide-backend-server - ideas-math @@ -2500,7 +2484,6 @@ dont-distribute-packages: - landlock - lang - language-Modula2 - - language-ats - language-boogie - language-ecmascript-analysis - language-eiffel @@ -2573,7 +2556,6 @@ dont-distribute-packages: - linnet-conduit - linux-ptrace - lio-eci11 - - lion - liquid-base - liquid-bytestring - liquid-containers @@ -3157,7 +3139,7 @@ dont-distribute-packages: - poseidon - poseidon-postgis - postgresql-common-persistent - - postgresql-libpq_0_10_2_0 + - postgresql-libpq_0_11_0_0 - postgresql-pure - postgresql-simple-ltree - postgresql-simple-queue @@ -3306,6 +3288,7 @@ dont-distribute-packages: - rc - rdf4h-vocab-activitystreams - rdioh + - rds-data - react-flux-servant - reactive - reactive-banana-sdl @@ -3403,8 +3386,6 @@ dont-distribute-packages: - restricted-workers - rethinkdb-model - rethinkdb-wereHamster - - retroclash-lib - - retroclash-sim - rewrite - rewriting - rezoom @@ -3556,11 +3537,11 @@ dont-distribute-packages: - seqloc-datafiles - sequor - serdoc-binary - - serial-test-generators - serpentine - serv - serv-wai - servant-aeson-generics-typescript + - servant-auth-client_0_4_2_0 - servant-auth-hmac - servant-auth-token - servant-auth-token-acid @@ -4297,7 +4278,6 @@ dont-distribute-packages: - yesod-raml-bin - yesod-raml-docs - yesod-raml-mock - - yesod-routes-flow - yesod-routes-typescript - yesod-session-redis - yesod-worker diff --git a/pkgs/development/haskell-modules/hackage-packages.nix b/pkgs/development/haskell-modules/hackage-packages.nix index ab91a00f78d39..46071ca84040c 100644 --- a/pkgs/development/haskell-modules/hackage-packages.nix +++ b/pkgs/development/haskell-modules/hackage-packages.nix @@ -2124,7 +2124,7 @@ self: { license = lib.licenses.mit; }) {}; - "Blammo_2_1_0_0" = callPackage + "Blammo_2_1_1_0" = callPackage ({ mkDerivation, aeson, base, bytestring, containers, dlist , envparse, exceptions, fast-logger, hspec, lens, markdown-unlit , monad-logger-aeson, mtl, text, time, unliftio, unliftio-core @@ -2132,8 +2132,8 @@ self: { }: mkDerivation { pname = "Blammo"; - version = "2.1.0.0"; - sha256 = "0cdif1n1s7isqhfdwk3azdbipwpsxzf7g274hllclx9fbg6l48y9"; + version = "2.1.1.0"; + sha256 = "0n0vybpqvdi20jgdmzpbcb87a96s7npa1gbmvqplc0sqlnrx2cx6"; libraryHaskellDepends = [ aeson base bytestring containers dlist envparse exceptions fast-logger lens monad-logger-aeson mtl text time unliftio @@ -3365,6 +3365,25 @@ self: { license = lib.licenses.mit; }) {}; + "ChasingBottoms_1_3_1_15" = callPackage + ({ mkDerivation, array, base, containers, mtl, QuickCheck, random + , syb + }: + mkDerivation { + pname = "ChasingBottoms"; + version = "1.3.1.15"; + sha256 = "0if8h6xq10y1xa90cwmx2jkxjn9628rzs8y6fsjmpjdcvcyr5wnj"; + libraryHaskellDepends = [ + base containers mtl QuickCheck random syb + ]; + testHaskellDepends = [ + array base containers mtl QuickCheck random syb + ]; + description = "For testing partial and infinite values"; + license = lib.licenses.mit; + hydraPlatforms = lib.platforms.none; + }) {}; + "CheatSheet" = callPackage ({ mkDerivation, base, containers, directory }: mkDerivation { @@ -14360,17 +14379,17 @@ self: { "MicroHs" = callPackage ({ mkDerivation, base, deepseq, directory, ghc-prim, haskeline - , process, time + , process, text, time }: mkDerivation { pname = "MicroHs"; - version = "0.9.16.0"; - sha256 = "0p3lzl1yh1r25s7mr0pipf6ym56syydi9ljbkyfp1i0yv4ynqy17"; + version = "0.9.17.0"; + sha256 = "00dvbpdpbx1dh44rixsw16gb748bdxiizdivnl3i4v9826hfx8x0"; isLibrary = false; isExecutable = true; enableSeparateDataOutput = true; executableHaskellDepends = [ - base deepseq directory ghc-prim haskeline process time + base deepseq directory ghc-prim haskeline process text time ]; description = "A compiler for Haskell"; license = lib.licenses.asl20; @@ -26117,8 +26136,8 @@ self: { pname = "aeson"; version = "2.2.3.0"; sha256 = "1akbrh8iz47f0ai30yabg1n4vcf1fx0a9gzj45fx0si553s5r8ns"; - revision = "1"; - editedCabalFile = "0q1nw6p4p0c4mjgi4hmiqj7npb5kbdsdbprq90a7mn5qnnfd4rpg"; + revision = "2"; + editedCabalFile = "0rl8llwk5cjxdryar3yy5pa6gc4vj7f5m0jwxjjim0ksgpba47q1"; libraryHaskellDepends = [ base bytestring character-ps containers data-fix deepseq dlist exceptions generically ghc-prim hashable indexed-traversable @@ -36510,7 +36529,6 @@ self: { ]; description = "Simple literate programming preprocessor"; license = lib.licenses.gpl3Only; - hydraPlatforms = lib.platforms.none; mainProgram = "anansi"; }) {}; @@ -36527,7 +36545,6 @@ self: { ]; description = "Colorized looms for Anansi"; license = lib.licenses.gpl3Only; - hydraPlatforms = lib.platforms.none; }) {}; "anansi-pandoc" = callPackage @@ -38161,24 +38178,25 @@ self: { }) {}; "api-tools" = callPackage - ({ mkDerivation, aeson, aeson-pretty, alex, array, attoparsec, base - , base16-bytestring, base64-bytestring, bytestring - , case-insensitive, cborg, containers, criterion, deepseq, happy - , lens, QuickCheck, regex-base, regex-tdfa, safe, safecopy - , scientific, serialise, tasty, tasty-hunit, tasty-quickcheck - , template-haskell, text, time, unordered-containers, vector + ({ mkDerivation, aeson, aeson-pretty, alex, array, attoparsec + , attoparsec-aeson, base, base16-bytestring, base64-bytestring + , bytestring, case-insensitive, cborg, containers, criterion + , deepseq, happy, lens, QuickCheck, regex-base, regex-tdfa, safe + , safecopy, scientific, serialise, tasty, tasty-hunit + , tasty-quickcheck, template-haskell, text, time + , unordered-containers, vector }: mkDerivation { pname = "api-tools"; - version = "0.10.1.0"; - sha256 = "1lmgjixga0jsli98xs6yi09pcgn9d44h9hd2gy17d30mzlyfrpx4"; + version = "0.10.1.1"; + sha256 = "19sfnzbyjl19rm0hyz5w9lpw4dsp4dns74jwn2d7ga6rzp2jp59z"; isLibrary = true; isExecutable = true; libraryHaskellDepends = [ - aeson aeson-pretty array attoparsec base base16-bytestring - base64-bytestring bytestring case-insensitive cborg containers - deepseq lens QuickCheck regex-base regex-tdfa safe safecopy - scientific serialise template-haskell text time + aeson aeson-pretty array attoparsec attoparsec-aeson base + base16-bytestring base64-bytestring bytestring case-insensitive + cborg containers deepseq lens QuickCheck regex-base regex-tdfa safe + safecopy scientific serialise template-haskell text time unordered-containers vector ]; libraryToolDepends = [ alex happy ]; @@ -42790,6 +42808,8 @@ self: { pname = "attoparsec-iso8601"; version = "1.1.1.0"; sha256 = "0yn9l9drza1wcj59a9dzm4vnihwmsxk6zd3fqg6kgww1an8x3k9l"; + revision = "1"; + editedCabalFile = "0chjsgkkdvnj6zps4gj80dwdfxmic1dal0cs5jfmrw8jalkqflzl"; libraryHaskellDepends = [ attoparsec base integer-conversion text time time-compat ]; @@ -43335,15 +43355,15 @@ self: { license = lib.licenses.mit; }) {}; - "autodocodec_0_4_2_0" = callPackage + "autodocodec_0_4_2_2" = callPackage ({ mkDerivation, aeson, base, bytestring, containers, dlist , doctest, hashable, mtl, scientific, text, time , unordered-containers, validity, validity-scientific, vector }: mkDerivation { pname = "autodocodec"; - version = "0.4.2.0"; - sha256 = "041lkn9msxgbq9fkn90a44j3cygn98l6c90f7mjwzg6a2519r6fh"; + version = "0.4.2.2"; + sha256 = "1m6mhss3iw49xsc0yr663hy9prkwwwsbzg82mi27z4iq4v0hdmm6"; libraryHaskellDepends = [ aeson base bytestring containers dlist hashable mtl scientific text time unordered-containers validity validity-scientific vector @@ -43360,8 +43380,8 @@ self: { }: mkDerivation { pname = "autodocodec-nix"; - version = "0.0.1.0"; - sha256 = "1v38vdf0p110swj5gq2j8mz08gwy33myf602kn2wqz142mjsl2q6"; + version = "0.0.1.4"; + sha256 = "1awfc6gvmqs5gz0vb6gihs3f8csrqhk1b8yni21np72y2j29pzfw"; libraryHaskellDepends = [ aeson autodocodec base containers scientific text unordered-containers vector @@ -44206,24 +44226,24 @@ self: { }) {}; "aws-arn" = callPackage - ({ mkDerivation, base, deriving-compat, hashable, profunctors - , tagged, tasty, tasty-discover, tasty-hunit, text + ({ mkDerivation, base, deriving-compat, hashable, microlens-pro + , profunctors, tagged, tasty, tasty-discover, tasty-hunit, text }: mkDerivation { pname = "aws-arn"; - version = "0.3.1.0"; - sha256 = "09jd8lf6w76adkcq5kycj1nwhr7qpn5ivm6dap3zlkngp0z9sdqb"; - revision = "1"; - editedCabalFile = "029q777z4pd0vnj9c4v1ivzjb7azj6aq8gb55bwidw21lq55p98r"; + version = "0.3.2.0"; + sha256 = "14384l3k5c1qj830lq8jv22gx9ciklsvcap247p02wq2qwrp1rfy"; libraryHaskellDepends = [ - base deriving-compat hashable profunctors tagged text + base deriving-compat hashable microlens-pro profunctors tagged text ]; testHaskellDepends = [ - base deriving-compat profunctors tagged tasty tasty-hunit text + base deriving-compat microlens-pro profunctors tagged tasty + tasty-hunit text ]; testToolDepends = [ tasty-discover ]; description = "Types and optics for manipulating Amazon Resource Names (ARNs)"; license = lib.licenses.bsd3; + hydraPlatforms = lib.platforms.none; }) {}; "aws-cloudfront-signed-cookies" = callPackage @@ -47730,8 +47750,8 @@ self: { pname = "beam-postgres"; version = "0.5.3.1"; sha256 = "19gagw9r2wfy398calkcnilsgl89sjpy8vj9bdswg390mw15m41n"; - revision = "1"; - editedCabalFile = "17ssja9yy1yzjyngrvyr72gr8hrvkw4q8w8cb20kdfrz0m83c17w"; + revision = "2"; + editedCabalFile = "11f3jxljrfa4rva21r561w7vxafv63wmmsa9cq8bydcp3gzlgr4p"; libraryHaskellDepends = [ aeson attoparsec base beam-core beam-migrate bytestring case-insensitive conduit free hashable haskell-src-exts lifted-base @@ -47823,15 +47843,15 @@ self: { }) {}; "bearriver" = callPackage - ({ mkDerivation, base, deepseq, dunai, MonadRandom, mtl + ({ mkDerivation, base, deepseq, dunai, mtl, random , simple-affine-space, transformers }: mkDerivation { pname = "bearriver"; - version = "0.14.9"; - sha256 = "10xcl4nms1bcfni9z7mqirf6ifii99y6yb16r2pwrfs20vnhwx7w"; + version = "0.14.10"; + sha256 = "0fyjrwb3f7sqs1bbiga98h6bylgvmqfpqg59p07lhv4hrrgmx8ff"; libraryHaskellDepends = [ - base deepseq dunai MonadRandom mtl simple-affine-space transformers + base deepseq dunai mtl random simple-affine-space transformers ]; description = "FRP Yampa replacement implemented with Monadic Stream Functions"; license = lib.licenses.bsd3; @@ -48923,6 +48943,8 @@ self: { pname = "bin"; version = "0.1.4"; sha256 = "0amz5naq6p2jpm4rb9ycjg7j75qylp3d689cl55f71rs2idrazpp"; + revision = "1"; + editedCabalFile = "1bxybxc32zzwrpmvbl0a0scz7zpi6dhm4pgv2zrbnmf40s858mjm"; libraryHaskellDepends = [ base boring dec deepseq fin hashable QuickCheck some ]; @@ -52073,7 +52095,6 @@ self: { ]; description = "Decentralized, k-ordered unique ID generator"; license = lib.licenses.asl20; - hydraPlatforms = lib.platforms.none; }) {}; "blagda" = callPackage @@ -52568,8 +52589,8 @@ self: { pname = "blaze-svg"; version = "0.3.7"; sha256 = "0pqnx1zrvm2pliya76f4m8d6aycncfp08c2n1fiyzvl1fgk62z2c"; - revision = "1"; - editedCabalFile = "0szq7fnck2fchhck7984zar92da2lc63gjy4p7zx0975jxx0xrg9"; + revision = "2"; + editedCabalFile = "0d8wylydvflhd1yyd91a8ss8khxr5j83f7j7h6qn36zagnyci1f5"; libraryHaskellDepends = [ base blaze-markup mtl ]; description = "SVG combinator library"; license = lib.licenses.bsd3; @@ -52796,8 +52817,8 @@ self: { }: mkDerivation { pname = "blockfrost-api"; - version = "0.10.0.0"; - sha256 = "1l7sj5b4f8byvmz9090wl6rq6fdhx2y8xiqnwcxmn3z487858w6w"; + version = "0.11.0.0"; + sha256 = "1lqbpjzvz5rc3bkfgk09mgz6p99cxy19yx2azyshb37xxiaj8www"; libraryHaskellDepends = [ aeson base bytestring containers data-default-class deriving-aeson lens safe-money servant servant-docs servant-multipart-api @@ -53214,8 +53235,10 @@ self: { ({ mkDerivation, bluefin-internal }: mkDerivation { pname = "bluefin"; - version = "0.0.6.1"; - sha256 = "1ihs05h8mbp205swlx2zbh3fi2d9m33sg06d43nqxmrgdvbh57rd"; + version = "0.0.7.0"; + sha256 = "1nr6kcckhz3k7nfzavjf24c655ccin0fnyxl238asic01h1d1bny"; + revision = "1"; + editedCabalFile = "1z6y9m8ikhy1h9hjvb3dccpqb567svzavl42i9s74aiybz3gs2gv"; libraryHaskellDepends = [ bluefin-internal ]; description = "The Bluefin effect system"; license = lib.licenses.mit; @@ -53241,15 +53264,16 @@ self: { }) {}; "bluefin-internal" = callPackage - ({ mkDerivation, base, monad-control, transformers + ({ mkDerivation, async, base, monad-control, transformers , transformers-base, unliftio-core }: mkDerivation { pname = "bluefin-internal"; - version = "0.0.6.1"; - sha256 = "12k7h2qs912nyy482h2cddwp0xafdk8pj7zc983lhw07pwdy0mi4"; + version = "0.0.7.0"; + sha256 = "1p6fz1nd4976ibb23ni8fdrp9i47m29gfq9v77rlp6biqappjakv"; libraryHaskellDepends = [ - base monad-control transformers transformers-base unliftio-core + async base monad-control transformers transformers-base + unliftio-core ]; testHaskellDepends = [ base ]; description = "The Bluefin effect system, internals"; @@ -55082,8 +55106,8 @@ self: { }: mkDerivation { pname = "brick-panes"; - version = "1.0.1.0"; - sha256 = "0ngw5mwnv92w6hyyz6jcjsz2cs4ix4dyd6z41ggjy0lzjxd40gsq"; + version = "1.0.2.0"; + sha256 = "1rdkwvsmm0dyzinvvc4z933vdz7hj9kz7zvbmnmmlpffbal1avjf"; isLibrary = true; isExecutable = true; libraryHaskellDepends = [ base brick containers microlens vty ]; @@ -56235,22 +56259,22 @@ self: { "build-env" = callPackage ({ mkDerivation, aeson, async, base, bytestring, containers - , directory, filepath, optparse-applicative, process, temporary - , text, time, transformers + , directory, filepath, optparse-applicative, process + , semaphore-compat, temporary, text, time, transformers }: mkDerivation { pname = "build-env"; - version = "1.1.0.0"; - sha256 = "07gw9wzyx92as7didf32b6q8nmjifsxg4z27gqb61dnq7hrrjhf4"; + version = "1.2.0.0"; + sha256 = "1qc03fvhj6as656g5krzvvrmqkkbxybyw4q1jgh8aw3n4mr76lbm"; isLibrary = true; isExecutable = true; libraryHaskellDepends = [ aeson async base bytestring containers directory filepath process - temporary text time transformers + semaphore-compat temporary text time transformers ]; executableHaskellDepends = [ base bytestring containers directory filepath optparse-applicative - text + semaphore-compat text ]; description = "Compute, fetch and install Cabal build plans into a local environment"; license = lib.licenses.bsd3; @@ -57485,6 +57509,23 @@ self: { license = lib.licenses.bsd3; }) {}; + "bytestring-lexing_0_5_0_14" = callPackage + ({ mkDerivation, base, bytestring, tasty, tasty-quickcheck + , tasty-smallcheck + }: + mkDerivation { + pname = "bytestring-lexing"; + version = "0.5.0.14"; + sha256 = "10r12gsms3bmakxfsqg24l7v87lq4hxgz3g8c3mz8wdcd5bds4l0"; + libraryHaskellDepends = [ base bytestring ]; + testHaskellDepends = [ + base bytestring tasty tasty-quickcheck tasty-smallcheck + ]; + description = "Efficiently parse and produce common integral and fractional numbers"; + license = lib.licenses.bsd3; + hydraPlatforms = lib.platforms.none; + }) {}; + "bytestring-mmap" = callPackage ({ mkDerivation, base, bytestring, unix }: mkDerivation { @@ -57715,6 +57756,28 @@ self: { license = lib.licenses.bsd3; }) {}; + "bytestring-trie_0_2_7_5" = callPackage + ({ mkDerivation, base, binary, bytestring, criterion, deepseq + , QuickCheck, smallcheck, tasty, tasty-hunit, tasty-quickcheck + , tasty-smallcheck + }: + mkDerivation { + pname = "bytestring-trie"; + version = "0.2.7.5"; + sha256 = "02z15mqn7rlpa6w41mwibhm3v33p03dp3mdv1b3q4s1jkn63lw2d"; + libraryHaskellDepends = [ base binary bytestring deepseq ]; + testHaskellDepends = [ + base binary bytestring deepseq QuickCheck smallcheck tasty + tasty-hunit tasty-quickcheck tasty-smallcheck + ]; + benchmarkHaskellDepends = [ + base binary bytestring criterion deepseq QuickCheck + ]; + description = "An efficient finite map from bytestrings to values"; + license = lib.licenses.bsd3; + hydraPlatforms = lib.platforms.none; + }) {}; + "bytestring-typenats" = callPackage ({ mkDerivation, base, binary, blake2, bytestring, cereal , criterion, cryptohash, deepseq, entropy, QuickCheck @@ -58271,6 +58334,32 @@ self: { broken = true; }) {youProbablyWantCapitalCabal = null;}; + "cabal-add" = callPackage + ({ mkDerivation, base, bytestring, Cabal, cabal-install-parsers + , Cabal-syntax, containers, Diff, directory, filepath, mtl + , optparse-applicative, process, string-qq, tasty, temporary + }: + mkDerivation { + pname = "cabal-add"; + version = "0.1"; + sha256 = "1szbi0z8yf98641rwnj856gcfsvvflxwrfxraxy6rl60m7i0mab1"; + isLibrary = true; + isExecutable = true; + libraryHaskellDepends = [ + base bytestring Cabal Cabal-syntax containers mtl + ]; + executableHaskellDepends = [ + base bytestring Cabal cabal-install-parsers directory filepath + optparse-applicative process + ]; + testHaskellDepends = [ + base Diff directory process string-qq tasty temporary + ]; + description = "Extend Cabal build-depends from the command line"; + license = lib.licenses.bsd3; + mainProgram = "cabal-add"; + }) {}; + "cabal-appimage" = callPackage ({ mkDerivation, base, Cabal, filepath }: mkDerivation { @@ -58282,6 +58371,18 @@ self: { license = lib.licenses.agpl3Only; }) {}; + "cabal-appimage_0_4_0_5" = callPackage + ({ mkDerivation, base, Cabal, filepath }: + mkDerivation { + pname = "cabal-appimage"; + version = "0.4.0.5"; + sha256 = "0ir952hdpyf62xc799fq22qmj7n09cbc0v3jldlr40iv0200isr2"; + libraryHaskellDepends = [ base Cabal filepath ]; + description = "Cabal support for creating AppImage applications"; + license = lib.licenses.agpl3Only; + hydraPlatforms = lib.platforms.none; + }) {}; + "cabal-audit" = callPackage ({ mkDerivation, base, Cabal, directory, filepath, HTTP , optparse-applicative @@ -65905,7 +66006,6 @@ self: { testHaskellDepends = [ base clash-prelude ]; description = "A source plugin for manipulating circuits in clash with a arrow notation"; license = lib.licenses.bsd3; - hydraPlatforms = lib.platforms.none; }) {}; "circular" = callPackage @@ -66425,7 +66525,6 @@ self: { executableHaskellDepends = [ base ]; description = "Clash: a functional hardware description language - GHC frontend"; license = lib.licenses.bsd2; - hydraPlatforms = lib.platforms.none; }) {}; "clash-lib" = callPackage @@ -66477,7 +66576,6 @@ self: { ]; description = "Clash: a functional hardware description language - As a library"; license = lib.licenses.bsd2; - hydraPlatforms = lib.platforms.none; mainProgram = "v16-upgrade-primitives"; }) {}; @@ -66514,7 +66612,6 @@ self: { base clash-prelude deepseq ghc-typelits-knownnat QuickCheck ]; license = lib.licenses.bsd3; - hydraPlatforms = lib.platforms.none; }) {}; "clash-prelude" = callPackage @@ -66556,8 +66653,6 @@ self: { ]; description = "Clash: a functional hardware description language - Prelude library"; license = lib.licenses.bsd2; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "clash-prelude-hedgehog" = callPackage @@ -66574,7 +66669,6 @@ self: { ]; description = "Hedgehog Generators for clash-prelude"; license = lib.licenses.bsd2; - hydraPlatforms = lib.platforms.none; }) {}; "clash-prelude-quickcheck" = callPackage @@ -66587,7 +66681,6 @@ self: { libraryHaskellDepends = [ base clash-prelude QuickCheck ]; description = "QuickCheck instances for various types in the CλaSH Prelude"; license = "unknown"; - hydraPlatforms = lib.platforms.none; }) {}; "clash-shake" = callPackage @@ -66607,7 +66700,6 @@ self: { ]; description = "Shake rules for building Clash programs"; license = lib.licenses.mit; - hydraPlatforms = lib.platforms.none; }) {}; "clash-systemverilog" = callPackage @@ -66625,7 +66717,6 @@ self: { ]; description = "CAES Language for Synchronous Hardware - SystemVerilog backend"; license = lib.licenses.bsd2; - hydraPlatforms = lib.platforms.none; }) {}; "clash-verilog" = callPackage @@ -66643,7 +66734,6 @@ self: { ]; description = "CAES Language for Synchronous Hardware - Verilog backend"; license = lib.licenses.bsd2; - hydraPlatforms = lib.platforms.none; }) {}; "clash-vhdl" = callPackage @@ -66661,7 +66751,6 @@ self: { ]; description = "CAES Language for Synchronous Hardware - VHDL backend"; license = lib.licenses.bsd2; - hydraPlatforms = lib.platforms.none; }) {}; "clashilator" = callPackage @@ -66685,7 +66774,6 @@ self: { ]; description = "Automated Clash to Verilator bridge"; license = lib.licenses.mit; - hydraPlatforms = lib.platforms.none; mainProgram = "clashilator"; }) {}; @@ -73069,6 +73157,33 @@ self: { license = lib.licenses.mit; }) {}; + "conduit_1_3_6" = callPackage + ({ mkDerivation, base, bytestring, containers, deepseq, directory + , exceptions, filepath, gauge, hspec, mono-traversable, mtl + , mwc-random, primitive, QuickCheck, resourcet, safe, silently + , split, text, transformers, unix, unliftio, unliftio-core, vector + }: + mkDerivation { + pname = "conduit"; + version = "1.3.6"; + sha256 = "13aivqg5js60yvcbpbl7fgrxa5z2wswrmjjlm1bhrcj2qx49mrik"; + libraryHaskellDepends = [ + base bytestring directory exceptions filepath mono-traversable mtl + primitive resourcet text transformers unix unliftio-core vector + ]; + testHaskellDepends = [ + base bytestring containers directory exceptions filepath hspec + mono-traversable mtl QuickCheck resourcet safe silently split text + transformers unliftio vector + ]; + benchmarkHaskellDepends = [ + base containers deepseq gauge hspec mwc-random transformers vector + ]; + description = "Streaming data processing library"; + license = lib.licenses.mit; + hydraPlatforms = lib.platforms.none; + }) {}; + "conduit-aeson" = callPackage ({ mkDerivation, aeson, attoparsec, attoparsec-aeson, base , bytestring, conduit, conduit-extra, containers, doctest, hspec @@ -74930,21 +75045,22 @@ self: { "consumers" = callPackage ({ mkDerivation, base, containers, exceptions, hpqtypes , hpqtypes-extras, HUnit, lifted-base, lifted-threads, log-base - , monad-control, monad-loops, monad-time, mtl, stm, text, text-show - , time, transformers, transformers-base + , monad-control, monad-time, mtl, safe-exceptions, stm, text + , text-show, time, transformers, transformers-base }: mkDerivation { pname = "consumers"; - version = "2.3.1.0"; - sha256 = "084i9lgrdn0f7pwk9b7rap66rg5z5f24az41jw7a9g9ddfq39fai"; + version = "2.3.2.0"; + sha256 = "1kj7ng8cpwvbc8x3bzcnkk19g3hrcy3v2c5kpxqn52x607c9flmf"; libraryHaskellDepends = [ base containers exceptions hpqtypes lifted-base lifted-threads - log-base monad-control monad-time mtl stm time transformers-base + log-base monad-control monad-time mtl safe-exceptions stm text time + transformers-base ]; testHaskellDepends = [ base exceptions hpqtypes hpqtypes-extras HUnit log-base - monad-control monad-loops monad-time mtl stm text text-show time - transformers transformers-base + monad-control monad-time mtl stm text text-show time transformers + transformers-base ]; description = "Concurrent PostgreSQL data consumers"; license = lib.licenses.bsd3; @@ -78652,20 +78768,22 @@ self: { }) {}; "crucible" = callPackage - ({ mkDerivation, base, bimap, bv-sized, containers, exceptions, fgl - , hashable, hspec, json, lens, mtl, panic, parameterized-utils - , prettyprinter, QuickCheck, tasty, tasty-hspec, tasty-hunit - , tasty-quickcheck, template-haskell, text, th-abstraction, time - , transformers, unordered-containers, vector, what4 + ({ mkDerivation, async, base, bimap, bv-sized, containers + , exceptions, fgl, hashable, hspec, json, lens, mtl, panic + , parameterized-utils, prettyprinter, QuickCheck, tasty + , tasty-hspec, tasty-hunit, tasty-quickcheck, template-haskell + , text, th-abstraction, time, transformers, unordered-containers + , vector, what4 }: mkDerivation { pname = "crucible"; - version = "0.7"; - sha256 = "0wz71bx59bysylb8w05d59awh6l9bbw3na6xk4j9dprjx5caccjk"; + version = "0.7.1"; + sha256 = "1c9a8km88ngxghn35f6wnaddm534ixmz1iciyn0whl0xmp27f4zv"; libraryHaskellDepends = [ - base bimap bv-sized containers exceptions fgl hashable json lens - mtl panic parameterized-utils prettyprinter template-haskell text - th-abstraction time transformers unordered-containers vector what4 + async base bimap bv-sized containers exceptions fgl hashable json + lens mtl panic parameterized-utils prettyprinter template-haskell + text th-abstraction time transformers unordered-containers vector + what4 ]; testHaskellDepends = [ base containers hspec mtl panic parameterized-utils QuickCheck @@ -78686,8 +78804,8 @@ self: { }: mkDerivation { pname = "crucible-llvm"; - version = "0.6"; - sha256 = "0mjyldz65qssx31fryv74wmkfz68j735cvcp6qd2z02p73fbbdi7"; + version = "0.7"; + sha256 = "0v4d3c971w6acka4s1lg9iai55ghk054hkkka5jbinyhhymmaf0k"; libraryHaskellDepends = [ attoparsec base bv-sized bytestring containers crucible crucible-symio extra itanium-abi lens llvm-pretty mtl @@ -78711,8 +78829,8 @@ self: { }: mkDerivation { pname = "crucible-symio"; - version = "0.1"; - sha256 = "0b6c1sk7lg8qf3v1z4shzqwqcbwqbf4sir28iz52063pakvgr4q8"; + version = "0.1.1"; + sha256 = "0c96c0iqdx2ahc9sjslck1bfnjkha1kii1p3izhw9b9d34h339d7"; libraryHaskellDepends = [ aeson base bv-sized bytestring containers crucible directory filemanip filepath IntervalMap lens mtl parameterized-utils text @@ -78773,8 +78891,8 @@ self: { }: mkDerivation { pname = "crux"; - version = "0.7"; - sha256 = "0bbkg6l5322a50wgfdswq9m75vinm5xfv7lwl4sfy6604ckjy85i"; + version = "0.7.1"; + sha256 = "0l5nl9rv3kl07pwvj7dpw6njr6bh127ckallnlgkvp7c8l4cxgdy"; libraryHaskellDepends = [ aeson ansi-terminal async attoparsec base bv-sized bytestring config-schema config-value containers contravariant crucible @@ -78799,8 +78917,8 @@ self: { }: mkDerivation { pname = "crux-llvm"; - version = "0.8"; - sha256 = "116vgh9h2dmx1cahs2kl7rm46v9wn88x6i1pjp5m1z6mw9694xh4"; + version = "0.9"; + sha256 = "0nrqaqs9l3kyj954swlln12b75xszcwrgwscc5n0r0pmi6sszrqj"; isLibrary = true; isExecutable = true; enableSeparateDataOutput = true; @@ -79538,8 +79656,8 @@ self: { ({ mkDerivation, alex, ansi-terminal, arithmoi, array, async, base , base-compat, blaze-html, bv-sized, bytestring, containers , criterion, criterion-measurement, cryptohash-sha1, deepseq - , directory, exceptions, extra, filepath, ghc-bignum, ghc-prim - , gitrev, GraphSCC, happy, haskeline, heredoc, hgmp, language-c99 + , directory, exceptions, extra, file-embed, filepath, ghc-bignum + , ghc-prim, gitrev, GraphSCC, happy, haskeline, hgmp, language-c99 , language-c99-simple, libBF, libffi, MemoTrie, monad-control , monadLib, mtl, optparse-applicative, panic, parameterized-utils , pretty, pretty-show, prettyprinter, process, sbv, simple-smt, stm @@ -79548,15 +79666,15 @@ self: { }: mkDerivation { pname = "cryptol"; - version = "3.1.0"; - sha256 = "00qb0pmhmjcfkg6a7x948azp35rriajh4bfa1r8yb78in0ahyngj"; + version = "3.2.0"; + sha256 = "0nx25dfsnz1sd33kzicz9wqw4nsjv5s86s9w83mnh93xpmjqj1zd"; isLibrary = true; isExecutable = true; enableSeparateDataOutput = true; libraryHaskellDepends = [ arithmoi array async base base-compat bv-sized bytestring containers criterion-measurement cryptohash-sha1 deepseq directory - exceptions filepath ghc-bignum ghc-prim gitrev GraphSCC heredoc + exceptions file-embed filepath ghc-bignum ghc-prim gitrev GraphSCC hgmp language-c99 language-c99-simple libBF libffi MemoTrie monad-control monadLib mtl panic parameterized-utils pretty pretty-show prettyprinter process sbv simple-smt stm strict text @@ -80689,8 +80807,8 @@ self: { ({ mkDerivation, aeson, base, bytestring, curl, text }: mkDerivation { pname = "curl-aeson"; - version = "0.1.0.1"; - sha256 = "1hiz2rwbycl2nx5k1157nnl661rk1gkj7m4vc4qac1saqvf9jxdz"; + version = "0.1.0.2"; + sha256 = "0dsgc8sfydk1a73i3n66l7ffdprhd9w7q8ls1m5cj9fvwqpzb0rg"; libraryHaskellDepends = [ aeson base bytestring curl text ]; description = "Communicate with web services using JSON"; license = lib.licenses.bsd3; @@ -80955,8 +81073,8 @@ self: { }: mkDerivation { pname = "curryer-rpc"; - version = "0.3.6"; - sha256 = "0likxfgjv287c7xf5xq6hrzfqmh0vn6lv93s3chbp75gfxs8pwls"; + version = "0.3.7"; + sha256 = "1g8afbpayw6hcbgrfzqpipp3r0657mcimlmpizdxdk5xbl2j2r03"; isLibrary = true; isExecutable = true; libraryHaskellDepends = [ @@ -82917,14 +83035,16 @@ self: { "data-effects" = callPackage ({ mkDerivation, base, data-default, data-effects-core - , data-effects-th, tasty, tasty-discover, tasty-hunit, these + , data-effects-th, lens, tasty, tasty-discover, tasty-hunit, text + , these, time }: mkDerivation { pname = "data-effects"; - version = "0.1.0.0"; - sha256 = "0rq882lpi3j6g1pj3p60lqb2ad1is9zppng6vxh1vagjfk0jpj87"; + version = "0.1.1.0"; + sha256 = "0ypwb4618hjsvsdrwb1xbdq427g1bfc5dm9xibjbm2yrami16qr2"; libraryHaskellDepends = [ - base data-default data-effects-core data-effects-th these + base data-default data-effects-core data-effects-th lens text these + time ]; testHaskellDepends = [ base tasty tasty-hunit ]; testToolDepends = [ tasty-discover ]; @@ -82958,8 +83078,8 @@ self: { }: mkDerivation { pname = "data-effects-th"; - version = "0.1.0.0"; - sha256 = "1vq976iyn0k95p884pvwgq154jfjidbs7dyrql4hhldncz2v2j85"; + version = "0.1.1.0"; + sha256 = "0xs8n5f6v3dani9j2rpl75d8bx02295aimy0fh714qqwg1cmiml6"; libraryHaskellDepends = [ base containers data-default data-effects-core either extra formatting infinite-list lens mtl template-haskell text @@ -88445,7 +88565,6 @@ self: { benchmarkHaskellDepends = [ base bytestring criterion ]; description = "Lexer for the Dhall language"; license = lib.licenses.bsd3; - hydraPlatforms = lib.platforms.none; }) {}; "dhall-lsp-server" = callPackage @@ -88802,8 +88921,8 @@ self: { ({ mkDerivation, aeson, base, containers, QuickCheck, random }: mkDerivation { pname = "dhscanner-ast"; - version = "0.1.0.2"; - sha256 = "1q8wklhn4nyw2ryb8bdgfwvx4v5maf2minms5zkigqb1rh1snc8g"; + version = "0.1.0.3"; + sha256 = "1xksb6ilmdihq9rx6fcabwphlvwdsjss34aw1iqgc8gsiw60lm8c"; libraryHaskellDepends = [ aeson base containers ]; testHaskellDepends = [ base QuickCheck random ]; description = "abstract syntax tree for multiple programming languages"; @@ -88816,8 +88935,8 @@ self: { }: mkDerivation { pname = "dhscanner-bitcode"; - version = "0.1.0.1"; - sha256 = "036m2iix36ybcc8bqr9wz92rp4zq63qzyqgbm8bzk79zwdc432q2"; + version = "0.1.0.2"; + sha256 = "1ixm87h6ycbzf7b6jzwivcnvw96xlm8gmcw032hk54z8c9szrx3d"; libraryHaskellDepends = [ aeson base containers dhscanner-ast ]; testHaskellDepends = [ base containers dhscanner-ast QuickCheck random @@ -89331,8 +89450,8 @@ self: { pname = "diagrams-lib"; version = "1.4.6.2"; sha256 = "0qz5yrrg4k4f72fg20b1rq5mk7n7q531qmj0irpg9lmrr596bdh9"; - revision = "2"; - editedCabalFile = "1mdz1s014pn3v7b301d409zv5npw1gkdqkq2hzn8klnawcnmng57"; + revision = "3"; + editedCabalFile = "0sffvdkbxm1lsl2b7sd6psrrnc4lcc1c5ipvc2hhpmzzmfyc49fc"; libraryHaskellDepends = [ active adjunctions array base bytestring cereal colour containers data-default-class diagrams-core diagrams-solve directory @@ -89429,8 +89548,8 @@ self: { pname = "diagrams-postscript"; version = "1.5.1.1"; sha256 = "1kwb100k3qif9gc8kgvglya5by61522128cxsjrxk5a8dzpgwal4"; - revision = "3"; - editedCabalFile = "1yd084lqh2fs2m42a0744b7xlpsxk59ivjnaq99jkf1d6xq8kpak"; + revision = "4"; + editedCabalFile = "1wm9y3dj5bg6k2jm1ycy8sdg54pzgy2lrhdv9wm2n8jhhk3884qy"; libraryHaskellDepends = [ base bytestring containers data-default-class diagrams-core diagrams-lib hashable lens monoid-extras mtl semigroups split @@ -89466,8 +89585,8 @@ self: { pname = "diagrams-rasterific"; version = "1.4.2.3"; sha256 = "0n46scybjs8mnhrnh5z3nkrah6f8v1rv4cca8k8mqzsf8ss30q5l"; - revision = "2"; - editedCabalFile = "1v8djd4qndmkl8lc966pkh9gbgb8rkwqg2395xad6i03gqxvl55d"; + revision = "3"; + editedCabalFile = "0yz8vkxp8vi3di8wli6m8090vs56mngv3wr9riam896n1z0xqzg7"; libraryHaskellDepends = [ base bytestring containers data-default-class diagrams-core diagrams-lib file-embed filepath FontyFruity hashable JuicyPixels @@ -89552,6 +89671,26 @@ self: { license = lib.licenses.bsd3; }) {}; + "diagrams-svg_1_4_3_2" = callPackage + ({ mkDerivation, base, base64-bytestring, bytestring, colour + , containers, diagrams-core, diagrams-lib, filepath, hashable + , JuicyPixels, lens, monoid-extras, mtl, optparse-applicative + , semigroups, split, svg-builder, text + }: + mkDerivation { + pname = "diagrams-svg"; + version = "1.4.3.2"; + sha256 = "06syqgwprbzrmjylbw9rn7f4vz6fzbw0g0052mnzs92w5ddhkivg"; + libraryHaskellDepends = [ + base base64-bytestring bytestring colour containers diagrams-core + diagrams-lib filepath hashable JuicyPixels lens monoid-extras mtl + optparse-applicative semigroups split svg-builder text + ]; + description = "SVG backend for diagrams drawing EDSL"; + license = lib.licenses.bsd3; + hydraPlatforms = lib.platforms.none; + }) {}; + "diagrams-tikz" = callPackage ({ mkDerivation, base, diagrams-core, diagrams-lib, dlist, mtl }: mkDerivation { @@ -90400,6 +90539,25 @@ self: { license = lib.licenses.bsd3; }) {}; + "dimensional_1_6" = callPackage + ({ mkDerivation, base, criterion, deepseq, exact-pi, hspec + , hspec-discover, ieee754, numtype-dk, QuickCheck, vector + }: + mkDerivation { + pname = "dimensional"; + version = "1.6"; + sha256 = "05ikvdpl9j94alyf3r9fwfwn354z4gifbhp1fasspmd9s0bhi7wl"; + libraryHaskellDepends = [ + base deepseq exact-pi ieee754 numtype-dk vector + ]; + testHaskellDepends = [ base hspec QuickCheck ]; + testToolDepends = [ hspec-discover ]; + benchmarkHaskellDepends = [ base criterion deepseq ]; + description = "Statically checked physical dimensions"; + license = lib.licenses.bsd3; + hydraPlatforms = lib.platforms.none; + }) {}; + "dimensional-codata" = callPackage ({ mkDerivation, base, dimensional, numtype-dk }: mkDerivation { @@ -90550,9 +90708,7 @@ self: { ]; description = "Gemini client"; license = lib.licenses.gpl3Only; - hydraPlatforms = lib.platforms.none; mainProgram = "diohsc"; - broken = true; }) {}; "diophantine" = callPackage @@ -90986,7 +91142,6 @@ self: { ]; description = "Easily stream directory contents in constant memory"; license = lib.licenses.bsd3; - hydraPlatforms = lib.platforms.none; maintainers = [ lib.maintainers.Gabriella439 ]; }) {}; @@ -91991,8 +92146,8 @@ self: { }: mkDerivation { pname = "distributed-process-simplelocalnet"; - version = "0.3.0"; - sha256 = "1y9jxn1f56k5845dynac5hapfgsq66wibw2ypdzsp2lqh4ggs2jz"; + version = "0.3.1"; + sha256 = "06p7cynv7z4h62srzq99fi5v23v66g93k77wb6xiv0va83nqa0xr"; libraryHaskellDepends = [ base binary bytestring containers data-accessor distributed-process exceptions network network-multicast network-transport @@ -92099,16 +92254,16 @@ self: { ({ mkDerivation, ansi-terminal, base, binary, bytestring , distributed-process, distributed-static, exceptions, HUnit , network, network-transport, network-transport-inmemory, random - , rematch, setenv, stm, test-framework, test-framework-hunit + , rematch, stm, test-framework, test-framework-hunit }: mkDerivation { pname = "distributed-process-tests"; - version = "0.4.12"; - sha256 = "1jr7xgmwsy89hyih81w54bid8664rgqd8mxvwcd6xa6b41n90r7f"; + version = "0.5.0"; + sha256 = "01rpq0hgmvx7703xdx8x0ycfkbj7bpp3yqfxgzm8xy20d98cf9z7"; libraryHaskellDepends = [ ansi-terminal base binary bytestring distributed-process distributed-static exceptions HUnit network network-transport - random rematch setenv stm test-framework test-framework-hunit + random rematch stm test-framework test-framework-hunit ]; testHaskellDepends = [ base network network-transport network-transport-inmemory @@ -95694,8 +95849,8 @@ self: { }: mkDerivation { pname = "dunai"; - version = "0.13.0"; - sha256 = "1zbdl440xgb9s6nkqxg7fa2pc7m75w0bbndlfks4jqr1jq9f4hfh"; + version = "0.13.1"; + sha256 = "1hamj3yv6v0rdr06889iidhzpz6jbskq3bc5gbf45gzvq7bvcds7"; libraryHaskellDepends = [ base MonadRandom simple-affine-space transformers transformers-base ]; @@ -95726,8 +95881,8 @@ self: { ({ mkDerivation, base, dunai, normaldistribution, QuickCheck }: mkDerivation { pname = "dunai-test"; - version = "0.13.0"; - sha256 = "14ckh9bshfjcinj637cmbfq6jx85ga0z98v3sqm66jw84zdqr4sy"; + version = "0.13.1"; + sha256 = "0hm5c9n890cxnw0pp62vqlw7yqmrzy2xb0inhbzcjm49i5gacfdq"; libraryHaskellDepends = [ base dunai normaldistribution QuickCheck ]; @@ -98267,6 +98422,8 @@ self: { pname = "ekg"; version = "0.4.1.0"; sha256 = "03dgsgf67clk4wqrk69jqfh0ap406k0hgz257j0f5kixpws42ahp"; + revision = "1"; + editedCabalFile = "0frwz3jyxj0laaanzq39p74lzgq6cjxzhky51fkwa63qmlv5qfda"; enableSeparateDataOutput = true; libraryHaskellDepends = [ aeson base bytestring ekg-core ekg-json filepath network snap-core @@ -98410,6 +98567,8 @@ self: { pname = "ekg-json"; version = "0.1.1.0"; sha256 = "0wwzv2hfznd19385imajcarj0c42c3zczg3hlh39afy5k71hgvpp"; + revision = "1"; + editedCabalFile = "0zwmllpmczf9h6y8fagzinxin321z0fyxiyxlyw191i8zp57m579"; libraryHaskellDepends = [ aeson base ekg-core text unordered-containers ]; @@ -98443,10 +98602,8 @@ self: { }: mkDerivation { pname = "ekg-prometheus-adapter"; - version = "0.1.0.4"; - sha256 = "1i9bqbn8zj7hbkc7iypmjji4sh8s2h9jix2ngp77mkmii6wblfx2"; - revision = "1"; - editedCabalFile = "1aq3x5j33bb0rwlip0p3y6ppk8m1x8k3hnrwnb7pca98gyz8fm6r"; + version = "0.1.0.5"; + sha256 = "0k4dkf42jh4d19dj5x7crby5agb3rl62cd7zmd4zsnb3vih44v8y"; libraryHaskellDepends = [ base containers ekg-core microlens-th prometheus text transformers unordered-containers @@ -99228,8 +99385,8 @@ self: { }: mkDerivation { pname = "elminator"; - version = "0.2.4.2"; - sha256 = "1icmj116hlmgjbss1fnbzav327dl5ga8l092791rc5bf6m0m644z"; + version = "0.2.4.4"; + sha256 = "03sgjinzkdwmflcirzri3qyp180g35rib34kljd5yb0vskb3sa0g"; libraryHaskellDepends = [ aeson base containers mtl template-haskell text ]; @@ -101750,8 +101907,8 @@ self: { }: mkDerivation { pname = "escaped"; - version = "1.0.0.0"; - sha256 = "1fpnaj0ycjhb73skv5dxrycwyyvy0rripvcag88hsjyh1ybxx91v"; + version = "1.1.0.0"; + sha256 = "0xbpnvr4l7041m9zysn3gi589pp0snwmvpngvfb83jl3qh1j75ak"; isLibrary = true; isExecutable = true; libraryHaskellDepends = [ @@ -105972,8 +106129,8 @@ self: { }: mkDerivation { pname = "fast-builder"; - version = "0.1.3.0"; - sha256 = "0j2dfh6y689sk5ahh232zl8glbmwp34xnqkmaq9n9jwbddw4fg5z"; + version = "0.1.4.0"; + sha256 = "0v8nzzlnk5zvyfd4k8xakxdrgi0m23mk8k2bglm1447fgg6s02ma"; libraryHaskellDepends = [ base bytestring ghc-prim ]; testHaskellDepends = [ base bytestring process QuickCheck stm ]; benchmarkHaskellDepends = [ @@ -108832,6 +108989,8 @@ self: { pname = "fin"; version = "0.3.1"; sha256 = "1y98g48dr046d1v300aj10dq5mrn79yj769gcld01834xi0ng010"; + revision = "1"; + editedCabalFile = "1q6hq4m95b89ig3c21p36ng904vj84r5ga3brj589ifs068lpvv4"; libraryHaskellDepends = [ base boring dec deepseq hashable QuickCheck some universe-base ]; @@ -111538,6 +111697,8 @@ self: { pname = "foldl"; version = "1.4.16"; sha256 = "18bbhz0bjxb30ni9m9nm4aj8klakkd2fbjaymg8j3f0kdki3isj9"; + revision = "1"; + editedCabalFile = "1p628vf9s2ypblfsc5i1vb9xchy6big5nggcqns9xznncvpp23zc"; libraryHaskellDepends = [ base bytestring comonad containers contravariant hashable primitive profunctors random semigroupoids text transformers @@ -111550,6 +111711,29 @@ self: { maintainers = [ lib.maintainers.Gabriella439 ]; }) {}; + "foldl_1_4_17" = callPackage + ({ mkDerivation, base, bytestring, comonad, containers + , contravariant, criterion, doctest, hashable, primitive + , profunctors, random, semigroupoids, text, transformers + , unordered-containers, vector + }: + mkDerivation { + pname = "foldl"; + version = "1.4.17"; + sha256 = "1bk02j6niyw39279cf1im62lzd3gz8dc9qa7kgplz3fyb4chswgm"; + libraryHaskellDepends = [ + base bytestring comonad containers contravariant hashable primitive + profunctors random semigroupoids text transformers + unordered-containers vector + ]; + testHaskellDepends = [ base doctest ]; + benchmarkHaskellDepends = [ base criterion profunctors ]; + description = "Composable, streaming, and efficient left folds"; + license = lib.licenses.bsd3; + hydraPlatforms = lib.platforms.none; + maintainers = [ lib.maintainers.Gabriella439 ]; + }) {}; + "foldl-exceptions" = callPackage ({ mkDerivation, base, foldl, hedgehog, safe-exceptions }: mkDerivation { @@ -113424,8 +113608,8 @@ self: { }: mkDerivation { pname = "free-algebras"; - version = "0.1.1.0"; - sha256 = "16y0jvvsz1wr1w0hibnh94r438576ciq5snwjha8ca5b4c9ym980"; + version = "0.1.2.0"; + sha256 = "1q8l0ysn18v1qgi91b4nj26pv9iq1pwilzg19ql36aji193cirxy"; libraryHaskellDepends = [ base containers data-fix dlist free groups kan-extensions mtl transformers @@ -113473,6 +113657,8 @@ self: { pname = "free-category"; version = "0.0.4.5"; sha256 = "0ag52rmxrlhf5afk6nhrcpqwknvqrk9rhfn977zn1i0ad5b6ghag"; + revision = "1"; + editedCabalFile = "12fcz3ja47z0ri3f8nyj7pwizlbgir66z37z01x7l48d0lbg6jgj"; libraryHaskellDepends = [ base free-algebras ]; testHaskellDepends = [ base free-algebras QuickCheck tasty tasty-quickcheck @@ -114550,6 +114736,28 @@ self: { mainProgram = "frquotes"; }) {}; + "fs-api" = callPackage + ({ mkDerivation, base, bytestring, containers, deepseq, digest + , directory, filepath, io-classes, primitive, safe-wild-cards + , tasty, tasty-quickcheck, temporary, text, unix, unix-bytestring + }: + mkDerivation { + pname = "fs-api"; + version = "0.3.0.0"; + sha256 = "1l8rs0r6vbjb06qb5cd2qc9b8lb4cd0n159907q5s5zvm9nfgmd1"; + libraryHaskellDepends = [ + base bytestring containers deepseq digest directory filepath + io-classes primitive safe-wild-cards text unix unix-bytestring + ]; + testHaskellDepends = [ + base bytestring filepath primitive tasty tasty-quickcheck temporary + text + ]; + description = "Abstract interface for the file system"; + license = lib.licenses.asl20; + hydraPlatforms = lib.platforms.none; + }) {}; + "fs-events" = callPackage ({ mkDerivation, base }: mkDerivation { @@ -114563,6 +114771,31 @@ self: { broken = true; }) {}; + "fs-sim" = callPackage + ({ mkDerivation, base, base16-bytestring, bifunctors, bytestring + , containers, fs-api, generics-sop, io-classes, mtl, pretty-show + , primitive, QuickCheck, quickcheck-state-machine, random + , safe-wild-cards, strict-stm, tasty, tasty-hunit, tasty-quickcheck + , temporary, text + }: + mkDerivation { + pname = "fs-sim"; + version = "0.3.0.0"; + sha256 = "0wphs3i5f400i313qgii0z76mk3xqvzr5swnmhyc67kcl50l807q"; + libraryHaskellDepends = [ + base base16-bytestring bytestring containers fs-api io-classes mtl + primitive QuickCheck safe-wild-cards strict-stm text + ]; + testHaskellDepends = [ + base bifunctors bytestring containers fs-api generics-sop + pretty-show primitive QuickCheck quickcheck-state-machine random + strict-stm tasty tasty-hunit tasty-quickcheck temporary text + ]; + description = "Simulated file systems"; + license = lib.licenses.asl20; + hydraPlatforms = lib.platforms.none; + }) {}; + "fsh-csv" = callPackage ({ mkDerivation, base, hint }: mkDerivation { @@ -115636,6 +115869,27 @@ self: { license = lib.licenses.bsd3; }) {}; + "fused-effects_1_1_2_3" = callPackage + ({ mkDerivation, base, containers, hedgehog, hedgehog-fn + , inspection-testing, markdown-unlit, tasty-bench, transformers + , unliftio-core + }: + mkDerivation { + pname = "fused-effects"; + version = "1.1.2.3"; + sha256 = "0z0gwkb3rw9jpa3zxz5w3fc0x54xww0p5wzp4f0xdargjy1jhmk0"; + libraryHaskellDepends = [ base transformers unliftio-core ]; + testHaskellDepends = [ + base containers hedgehog hedgehog-fn inspection-testing + transformers + ]; + testToolDepends = [ markdown-unlit ]; + benchmarkHaskellDepends = [ base tasty-bench transformers ]; + description = "A fast, flexible, fused effect system"; + license = lib.licenses.bsd3; + hydraPlatforms = lib.platforms.none; + }) {}; + "fused-effects-exceptions" = callPackage ({ mkDerivation, base, fused-effects, markdown-unlit, tasty , tasty-hunit, transformers @@ -115844,8 +116098,8 @@ self: { }: mkDerivation { pname = "futhark"; - version = "0.25.20"; - sha256 = "149fzcd6rijr5vzpn42xfjr8k9pgijmqm4c754na1vj8d926sjgw"; + version = "0.25.21"; + sha256 = "1qhidm4vlpqh99mk6nn0kx95wbfhkkjy0dfcfvblkp03ckg0qbhm"; isLibrary = true; isExecutable = true; libraryHaskellDepends = [ @@ -120240,8 +120494,8 @@ self: { ({ mkDerivation, base, deepseq, ghc-heap, ghc-prim }: mkDerivation { pname = "ghc-datasize"; - version = "0.2.6"; - sha256 = "0nprk7mzr6n63ihjdqrs2kd16hzl72n04zi3hpsjlszy8gzizqg5"; + version = "0.2.7"; + sha256 = "0xndiq2049nrfwrgzdz1m0rkskiqcsblkfxwijxf0lzy4avj4bh1"; libraryHaskellDepends = [ base deepseq ghc-heap ghc-prim ]; description = "Determine the size of data structures in GHC's memory"; license = lib.licenses.bsd3; @@ -121758,8 +122012,8 @@ self: { }: mkDerivation { pname = "ghc-tags-core"; - version = "0.6.1.0"; - sha256 = "0x2l1n8fsg7z0x3bvqa806l4ldzxjsapfv9cf3fnvandh9d2dc4p"; + version = "0.6.1.1"; + sha256 = "1p1ykmbq16lg30s2cnwds16aiq4wxiv9s59sa933fk9mv2841gb1"; libraryHaskellDepends = [ attoparsec base bytestring containers deepseq filepath ghc text ]; @@ -121790,8 +122044,8 @@ self: { }: mkDerivation { pname = "ghc-tags-plugin"; - version = "0.6.1.0"; - sha256 = "1c3vr9754szadl4bj98hmjz5jmqahggakm7x3838cccqbdrpxyh0"; + version = "0.6.1.1"; + sha256 = "1w1m942hzw63igdjvhb15n5w0yzkm2hp5lyv1dl815dvzj0bn8kq"; isLibrary = true; isExecutable = true; libraryHaskellDepends = [ @@ -124690,8 +124944,8 @@ self: { }: mkDerivation { pname = "git-annex"; - version = "10.20240808"; - sha256 = "0593kq47kv8zqlknsicih5kh0f0qxy3xwadaqmi5gffrjpvapdf5"; + version = "10.20240831"; + sha256 = "1ly9iirr0669i5aq3k1lf60sg5z3p08kn4jnvnjcx0l114b67q3j"; configureFlags = [ "-fassistant" "-f-benchmark" "-fcrypton" "-fdbus" "-f-debuglocks" "-fmagicmime" "-fpairing" "-fproduction" "-ftorrentparser" @@ -139483,17 +139737,17 @@ self: { }) {}; "hashes" = callPackage - ({ mkDerivation, base, bytestring, criterion, openssl, QuickCheck - , sha-validation, sydtest, vector + ({ mkDerivation, base, bytestring, criterion, hspec, openssl + , QuickCheck, sha-validation, vector }: mkDerivation { pname = "hashes"; - version = "0.3.0"; - sha256 = "007hn43jnz0pgv49if9g4z3r13q8kkla9w15ggbdrc2hksdbzf3v"; + version = "0.3.0.1"; + sha256 = "0frrqa16p855qgs2lphdl9ka803j3xra7jw31s51r6xdh2ilb9jd"; libraryHaskellDepends = [ base bytestring ]; librarySystemDepends = [ openssl ]; testHaskellDepends = [ - base bytestring QuickCheck sha-validation sydtest vector + base bytestring hspec QuickCheck sha-validation vector ]; testSystemDepends = [ openssl ]; benchmarkHaskellDepends = [ base bytestring criterion ]; @@ -144115,19 +144369,20 @@ self: { }) {}; "hasmtlib" = callPackage - ({ mkDerivation, attoparsec, base, bitvec, bytestring, containers - , data-default, dependent-map, finite-typelits, lens, mtl - , smtlib-backends, smtlib-backends-process, some, text, utf8-string - , vector-sized + ({ mkDerivation, array, attoparsec, base, bitvec, bytestring + , containers, data-default, dependent-map, finite-typelits, lens + , mtl, smtlib-backends, smtlib-backends-process, some, text + , unordered-containers, utf8-string, vector-sized }: mkDerivation { pname = "hasmtlib"; - version = "2.3.2"; - sha256 = "11vbxn0lkfnasc9qvk8bjqd7nk7fwbs9zjgwwsfzgz5ann3aja8p"; + version = "2.6.1"; + sha256 = "004dic90jsf65z6y8zv0ik3bb9ln1zw5b42kgdm5a4cg97q02fy2"; libraryHaskellDepends = [ - attoparsec base bitvec bytestring containers data-default + array attoparsec base bitvec bytestring containers data-default dependent-map finite-typelits lens mtl smtlib-backends - smtlib-backends-process some text utf8-string vector-sized + smtlib-backends-process some text unordered-containers utf8-string + vector-sized ]; description = "A monad for interfacing with external SMT solvers"; license = lib.licenses.gpl3Only; @@ -144210,7 +144465,7 @@ self: { license = lib.licenses.mit; }) {}; - "hasql_1_8" = callPackage + "hasql_1_8_0_2" = callPackage ({ mkDerivation, aeson, attoparsec, base, bytestring , bytestring-strict-builder, contravariant, contravariant-extras , criterion, dlist, hashable, hashtables, hspec, hspec-discover @@ -144221,8 +144476,8 @@ self: { }: mkDerivation { pname = "hasql"; - version = "1.8"; - sha256 = "0jaapi6p45iy1z62pi81h1w52icvk1lbd7nsx16wnl6h9bx10mr4"; + version = "1.8.0.2"; + sha256 = "0dgvbvvkn7d5khz5p97ndbw6j72zram986yn6m519ng3c30d51q9"; libraryHaskellDepends = [ aeson attoparsec base bytestring bytestring-strict-builder contravariant dlist hashable hashtables iproute mtl @@ -147848,8 +148103,8 @@ self: { }: mkDerivation { pname = "heftia"; - version = "0.2.0.0"; - sha256 = "1kqpg346sbavphq00spl9pmj1f7d9n467zc8qil82q71nsmhqni3"; + version = "0.3.0.0"; + sha256 = "1brmn77ihnx2a7w64ikw9n8ym4gkaw7zkz5ycrc5dfzsl9ai220s"; libraryHaskellDepends = [ base constraints data-effects extensible free kan-extensions membership mtl singletons-base singletons-th transformers @@ -147864,25 +148119,27 @@ self: { "heftia-effects" = callPackage ({ mkDerivation, base, containers, data-effects, extensible, extra - , free, ghc-typelits-knownnat, heftia, loglevel, mtl, tasty - , tasty-discover, tasty-hunit, text, time, transformers, unliftio + , free, ghc-typelits-knownnat, heftia, hspec, mtl, tasty + , tasty-discover, tasty-hspec, text, time, transformers + , unbounded-delays, unliftio }: mkDerivation { pname = "heftia-effects"; - version = "0.2.0.0"; - sha256 = "0jk9gmrh1y9dzxsva4azbd74bgxfqswh4awsxgmpqigg1g36m6sh"; + version = "0.3.0.0"; + sha256 = "00lgnsnyn0rwhgnzfdq6kq5wxcs3w6d6awcj65kikhp9ysnv0j5n"; isLibrary = true; isExecutable = true; libraryHaskellDepends = [ - base containers data-effects extensible free ghc-typelits-knownnat - heftia mtl transformers unliftio + base containers data-effects extensible extra free + ghc-typelits-knownnat heftia mtl time transformers unbounded-delays + unliftio ]; executableHaskellDepends = [ - base data-effects extra ghc-typelits-knownnat heftia loglevel text - time + base data-effects extra ghc-typelits-knownnat heftia text time ]; testHaskellDepends = [ - base data-effects ghc-typelits-knownnat heftia tasty tasty-hunit + base data-effects ghc-typelits-knownnat heftia hspec tasty + tasty-hspec unliftio ]; testToolDepends = [ tasty-discover ]; description = "higher-order effects done right"; @@ -149490,6 +149747,19 @@ self: { license = lib.licenses.bsd3; }) {}; + "hexml_0_3_5" = callPackage + ({ mkDerivation, base, bytestring, extra }: + mkDerivation { + pname = "hexml"; + version = "0.3.5"; + sha256 = "15mjy6cxihh4bwdi0mh2vawqimpylzvl0jnpxwgalg96dsnj30a1"; + libraryHaskellDepends = [ base bytestring extra ]; + testHaskellDepends = [ base bytestring ]; + description = "XML subset DOM parser"; + license = lib.licenses.bsd3; + hydraPlatforms = lib.platforms.none; + }) {}; + "hexml-lens" = callPackage ({ mkDerivation, base, bytestring, contravariant, foundation, hexml , hspec, lens, profunctors, text, wreq @@ -151128,6 +151398,8 @@ self: { pname = "higgledy"; version = "0.4.2.1"; sha256 = "0gwlksxqfngd3ikc5nlbh7jq42l8siriqmgbravkvk1f78p1rcy3"; + revision = "1"; + editedCabalFile = "1qfknh9696gywnwrp45xrqzw1dqv1pr3gsla9fw9rr4i28pbd4br"; setupHaskellDepends = [ base Cabal cabal-doctest ]; libraryHaskellDepends = [ barbies base generic-lens generic-lens-core named QuickCheck @@ -153530,7 +153802,7 @@ self: { license = lib.licenses.bsd3; hydraPlatforms = lib.platforms.none; broken = true; - }) {inherit (pkgs) fam;}; + }) {fam = null;}; "hlibgit2" = callPackage ({ mkDerivation, base, bindings-DSL, git, openssl, process, zlib }: @@ -159267,6 +159539,28 @@ self: { license = lib.licenses.bsd3; }) {GeoIP = null;}; + "hs-asapo" = callPackage + ({ mkDerivation, base, bytestring, cabal-doctest, clock, doctest + , libasapo-consumer, libasapo-producer, optparse-applicative, text + , time, timerep + }: + mkDerivation { + pname = "hs-asapo"; + version = "0.9.0"; + sha256 = "0629yz0zpq6zyqxxczmpv246nz4mv2vz1nv46w72cqz4b5mbanmf"; + setupHaskellDepends = [ base cabal-doctest ]; + libraryHaskellDepends = [ + base bytestring clock text time timerep + ]; + libraryPkgconfigDepends = [ libasapo-consumer libasapo-producer ]; + testHaskellDepends = [ + base bytestring clock doctest text time timerep + ]; + benchmarkHaskellDepends = [ base optparse-applicative text time ]; + description = "Haskell bindings for ASAP:O"; + license = lib.licenses.mit; + }) {libasapo-consumer = null; libasapo-producer = null;}; + "hs-aws-lambda" = callPackage ({ mkDerivation, aeson, base, base64, bytestring, case-insensitive , containers, deepseq, http-client, http-types, safe-exceptions @@ -159597,6 +159891,22 @@ self: { broken = true; }) {}; + "hs-highlight" = callPackage + ({ mkDerivation, base, bytestring, hspec }: + mkDerivation { + pname = "hs-highlight"; + version = "1.0.3"; + sha256 = "0m6x96v5h2xdw618y5ljp0cpy52np8lvd126sp7mqfqr318vx51x"; + isLibrary = true; + isExecutable = true; + libraryHaskellDepends = [ base bytestring ]; + executableHaskellDepends = [ base ]; + testHaskellDepends = [ base hspec ]; + description = "A tool to highlight terminal strings"; + license = lib.licenses.mit; + mainProgram = "test-exe"; + }) {}; + "hs-inspector" = callPackage ({ mkDerivation, base, haskell-src, hspec }: mkDerivation { @@ -160693,7 +161003,6 @@ self: { benchmarkHaskellDepends = [ base criterion ]; description = "Create ATS types from Haskell types"; license = lib.licenses.bsd3; - hydraPlatforms = lib.platforms.none; mainProgram = "hs2ats"; }) {}; @@ -162881,6 +163190,8 @@ self: { pname = "hslua-module-zip"; version = "1.1.3"; sha256 = "1fws5jwf1zwqilgm05y28ywgxavygnjpdlj43nhfg8cmng1p0kyq"; + revision = "1"; + editedCabalFile = "1ml14hycwh4wg8351b8dq94qyppkzhw8jk0b0dgahqvy7p5w86y3"; libraryHaskellDepends = [ base bytestring filepath hslua-core hslua-list hslua-marshalling hslua-packaging hslua-typing text time zip-archive @@ -163514,7 +163825,6 @@ self: { testHaskellDepends = [ base hspec ]; description = "Helper functions to simplify adding integration tests"; license = lib.licenses.bsd3; - hydraPlatforms = lib.platforms.none; }) {}; "hspec-discover_2_7_10" = callPackage @@ -163790,14 +164100,14 @@ self: { license = lib.licenses.bsd3; }) {}; - "hspec-hedgehog_0_2_0_0" = callPackage + "hspec-hedgehog_0_3_0_0" = callPackage ({ mkDerivation, base, hedgehog, hspec, hspec-core, hspec-discover , HUnit, QuickCheck, splitmix }: mkDerivation { pname = "hspec-hedgehog"; - version = "0.2.0.0"; - sha256 = "1xf0sl6sliri7cc6wp5h9l90a732fkycmr71af2jv6yr8nv5rpak"; + version = "0.3.0.0"; + sha256 = "1px71jwxvqdh837fvlmx4smcvci9bbkygb7n10vasfpyb2k0yhzy"; libraryHaskellDepends = [ base hedgehog hspec hspec-core QuickCheck splitmix ]; @@ -165853,8 +166163,8 @@ self: { ({ mkDerivation, base, http-api-data, text }: mkDerivation { pname = "htmx"; - version = "0.1.0.0"; - sha256 = "0b2rjq3qv68vr7ljy844w9fiz93f0v0y2dykybhl5addbyz6z4nm"; + version = "0.1.0.1"; + sha256 = "06wnjhjgimggfhl2510lxwabqr5hdzb7yqlbmv9mi01c50q6idam"; libraryHaskellDepends = [ base http-api-data text ]; description = "Use htmx with various haskell libraries"; license = lib.licenses.mit; @@ -165878,8 +166188,8 @@ self: { ({ mkDerivation, base, htmx, htmx-lucid, lucid2, servant, text }: mkDerivation { pname = "htmx-servant"; - version = "0.2.0.0"; - sha256 = "0xckwxigcjfsf9idw056fnks7b3chdd9bawilwf252mcm45ywaqy"; + version = "0.2.0.1"; + sha256 = "0vwj3d34ada0iskjr4k7a75x6hf750b71acjphnwddpqf233mfla"; libraryHaskellDepends = [ base htmx htmx-lucid lucid2 servant text ]; @@ -166227,8 +166537,8 @@ self: { }: mkDerivation { pname = "http-barf"; - version = "0.1.0.0"; - sha256 = "0x5aczgzg1ck0yb7mjphl8p45y3kdg83zrzr5l2pvmpb5i6y7v6r"; + version = "0.1.1.0"; + sha256 = "1x1jmyqyrh4jmagml1vnjaf2hr5qvs1fjnvabslvvz33hx601398"; libraryHaskellDepends = [ aeson base bytestring http-client http-client-tls mtl vector ]; @@ -166579,6 +166889,37 @@ self: { license = lib.licenses.bsd3; }) {}; + "http-conduit_2_3_9" = callPackage + ({ mkDerivation, aeson, attoparsec, attoparsec-aeson, base + , blaze-builder, bytestring, case-insensitive, conduit + , conduit-extra, cookie, crypton-connection, data-default-class + , hspec, http-client, http-client-tls, http-types, HUnit, mtl + , network, resourcet, streaming-commons, temporary, text, time, tls + , transformers, unliftio, unliftio-core, utf8-string, wai + , wai-conduit, warp, warp-tls + }: + mkDerivation { + pname = "http-conduit"; + version = "2.3.9"; + sha256 = "0mg9l71lcilgc5mfc6syw71hqk17jc7f880s63zrwvfxnhc2cvi9"; + libraryHaskellDepends = [ + aeson attoparsec attoparsec-aeson base bytestring conduit + conduit-extra http-client http-client-tls http-types mtl resourcet + transformers unliftio-core + ]; + testHaskellDepends = [ + aeson attoparsec-aeson base blaze-builder bytestring + case-insensitive conduit conduit-extra cookie crypton-connection + data-default-class hspec http-client http-types HUnit network + resourcet streaming-commons temporary text time tls transformers + unliftio utf8-string wai wai-conduit warp warp-tls + ]; + doCheck = false; + description = "HTTP client package with conduit interface and HTTPS support"; + license = lib.licenses.bsd3; + hydraPlatforms = lib.platforms.none; + }) {}; + "http-conduit-browser" = callPackage ({ mkDerivation, base, base64-bytestring, blaze-builder, bytestring , case-insensitive, conduit, containers, cookie, data-default @@ -166814,8 +167155,8 @@ self: { }: mkDerivation { pname = "http-interchange"; - version = "0.3.2.1"; - sha256 = "1jji8wjdivpwd4zmhljn39d2rwvrlyxz7gmnacm8qkjmfhkhppkq"; + version = "0.3.2.2"; + sha256 = "0smmf2c86s01vp8vdyjl2hcqmq3q95r8ngdvs2d8drr7llf0dizv"; libraryHaskellDepends = [ base bytebuild byteslice bytesmith contiguous primitive text ]; @@ -167225,8 +167566,8 @@ self: { }: mkDerivation { pname = "http-semantics"; - version = "0.2.0"; - sha256 = "0n37zspfc6n5rswn10rxg21azkc40a60sl3c2f0zvzkqvsvfp0q3"; + version = "0.2.1"; + sha256 = "1nzxqrlxmkld86msmdp1zaqvsw3jbbj63n7r0bpgmyq7nnxqxiks"; libraryHaskellDepends = [ array base bytestring case-insensitive http-types network network-byte-order time-manager utf8-string @@ -167456,24 +167797,24 @@ self: { license = lib.licenses.bsd3; }) {}; - "http2_5_3_2" = callPackage + "http2_5_3_4" = callPackage ({ mkDerivation, aeson, aeson-pretty, array, async, base , base16-bytestring, bytestring, case-insensitive, containers - , crypton, directory, filepath, gauge, Glob, hspec, hspec-discover - , http-semantics, http-types, network, network-byte-order - , network-control, network-run, random, stm, text, time-manager - , typed-process, unix-time, unliftio, unordered-containers - , utf8-string, vector + , criterion, crypton, directory, filepath, Glob, hspec + , hspec-discover, http-semantics, http-types, iproute, network + , network-byte-order, network-control, network-run, random, stm + , text, time-manager, typed-process, unix-time, unliftio + , unordered-containers, utf8-string, vector }: mkDerivation { pname = "http2"; - version = "5.3.2"; - sha256 = "18nhxfshlddf8dgl1lbnkswjrm1zw91hsbcmvlw9ninnaqvzz93k"; + version = "5.3.4"; + sha256 = "006l2asgkcgdiyknl363n3wfdmaxbqnnf9kls4ljqxvc677l2jj3"; isLibrary = true; isExecutable = true; libraryHaskellDepends = [ array async base bytestring case-insensitive containers - http-semantics http-types network network-byte-order + http-semantics http-types iproute network network-byte-order network-control stm time-manager unix-time unliftio utf8-string ]; testHaskellDepends = [ @@ -167484,8 +167825,8 @@ self: { ]; testToolDepends = [ hspec-discover ]; benchmarkHaskellDepends = [ - array base bytestring case-insensitive containers gauge - network-byte-order stm + array base bytestring case-insensitive containers criterion + network-byte-order stm unliftio ]; description = "HTTP/2 library"; license = lib.licenses.bsd3; @@ -167637,8 +167978,8 @@ self: { }: mkDerivation { pname = "http3"; - version = "0.0.17"; - sha256 = "1dq8qbrq1gfpdvkahpxgg11diyfqk59srnp4hl8sbw0fsdxmiawp"; + version = "0.0.18"; + sha256 = "1wmh13irvsfkbzmg1xh5p68xqhvs21hr9dk3dk845xdn269vxidq"; isLibrary = true; isExecutable = true; libraryHaskellDepends = [ @@ -169483,8 +169824,8 @@ self: { }: mkDerivation { pname = "hw-polysemy"; - version = "0.2.14.0"; - sha256 = "0scmhk2wwgf4dpwwjw3idhhjqma58i0smcc2s2amgbw294bjnxw4"; + version = "0.2.14.2"; + sha256 = "08cllz3vm444yzvds9b5057l235gs5ardy9x9fbkagdryids6afp"; libraryHaskellDepends = [ aeson aeson-pretty async base binary bytestring contravariant Diff directory exceptions filepath generic-lens ghc-prim http-conduit @@ -171556,7 +171897,6 @@ self: { ]; description = "Lattice iCE40 Primitive IP"; license = lib.licenses.bsd3; - hydraPlatforms = lib.platforms.none; }) {}; "icepeak" = callPackage @@ -176679,18 +177019,21 @@ self: { }) {}; "io-classes" = callPackage - ({ mkDerivation, array, async, base, bytestring, mtl, primitive - , stm, time + ({ mkDerivation, array, async, base, bytestring, deepseq, nothunks + , primitive, QuickCheck, stm, tasty, tasty-quickcheck, time }: mkDerivation { pname = "io-classes"; - version = "1.5.0.0"; - sha256 = "1iwzmi6z3v9sx7n3x8yg1xa262i898f6vddxhx9lhgby0hw3r4i9"; - revision = "1"; - editedCabalFile = "0mqx8dq16y6ig3gxn7cdr6h3d6via1j5q8n7a3s8sln0apkak440"; + version = "1.7.0.0"; + sha256 = "1lnp09xmkl63zfy3ly5lmy1fsidngzksh35ws753s9287wc9fxbh"; + revision = "2"; + editedCabalFile = "1lkffla90j6fp64kbw220dsqxy0cqwa0987ssp24skkkgk5j0132"; libraryHaskellDepends = [ - array async base bytestring mtl primitive stm time + array async base bytestring deepseq nothunks primitive QuickCheck + stm time ]; + testHaskellDepends = [ base QuickCheck tasty tasty-quickcheck ]; + doHaddock = false; description = "Type classes for concurrency with STM, ST and timing"; license = lib.licenses.asl20; }) {}; @@ -176778,20 +177121,21 @@ self: { "io-sim" = callPackage ({ mkDerivation, array, base, containers, criterion, deepseq , exceptions, io-classes, nothunks, parallel, primitive, psqueues - , QuickCheck, quiet, si-timers, strict-stm, tasty, tasty-hunit - , tasty-quickcheck, time + , QuickCheck, quiet, tasty, tasty-hunit, tasty-quickcheck, time }: mkDerivation { pname = "io-sim"; - version = "1.5.0.0"; - sha256 = "0074ngiwrs7fnrllnzh7dz5k1f5dv65d7b9bjmx6kzfn38pmmn0v"; + version = "1.6.0.0"; + sha256 = "0ripyhcmvvlqhb2v2gnbvbmb6bi7pqlcnly7cs7a5rxb9iww4qla"; + revision = "3"; + editedCabalFile = "16if6l47s01q7lbx8b1ymi4gj6bzd53jajm89gwnrg8033mbx6cy"; libraryHaskellDepends = [ base containers deepseq exceptions io-classes nothunks parallel - primitive psqueues QuickCheck quiet si-timers strict-stm time + primitive psqueues QuickCheck quiet time ]; testHaskellDepends = [ - array base containers io-classes QuickCheck si-timers strict-stm - tasty tasty-hunit tasty-quickcheck time + array base containers io-classes QuickCheck tasty tasty-hunit + tasty-quickcheck time ]; benchmarkHaskellDepends = [ base criterion io-classes ]; description = "A pure simulator for monadic concurrency with STM"; @@ -177650,27 +177994,24 @@ self: { }) {}; "iri" = callPackage - ({ mkDerivation, attoparsec, base, bytestring, contravariant - , hashable, ip, profunctors, ptr, punycode, QuickCheck - , quickcheck-instances, rerebase, semigroups, tasty, tasty-hunit - , tasty-quickcheck, template-haskell, text, text-builder, th-lift + ({ mkDerivation, attoparsec, base, bytestring, cereal + , contravariant, hashable, ip, mtl, profunctors, ptr, rerebase + , tasty, tasty-hunit, template-haskell, text, text-builder, th-lift , th-lift-instances, unordered-containers, vector, vector-builder - , vector-instances + , vector-instances, wide-word }: mkDerivation { pname = "iri"; - version = "0.4"; - sha256 = "0v790f2fl4hcb6069ak5cscd156ry3065cshjh9c30239allw7m5"; + version = "0.5.1"; + sha256 = "0r1isflm644d823vwimrcmh4s8ash84gi4hgav1gxgiryw9j013n"; libraryHaskellDepends = [ - attoparsec base bytestring contravariant hashable ip profunctors - ptr punycode semigroups template-haskell text text-builder th-lift + attoparsec base bytestring cereal contravariant hashable ip mtl + profunctors ptr template-haskell text text-builder th-lift th-lift-instances unordered-containers vector vector-builder - vector-instances - ]; - testHaskellDepends = [ - QuickCheck quickcheck-instances rerebase tasty tasty-hunit - tasty-quickcheck + vector-instances wide-word ]; + testHaskellDepends = [ rerebase tasty tasty-hunit ]; + doHaddock = false; description = "RFC-based resource identifier library"; license = lib.licenses.mit; hydraPlatforms = lib.platforms.none; @@ -183181,7 +183522,7 @@ self: { license = lib.licenses.bsd3; }) {}; - "katip_0_8_8_1" = callPackage + "katip_0_8_8_2" = callPackage ({ mkDerivation, aeson, async, auto-update, base, blaze-builder , bytestring, containers, criterion, deepseq, directory, either , filepath, hostname, microlens, microlens-th, monad-control, mtl @@ -183194,8 +183535,8 @@ self: { }: mkDerivation { pname = "katip"; - version = "0.8.8.1"; - sha256 = "1745h9rkrm8dzvx1px62vq1rbgnwqxwrrz72m6vc4yyj1pzhhykc"; + version = "0.8.8.2"; + sha256 = "12g0i1ndzzkgf0qgkxx525d742mkfnsdwb9rhi6z8jn5hc38sps4"; libraryHaskellDepends = [ aeson async auto-update base bytestring containers either hostname microlens microlens-th monad-control mtl old-locale resourcet @@ -187410,7 +187751,6 @@ self: { benchmarkHaskellDepends = [ base criterion ]; description = "Parser and pretty-printer for ATS"; license = lib.licenses.bsd3; - hydraPlatforms = lib.platforms.none; }) {}; "language-avro" = callPackage @@ -189895,6 +190235,22 @@ self: { license = lib.licenses.mit; }) {}; + "lazyppl" = callPackage + ({ mkDerivation, base, containers, hmatrix, log-domain + , math-functions, monad-extras, mtl, random, transformers + }: + mkDerivation { + pname = "lazyppl"; + version = "1.0"; + sha256 = "1agm2d6yxsn9m46lljcnys85nwr29nhghffwhr6y9xgpdrf6gvzw"; + libraryHaskellDepends = [ + base containers hmatrix log-domain math-functions monad-extras mtl + random transformers + ]; + description = "Lazy Probabilistic Programming Library"; + license = lib.licenses.mit; + }) {}; + "lazyset" = callPackage ({ mkDerivation, base, containers, data-ordlist, HUnit, time , timeit @@ -192576,12 +192932,16 @@ self: { ({ mkDerivation, base, hspec, QuickCheck, split }: mkDerivation { pname = "libroman"; - version = "3.1.1"; - sha256 = "11yg74v290s4dy5bn94hb0lwncbbxqljgjldaxr80iy9c52z9hzi"; + version = "3.2.0"; + sha256 = "0y1n3c5a2qmazaifi760lsiy17vbmnhrm8v1ixs54y1ww75gpgw6"; + isLibrary = true; + isExecutable = true; libraryHaskellDepends = [ base split ]; + executableHaskellDepends = [ base ]; testHaskellDepends = [ base hspec QuickCheck ]; description = "Use Roman Numerals as a Numeric Datatype (sort of)"; license = lib.licenses.bsd3; + mainProgram = "roman"; }) {}; "libsecp256k1" = callPackage @@ -192735,10 +193095,8 @@ self: { }: mkDerivation { pname = "libsystemd-journal"; - version = "1.4.5.1"; - sha256 = "1d2pm38nq8bk55lva1y1p5789qdkcmmc1z376lnjs4f0jgb6pnhn"; - revision = "1"; - editedCabalFile = "0daj8yrxp9zph3jgyxp10gj0pi0yba58jv7iy67j6zi23hbzm6ar"; + version = "1.4.6.0"; + sha256 = "0wxf56i9mv6fm40rwzawbf829z73r4x7jchgardl770dg5zmy9yb"; libraryHaskellDepends = [ base bytestring hashable hsyslog pipes pipes-safe semigroups text transformers uniplate unix-bytestring unordered-containers uuid @@ -193270,8 +193628,8 @@ self: { }: mkDerivation { pname = "lifx-lan"; - version = "0.8.2"; - sha256 = "17n684whz5b80zg1jr7l5dp5qz2fa6g3hgqn5b8mjhqlrgqsmfwn"; + version = "0.8.3"; + sha256 = "0077wdyrfz20lrd55lzv3bd1ab9cckppkm1gyzp1g23b8xwdayz5"; libraryHaskellDepends = [ ansi-terminal base binary bytestring colour composition containers extra monad-loops mtl network random safe text time transformers @@ -194724,7 +195082,6 @@ self: { ]; description = "RISC-V Core"; license = lib.licenses.bsd3; - hydraPlatforms = lib.platforms.none; }) {}; "lipsum-gen" = callPackage @@ -194826,13 +195183,13 @@ self: { , optparse-applicative, parallel, parser-combinators, pretty , process, rest-rewrite, smtlib-backends, smtlib-backends-process , stm, store, syb, tagged, tasty, tasty-ant-xml, tasty-hunit - , tasty-quickcheck, tasty-rerun, text, transformers, typed-process + , tasty-quickcheck, tasty-rerun, text, transformers , unordered-containers, vector, z3 }: mkDerivation { pname = "liquid-fixpoint"; - version = "0.9.6.3"; - sha256 = "0vir7l5wpbpcgvydncxsn6yk6xi2v8ax4r75zb4cn0sl4cyswp4m"; + version = "0.9.6.3.1"; + sha256 = "1lad9s2slvbz0msdk43554h73zhw8cxcbj7fnj2nbj0rni8q0i0i"; configureFlags = [ "-fbuild-external" ]; isLibrary = true; isExecutable = true; @@ -194842,14 +195199,14 @@ self: { fgl filepath hashable intern lens-family megaparsec mtl parallel parser-combinators pretty process rest-rewrite smtlib-backends smtlib-backends-process stm store syb text transformers - typed-process unordered-containers vector + unordered-containers vector ]; executableHaskellDepends = [ base ]; testHaskellDepends = [ base containers directory filepath hashable mtl optparse-applicative process stm tagged tasty tasty-ant-xml tasty-hunit tasty-quickcheck tasty-rerun text transformers - typed-process unordered-containers + unordered-containers ]; testSystemDepends = [ git nettools z3 ]; doCheck = false; @@ -194918,10 +195275,8 @@ self: { }: mkDerivation { pname = "liquid-prelude"; - version = "0.9.2.8.1"; - sha256 = "1yan7blwns2r39qgrrzn2q7z9j6m72jllnl523w61frr7yzlxkck"; - revision = "1"; - editedCabalFile = "08zwppn1jpf1cpz1f3pq18wxdl20spmkkfj604kn8x0bz4d0386d"; + version = "0.9.2.8.2"; + sha256 = "0ldap73vg5qxw9fh2mmfinhg78wpqf8nnpd4kd7abpxlpmni8d3r"; setupHaskellDepends = [ base Cabal liquidhaskell-boot ]; libraryHaskellDepends = [ base bytestring containers ghc-prim liquidhaskell @@ -194948,15 +195303,16 @@ self: { "liquidhaskell" = callPackage ({ mkDerivation, base, bytestring, Cabal, containers, ghc-bignum - , ghc-prim, liquidhaskell-boot, z3 + , ghc-internal, ghc-prim, liquidhaskell-boot, z3 }: mkDerivation { pname = "liquidhaskell"; - version = "0.9.8.1"; - sha256 = "0dak8ixjylm4lznzddn4zcjdb8nm9ha5l6p29l6bhk54gfzccsn8"; + version = "0.9.10.1"; + sha256 = "1r3syj0c2v8x3xd2bqywf8f596r9mnf85mr2r9xvfxxd6dlmyz85"; setupHaskellDepends = [ base Cabal liquidhaskell-boot ]; libraryHaskellDepends = [ - base bytestring containers ghc-bignum ghc-prim liquidhaskell-boot + base bytestring containers ghc-bignum ghc-internal ghc-prim + liquidhaskell-boot ]; testSystemDepends = [ z3 ]; description = "Liquid Types for Haskell"; @@ -194968,16 +195324,16 @@ self: { ({ mkDerivation, aeson, base, binary, bytestring, Cabal, cereal , cmdargs, containers, data-default, data-fix, deepseq, Diff , directory, exceptions, extra, filepath, fingertree, free, ghc - , ghc-boot, ghc-paths, ghc-prim, githash, gitrev, hashable - , hscolour, liquid-fixpoint, megaparsec, mtl, optparse-applicative - , pretty, recursion-schemes, split, syb, tasty, tasty-ant-xml - , tasty-hunit, template-haskell, temporary, text, th-compat, time - , transformers, unordered-containers, vector + , ghc-boot, ghc-internal, ghc-paths, ghc-prim, githash, gitrev + , hashable, hscolour, liquid-fixpoint, megaparsec, mtl + , optparse-applicative, pretty, recursion-schemes, split, syb + , tasty, tasty-ant-xml, tasty-hunit, template-haskell, temporary + , text, th-compat, time, transformers, unordered-containers, vector }: mkDerivation { pname = "liquidhaskell-boot"; - version = "0.9.8.1"; - sha256 = "00cm1myw2l051nspx04vn332jxn2wary2mn5yhv0pqsvi28j2vnw"; + version = "0.9.10.1"; + sha256 = "11dl8lsw0wqacfjhvs03ymrsv2gxfkgjv5mbp30vmd0c3gb34fgl"; libraryHaskellDepends = [ aeson base binary bytestring Cabal cereal cmdargs containers data-default data-fix deepseq Diff directory exceptions extra @@ -194988,8 +195344,9 @@ self: { unordered-containers vector ]; testHaskellDepends = [ - base directory filepath ghc ghc-paths liquid-fixpoint megaparsec - syb tasty tasty-ant-xml tasty-hunit time + base directory filepath ghc ghc-internal ghc-paths ghc-prim + liquid-fixpoint megaparsec syb tasty tasty-ant-xml tasty-hunit + template-haskell time unordered-containers ]; description = "Liquid Types for Haskell"; license = lib.licenses.bsd3; @@ -196172,8 +196529,8 @@ self: { }: mkDerivation { pname = "llvm-pretty"; - version = "0.12.0.0"; - sha256 = "1xdlic9rl63617qqwxlf2sn0j67wsnarhllf1k5anzgprd64vylj"; + version = "0.12.1.0"; + sha256 = "113avpn33gyh65yd0bbfwni044ih5vcbnv8l43siy8a4asp0xfwi"; libraryHaskellDepends = [ base containers microlens microlens-th monadLib parsec pretty syb template-haskell th-abstraction @@ -196199,8 +196556,8 @@ self: { }: mkDerivation { pname = "llvm-pretty-bc-parser"; - version = "0.4.1.0"; - sha256 = "1nc8znxzzg2qgn3x52a310rn8lg647k495927k6zfs2x07chy5gh"; + version = "0.4.2.0"; + sha256 = "1y0wvczlrmx990c9i697vy30bpl7109k9psxpldd3857cadmkmdi"; isLibrary = true; isExecutable = true; libraryHaskellDepends = [ @@ -198812,6 +199169,21 @@ self: { license = lib.licenses.mit; }) {inherit (pkgs) lua5_4;}; + "lua_2_3_3" = callPackage + ({ mkDerivation, base, lua5_4, tasty, tasty-hunit }: + mkDerivation { + pname = "lua"; + version = "2.3.3"; + sha256 = "0xvhfq8ms5wbchrscxaqf4a9panfnzgz5xdlg86790nydab2kals"; + configureFlags = [ "-fsystem-lua" "-f-use-pkgconfig" ]; + libraryHaskellDepends = [ base ]; + librarySystemDepends = [ lua5_4 ]; + testHaskellDepends = [ base tasty tasty-hunit ]; + description = "Lua, an embeddable scripting language"; + license = lib.licenses.mit; + hydraPlatforms = lib.platforms.none; + }) {inherit (pkgs) lua5_4;}; + "lua-arbitrary" = callPackage ({ mkDerivation, base, lua, QuickCheck }: mkDerivation { @@ -202955,8 +203327,8 @@ self: { }: mkDerivation { pname = "matterhorn"; - version = "90000.0.0"; - sha256 = "0vc63h1xcg578c88wra66lb1x4spqqbcg5kfgjqqy3klqs2qz0sp"; + version = "90000.0.1"; + sha256 = "09zgjg6ymclxjbmlcrvwhd9nfjiqnx13ln52gvgk6wxkksdxb614"; isLibrary = true; isExecutable = true; enableSeparateDataOutput = true; @@ -204065,6 +204437,8 @@ self: { pname = "melf"; version = "1.3.1"; sha256 = "0ivfzsw36qy0m93h353r3963vmhirzg3a5mirqn1hfbsk24xf1dx"; + revision = "2"; + editedCabalFile = "0q822xj2z2xbdi8wk0dyny9k3lbpx6c3dmxrlimdnz43218x58rn"; isLibrary = true; isExecutable = true; enableSeparateDataOutput = true; @@ -210271,11 +210645,11 @@ self: { ({ mkDerivation, base }: mkDerivation { pname = "monadLib"; - version = "3.10.1"; - sha256 = "0n5fmmsc0qww0nz3k2j4j68qdpq3px46abl9igvv06iz2xi8b778"; + version = "3.10.3"; + sha256 = "048xk3zr7237c0mzr6lfca3qsgh60icnp8vw3vg2pj12z8id62ka"; libraryHaskellDepends = [ base ]; description = "A collection of monad transformers"; - license = lib.licenses.bsd3; + license = lib.licenses.isc; }) {}; "monadLib-compose" = callPackage @@ -218651,15 +219025,15 @@ self: { license = lib.licenses.bsd3; }) {}; - "network_3_2_1_0" = callPackage + "network_3_2_2_0" = callPackage ({ mkDerivation, base, bytestring, deepseq, directory, hspec - , hspec-discover, HUnit, QuickCheck, temporary + , hspec-discover, HUnit, QuickCheck, stm, temporary }: mkDerivation { pname = "network"; - version = "3.2.1.0"; - sha256 = "00fjgg9zj5nhw1ra8kqaaa3cxzkf0lxnzcfdqvagxx7fdvbwdw4h"; - libraryHaskellDepends = [ base bytestring deepseq directory ]; + version = "3.2.2.0"; + sha256 = "033zcj1ibrw49h4rbkhbznyz0na25zyaihh2m35wqlkgji3lkc7g"; + libraryHaskellDepends = [ base bytestring deepseq directory stm ]; testHaskellDepends = [ base bytestring directory hspec HUnit QuickCheck temporary ]; @@ -220510,8 +220884,8 @@ self: { }: mkDerivation { pname = "ngx-export-tools-extra"; - version = "1.2.8.1"; - sha256 = "0x56jxbswzs371z8a93h5zbda4h6y9l2jnlp15h5vg9lsn2fhrnw"; + version = "1.2.9.1"; + sha256 = "0mafzhc6lnari85ng2iw025nhyvwsqkaamxf6jlkkm45k9zsa59y"; libraryHaskellDepends = [ aeson array async base base64 binary bytestring case-insensitive containers ede enclosed-exceptions http-client @@ -225260,10 +225634,10 @@ self: { ({ mkDerivation, base, containers, ghc, safe }: mkDerivation { pname = "om-plugin-imports"; - version = "0.3.0.0.9.10"; - sha256 = "0x3h9maja4vq3zzh0swi6yfhc149gh4m01mdbhy0v2l6054mfl51"; + version = "0.4.0.0.9.10"; + sha256 = "07ghwn2jpy580mzf70x0rawmxsqsbyy1adp204vydxapp04xbv0k"; libraryHaskellDepends = [ base containers ghc safe ]; - description = "Plugin-based import warnings"; + description = "Plugin-based explicit import generation"; license = lib.licenses.mit; hydraPlatforms = lib.platforms.none; broken = true; @@ -232136,8 +232510,8 @@ self: { pname = "parameterized-utils"; version = "2.1.8.0"; sha256 = "026lrdnw5rjvny380rmrzpwhmcfgp551whbk0mnx2y2q6ij0sjfm"; - revision = "1"; - editedCabalFile = "0c253mwkk7a58frhavl9nzwlmps4kzvi5a5hsdv6mbsaqq5vq7vw"; + revision = "2"; + editedCabalFile = "1kk13926s885fxss2hz6h438k526s8agnhg8v199qam862f16yhh"; libraryHaskellDepends = [ base base-orphans constraints containers deepseq ghc-prim hashable hashtables indexed-traversable lens mtl profunctors @@ -235879,6 +236253,45 @@ self: { maintainers = [ lib.maintainers.psibi ]; }) {}; + "persistent_2_14_6_3" = callPackage + ({ mkDerivation, aeson, attoparsec, attoparsec-aeson, base + , base64-bytestring, blaze-html, bytestring, conduit, containers + , criterion, deepseq, fast-logger, file-embed, hspec, http-api-data + , lift-type, monad-logger, mtl, path-pieces, QuickCheck + , quickcheck-instances, resource-pool, resourcet, scientific + , shakespeare, silently, template-haskell, text, th-lift-instances + , time, transformers, unliftio, unliftio-core, unordered-containers + , vault, vector + }: + mkDerivation { + pname = "persistent"; + version = "2.14.6.3"; + sha256 = "1nqmd1ml1s4cm9hwfz9cz5qj4i9zm8ip69gmgysfgbs0h64f7w2d"; + libraryHaskellDepends = [ + aeson attoparsec attoparsec-aeson base base64-bytestring blaze-html + bytestring conduit containers deepseq fast-logger http-api-data + lift-type monad-logger mtl path-pieces resource-pool resourcet + scientific silently template-haskell text th-lift-instances time + transformers unliftio unliftio-core unordered-containers vault + vector + ]; + testHaskellDepends = [ + aeson attoparsec base base64-bytestring blaze-html bytestring + conduit containers deepseq fast-logger hspec http-api-data + monad-logger mtl path-pieces QuickCheck quickcheck-instances + resource-pool resourcet scientific shakespeare silently + template-haskell text th-lift-instances time transformers unliftio + unliftio-core unordered-containers vector + ]; + benchmarkHaskellDepends = [ + base criterion deepseq file-embed template-haskell text + ]; + description = "Type-safe, multi-backend data serialization"; + license = lib.licenses.mit; + hydraPlatforms = lib.platforms.none; + maintainers = [ lib.maintainers.psibi ]; + }) {}; + "persistent-audit" = callPackage ({ mkDerivation, aeson, attoparsec, base, bytestring , getopt-generics, hashable, hspec, mongoDB, persistent @@ -236393,6 +236806,8 @@ self: { pname = "persistent-postgresql"; version = "2.13.6.2"; sha256 = "1z6cy54qnxpml86b6dr67kin6ww0dfn9vg3bzb3iw5s9srf7zwn2"; + revision = "1"; + editedCabalFile = "1a58a602nnwrb3s72q12piw18r458w3ha9nfjmpz5na566ndqmgl"; isLibrary = true; isExecutable = true; libraryHaskellDepends = [ @@ -237245,8 +237660,8 @@ self: { ({ mkDerivation, base, bytestring, containers, QuickCheck, text }: mkDerivation { pname = "phaser"; - version = "1.0.1.0"; - sha256 = "0c4b5mx2nz8r0bpk29knzgs1hq5f69wsscplk7dcfsqwkngid930"; + version = "1.0.2.0"; + sha256 = "1zykmcbhi8plrdp9n1idz3n0181ml9q5k1zj508f6a2pvyl4jcxa"; libraryHaskellDepends = [ base bytestring containers text ]; testHaskellDepends = [ base bytestring containers QuickCheck text @@ -241106,8 +241521,8 @@ self: { }: mkDerivation { pname = "plots"; - version = "0.1.1.4"; - sha256 = "1b68dd1xk6kqfgyypddk4zcllm8lnfxz2a2fhvb4d09ar3ix7s40"; + version = "0.1.1.5"; + sha256 = "0dgjg1idfhmnzdy7c2my1ri98psbm8jq67ssnb2iss4ay9fs13fw"; libraryHaskellDepends = [ adjunctions base base-orphans colour containers data-default diagrams-core diagrams-lib directory distributive filepath @@ -242272,6 +242687,8 @@ self: { pname = "polysemy-blockfrost"; version = "0.1.4.0"; sha256 = "0l4qna29fv8z2mh9aywp30mmlpw73hn40gwkzhpv8hjdlppvlri1"; + revision = "1"; + editedCabalFile = "1jljm9ajc8nkqgbm0by2mnascflypw47l6zr22msifxrmlvvyik7"; libraryHaskellDepends = [ base blockfrost-api blockfrost-client polysemy polysemy-plugin text ]; @@ -244479,14 +244896,14 @@ self: { license = lib.licenses.bsd3; }) {inherit (pkgs) postgresql;}; - "postgresql-libpq_0_10_2_0" = callPackage + "postgresql-libpq_0_11_0_0" = callPackage ({ mkDerivation, base, bytestring, postgresql-libpq-configure , tasty, tasty-hunit, unix }: mkDerivation { pname = "postgresql-libpq"; - version = "0.10.2.0"; - sha256 = "1vsb95m7k7j7k1156bb2kn1iavj4x3mvczpybw0mypa76a1ppsck"; + version = "0.11.0.0"; + sha256 = "18yj7vb51r72ybzi7849w83b79gydnh7az1wkc037fz6iwhb2jh3"; libraryHaskellDepends = [ base bytestring postgresql-libpq-configure unix ]; @@ -244500,8 +244917,8 @@ self: { ({ mkDerivation, base }: mkDerivation { pname = "postgresql-libpq-configure"; - version = "0.10"; - sha256 = "00483rfqa65ivxlm3smbr3n4k397izifarjx408pnibqcj4s6yd7"; + version = "0.11"; + sha256 = "1n5jjnnflh2ldqvcs44al572240s2435bh5m761hrpbmai5y6kwd"; libraryHaskellDepends = [ base ]; doHaddock = false; description = "low-level binding to libpq: configure based provider"; @@ -244531,8 +244948,8 @@ self: { ({ mkDerivation, base, libpq }: mkDerivation { pname = "postgresql-libpq-pkgconfig"; - version = "0.10"; - sha256 = "1vjfq3iiwygfyb16q84xfa1zhhr63ammfdzq6ks1si02na3k3paw"; + version = "0.11"; + sha256 = "19n0kqpx0qbhfcpw61n6wg8ll421bsyqmfgsyh6zs7laykhhmigr"; libraryHaskellDepends = [ base ]; libraryPkgconfigDepends = [ libpq ]; doHaddock = false; @@ -244819,8 +245236,8 @@ self: { pname = "postgresql-simple"; version = "0.7.0.0"; sha256 = "0gm1wk2zq35h46v0l1qc0z63jv3gxgqd059j1mcmww80a6sipf4c"; - revision = "2"; - editedCabalFile = "0y86qpm3pffk08d6smpqjfbqmn7bh8yyahc901vk86aln22nqf6w"; + revision = "3"; + editedCabalFile = "1vbdiniz18m1kk4wxdnc43ry7gq00vxxvklmnrn8v3vc5r55inka"; libraryHaskellDepends = [ aeson attoparsec base bytestring case-insensitive containers hashable Only postgresql-libpq scientific template-haskell text @@ -245973,8 +246390,8 @@ self: { ({ mkDerivation, adjunctions, base, deepseq, lens, mtl }: mkDerivation { pname = "predicate-transformers"; - version = "0.13.0.0"; - sha256 = "1ki2qqbraddncvg7ya9l5l6f362cxvrp0ygn6hvdl3xcljzq0hqr"; + version = "0.15.0.0"; + sha256 = "0kjmdbm0a7c2vik0hansvkri7c9zp5cfazgk00r65syflsgfk91s"; libraryHaskellDepends = [ adjunctions base deepseq lens mtl ]; description = "A library for writing predicates and transformations over predicates in Haskell"; license = lib.licenses.bsd3; @@ -248821,8 +249238,8 @@ self: { }: mkDerivation { pname = "project-m36"; - version = "1.0.2"; - sha256 = "0sbp2g5cpw46v3xjj5c3jpznc1sfhdn4ycvfp8ci03m88mp8bjsm"; + version = "1.1.0"; + sha256 = "1nqdfvzq4pm8dgds0r7k5fv4sw10nfygnz0w9dvb118s14sap1fi"; isLibrary = true; isExecutable = true; libraryHaskellDepends = [ @@ -249346,8 +249763,8 @@ self: { ({ mkDerivation, base, containers }: mkDerivation { pname = "propeller"; - version = "0.3.0.0"; - sha256 = "0nx76898abx6p71z8bn0sdxi7728zk6dfxgdcz2lp002mbjiawqb"; + version = "0.4.0.0"; + sha256 = "07mj8qj4m43ap7y6mh622qh0n0z9pq2i5rxpqrk89fwjcl26gsrm"; libraryHaskellDepends = [ base containers ]; testHaskellDepends = [ base containers ]; description = "A Propagator Library"; @@ -249452,6 +249869,8 @@ self: { pname = "proquint"; version = "0.1.0.0"; sha256 = "04hhvrrclyav0nhk6zqp9s58vxad8ndi6yw851qprd6h7wr57wg5"; + revision = "1"; + editedCabalFile = "1p3s3jpck7w9h5qxqp9w59mmf6yr9bgx339l1m01f6yjq720a6l6"; libraryHaskellDepends = [ array base ]; testHaskellDepends = [ base tasty tasty-hunit tasty-quickcheck ]; description = "Proquints: Identifiers that are Readable, Spellable, and Pronounceable"; @@ -250319,6 +250738,8 @@ self: { pname = "pseudo-boolean"; version = "0.1.11.0"; sha256 = "04hkg7nlyrziq3pm44sqr6b5zjb5x3d70xqzblp3h7f1sc6839rr"; + revision = "1"; + editedCabalFile = "1myzfrrjj9j0xd9la3iv9jzlgir6l5wxmh279rykjw2whkys20ry"; libraryHaskellDepends = [ attoparsec base bytestring bytestring-builder containers deepseq dlist hashable megaparsec parsec void @@ -250434,6 +250855,8 @@ self: { pname = "psqueues"; version = "0.2.8.0"; sha256 = "0qp48qxqfz3bzl10l1wq3fi2j88bcx71a8g5x3qdaia884wf4vdk"; + revision = "1"; + editedCabalFile = "0yp0i8fkm0gczdgki0qmvcnj5wvrfxjcs7cpmm4ifi9z857l9dy6"; libraryHaskellDepends = [ base deepseq ghc-prim hashable ]; testHaskellDepends = [ array base deepseq ghc-prim hashable HUnit QuickCheck tagged tasty @@ -253082,6 +253505,8 @@ self: { pname = "quic"; version = "0.2.2"; sha256 = "0bx6bccnfrqm7593mwi1c52pmb2dimxp3pllc6m818bgwrkii61w"; + revision = "2"; + editedCabalFile = "1mkqx0kadpd99d4izkqg7wm86ffvxr0xvz3p424563dx4k1c2apk"; isLibrary = true; isExecutable = true; libraryHaskellDepends = [ @@ -253417,10 +253842,8 @@ self: { }: mkDerivation { pname = "quickcheck-lockstep"; - version = "0.5.0"; - sha256 = "0ap8qgv33a6rwvvplmmf2hh68hk257l0maznkvlmi7cds6z90bk4"; - revision = "1"; - editedCabalFile = "19iqirk5k92l8k04clppvv84i0z9kfvbffk0jwvljs4jn35qx5mq"; + version = "0.5.1"; + sha256 = "0dsklypvflwgaj6fdh52sw2bzznz1kmmcdbs39nsjji7bkbn7gqp"; libraryHaskellDepends = [ base constraints containers mtl QuickCheck quickcheck-dynamic ]; @@ -254770,23 +255193,25 @@ self: { }) {}; "rails-session" = callPackage - ({ mkDerivation, base, base-compat, base16-bytestring - , base64-bytestring, bytestring, containers, cryptonite, filepath - , hspec, http-types, pbkdf, ruby-marshal, semigroups, string-conv - , tasty, tasty-hspec, transformers, vector + ({ mkDerivation, aeson, aeson-qq, base, base-compat + , base16-bytestring, base64-bytestring, bytestring, containers + , crypton, filepath, hspec, http-types, memory, pbkdf, ruby-marshal + , semigroups, string-conv, tasty, tasty-hspec, text, transformers + , vector }: mkDerivation { pname = "rails-session"; - version = "0.1.3.0"; - sha256 = "0fybpyg5si9rizifxdghilffvqmszm8h7w5v8b7xdmsw1i5gv56m"; + version = "0.1.4.0"; + sha256 = "1gmy0xf7fsjaadmawzssaas7ngwgil9sgnw7s0xhqx1kxz2860sz"; + enableSeparateDataOutput = true; libraryHaskellDepends = [ - base base-compat base16-bytestring base64-bytestring bytestring - containers cryptonite http-types pbkdf ruby-marshal string-conv - vector + aeson base base-compat base16-bytestring base64-bytestring + bytestring containers crypton http-types memory pbkdf ruby-marshal + string-conv text vector ]; testHaskellDepends = [ - base bytestring filepath hspec ruby-marshal semigroups tasty - tasty-hspec transformers vector + aeson aeson-qq base bytestring filepath hspec ruby-marshal + semigroups tasty tasty-hspec text transformers vector ]; description = "Decrypt Ruby on Rails sessions in Haskell"; license = lib.licenses.bsd3; @@ -254959,6 +255384,8 @@ self: { pname = "ral"; version = "0.2.2"; sha256 = "1c301l9mcq86wkgb4x8vhjrzb0nmv75dsixg5bgmwqp8rbh0xis6"; + revision = "1"; + editedCabalFile = "1j3fqas4xxjs59x8flgm7y7hd21cxs3ahx2zgx5294f844bgkjxb"; libraryHaskellDepends = [ adjunctions base bin boring deepseq distributive fin hashable indexed-traversable QuickCheck semigroupoids @@ -256575,6 +257002,49 @@ self: { hydraPlatforms = lib.platforms.none; }) {}; + "rds-data" = callPackage + ({ mkDerivation, aeson, aeson-pretty, amazonka, amazonka-core + , amazonka-rds, amazonka-rds-data, amazonka-secretsmanager, base + , base64-bytestring, bytestring, contravariant, generic-lens + , hedgehog, hedgehog-extras, http-client, hw-polysemy, microlens + , mtl, optparse-applicative, polysemy-log, polysemy-plugin + , polysemy-time, resourcet, stm, tasty, tasty-discover + , tasty-hedgehog, testcontainers, text, time, transformers, ulid + , uuid + }: + mkDerivation { + pname = "rds-data"; + version = "0.0.0.2"; + sha256 = "1gfqxffl7fncmwriyrc328imkv98vwls4jdva5klgaw3gwrq1l2x"; + isLibrary = false; + isExecutable = true; + libraryHaskellDepends = [ + aeson amazonka amazonka-core amazonka-rds amazonka-rds-data + amazonka-secretsmanager base base64-bytestring bytestring + contravariant generic-lens hw-polysemy microlens mtl polysemy-log + polysemy-plugin text time transformers ulid uuid + ]; + executableHaskellDepends = [ + aeson amazonka amazonka-rds-data base bytestring generic-lens + hedgehog http-client hw-polysemy microlens optparse-applicative + polysemy-log polysemy-plugin polysemy-time resourcet stm + testcontainers text time ulid uuid + ]; + testHaskellDepends = [ + aeson aeson-pretty amazonka amazonka-core amazonka-rds + amazonka-rds-data amazonka-secretsmanager base base64-bytestring + bytestring generic-lens hedgehog hedgehog-extras hw-polysemy + microlens polysemy-log polysemy-plugin tasty tasty-discover + tasty-hedgehog testcontainers text time ulid uuid + ]; + testToolDepends = [ tasty-discover ]; + doHaddock = false; + description = "Codecs for use with AWS rds-data"; + license = lib.licenses.bsd3; + hydraPlatforms = lib.platforms.none; + mainProgram = "rds-data"; + }) {}; + "rds-data-codecs" = callPackage ({ mkDerivation, aeson, aeson-pretty, amazonka, amazonka-core , amazonka-rds-data, base, bytestring, contravariant, doctest @@ -256816,8 +257286,8 @@ self: { pname = "reactive-banana"; version = "1.3.2.0"; sha256 = "0mrsw3hkl0sgwcbay4m1lzs4bilss80g9p6njbbhapbfjyzsr36k"; - revision = "3"; - editedCabalFile = "0gwky9jadzy025w1d4r3k1kf8g1i4y0v15j8di14402gzpin9n4j"; + revision = "4"; + editedCabalFile = "1nijajqvp7i5jq99y9c3z969ljgagkarpn5ikbd3bir2msz54pyn"; libraryHaskellDepends = [ base containers deepseq hashable pqueue semigroups stm these transformers unordered-containers vault @@ -259462,17 +259932,17 @@ self: { "reflex-sdl2" = callPackage ({ mkDerivation, async, base, containers, dependent-sum - , exception-transformers, mtl, primitive, ref-tf, reflex, sdl2, stm + , exception-transformers, mtl, ref-tf, reflex, sdl2, stm }: mkDerivation { pname = "reflex-sdl2"; - version = "0.3.0.0"; - sha256 = "1mjynfdxnjdd308jp2gcpl8x00pmzshm81ramls7hzmkkvfm2xdb"; + version = "0.3.0.3"; + sha256 = "10lc0arzn2sxb69sah13fkn4zd2hsj2gwnblr4djzwzap409xiyh"; isLibrary = true; isExecutable = true; libraryHaskellDepends = [ async base containers dependent-sum exception-transformers mtl - primitive ref-tf reflex sdl2 stm + ref-tf reflex sdl2 stm ]; executableHaskellDepends = [ base mtl reflex ]; description = "SDL2 and reflex FRP"; @@ -263006,6 +263476,32 @@ self: { pname = "rest-rewrite"; version = "0.4.3"; sha256 = "0rvqagskkibwadqdkfqqjp0vrdxfn1hnb6g27ps7h160knygaa1d"; + revision = "1"; + editedCabalFile = "0m0m3brlxx945lrr34wpmn5jgzdpw9ck0qxj23s8av4rlh1a9hx1"; + libraryHaskellDepends = [ + base containers hashable monad-loops mtl parsec process QuickCheck + text time unordered-containers + ]; + testHaskellDepends = [ + base containers hashable mtl QuickCheck text time + unordered-containers + ]; + testSystemDepends = [ graphviz z3 ]; + doHaddock = false; + description = "Rewriting library with online termination checking"; + license = lib.licenses.bsd3; + maintainers = [ lib.maintainers.tbidne ]; + }) {inherit (pkgs) graphviz; inherit (pkgs) z3;}; + + "rest-rewrite_0_4_4" = callPackage + ({ mkDerivation, base, containers, graphviz, hashable, monad-loops + , mtl, parsec, process, QuickCheck, text, time + , unordered-containers, z3 + }: + mkDerivation { + pname = "rest-rewrite"; + version = "0.4.4"; + sha256 = "03jn5wclljkfdj1nvzbs5jvgsh343g1qr864pivgmxbc5ngrdk91"; libraryHaskellDepends = [ base containers hashable monad-loops mtl parsec process QuickCheck text time unordered-containers @@ -263018,6 +263514,7 @@ self: { doHaddock = false; description = "Rewriting library with online termination checking"; license = lib.licenses.bsd3; + hydraPlatforms = lib.platforms.none; maintainers = [ lib.maintainers.tbidne ]; }) {inherit (pkgs) graphviz; inherit (pkgs) z3;}; @@ -263399,7 +263896,6 @@ self: { ]; description = "Code shared across the code samples in the book \"Retrocomputing with Clash\""; license = lib.licenses.mit; - hydraPlatforms = lib.platforms.none; }) {}; "retroclash-sim" = callPackage @@ -263421,7 +263917,6 @@ self: { ]; description = "High-level simulators from the book \"Retrocomputing with Clash\""; license = lib.licenses.mit; - hydraPlatforms = lib.platforms.none; }) {}; "retry" = callPackage @@ -264387,8 +264882,8 @@ self: { }: mkDerivation { pname = "ridley"; - version = "0.3.4.1"; - sha256 = "03y25hcmh38psf5gs28aa21ibkcg16d3kk2xmv073v50b14dxysr"; + version = "0.4.0.0"; + sha256 = "0g6bxxmlnlcbic8v91wah5xw0a1b4fy81y328j49dyi3xcf88nka"; isLibrary = true; isExecutable = true; libraryHaskellDepends = [ @@ -266875,8 +267370,8 @@ self: { pname = "ruby-marshal"; version = "0.2.1"; sha256 = "18kdagf0lyghpaffzgw42ql1wrqkh13rfqjpj23i09i67pqrv3lk"; - revision = "1"; - editedCabalFile = "0f3jdq5ca12mbgawziakl0bw14gy1ycmvyp4ljffsghcg5fghxg9"; + revision = "2"; + editedCabalFile = "0sm6gk2v7f3hsr5y22g35bl2fdia5827bfk8pnrv3sf61fjh6mrd"; libraryHaskellDepends = [ base bytestring cereal containers fail mtl string-conv vector ]; @@ -269338,7 +269833,7 @@ self: { license = lib.licenses.mit; }) {}; - "sbp_6_0_1" = callPackage + "sbp_6_1_0" = callPackage ({ mkDerivation, aeson, aeson-pretty, array, base , base64-bytestring, basic-prelude, binary, binary-conduit , bytestring, cmdargs, conduit, conduit-extra, data-binary-ieee754 @@ -269347,8 +269842,8 @@ self: { }: mkDerivation { pname = "sbp"; - version = "6.0.1"; - sha256 = "12q23hdj8xddq9kq73nqf50qwdazqlv6xrb0dyxs5xg3kvlpccwq"; + version = "6.1.0"; + sha256 = "1ihnsxil3f1fccm6zf3daiw12qblmxmrpfs6spqnh2jfyxgmrmkx"; isLibrary = true; isExecutable = true; libraryHaskellDepends = [ @@ -272013,15 +272508,15 @@ self: { license = lib.licenses.mit; }) {inherit (pkgs) secp256k1;}; - "secp256k1-haskell_1_2_0" = callPackage + "secp256k1-haskell_1_4_0" = callPackage ({ mkDerivation, base, base16, bytestring, deepseq, entropy , hashable, hspec, hspec-discover, HUnit, monad-par, mtl , QuickCheck, secp256k1, string-conversions, unliftio-core }: mkDerivation { pname = "secp256k1-haskell"; - version = "1.2.0"; - sha256 = "1lr2sq8r3sx41f99pvga9ck0vw0sy7034zra80gxq1hnifjnd5q3"; + version = "1.4.0"; + sha256 = "1nba3f1952p229wbjmbpx80h212mmf1njvyxikiw9c4vpkfksx8b"; libraryHaskellDepends = [ base base16 bytestring deepseq entropy hashable QuickCheck string-conversions unliftio-core @@ -273339,6 +273834,30 @@ self: { license = lib.licenses.gpl3Only; }) {}; + "sequence-formats_1_8_1_1" = callPackage + ({ mkDerivation, attoparsec, base, bytestring, containers, errors + , exceptions, foldl, hspec, lens-family, pipes, pipes-attoparsec + , pipes-bytestring, pipes-safe, pipes-zlib, tasty, tasty-hunit + , transformers, vector + }: + mkDerivation { + pname = "sequence-formats"; + version = "1.8.1.1"; + sha256 = "09k7iqi1cjynxvdqihg6p98isx9i7z3xiw5h9gll5d2hyz040vya"; + libraryHaskellDepends = [ + attoparsec base bytestring containers errors exceptions foldl + lens-family pipes pipes-attoparsec pipes-bytestring pipes-safe + pipes-zlib transformers vector + ]; + testHaskellDepends = [ + base bytestring containers foldl hspec pipes pipes-safe tasty + tasty-hunit transformers vector + ]; + description = "A package with basic parsing utilities for several Bioinformatic data formats"; + license = lib.licenses.gpl3Only; + hydraPlatforms = lib.platforms.none; + }) {}; + "sequenceTools" = callPackage ({ mkDerivation, ansi-wl-pprint, base, bytestring, foldl, hspec , lens-family, optparse-applicative, pipes, pipes-group @@ -273530,7 +274049,6 @@ self: { ]; description = "Test your 'Aeson' 'Serialize' and 'Binary' instances for stability over time"; license = lib.licenses.mit; - hydraPlatforms = lib.platforms.none; }) {}; "serialise" = callPackage @@ -273735,6 +274253,33 @@ self: { license = lib.licenses.bsd3; }) {}; + "servant_0_20_2" = callPackage + ({ mkDerivation, aeson, attoparsec, base, bifunctors, bytestring + , case-insensitive, constraints, containers, deepseq, hspec + , hspec-discover, http-api-data, http-media, http-types, mmorph + , mtl, network-uri, QuickCheck, quickcheck-instances + , singleton-bool, sop-core, text, transformers, vault + }: + mkDerivation { + pname = "servant"; + version = "0.20.2"; + sha256 = "0rakyjrmn05sb2gxk4bkxlb23zfwm1pjkdg9mh7b4hjgsdwy4fba"; + libraryHaskellDepends = [ + aeson attoparsec base bifunctors bytestring case-insensitive + constraints containers deepseq http-api-data http-media http-types + mmorph mtl network-uri QuickCheck singleton-bool sop-core text + transformers vault + ]; + testHaskellDepends = [ + aeson base bytestring hspec http-media mtl QuickCheck + quickcheck-instances text + ]; + testToolDepends = [ hspec-discover ]; + description = "A family of combinators for defining webservices APIs"; + license = lib.licenses.bsd3; + hydraPlatforms = lib.platforms.none; + }) {}; + "servant-JuicyPixels" = callPackage ({ mkDerivation, base, bytestring, http-media, JuicyPixels, servant , servant-server, wai, warp @@ -273850,6 +274395,22 @@ self: { license = lib.licenses.bsd3; }) {}; + "servant-auth_0_4_2_0" = callPackage + ({ mkDerivation, aeson, base, containers, jose, lens, servant, text + , unordered-containers + }: + mkDerivation { + pname = "servant-auth"; + version = "0.4.2.0"; + sha256 = "0h71v9n3vd1ca9kav2b6w53wnk950hxlgp3hcnhyk7yd9aph4nwx"; + libraryHaskellDepends = [ + aeson base containers jose lens servant text unordered-containers + ]; + description = "Authentication combinators for servant"; + license = lib.licenses.bsd3; + hydraPlatforms = lib.platforms.none; + }) {}; + "servant-auth-client" = callPackage ({ mkDerivation, aeson, base, bytestring, containers, hspec , hspec-discover, http-client, http-types, jose, QuickCheck @@ -273876,6 +274437,31 @@ self: { license = lib.licenses.bsd3; }) {}; + "servant-auth-client_0_4_2_0" = callPackage + ({ mkDerivation, aeson, base, bytestring, containers, hspec + , hspec-discover, http-client, http-types, jose, QuickCheck + , servant, servant-auth, servant-auth-server, servant-client + , servant-client-core, servant-server, time, transformers, wai + , warp + }: + mkDerivation { + pname = "servant-auth-client"; + version = "0.4.2.0"; + sha256 = "1pvqiygnwnkj6y4mi03qnpjlp305cjmpzp7nrqmc2p6qwnl2l4q9"; + libraryHaskellDepends = [ + base bytestring containers servant servant-auth servant-client-core + ]; + testHaskellDepends = [ + aeson base bytestring hspec http-client http-types jose QuickCheck + servant servant-auth servant-auth-server servant-client + servant-server time transformers wai warp + ]; + testToolDepends = [ hspec-discover ]; + description = "servant-client/servant-auth compatibility"; + license = lib.licenses.bsd3; + hydraPlatforms = lib.platforms.none; + }) {}; + "servant-auth-cookie" = callPackage ({ mkDerivation, base, base64-bytestring, blaze-builder, bytestring , cereal, cereal-time, cookie, criterion, cryptonite, data-default @@ -273932,6 +274518,29 @@ self: { license = lib.licenses.bsd3; }) {}; + "servant-auth-docs_0_2_11_0" = callPackage + ({ mkDerivation, base, Cabal, cabal-doctest, doctest, hspec + , hspec-discover, lens, QuickCheck, servant, servant-auth + , servant-docs, template-haskell, text + }: + mkDerivation { + pname = "servant-auth-docs"; + version = "0.2.11.0"; + sha256 = "127w2ggii2vqs60cnd5ir4azyrxnm7mhfydi156liykk2v8jkkaj"; + setupHaskellDepends = [ base Cabal cabal-doctest ]; + libraryHaskellDepends = [ + base lens servant servant-auth servant-docs + ]; + testHaskellDepends = [ + base doctest hspec lens QuickCheck servant servant-auth + servant-docs template-haskell text + ]; + testToolDepends = [ hspec-discover ]; + description = "servant-docs/servant-auth compatibility"; + license = lib.licenses.bsd3; + hydraPlatforms = lib.platforms.none; + }) {}; + "servant-auth-hmac" = callPackage ({ mkDerivation, aeson, attoparsec, base, base64-bytestring , blaze-html, blaze-markup, bytestring, case-insensitive, cereal @@ -274001,6 +274610,36 @@ self: { broken = true; }) {}; + "servant-auth-server_0_4_9_0" = callPackage + ({ mkDerivation, aeson, base, base64-bytestring, blaze-builder + , bytestring, case-insensitive, cookie, data-default-class, entropy + , hspec, hspec-discover, http-client, http-types, jose, lens + , lens-aeson, markdown-unlit, memory, monad-time, mtl, QuickCheck + , servant, servant-auth, servant-server, tagged, text, time + , transformers, unordered-containers, wai, warp, wreq + }: + mkDerivation { + pname = "servant-auth-server"; + version = "0.4.9.0"; + sha256 = "0fhk2z9n9ax4g7iisdgcd87wgj9wvazhl86kjh364gsj1g8a5y99"; + libraryHaskellDepends = [ + aeson base base64-bytestring blaze-builder bytestring + case-insensitive cookie data-default-class entropy http-types jose + lens memory monad-time mtl servant servant-auth servant-server + tagged text time unordered-containers wai + ]; + testHaskellDepends = [ + aeson base bytestring case-insensitive hspec http-client http-types + jose lens lens-aeson mtl QuickCheck servant servant-auth + servant-server text time transformers wai warp wreq + ]; + testToolDepends = [ hspec-discover markdown-unlit ]; + description = "servant-server/servant-auth compatibility"; + license = lib.licenses.bsd3; + hydraPlatforms = lib.platforms.none; + broken = true; + }) {}; + "servant-auth-swagger" = callPackage ({ mkDerivation, base, hspec, hspec-discover, lens, QuickCheck , servant, servant-auth, servant-swagger, swagger2, text @@ -274023,6 +274662,27 @@ self: { license = lib.licenses.bsd3; }) {}; + "servant-auth-swagger_0_2_11_0" = callPackage + ({ mkDerivation, base, hspec, hspec-discover, lens, QuickCheck + , servant, servant-auth, servant-swagger, swagger2, text + }: + mkDerivation { + pname = "servant-auth-swagger"; + version = "0.2.11.0"; + sha256 = "1h5ckkai4qxz9c2a62l2lv0ss8az5j1lwyzs4g652zffrgx9qk28"; + libraryHaskellDepends = [ + base lens servant servant-auth servant-swagger swagger2 text + ]; + testHaskellDepends = [ + base hspec lens QuickCheck servant servant-auth servant-swagger + swagger2 text + ]; + testToolDepends = [ hspec-discover ]; + description = "servant-swagger/servant-auth compatibility"; + license = lib.licenses.bsd3; + hydraPlatforms = lib.platforms.none; + }) {}; + "servant-auth-token" = callPackage ({ mkDerivation, aeson-injector, base, byteable, bytestring , containers, http-api-data, mtl, pwstore-fast, servant @@ -274354,6 +275014,37 @@ self: { license = lib.licenses.bsd3; }) {}; + "servant-client_0_20_2" = callPackage + ({ mkDerivation, aeson, base, base-compat, bytestring, containers + , deepseq, entropy, exceptions, hspec, hspec-discover + , http-api-data, http-client, http-media, http-types, HUnit + , kan-extensions, markdown-unlit, monad-control, mtl, network + , QuickCheck, semigroupoids, servant, servant-client-core + , servant-server, sop-core, stm, text, time, transformers + , transformers-base, wai, warp + }: + mkDerivation { + pname = "servant-client"; + version = "0.20.2"; + sha256 = "026bp0qk2bx672834yjxmqrfacyzzdssm89bd0niz1xzxzmw5r7g"; + libraryHaskellDepends = [ + base base-compat bytestring containers deepseq exceptions + http-client http-media http-types kan-extensions monad-control mtl + semigroupoids servant servant-client-core stm time transformers + transformers-base + ]; + testHaskellDepends = [ + aeson base base-compat bytestring entropy hspec http-api-data + http-client http-types HUnit markdown-unlit mtl network QuickCheck + servant servant-client-core servant-server sop-core stm text + transformers wai warp + ]; + testToolDepends = [ hspec-discover markdown-unlit ]; + description = "Automatic derivation of querying functions for servant"; + license = lib.licenses.bsd3; + hydraPlatforms = lib.platforms.none; + }) {}; + "servant-client-core" = callPackage ({ mkDerivation, aeson, base, base-compat, base64-bytestring , bytestring, constraints, containers, deepseq, exceptions, free @@ -274379,6 +275070,28 @@ self: { license = lib.licenses.bsd3; }) {}; + "servant-client-core_0_20_2" = callPackage + ({ mkDerivation, aeson, base, base-compat, base64-bytestring + , bytestring, constraints, containers, deepseq, exceptions, free + , hspec, hspec-discover, http-media, http-types, network-uri + , QuickCheck, safe, servant, sop-core, template-haskell, text + }: + mkDerivation { + pname = "servant-client-core"; + version = "0.20.2"; + sha256 = "10nv810ns8v1d9a2fkg9bgi7h9gm4yap1y6mg2r15d569i27rrvc"; + libraryHaskellDepends = [ + aeson base base-compat base64-bytestring bytestring constraints + containers deepseq exceptions free http-media http-types + network-uri safe servant sop-core template-haskell text + ]; + testHaskellDepends = [ base base-compat deepseq hspec QuickCheck ]; + testToolDepends = [ hspec-discover ]; + description = "Core functionality and class for client function generation for servant APIs"; + license = lib.licenses.bsd3; + hydraPlatforms = lib.platforms.none; + }) {}; + "servant-client-js" = callPackage ({ mkDerivation, base, binary, bytestring, case-insensitive , containers, exceptions, http-media, http-types, jsaddle @@ -274470,6 +275183,27 @@ self: { license = lib.licenses.bsd3; }) {}; + "servant-conduit_0_16_1" = callPackage + ({ mkDerivation, base, base-compat, bytestring, conduit + , http-client, http-media, mtl, resourcet, servant, servant-client + , servant-server, unliftio-core, wai, warp + }: + mkDerivation { + pname = "servant-conduit"; + version = "0.16.1"; + sha256 = "0qxddrkqbglb1ifrcjg8bx86in0na3pmsvgb5q5486bzzsximl48"; + libraryHaskellDepends = [ + base bytestring conduit mtl resourcet servant unliftio-core + ]; + testHaskellDepends = [ + base base-compat bytestring conduit http-client http-media + resourcet servant servant-client servant-server wai warp + ]; + description = "Servant Stream support for conduit"; + license = lib.licenses.bsd3; + hydraPlatforms = lib.platforms.none; + }) {}; + "servant-csharp" = callPackage ({ mkDerivation, aeson, base, bytestring, directory, filepath , heredocs, http-types, lens, mtl, servant, servant-foreign @@ -274583,6 +275317,36 @@ self: { mainProgram = "greet-docs"; }) {}; + "servant-docs_0_13_1" = callPackage + ({ mkDerivation, aeson, aeson-pretty, base, base-compat, bytestring + , case-insensitive, hashable, http-media, http-types, lens, servant + , string-conversions, tasty, tasty-golden, tasty-hunit, text + , transformers, universe-base, unordered-containers + }: + mkDerivation { + pname = "servant-docs"; + version = "0.13.1"; + sha256 = "1gdv5yrdqfsb4am8rn9fj7gl4f1nswlcbqnp6kc33j5z0mv35z4y"; + isLibrary = true; + isExecutable = true; + libraryHaskellDepends = [ + aeson aeson-pretty base base-compat bytestring case-insensitive + hashable http-media http-types lens servant string-conversions text + universe-base unordered-containers + ]; + executableHaskellDepends = [ + aeson base lens servant string-conversions text + ]; + testHaskellDepends = [ + aeson base base-compat lens servant string-conversions tasty + tasty-golden tasty-hunit transformers + ]; + description = "generate API docs for your servant webservice"; + license = lib.licenses.bsd3; + hydraPlatforms = lib.platforms.none; + mainProgram = "greet-docs"; + }) {}; + "servant-docs-simple" = callPackage ({ mkDerivation, aeson, aeson-pretty, base, bytestring, hspec , hspec-core, prettyprinter, raw-strings-qq, servant, text @@ -274820,6 +275584,24 @@ self: { license = lib.licenses.bsd3; }) {}; + "servant-foreign_0_16_1" = callPackage + ({ mkDerivation, base, base-compat, hspec, hspec-discover + , http-types, lens, servant, text + }: + mkDerivation { + pname = "servant-foreign"; + version = "0.16.1"; + sha256 = "15a5cfiihmav7yq6nfp5f365649q054nk02hpf3lsaw8alpbivpp"; + libraryHaskellDepends = [ + base base-compat http-types lens servant text + ]; + testHaskellDepends = [ base hspec servant ]; + testToolDepends = [ hspec-discover ]; + description = "Helpers for generating clients for servant APIs in any programming language"; + license = lib.licenses.bsd3; + hydraPlatforms = lib.platforms.none; + }) {}; + "servant-gdp" = callPackage ({ mkDerivation, aeson, base, gdp, servant-server, text }: mkDerivation { @@ -275023,6 +275805,40 @@ self: { broken = true; }) {}; + "servant-http-streams_0_20_2" = callPackage + ({ mkDerivation, aeson, base, base-compat, bytestring + , case-insensitive, containers, deepseq, entropy, exceptions, hspec + , hspec-discover, http-api-data, http-common, http-media + , http-streams, http-types, HUnit, io-streams, kan-extensions + , markdown-unlit, monad-control, mtl, network, QuickCheck + , semigroupoids, servant, servant-client-core, servant-server, stm + , text, time, transformers, transformers-base, transformers-compat + , wai, warp + }: + mkDerivation { + pname = "servant-http-streams"; + version = "0.20.2"; + sha256 = "029i6rqmj6q5fn32vimr92rwgfb0c5l5cm19ncrw48nh78pgp0zm"; + libraryHaskellDepends = [ + base base-compat bytestring case-insensitive containers deepseq + exceptions http-common http-media http-streams http-types + io-streams kan-extensions monad-control mtl semigroupoids servant + servant-client-core text time transformers transformers-base + transformers-compat + ]; + testHaskellDepends = [ + aeson base base-compat bytestring deepseq entropy hspec + http-api-data http-streams http-types HUnit kan-extensions + markdown-unlit mtl network QuickCheck servant servant-client-core + servant-server stm text transformers transformers-compat wai warp + ]; + testToolDepends = [ hspec-discover markdown-unlit ]; + description = "Automatic derivation of querying functions for servant"; + license = lib.licenses.bsd3; + hydraPlatforms = lib.platforms.none; + broken = true; + }) {}; + "servant-http2-client" = callPackage ({ mkDerivation, aeson, async, base, binary, bytestring , case-insensitive, containers, data-default-class, exceptions @@ -275189,6 +276005,26 @@ self: { broken = true; }) {}; + "servant-lint" = callPackage + ({ mkDerivation, base, bytestring, containers, safe-coloured-text + , servant, servant-server, sydtest, text + }: + mkDerivation { + pname = "servant-lint"; + version = "0.1.0.0"; + sha256 = "1y9fc8kp8mclxm0njpdn121k7qa4f4vnwkcxr658pd26g34daqqk"; + libraryHaskellDepends = [ + base bytestring containers safe-coloured-text servant + servant-server text + ]; + testHaskellDepends = [ + base bytestring containers safe-coloured-text servant + servant-server sydtest text + ]; + description = "Lint Servant Routes"; + license = lib.licenses.bsd3; + }) {}; + "servant-lucid" = callPackage ({ mkDerivation, base, http-media, lucid, servant, servant-server , text, wai, warp @@ -275225,6 +276061,25 @@ self: { license = lib.licenses.bsd3; }) {}; + "servant-machines_0_16_1" = callPackage + ({ mkDerivation, base, base-compat, bytestring, http-client + , http-media, machines, mtl, servant, servant-client + , servant-server, wai, warp + }: + mkDerivation { + pname = "servant-machines"; + version = "0.16.1"; + sha256 = "0qhy99bx9lv35jpz5k19391z2ph91a7yp8z3ffcsc6lj4gd5nnak"; + libraryHaskellDepends = [ base bytestring machines mtl servant ]; + testHaskellDepends = [ + base base-compat bytestring http-client http-media machines servant + servant-client servant-server wai warp + ]; + description = "Servant Stream support for machines"; + license = lib.licenses.bsd3; + hydraPlatforms = lib.platforms.none; + }) {}; + "servant-match" = callPackage ({ mkDerivation, base, bytestring, hspec, http-types, network-uri , servant, text, utf8-string @@ -275572,6 +276427,28 @@ self: { license = lib.licenses.bsd3; }) {}; + "servant-pipes_0_16_1" = callPackage + ({ mkDerivation, base, base-compat, bytestring, http-client + , http-media, monad-control, mtl, pipes, pipes-bytestring + , pipes-safe, servant, servant-client, servant-server, wai, warp + }: + mkDerivation { + pname = "servant-pipes"; + version = "0.16.1"; + sha256 = "0n5l2dwnp0p8gjnz05rqiwxbn0qvngkrlc76ywvampvp1m4kbmhl"; + libraryHaskellDepends = [ + base bytestring monad-control mtl pipes pipes-safe servant + ]; + testHaskellDepends = [ + base base-compat bytestring http-client http-media pipes + pipes-bytestring pipes-safe servant servant-client servant-server + wai warp + ]; + description = "Servant Stream support for pipes"; + license = lib.licenses.bsd3; + hydraPlatforms = lib.platforms.none; + }) {}; + "servant-polysemy" = callPackage ({ mkDerivation, base, deepseq, http-client, http-client-tls, lens , mtl, polysemy, polysemy-plugin, polysemy-zoo, servant @@ -275818,8 +276695,8 @@ self: { }: mkDerivation { pname = "servant-quickcheck"; - version = "0.1.0.0"; - sha256 = "0bb6h0x1hcms10qmwxka7b6y8b1pigwa639sw0n1dn2jipzwxbla"; + version = "0.1.1.0"; + sha256 = "0hzfwqxbcgf9mxzlhw53pv99jxlpib56xjsnh8yw15j2pgb908qs"; libraryHaskellDepends = [ aeson base base-compat-batteries bytestring case-insensitive clock data-default-class hspec http-client http-media http-types mtl @@ -276142,6 +277019,42 @@ self: { mainProgram = "greet"; }) {}; + "servant-server_0_20_2" = callPackage + ({ mkDerivation, aeson, base, base-compat, base64-bytestring + , bytestring, constraints, containers, directory, exceptions + , filepath, hspec, hspec-discover, hspec-wai, http-api-data + , http-media, http-types, monad-control, mtl, network, resourcet + , safe, servant, should-not-typecheck, sop-core, tagged, temporary + , text, transformers, transformers-base, wai, wai-app-static + , wai-extra, warp, word8 + }: + mkDerivation { + pname = "servant-server"; + version = "0.20.2"; + sha256 = "0fqgnzzgbj4w441h3v841lav7gxazakz04s354r24pq4rh6m1kqy"; + isLibrary = true; + isExecutable = true; + libraryHaskellDepends = [ + base base64-bytestring bytestring constraints containers exceptions + filepath http-api-data http-media http-types monad-control mtl + network resourcet servant sop-core tagged text transformers + transformers-base wai wai-app-static word8 + ]; + executableHaskellDepends = [ + aeson base base-compat text wai warp + ]; + testHaskellDepends = [ + aeson base base-compat base64-bytestring bytestring directory hspec + hspec-wai http-types mtl resourcet safe servant + should-not-typecheck temporary text wai wai-extra + ]; + testToolDepends = [ hspec-discover ]; + description = "A family of combinators for defining webservices APIs and serving them"; + license = lib.licenses.bsd3; + hydraPlatforms = lib.platforms.none; + mainProgram = "greet"; + }) {}; + "servant-server-namedargs" = callPackage ({ mkDerivation, base, bytestring, http-api-data, http-types, named , servant, servant-namedargs, servant-server, string-conversions @@ -276446,6 +277359,35 @@ self: { license = lib.licenses.bsd3; }) {}; + "servant-swagger_1_2_1" = callPackage + ({ mkDerivation, aeson, aeson-pretty, base, base-compat, bytestring + , Cabal, cabal-doctest, directory, doctest, filepath, hspec + , hspec-discover, http-media, insert-ordered-containers, lens + , lens-aeson, QuickCheck, servant, singleton-bool, swagger2 + , template-haskell, text, time, unordered-containers, utf8-string + , vector + }: + mkDerivation { + pname = "servant-swagger"; + version = "1.2.1"; + sha256 = "18cvybmmp8cp8scpb7hncgn8jra8v82mby1bibysn6xbjy5pqlxq"; + setupHaskellDepends = [ base Cabal cabal-doctest ]; + libraryHaskellDepends = [ + aeson aeson-pretty base base-compat bytestring hspec http-media + insert-ordered-containers lens QuickCheck servant singleton-bool + swagger2 text unordered-containers + ]; + testHaskellDepends = [ + aeson base base-compat directory doctest filepath hspec lens + lens-aeson QuickCheck servant swagger2 template-haskell text time + utf8-string vector + ]; + testToolDepends = [ hspec-discover ]; + description = "Generate a Swagger/OpenAPI/OAS 2.0 specification for your servant API."; + license = lib.licenses.bsd3; + hydraPlatforms = lib.platforms.none; + }) {}; + "servant-swagger-tags" = callPackage ({ mkDerivation, base, insert-ordered-containers, lens, servant , servant-mock, servant-server, servant-swagger, swagger2, text @@ -277074,8 +278016,8 @@ self: { }: mkDerivation { pname = "serversession-backend-persistent"; - version = "2.0.1"; - sha256 = "1x08a5xhg2f48hjj651gchn17k7fg1n4a64vmyzy2ps2xrgqr2sy"; + version = "2.0.2"; + sha256 = "19jsswwc38514fqg2asshsvx1x3zx930887k63my4dmidyvvqmwd"; libraryHaskellDepends = [ aeson base base64-bytestring bytestring cereal path-pieces persistent serversession tagged text time transformers @@ -294280,6 +295222,19 @@ self: { license = lib.licenses.mit; }) {}; + "strict-mutable-base" = callPackage + ({ mkDerivation, base, deepseq }: + mkDerivation { + pname = "strict-mutable-base"; + version = "1.0.0.0"; + sha256 = "06d46902d79ryg7yy2zc973mgjdr3rc2i486xs6f8lhnrlwq9v3n"; + revision = "1"; + editedCabalFile = "1nqhm00lr9ashsjd38dwax2mn228kqjqshqx39plsjnf25kri5xq"; + libraryHaskellDepends = [ base deepseq ]; + description = "Strict variants of mutable data types from base"; + license = lib.licenses.bsd3; + }) {}; + "strict-mvar" = callPackage ({ mkDerivation, base, io-classes, io-sim, nothunks, QuickCheck , tasty, tasty-quickcheck @@ -294326,6 +295281,8 @@ self: { pname = "strict-tuple"; version = "0.1.5.4"; sha256 = "1znx5lmi7lgn4jzkr73lsc2xac0ypl65bx0pa1hxrc4c74ilysbk"; + revision = "1"; + editedCabalFile = "05s4z3crwb0akjfgcgrqrmzd690wn5s765srhmwdg6b1is8zm1zn"; libraryHaskellDepends = [ base bifunctors deepseq hashable ]; testHaskellDepends = [ base ]; description = "Strict tuples"; @@ -296945,8 +297902,8 @@ self: { pname = "svg-builder"; version = "0.1.1"; sha256 = "1k420f497lzkymmxin88ql6ib8dziic43avykv31yq65rgrf7l2g"; - revision = "9"; - editedCabalFile = "0ca6bgv5xrk6pz12j35jv1gbp06z6kk7fs7nc1bwjjxy6c6x4vm5"; + revision = "10"; + editedCabalFile = "1a57i9fgmjaz2m68i21dp6hi1qwfmza0d1rcygvq61sxrr9gvfpr"; libraryHaskellDepends = [ base blaze-builder bytestring hashable text unordered-containers ]; @@ -296975,8 +297932,8 @@ self: { ({ mkDerivation, base, blaze-markup, blaze-svg, directory, text }: mkDerivation { pname = "svg-icons"; - version = "3.9"; - sha256 = "1iyj0g9plzvih50j9sx41dpksj4avllr9csf8sp577zrq334r1l1"; + version = "3.10"; + sha256 = "15sgf8k8akvgv8xb884l9g5iydfybgp1l6aqndi749qpl8qy5a46"; isLibrary = true; isExecutable = true; libraryHaskellDepends = [ @@ -299430,8 +300387,6 @@ self: { ]; description = "Consistent filesystem interaction across GHC versions (deprecated)"; license = lib.licenses.mit; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "system-filepath" = callPackage @@ -303347,8 +304302,8 @@ self: { }: mkDerivation { pname = "telegram-bot-simple"; - version = "0.14.1"; - sha256 = "0v025wkhjnxjqzisj3x1gfv1qk9c17j2czdf0iv5fsxdkz2vc949"; + version = "0.14.2"; + sha256 = "10jwvx6m8zqzicfy3iyc9igxlnzyd8h320280q9s53420gzfpdf4"; isLibrary = true; isExecutable = true; libraryHaskellDepends = [ @@ -304339,19 +305294,17 @@ self: { }) {}; "tensort" = callPackage - ({ mkDerivation, base, mtl, QuickCheck, random, random-shuffle - , time - }: + ({ mkDerivation, base, mtl, QuickCheck, random, random-shuffle }: mkDerivation { pname = "tensort"; - version = "0.2.0.3"; - sha256 = "0qkm7iy00z13drs1f3fd3zl6cc45c7s2k8pn6ya7pmpji424dwiw"; + version = "1.0.1.2"; + sha256 = "1hg647gjx24g38vnnkg61i9i42dinf27j3rr80wqm6wrkl7jzxvd"; isLibrary = true; isExecutable = true; libraryHaskellDepends = [ base mtl random random-shuffle ]; - executableHaskellDepends = [ base time ]; + executableHaskellDepends = [ base ]; testHaskellDepends = [ base mtl QuickCheck ]; - description = "Tunable sorting for responsive robustness and beyond!"; + description = "Tunable sorting for responsive robustness and beyond"; license = lib.licenses.mit; mainProgram = "tensort"; }) {}; @@ -306088,6 +307041,8 @@ self: { pname = "text-iso8601"; version = "0.1.1"; sha256 = "00l2m3xj39mrz7lbmbnir4k9jbn3jm3xa2q6zkh0zr7arsvx5slx"; + revision = "1"; + editedCabalFile = "0gfpfvsnd06rpnqwb24cqzs9v80f4zn15in9aslvjyc45rnhzx8a"; libraryHaskellDepends = [ base integer-conversion text time time-compat ]; @@ -308859,6 +309814,32 @@ self: { hydraPlatforms = lib.platforms.none; }) {}; + "tiktoken" = callPackage + ({ mkDerivation, base, base64, bytestring, containers, deepseq + , filepath, megaparsec, pcre-light, quickcheck-instances + , raw-strings-qq, tasty, tasty-bench, tasty-quickcheck + , tasty-silver, text, unordered-containers + }: + mkDerivation { + pname = "tiktoken"; + version = "1.0.3"; + sha256 = "0hy3y9rdgjirk8ji7458qnc7h9d2b6yipfri25qkay96kq91kmj6"; + enableSeparateDataOutput = true; + libraryHaskellDepends = [ + base base64 bytestring containers deepseq filepath megaparsec + pcre-light raw-strings-qq text unordered-containers + ]; + testHaskellDepends = [ + base bytestring quickcheck-instances tasty tasty-quickcheck + tasty-silver text + ]; + benchmarkHaskellDepends = [ + base bytestring deepseq filepath tasty-bench + ]; + description = "Haskell implementation of tiktoken"; + license = lib.licenses.bsd3; + }) {}; + "tikzsd" = callPackage ({ mkDerivation, array, base, containers, lens, mtl, parsec , transformers @@ -309493,19 +310474,17 @@ self: { "timeline" = callPackage ({ mkDerivation, base, bytestring, containers, hashable, hedgehog - , indexed-traversable, semigroupoids, tasty, tasty-discover - , tasty-golden, tasty-hedgehog, tasty-hunit, template-haskell, text - , th-compat, time, transformers + , indexed-traversable, tasty, tasty-discover, tasty-golden + , tasty-hedgehog, tasty-hunit, template-haskell, text, th-compat + , time, transformers }: mkDerivation { pname = "timeline"; - version = "0.1.0.0"; - sha256 = "0ya56j51vgg380yylpakfgr5srv20ybiyy7yhfyxz21sdgz7f168"; - revision = "6"; - editedCabalFile = "0wn1mvgqh4b9yrgbcmz6yks51bsidj40irb6j1w3am20k7mdb6rq"; + version = "0.1.1.0"; + sha256 = "15npn5wfhdg2mcvr92n7c9k7jj1jcifm6rcpmyi64mcfsb2g1ry6"; libraryHaskellDepends = [ - base containers hedgehog indexed-traversable semigroupoids - template-haskell text th-compat time + base containers hedgehog indexed-traversable template-haskell text + th-compat time ]; testHaskellDepends = [ base bytestring containers hashable hedgehog indexed-traversable @@ -317110,6 +318089,28 @@ self: { license = lib.licenses.mit; }) {}; + "typed-process_0_2_12_0" = callPackage + ({ mkDerivation, async, base, base64-bytestring, bytestring, hspec + , hspec-discover, process, stm, temporary, transformers + , unliftio-core + }: + mkDerivation { + pname = "typed-process"; + version = "0.2.12.0"; + sha256 = "1q8v2vn1p2sygjym4aamfv53hyabq081aryf807p5pjix0x3vvjc"; + libraryHaskellDepends = [ + async base bytestring process stm transformers unliftio-core + ]; + testHaskellDepends = [ + async base base64-bytestring bytestring hspec process stm temporary + transformers unliftio-core + ]; + testToolDepends = [ hspec-discover ]; + description = "Run external processes, with strong typing of streams"; + license = lib.licenses.mit; + hydraPlatforms = lib.platforms.none; + }) {}; + "typed-process-effectful" = callPackage ({ mkDerivation, base, bytestring, effectful, effectful-core, tasty , tasty-hunit, typed-process @@ -317133,15 +318134,19 @@ self: { "typed-session" = callPackage ({ mkDerivation, base, containers, fused-effects , fused-effects-random, io-classes, io-sim, random + , template-haskell, typed-session-state-algorithm }: mkDerivation { pname = "typed-session"; - version = "0.1.0.0"; - sha256 = "172gsby1jpqvyqpfh6jjnq7crhqmac9ka9h7kil4zk3b4sig5hz1"; - libraryHaskellDepends = [ base containers io-classes ]; + version = "0.2.0.1"; + sha256 = "1xi0ys8hhqa2jkdwm0a6r92lwcl4lqcnvi61yqci9vc41rpcazhj"; + libraryHaskellDepends = [ + base containers io-classes template-haskell + typed-session-state-algorithm + ]; testHaskellDepends = [ base containers fused-effects fused-effects-random io-classes - io-sim random + io-sim random template-haskell ]; description = "typed session framework"; license = lib.licenses.mit; @@ -317149,6 +318154,23 @@ self: { broken = true; }) {}; + "typed-session-state-algorithm" = callPackage + ({ mkDerivation, base, containers, fused-effects, megaparsec + , parser-combinators, prettyprinter, raw-strings-qq + }: + mkDerivation { + pname = "typed-session-state-algorithm"; + version = "0.4.2.1"; + sha256 = "0gzzqg0jcnlbm0v4zmbjl379qzwmb93hg1ph8ibp55zxr98chk4z"; + libraryHaskellDepends = [ + base containers fused-effects megaparsec parser-combinators + prettyprinter + ]; + testHaskellDepends = [ base raw-strings-qq ]; + description = "Automatically generate status for typed-session"; + license = lib.licenses.mit; + }) {}; + "typed-spreadsheet" = callPackage ({ mkDerivation, async, base, diagrams-cairo, diagrams-gtk , diagrams-lib, foldl, gtk, microlens, stm, text, transformers @@ -318775,8 +319797,8 @@ self: { }: mkDerivation { pname = "uncertain"; - version = "0.3.1.0"; - sha256 = "1wkgk6504qyirr2bq3m4pqgwdvrpnrig1bnzcls0r7krsig8arvg"; + version = "0.4.0.0"; + sha256 = "1v7q6ajyqx3m06w2iy6dxkbfk6f3878zmii892k4m5a0hzi82x0c"; libraryHaskellDepends = [ ad base base-compat containers free mwc-random primitive transformers @@ -319364,10 +320386,8 @@ self: { ({ mkDerivation, base, containers, logict, mtl }: mkDerivation { pname = "unification-fd"; - version = "0.11.2"; - sha256 = "1lyx3g10llkr7vl7c2j15ddlqrkz2r684d1laza7nvq97amrqnqv"; - revision = "1"; - editedCabalFile = "07xmrqmk99lnp3jyk0dqgnpprm3ghnyjdqva0y13ddh3nw8iiqdj"; + version = "0.11.2.2"; + sha256 = "0jgy507dy1j566j46gndd8b2543n847myibg2i22yw8chdpl15kc"; libraryHaskellDepends = [ base containers logict mtl ]; description = "Simple generic unification algorithms"; license = lib.licenses.bsd3; @@ -320549,6 +321569,18 @@ self: { license = lib.licenses.bsd3; }) {}; + "unix-bytestring_0_4_0_2" = callPackage + ({ mkDerivation, base, bytestring }: + mkDerivation { + pname = "unix-bytestring"; + version = "0.4.0.2"; + sha256 = "0pmkd5cvq3knsyl5izxpxs44axrf943xv4pwa1x20wmsg30fqmd2"; + libraryHaskellDepends = [ base bytestring ]; + description = "Unix/Posix-specific functions for ByteStrings"; + license = lib.licenses.bsd3; + hydraPlatforms = lib.platforms.none; + }) {}; + "unix-compat" = callPackage ({ mkDerivation, base, directory, extra, hspec, HUnit , monad-parallel, temporary, unix @@ -323107,12 +324139,12 @@ self: { }) {}; "uulib" = callPackage - ({ mkDerivation, base, ghc-prim }: + ({ mkDerivation, base }: mkDerivation { pname = "uulib"; - version = "0.9.24"; - sha256 = "10j40q1b1fkx0fv56cn0kkilbqhyh6xxya536xlbx365lnc1rk0i"; - libraryHaskellDepends = [ base ghc-prim ]; + version = "0.9.25"; + sha256 = "03ykq4ij56kkzmr1yfxs3z5zx4yqzscilfxpskyppjk6cj6nh2qq"; + libraryHaskellDepends = [ base ]; description = "Haskell Utrecht Tools Library"; license = lib.licenses.bsd3; }) {}; @@ -324070,8 +325102,8 @@ self: { pname = "vault"; version = "0.3.1.5"; sha256 = "181ksk1yixjg0jiggw5jvm8am8m8c7lim4xaixf8qnaqvxm6namc"; - revision = "7"; - editedCabalFile = "0jbbjmh3h9pkj1mfafysny20ynfl58ifchizn13dkqvclpkr770h"; + revision = "8"; + editedCabalFile = "0nabd5r1j6aq5ys3lsjh4i2ii9rza7923b5mg3vfbkj72w3dvgqv"; libraryHaskellDepends = [ base containers hashable unordered-containers ]; @@ -324384,6 +325416,8 @@ self: { pname = "vec"; version = "0.5.1"; sha256 = "0rswq31fjsqzzq88b920hz0j8v0rdjhb04v4fr10cdqbnxaqglb0"; + revision = "1"; + editedCabalFile = "0znfs73x9amng298hzi98cy15fbgx5hdkcfslwmdqsyarr9v0ffx"; libraryHaskellDepends = [ adjunctions base boring deepseq distributive fin hashable indexed-traversable QuickCheck semigroupoids transformers @@ -324974,6 +326008,8 @@ self: { pname = "vector-space"; version = "0.19"; sha256 = "09gbkwq0z47ahc5brq72i7xr7rwqvl3sy04j1h4my5ij282d25w9"; + revision = "1"; + editedCabalFile = "1bjnjz2r25jkjc5wr3fxfynnrqj6ilwcnms06k0qqm5lg71y0zv2"; libraryHaskellDepends = [ base Boolean MemoTrie NumInstances ]; description = "Vector & affine spaces, linear maps, and derivatives"; license = lib.licenses.bsd3; @@ -331459,37 +332495,6 @@ self: { "weeder" = callPackage ({ mkDerivation, aeson, algebraic-graphs, async, base, bytestring - , containers, directory, filepath, generic-lens, ghc, hspec, lens - , mtl, optparse-applicative, parallel, process, regex-tdfa, text - , toml-reader, transformers - }: - mkDerivation { - pname = "weeder"; - version = "2.8.0"; - sha256 = "086vni1i0sqy2xva63xdx1ppvwygyn1dav2bykggd6j1jrwi0m5p"; - isLibrary = true; - isExecutable = true; - libraryHaskellDepends = [ - algebraic-graphs async base bytestring containers directory - filepath generic-lens ghc lens mtl optparse-applicative parallel - regex-tdfa text toml-reader transformers - ]; - executableHaskellDepends = [ - base bytestring containers directory filepath ghc - optparse-applicative transformers - ]; - testHaskellDepends = [ - aeson algebraic-graphs base containers directory filepath ghc hspec - process text toml-reader - ]; - description = "Detect dead code"; - license = lib.licenses.bsd3; - mainProgram = "weeder"; - maintainers = [ lib.maintainers.maralorn ]; - }) {}; - - "weeder_2_9_0" = callPackage - ({ mkDerivation, aeson, algebraic-graphs, async, base, bytestring , containers, directory, filepath, generic-lens, ghc, Glob , hspec-discover, hspec-expectations, lens, mtl , optparse-applicative, parallel, process, regex-tdfa, tasty @@ -331515,7 +332520,6 @@ self: { testToolDepends = [ hspec-discover ]; description = "Detect dead code"; license = lib.licenses.bsd3; - hydraPlatforms = lib.platforms.none; mainProgram = "weeder"; maintainers = [ lib.maintainers.maralorn ]; }) {}; @@ -332399,8 +333403,8 @@ self: { }: mkDerivation { pname = "window-utils"; - version = "0.2.1.0"; - sha256 = "1db4dnvg5s790yql75spqy446317a16f92hni8sbzdh541aahw73"; + version = "0.2.2.0"; + sha256 = "08s9rjpc2idrb5mgrnbwj2d0m8aj33g4v9djyvrkqnq5jb8mbzrz"; libraryHaskellDepends = [ base bytestring JuicyPixels text vector X11 ]; @@ -334813,6 +335817,21 @@ self: { broken = true; }) {}; + "x-sum-type-boilerplate" = callPackage + ({ mkDerivation, base, hspec, hspec-discover, template-haskell }: + mkDerivation { + pname = "x-sum-type-boilerplate"; + version = "0.1.4"; + sha256 = "1wcbv3jyfdqgff493wc00cxi1iq4myfygwzscpv8s5wyc9pfn30s"; + libraryHaskellDepends = [ base template-haskell ]; + testHaskellDepends = [ + base hspec hspec-discover template-haskell + ]; + testToolDepends = [ hspec-discover ]; + description = "(Forked) Library for reducing the boilerplate involved with sum types"; + license = lib.licenses.mit; + }) {}; + "x11-xim" = callPackage ({ mkDerivation, base, utf8-string, X11 }: mkDerivation { @@ -336747,6 +337766,32 @@ self: { ]; }) {}; + "xmonad-contrib_0_18_1" = callPackage + ({ mkDerivation, base, bytestring, containers, deepseq, directory + , filepath, hspec, mtl, process, QuickCheck, random, time + , transformers, unix, utf8-string, X11, X11-xft, xmonad + }: + mkDerivation { + pname = "xmonad-contrib"; + version = "0.18.1"; + sha256 = "0ck4hq9yhdzggrs3q4ji6nbg6zwhmhc0ckf9vr9d716d98h9swq5"; + libraryHaskellDepends = [ + base bytestring containers deepseq directory filepath mtl process + random time transformers unix utf8-string X11 X11-xft xmonad + ]; + testHaskellDepends = [ + base bytestring containers deepseq directory hspec mtl process + QuickCheck random time unix utf8-string X11 xmonad + ]; + description = "Community-maintained extensions for xmonad"; + license = lib.licenses.bsd3; + hydraPlatforms = lib.platforms.none; + maintainers = [ + lib.maintainers.dschrempf lib.maintainers.ivanbrennan + lib.maintainers.peti lib.maintainers.slotThe + ]; + }) {}; + "xmonad-contrib-bluetilebranch" = callPackage ({ mkDerivation, base, containers, directory, extensible-exceptions , mtl, old-locale, old-time, process, random, unix, utf8-string @@ -336837,8 +337882,8 @@ self: { }: mkDerivation { pname = "xmonad-extras"; - version = "0.17.1"; - sha256 = "08kq9w38jk4nwb2dmqbmybiz50zy81md9sbjmwrkw5wjcdxgsgch"; + version = "0.17.2"; + sha256 = "0rcvmd6m17n8pqi9ky29hd431iniq3vck08wjvyxxgfvq3m842i8"; configureFlags = [ "-f-with_hlist" "-fwith_parsec" "-fwith_split" ]; @@ -340761,7 +341806,6 @@ self: { ]; description = "Generate Flow routes for Yesod"; license = lib.licenses.mit; - hydraPlatforms = lib.platforms.none; }) {}; "yesod-routes-typescript" = callPackage diff --git a/pkgs/development/haskell-modules/lib/compose.nix b/pkgs/development/haskell-modules/lib/compose.nix index 09de1d228d942..3661c74d499a2 100644 --- a/pkgs/development/haskell-modules/lib/compose.nix +++ b/pkgs/development/haskell-modules/lib/compose.nix @@ -184,6 +184,13 @@ rec { markBrokenVersion = version: drv: assert drv.version == version; markBroken drv; markUnbroken = overrideCabal (drv: { broken = false; }); + /* disableParallelBuilding drops the -j<n> option from the GHC + command line for the given package. This can be useful in rare + situations where parallel building of a package causes GHC to + fail for some reason. + */ + disableParallelBuilding = overrideCabal (drv: { enableParallelBuilding = false; }); + enableLibraryProfiling = overrideCabal (drv: { enableLibraryProfiling = true; }); disableLibraryProfiling = overrideCabal (drv: { enableLibraryProfiling = false; }); diff --git a/pkgs/development/haskell-modules/lib/default.nix b/pkgs/development/haskell-modules/lib/default.nix index 2bcd8f25d1146..976e62afc630d 100644 --- a/pkgs/development/haskell-modules/lib/default.nix +++ b/pkgs/development/haskell-modules/lib/default.nix @@ -176,6 +176,8 @@ rec { markBrokenVersion = compose.markBrokenVersion; markUnbroken = compose.markUnbroken; + disableParallelBuilding = compose.disableParallelBuilding; + enableLibraryProfiling = compose.enableLibraryProfiling; disableLibraryProfiling = compose.disableLibraryProfiling; diff --git a/pkgs/development/haskell-modules/non-hackage-packages.nix b/pkgs/development/haskell-modules/non-hackage-packages.nix index bb995435fc600..c5cfbcec0313b 100644 --- a/pkgs/development/haskell-modules/non-hackage-packages.nix +++ b/pkgs/development/haskell-modules/non-hackage-packages.nix @@ -17,6 +17,8 @@ self: super: { # from the latest master instead of the current version on Hackage. cabal2nix-unstable = self.callPackage ./cabal2nix-unstable.nix { }; + ghc-settings-edit = self.callPackage ../tools/haskell/ghc-settings-edit { }; + # https://github.com/channable/vaultenv/issues/1 vaultenv = self.callPackage ../tools/haskell/vaultenv { }; diff --git a/pkgs/development/tools/haskell/ghc-settings-edit/Setup.hs b/pkgs/development/tools/haskell/ghc-settings-edit/Setup.hs new file mode 100644 index 0000000000000..9a994af677b0d --- /dev/null +++ b/pkgs/development/tools/haskell/ghc-settings-edit/Setup.hs @@ -0,0 +1,2 @@ +import Distribution.Simple +main = defaultMain diff --git a/pkgs/development/tools/haskell/ghc-settings-edit/default.nix b/pkgs/development/tools/haskell/ghc-settings-edit/default.nix new file mode 100644 index 0000000000000..fa5146a128bbf --- /dev/null +++ b/pkgs/development/tools/haskell/ghc-settings-edit/default.nix @@ -0,0 +1,31 @@ +{ + mkDerivation, + base, + containers, + lib, +}: + +mkDerivation { + pname = "ghc-settings-edit"; + version = "0.1.0"; + src = lib.fileset.toSource { + root = ./.; + fileset = lib.fileset.unions [ + ./Setup.hs + ./ghc-settings-edit.lhs + ./ghc-settings-edit.cabal + ]; + }; + isLibrary = false; + isExecutable = true; + executableHaskellDepends = [ + base + containers + ]; + license = [ + lib.licenses.mit + lib.licenses.bsd3 + ]; + description = "Tool for editing GHC's settings file"; + mainProgram = "ghc-settings-edit"; +} diff --git a/pkgs/development/tools/haskell/ghc-settings-edit/ghc-settings-edit.cabal b/pkgs/development/tools/haskell/ghc-settings-edit/ghc-settings-edit.cabal new file mode 100644 index 0000000000000..e31515c6391fc --- /dev/null +++ b/pkgs/development/tools/haskell/ghc-settings-edit/ghc-settings-edit.cabal @@ -0,0 +1,22 @@ +cabal-version: 2.2 +name: ghc-settings-edit +version: 0.1.0 +synopsis: Tool for editing GHC's settings file +-- TODO: description for hackage +-- TODO: category for hackage +license: MIT AND BSD-3-Clause +author: sternenseemann +-- FIXME: must be email for potential Hackage upload +maintainer: @NixOS/haskell +copyright: © 2024 The Nixpkgs/NixOS contributors +stability: experimental +build-type: Simple +bug-reports: https://github.com/NixOS/nixpkgs/issues + +executable ghc-settings-edit + default-language: Haskell2010 + -- TODO: bounds for hackage + build-depends: base + , containers + main-is: ghc-settings-edit.lhs + hs-source-dirs: . diff --git a/pkgs/development/tools/haskell/ghc-settings-edit/ghc-settings-edit.lhs b/pkgs/development/tools/haskell/ghc-settings-edit/ghc-settings-edit.lhs new file mode 100644 index 0000000000000..3b37bafe0d622 --- /dev/null +++ b/pkgs/development/tools/haskell/ghc-settings-edit/ghc-settings-edit.lhs @@ -0,0 +1,109 @@ +ghc-settings-edit is a small tool for changing certain fields in the settings +file that is part of every GHC installation (usually located at +lib/ghc-$version/lib/settings or lib/ghc-$version/settings). This is sometimes +necessary because GHC's build process leaks the tools used at build time into +the final settings file. This is fine, as long as the build and host platform +of the GHC build is the same since it will be possible to execute the tools +used at build time at run time. In case we are cross compiling GHC itself, +the settings file needs to be changed so that the correct tools are used in the +final installation. The GHC build system itself doesn't allow for this due to +its somewhat peculiar bootstrapping mechanism. + +This tool was originally written by sternenseemann and is licensed under the MIT +license (as is nixpkgs) as well as the BSD 3 Clause license since it incorporates +some code from GHC. It is primarily intended for use in nixpkgs, so it should be +considered unstable: No guarantees about the stability of its command line +interface are made at this time. + +> -- SPDX-License-Identifier: MIT AND BSD-3-Clause +> {-# LANGUAGE LambdaCase #-} +> module Main where + +ghc-settings-edit requires no additional dependencies to the ones already +required to bootstrap GHC. This means that it only depends on GHC and core +libraries shipped with the compiler (base and containers). This property should +be preserved going forward as to not needlessly complicate bootstrapping GHC +in nixpkgs. Additionally, a wide range of library versions and thus GHC versions +should be supported (via CPP if necessary). + +> import Control.Monad (foldM) +> import qualified Data.Map.Lazy as Map +> import System.Environment (getArgs, getProgName) +> import Text.Read (readEither) + +Note that the containers dependency is needed to represent the contents of the +settings file. In theory, [(String, String)] (think lookup) would suffice, but +base doesn't provide any facilities for updating such lists. To avoid needlessly +reinventing the wheel here, we depend on an extra core library. + +> type SettingsMap = Map.Map String String + +ghc-settings-edit accepts the following arguments: + +- The path to the settings file which is edited in place. +- For every field in the settings file to be updated, two arguments need to be + passed: the name of the field and its new value. Any number of these pairs + may be provided. If a field is missing from the given settings file, + it won't be added (see also below). + +> usage :: String -> String +> usage name = "Usage: " ++ name ++ " FILE [KEY NEWVAL [KEY2 NEWVAL2 ...]]" + +The arguments and the contents of the settings file are fed into the performEdits +function which implements the main logic of ghc-settings-edit (except IO). + +> performEdits :: [String] -> String -> Either String String +> performEdits editArgs settingsString = do + +First, the settings file is parsed and read into the SettingsMap structure. For +parsing, we can simply rely read, as GHC uses the familiar Read/Show format +(plus some formatting) for storing its settings. This is the main reason +ghc-settings-edit is written in Haskell: We don't need to roll our own parser. + +> settingsMap <- Map.fromList <$> readEither settingsString + +We also need to parse the remaining command line arguments (after the path) +which means splitting them into pairs of arguments describing the individual +edits. We use the chunkList utility function from GHC for this which is vendored +below. Since it doesn't guarantee that all sublists have the exact length given, +we'll have to check the length of the returned “pairs” later. + +> let edits = chunkList 2 editArgs + +Since each edit is a transformation of the SettingsMap, we use a fold to go +through the edits. The Either monad allows us to bail out if one is malformed. +The use of Map.adjust ensures that fields that aren't present in the original +settings file aren't added since the corresponding GHC installation wouldn't +understand them. Note that this is done silently which may be suboptimal: +It could be better to fail. + +> show . Map.toList <$> foldM applyEdit settingsMap edits +> where +> applyEdit :: SettingsMap -> [String] -> Either String SettingsMap +> applyEdit m [key, newValue] = Right $ Map.adjust (const newValue) key m +> applyEdit _ _ = Left "Uneven number of edit arguments provided" + +main just wraps performEdits and takes care of reading from and writing to the +given file. + +> main :: IO () +> main = +> getArgs >>= \case +> (settingsFile:edits) -> do +> orig <- readFile settingsFile +> case performEdits edits orig of +> Right edited -> writeFile settingsFile edited +> Left errorMsg -> error errorMsg +> _ -> do +> name <- getProgName +> error $ usage name + +As mentioned, chunkList is taken from GHC, specifically GHC.Utils.Misc of GHC +verson 9.8.2. We don't depend on the ghc library directly (which would be +possible in theory) since there are no stability guarantees or deprecation +windows for the ghc's public library. + +> -- | Split a list into chunks of /n/ elements +> chunkList :: Int -> [a] -> [[a]] +> chunkList _ [] = [] +> chunkList n xs = as : chunkList n bs where (as,bs) = splitAt n xs diff --git a/pkgs/development/tools/misc/binutils/default.nix b/pkgs/development/tools/misc/binutils/default.nix index 491bfc19ae0fc..cbc6351d5545f 100644 --- a/pkgs/development/tools/misc/binutils/default.nix +++ b/pkgs/development/tools/misc/binutils/default.nix @@ -84,7 +84,7 @@ stdenv.mkDerivation (finalAttrs: { # not need to know binutils' BINDIR at all. It's an absolute path # where libraries are stored. ./plugins-no-BINDIR.patch - ] ++ lib.optionals buildPlatform.isDarwin [ + ] ++ lib.optionals hostPlatform.isDarwin [ # Note: Conditional to avoid Linux rebuilds on staging-next. Remove the conditional with the next update. # ld64 needs `-undefined dynamic_lookup` to link `libctf-nobfd.dylib`, but the Darwin # version detection in `libtool.m4` fails to detect the Darwin version correctly. @@ -122,7 +122,7 @@ stdenv.mkDerivation (finalAttrs: { ++ lib.optionals targetPlatform.isVc4 [ flex ] ; - buildInputs = [ zlib gettext ] ++ lib.optionals buildPlatform.isDarwin [ CoreServices ]; + buildInputs = [ zlib gettext ] ++ lib.optionals hostPlatform.isDarwin [ CoreServices ]; inherit noSysDirs; diff --git a/pkgs/test/cross/default.nix b/pkgs/test/cross/default.nix index bd233db4cd50f..f07e9c6220de7 100644 --- a/pkgs/test/cross/default.nix +++ b/pkgs/test/cross/default.nix @@ -146,6 +146,8 @@ let pkgs.pkgsCross.mips64el-linux-gnuabi64.stdenv pkgs.pkgsCross.mips64el-linux-gnuabin32.stdenv pkgs.pkgsCross.mingwW64.stdenv + # Uses the expression that is used by the most cross-compil_ed_ GHCs + pkgs.pkgsCross.riscv64.haskell.compiler.native-bignum.ghc948 ] ++ lib.optionals (with pkgs.stdenv.buildPlatform; isx86_64 && isLinux) [ # Musl-to-glibc cross on the same architecture tends to turn up diff --git a/pkgs/top-level/haskell-packages.nix b/pkgs/top-level/haskell-packages.nix index 6193d9d217ae9..7db5618ec3140 100644 --- a/pkgs/top-level/haskell-packages.nix +++ b/pkgs/top-level/haskell-packages.nix @@ -1,4 +1,4 @@ -{ buildPackages, pkgsBuildTarget, pkgs, newScope, stdenv }: +{ buildPackages, pkgsBuildBuild, pkgsBuildTarget, pkgs, newScope, stdenv }: let # These are attributes in compiler that support integer-simple. @@ -52,7 +52,18 @@ in { package-list = callPackage ../development/haskell-modules/package-list.nix {}; - compiler = { + # Always get boot compilers from `pkgsBuildBuild`. The boot (stage0) compiler + # is used to build another compiler (stage1) that'll be used to build the + # final compiler (stage2) (except when building a cross-compiler). This means + # that stage1's host platform is the same as stage0: build. Consequently, + # stage0 needs to be build->build. + # + # Note that we use bb.haskell.packages.*. haskell.packages.*.ghc is similar to + # stdenv: The ghc comes from the previous package set, i.e. this predicate holds: + # `name: pkgs: pkgs.haskell.packages.${name}.ghc == pkgs.buildPackages.haskell.compiler.${name}.ghc`. + # This isn't problematic since pkgsBuildBuild.buildPackages is also build->build, + # just something to keep in mind. + compiler = let bb = pkgsBuildBuild.haskell; in { ghc865Binary = callPackage ../development/compilers/ghc/8.6.5-binary.nix { # Should be llvmPackages_6 which has been removed from nixpkgs llvmPackages = null; @@ -73,11 +84,11 @@ in { ghc8107 = callPackage ../development/compilers/ghc/8.10.7.nix { bootPkgs = # the oldest ghc with aarch64-darwin support is 8.10.5 - if stdenv.hostPlatform.isPower64 && stdenv.hostPlatform.isLittleEndian then + if stdenv.buildPlatform.isPower64 && stdenv.buildPlatform.isLittleEndian then # to my (@a-m-joseph) knowledge there are no newer official binaries for this platform - packages.ghc865Binary + bb.packages.ghc865Binary else - packages.ghc8107Binary; + bb.packages.ghc8107Binary; inherit (buildPackages.python311Packages) sphinx; # a distutils issue with 3.12 python3 = buildPackages.python311; # so that we don't have two of them # Need to use apple's patched xattr until @@ -91,10 +102,10 @@ in { ghc902 = callPackage ../development/compilers/ghc/9.0.2.nix { bootPkgs = # the oldest ghc with aarch64-darwin support is 8.10.5 - if stdenv.hostPlatform.isPower64 && stdenv.hostPlatform.isLittleEndian then - packages.ghc810 + if stdenv.buildPlatform.isPower64 && stdenv.buildPlatform.isLittleEndian then + bb.packages.ghc810 else - packages.ghc8107Binary; + bb.packages.ghc8107Binary; inherit (buildPackages.python311Packages) sphinx; # a distutils issue with 3.12 python3 = buildPackages.python311; # so that we don't have two of them inherit (buildPackages.darwin) autoSignDarwinBinariesHook xattr; @@ -104,10 +115,10 @@ in { ghc90 = compiler.ghc902; ghc925 = callPackage ../development/compilers/ghc/9.2.5.nix { bootPkgs = - if stdenv.hostPlatform.isPower64 && stdenv.hostPlatform.isLittleEndian then - packages.ghc810 + if stdenv.buildPlatform.isPower64 && stdenv.buildPlatform.isLittleEndian then + bb.packages.ghc810 else - packages.ghc8107Binary; + bb.packages.ghc8107Binary; inherit (buildPackages.python311Packages) sphinx; # a distutils issue with 3.12 python3 = buildPackages.python311; # so that we don't have two of them # Need to use apple's patched xattr until @@ -119,10 +130,10 @@ in { }; ghc926 = callPackage ../development/compilers/ghc/9.2.6.nix { bootPkgs = - if stdenv.hostPlatform.isPower64 && stdenv.hostPlatform.isLittleEndian then - packages.ghc810 + if stdenv.buildPlatform.isPower64 && stdenv.buildPlatform.isLittleEndian then + bb.packages.ghc810 else - packages.ghc8107Binary; + bb.packages.ghc8107Binary; inherit (buildPackages.python311Packages) sphinx; # a distutils issue with 3.12 python3 = buildPackages.python311; # so that we don't have two of them # Need to use apple's patched xattr until @@ -134,10 +145,10 @@ in { }; ghc927 = callPackage ../development/compilers/ghc/9.2.7.nix { bootPkgs = - if stdenv.hostPlatform.isPower64 && stdenv.hostPlatform.isLittleEndian then - packages.ghc810 + if stdenv.buildPlatform.isPower64 && stdenv.buildPlatform.isLittleEndian then + bb.packages.ghc810 else - packages.ghc8107Binary; + bb.packages.ghc8107Binary; inherit (buildPackages.python311Packages) sphinx; # a distutils issue with 3.12 python3 = buildPackages.python311; # so that we don't have two of them # Need to use apple's patched xattr until @@ -149,10 +160,10 @@ in { }; ghc928 = callPackage ../development/compilers/ghc/9.2.8.nix { bootPkgs = - if stdenv.hostPlatform.isPower64 && stdenv.hostPlatform.isLittleEndian then - packages.ghc810 + if stdenv.buildPlatform.isPower64 && stdenv.buildPlatform.isLittleEndian then + bb.packages.ghc810 else - packages.ghc8107Binary; + bb.packages.ghc8107Binary; inherit (buildPackages.python311Packages) sphinx; # a distutils issue with 3.12 python3 = buildPackages.python311; # so that we don't have two of them # Need to use apple's patched xattr until @@ -170,14 +181,14 @@ in { # Use 8.10 as a workaround where possible to keep bootstrap path short. # On ARM text won't build with GHC 8.10.* - if stdenv.hostPlatform.isAarch then + if stdenv.buildPlatform.isAarch then # TODO(@sternenseemann): package bindist - packages.ghc902 + bb.packages.ghc902 # No suitable bindists for powerpc64le - else if stdenv.hostPlatform.isPower64 && stdenv.hostPlatform.isLittleEndian then - packages.ghc902 + else if stdenv.buildPlatform.isPower64 && stdenv.buildPlatform.isLittleEndian then + bb.packages.ghc902 else - packages.ghc8107Binary; + bb.packages.ghc8107Binary; inherit (buildPackages.python311Packages) sphinx; # a distutils issue with 3.12 python3 = buildPackages.python311; # so that we don't have two of them # Need to use apple's patched xattr until @@ -195,14 +206,14 @@ in { # Use 8.10 as a workaround where possible to keep bootstrap path short. # On ARM text won't build with GHC 8.10.* - if stdenv.hostPlatform.isAarch then + if stdenv.buildPlatform.isAarch then # TODO(@sternenseemann): package bindist - packages.ghc902 + bb.packages.ghc902 # No suitable bindists for powerpc64le - else if stdenv.hostPlatform.isPower64 && stdenv.hostPlatform.isLittleEndian then - packages.ghc902 + else if stdenv.buildPlatform.isPower64 && stdenv.buildPlatform.isLittleEndian then + bb.packages.ghc902 else - packages.ghc8107Binary; + bb.packages.ghc8107Binary; inherit (buildPackages.python311Packages) sphinx; # a distutils issue with 3.12 python3 = buildPackages.python311; # so that we don't have two of them # Need to use apple's patched xattr until @@ -220,14 +231,14 @@ in { # Use 8.10 as a workaround where possible to keep bootstrap path short. # On ARM text won't build with GHC 8.10.* - if stdenv.hostPlatform.isAarch then + if stdenv.buildPlatform.isAarch then # TODO(@sternenseemann): package bindist - packages.ghc902 + bb.packages.ghc902 # No suitable bindists for powerpc64le - else if stdenv.hostPlatform.isPower64 && stdenv.hostPlatform.isLittleEndian then - packages.ghc902 + else if stdenv.buildPlatform.isPower64 && stdenv.buildPlatform.isLittleEndian then + bb.packages.ghc902 else - packages.ghc8107Binary; + bb.packages.ghc8107Binary; inherit (buildPackages.python3Packages) sphinx; # Need to use apple's patched xattr until # https://github.com/xattr/xattr/issues/44 and @@ -244,14 +255,14 @@ in { # Use 8.10 as a workaround where possible to keep bootstrap path short. # On ARM text won't build with GHC 8.10.* - if stdenv.hostPlatform.isAarch then + if stdenv.buildPlatform.isAarch then # TODO(@sternenseemann): package bindist - packages.ghc902 + bb.packages.ghc902 # No suitable bindists for powerpc64le - else if stdenv.hostPlatform.isPower64 && stdenv.hostPlatform.isLittleEndian then - packages.ghc902 + else if stdenv.buildPlatform.isPower64 && stdenv.buildPlatform.isLittleEndian then + bb.packages.ghc902 else - packages.ghc8107Binary; + bb.packages.ghc8107Binary; inherit (buildPackages.python3Packages) sphinx; # Need to use apple's patched xattr until # https://github.com/xattr/xattr/issues/44 and @@ -265,12 +276,12 @@ in { ghc963 = callPackage ../development/compilers/ghc/9.6.3.nix { bootPkgs = # For GHC 9.2 no armv7l bindists are available. - if stdenv.hostPlatform.isAarch32 then - packages.ghc928 - else if stdenv.hostPlatform.isPower64 && stdenv.hostPlatform.isLittleEndian then - packages.ghc928 + if stdenv.buildPlatform.isAarch32 then + bb.packages.ghc928 + else if stdenv.buildPlatform.isPower64 && stdenv.buildPlatform.isLittleEndian then + bb.packages.ghc928 else - packages.ghc924Binary; + bb.packages.ghc924Binary; inherit (buildPackages.python3Packages) sphinx; # Need to use apple's patched xattr until # https://github.com/xattr/xattr/issues/44 and @@ -283,12 +294,12 @@ in { ghc964 = callPackage ../development/compilers/ghc/9.6.4.nix { bootPkgs = # For GHC 9.2 no armv7l bindists are available. - if stdenv.hostPlatform.isAarch32 then - packages.ghc928 - else if stdenv.hostPlatform.isPower64 && stdenv.hostPlatform.isLittleEndian then - packages.ghc928 + if stdenv.buildPlatform.isAarch32 then + bb.packages.ghc928 + else if stdenv.buildPlatform.isPower64 && stdenv.buildPlatform.isLittleEndian then + bb.packages.ghc928 else - packages.ghc924Binary; + bb.packages.ghc924Binary; inherit (buildPackages.python3Packages) sphinx; # Need to use apple's patched xattr until # https://github.com/xattr/xattr/issues/44 and @@ -301,12 +312,12 @@ in { ghc965 = callPackage ../development/compilers/ghc/9.6.5.nix { bootPkgs = # For GHC 9.2 no armv7l bindists are available. - if stdenv.hostPlatform.isAarch32 then - packages.ghc928 - else if stdenv.hostPlatform.isPower64 && stdenv.hostPlatform.isLittleEndian then - packages.ghc928 + if stdenv.buildPlatform.isAarch32 then + bb.packages.ghc928 + else if stdenv.buildPlatform.isPower64 && stdenv.buildPlatform.isLittleEndian then + bb.packages.ghc928 else - packages.ghc924Binary; + bb.packages.ghc924Binary; inherit (buildPackages.python3Packages) sphinx; # Need to use apple's patched xattr until # https://github.com/xattr/xattr/issues/44 and @@ -319,12 +330,12 @@ in { ghc966 = callPackage ../development/compilers/ghc/9.6.6.nix { bootPkgs = # For GHC 9.2 no armv7l bindists are available. - if stdenv.hostPlatform.isAarch32 then - packages.ghc928 - else if stdenv.hostPlatform.isPower64 && stdenv.hostPlatform.isLittleEndian then - packages.ghc928 + if stdenv.buildPlatform.isAarch32 then + bb.packages.ghc928 + else if stdenv.buildPlatform.isPower64 && stdenv.buildPlatform.isLittleEndian then + bb.packages.ghc928 else - packages.ghc924Binary; + bb.packages.ghc924Binary; inherit (buildPackages.python3Packages) sphinx; # Need to use apple's patched xattr until # https://github.com/xattr/xattr/issues/44 and @@ -338,12 +349,12 @@ in { ghc981 = callPackage ../development/compilers/ghc/9.8.1.nix { bootPkgs = # For GHC 9.6 no armv7l bindists are available. - if stdenv.hostPlatform.isAarch32 then - packages.ghc963 - else if stdenv.hostPlatform.isPower64 && stdenv.hostPlatform.isLittleEndian then - packages.ghc963 + if stdenv.buildPlatform.isAarch32 then + bb.packages.ghc963 + else if stdenv.buildPlatform.isPower64 && stdenv.buildPlatform.isLittleEndian then + bb.packages.ghc963 else - packages.ghc963Binary; + bb.packages.ghc963Binary; inherit (buildPackages.python3Packages) sphinx; # Need to use apple's patched xattr until # https://github.com/xattr/xattr/issues/44 and @@ -356,12 +367,12 @@ in { ghc982 = callPackage ../development/compilers/ghc/9.8.2.nix { bootPkgs = # For GHC 9.6 no armv7l bindists are available. - if stdenv.hostPlatform.isAarch32 then - packages.ghc963 - else if stdenv.hostPlatform.isPower64 && stdenv.hostPlatform.isLittleEndian then - packages.ghc963 + if stdenv.buildPlatform.isAarch32 then + bb.packages.ghc963 + else if stdenv.buildPlatform.isPower64 && stdenv.buildPlatform.isLittleEndian then + bb.packages.ghc963 else - packages.ghc963Binary; + bb.packages.ghc963Binary; inherit (buildPackages.python3Packages) sphinx; # Need to use apple's patched xattr until # https://github.com/xattr/xattr/issues/44 and @@ -375,19 +386,19 @@ in { ghc9101 = callPackage ../development/compilers/ghc/9.10.1.nix { bootPkgs = # For GHC 9.6 no armv7l bindists are available. - if stdenv.hostPlatform.isAarch32 then - packages.ghc963 - else if stdenv.hostPlatform.isPower64 && stdenv.hostPlatform.isLittleEndian then - packages.ghc963 - else if stdenv.hostPlatform.isDarwin then + if stdenv.buildPlatform.isAarch32 then + bb.packages.ghc963 + else if stdenv.buildPlatform.isPower64 && stdenv.buildPlatform.isLittleEndian then + bb.packages.ghc963 + else if stdenv.buildPlatform.isDarwin then # it seems like the GHC 9.6.* bindists are built with a different # toolchain than we are using (which I'm guessing from the fact # that 9.6.4 bindists pass linker flags our ld doesn't support). # With both 9.6.3 and 9.6.4 binary it is impossible to link against # the clock package (probably a hsc2hs problem). - packages.ghc963 + bb.packages.ghc963 else - packages.ghc963Binary; + bb.packages.ghc963Binary; inherit (buildPackages.python3Packages) sphinx; # Need to use apple's patched xattr until # https://github.com/xattr/xattr/issues/44 and @@ -401,12 +412,12 @@ in { ghcHEAD = callPackage ../development/compilers/ghc/head.nix { bootPkgs = # For GHC 9.6 no armv7l bindists are available. - if stdenv.hostPlatform.isAarch32 then - packages.ghc963 - else if stdenv.hostPlatform.isPower64 && stdenv.hostPlatform.isLittleEndian then - packages.ghc963 + if stdenv.buildPlatform.isAarch32 then + bb.packages.ghc963 + else if stdenv.buildPlatform.isPower64 && stdenv.buildPlatform.isLittleEndian then + bb.packages.ghc963 else - packages.ghc963Binary; + bb.packages.ghc963Binary; inherit (buildPackages.python3Packages) sphinx; # Need to use apple's patched xattr until # https://github.com/xattr/xattr/issues/44 and @@ -419,7 +430,7 @@ in { ghcjs = compiler.ghcjs810; ghcjs810 = callPackage ../development/compilers/ghcjs/8.10 { - bootPkgs = packages.ghc810; + bootPkgs = bb.packages.ghc810; ghcjsSrcJson = ../development/compilers/ghcjs/8.10/git.json; stage0 = ../development/compilers/ghcjs/8.10/stage0.nix; }; diff --git a/pkgs/top-level/release-haskell.nix b/pkgs/top-level/release-haskell.nix index 65f0ad17b5127..88518f6b1d2e6 100644 --- a/pkgs/top-level/release-haskell.nix +++ b/pkgs/top-level/release-haskell.nix @@ -327,7 +327,6 @@ let lambdabot lhs2tex madlang - mailctl matterhorn mkjson mueval @@ -394,19 +393,7 @@ let }; # GHCs linked to musl. - pkgsMusl.haskell.compiler = lib.recursiveUpdate - (packagePlatforms pkgs.pkgsMusl.haskell.compiler) - { - # remove musl ghc865Binary since it is known to be broken and - # causes an evaluation error on darwin. - ghc865Binary = {}; - - ghcjs = {}; - ghcjs810 = {}; - }; - - # Get some cache going for MUSL-enabled GHC. - pkgsMusl.haskellPackages = + pkgsMusl = removePlatforms [ # pkgsMusl is compiled natively with musl. It is not @@ -420,11 +407,26 @@ let "aarch64-darwin" ] { - inherit (packagePlatforms pkgs.pkgsMusl.haskellPackages) - hello - lens - random - ; + haskell.compiler = lib.recursiveUpdate + (packagePlatforms pkgs.pkgsMusl.haskell.compiler) + { + # remove musl ghc865Binary since it is known to be broken and + # causes an evaluation error on darwin. + ghc865Binary = {}; + + ghcjs = {}; + ghcjs810 = {}; + }; + + # Get some cache going for MUSL-enabled GHC. + haskellPackages = + { + inherit (packagePlatforms pkgs.pkgsMusl.haskellPackages) + hello + lens + random + ; + }; }; # Test some statically linked packages to catch regressions @@ -473,37 +475,65 @@ let }; }; - pkgsCross.ghcjs = - removePlatforms - [ - # Hydra output size of 3GB is exceeded - "aarch64-linux" - ] - { - haskellPackages = { - inherit (packagePlatforms pkgs.pkgsCross.ghcjs.haskellPackages) - ghc - hello - microlens - ; + pkgsCross = { + ghcjs = + removePlatforms + [ + # Hydra output size of 3GB is exceeded + "aarch64-linux" + ] + { + haskellPackages = { + inherit (packagePlatforms pkgs.pkgsCross.ghcjs.haskellPackages) + ghc + hello + microlens + ; + }; + + haskell.packages.ghc98 = { + inherit (packagePlatforms pkgs.pkgsCross.ghcjs.haskell.packages.ghc98) + ghc + hello + microlens + ; + }; + + haskell.packages.ghcHEAD = { + inherit (packagePlatforms pkgs.pkgsCross.ghcjs.haskell.packages.ghcHEAD) + ghc + hello + microlens + ; + }; }; - haskell.packages.ghc98 = { - inherit (packagePlatforms pkgs.pkgsCross.ghcjs.haskell.packages.ghc98) - ghc - hello - microlens + riscv64 = { + # Cross compilation of GHC + haskell.compiler = { + inherit (packagePlatforms pkgs.pkgsCross.riscv64.haskell.compiler) + # Our oldest GHC which still uses its own expression. 8.10.7 can + # theoretically be used to chain bootstrap all GHCs on riscv64 + # which doesn't have official bindists. + ghc8107 + # Latest GHC we are able to cross-compile. + ghc948 ; - }; + }; + }; - haskell.packages.ghcHEAD = { - inherit (packagePlatforms pkgs.pkgsCross.ghcjs.haskell.packages.ghcHEAD) - ghc - hello - microlens + aarch64-multiplatform = { + # Cross compilation of GHC + haskell.compiler = { + inherit (packagePlatforms pkgs.pkgsCross.aarch64-multiplatform.haskell.compiler) + # Uses a separate expression and LLVM backend for aarch64. + ghc8107 + # Latest GHC we are able to cross-compile. Uses NCG backend. + ghc948 ; - }; }; + }; + }; }) (versionedCompilerJobs { # Packages which should be checked on more than the @@ -549,7 +579,6 @@ let compilerNames.ghc9101 ] released; hoogle = lib.subtractLists [ - compilerNames.ghc9101 ] released; hlint = lib.subtractLists [ compilerNames.ghc902 |