From de44764f21a454d4543a8539b6fd45576984f0fe Mon Sep 17 00:00:00 2001 From: Alexandre Esteves Date: Wed, 18 Feb 2026 02:43:28 +0000 Subject: [PATCH 01/52] haskellPackages.basement: fix on ghcjs --- .../haskell-modules/configuration-common.nix | 7 +++---- .../haskell-modules/patches/basement-ghcjs.patch | 11 +++++++++++ 2 files changed, 14 insertions(+), 4 deletions(-) create mode 100644 pkgs/development/haskell-modules/patches/basement-ghcjs.patch diff --git a/pkgs/development/haskell-modules/configuration-common.nix b/pkgs/development/haskell-modules/configuration-common.nix index 662c682aaf17..3cb4d376fb13 100644 --- a/pkgs/development/haskell-modules/configuration-common.nix +++ b/pkgs/development/haskell-modules/configuration-common.nix @@ -494,6 +494,7 @@ with haskellLib; jpeg-turbo = dontCheck super.jpeg-turbo; JuicyPixels-jpeg-turbo = dontCheck super.JuicyPixels-jpeg-turbo; + # Repo is archived, package is abandoned: https://github.com/haskell-foundation/foundation basement = appendPatches [ # Fixes compilation for basement on i686 # https://github.com/haskell-foundation/foundation/pull/573 @@ -503,10 +504,8 @@ with haskellLib; sha256 = "17kz8glfim29vyhj8idw8bdh3id5sl9zaq18zzih3schfvyjppj7"; stripLen = 1; }) - - # Fixes compilation on windows - # Repo is archived, package is abandoned: https://github.com/haskell-foundation/foundation - ./patches/basement-add-cast.patch + ./patches/basement-add-cast.patch # Fixes compilation on windows + ./patches/basement-ghcjs.patch # Fixes compilation on ghcjs ] super.basement; diff --git a/pkgs/development/haskell-modules/patches/basement-ghcjs.patch b/pkgs/development/haskell-modules/patches/basement-ghcjs.patch new file mode 100644 index 000000000000..aa858a9c9b48 --- /dev/null +++ b/pkgs/development/haskell-modules/patches/basement-ghcjs.patch @@ -0,0 +1,11 @@ +diff --git a/basement.cabal b/basement.cabal +index f85f617..1484ad7 100644 +--- a/basement.cabal ++++ b/basement.cabal +@@ -156,4 +156,5 @@ library + else + cpp-options: -DARCH_IS_UNKNOWN_ENDIAN + include-dirs: cbits +- c-sources: cbits/foundation_mem.c ++ if !os(ghcjs) ++ c-sources: cbits/foundation_mem.c From 5bda4227ab5cafaf6e56665c8b007f03c19aad76 Mon Sep 17 00:00:00 2001 From: Alexandre Esteves Date: Wed, 18 Feb 2026 02:43:38 +0000 Subject: [PATCH 02/52] haskellPackages.foundation: fix on ghcjs --- .../haskell-modules/configuration-common.nix | 4 ++++ .../haskell-modules/patches/foundation-ghcjs.patch | 14 ++++++++++++++ 2 files changed, 18 insertions(+) create mode 100644 pkgs/development/haskell-modules/patches/foundation-ghcjs.patch diff --git a/pkgs/development/haskell-modules/configuration-common.nix b/pkgs/development/haskell-modules/configuration-common.nix index 3cb4d376fb13..eadc97a06776 100644 --- a/pkgs/development/haskell-modules/configuration-common.nix +++ b/pkgs/development/haskell-modules/configuration-common.nix @@ -509,6 +509,10 @@ with haskellLib; ] super.basement; + # Repo is archived, package is abandoned: https://github.com/haskell-foundation/foundation + # Fixes compilation on ghcjs + foundation = appendPatch ./patches/foundation-ghcjs.patch super.foundation; + # Fixes compilation of memory with GHC >= 9.4 on 32bit platforms # https://github.com/vincenthz/hs-memory/pull/99 memory = appendPatches [ diff --git a/pkgs/development/haskell-modules/patches/foundation-ghcjs.patch b/pkgs/development/haskell-modules/patches/foundation-ghcjs.patch new file mode 100644 index 000000000000..1b2cd33d63ab --- /dev/null +++ b/pkgs/development/haskell-modules/patches/foundation-ghcjs.patch @@ -0,0 +1,14 @@ +diff --git a/foundation.cabal b/foundation.cabal +index d33d874..654488b 100644 +--- a/foundation.cabal ++++ b/foundation.cabal +@@ -169,7 +169,8 @@ library + Foundation.System.Bindings.Hs + + include-dirs: cbits +- c-sources: cbits/foundation_random.c ++ if !os(ghcjs) ++ c-sources: cbits/foundation_random.c + cbits/foundation_network.c + cbits/foundation_time.c + cbits/foundation_utf8.c From 3750bf46f315929a74426eafa80b3f99492eb208 Mon Sep 17 00:00:00 2001 From: Alexandre Esteves Date: Sun, 8 Feb 2026 20:36:37 +0000 Subject: [PATCH 03/52] haskellPackages.iserv-proxy: fix on GHC 9.6 --- .../development/haskell-modules/configuration-ghc-9.6.x.nix | 5 ++++- pkgs/development/haskell-modules/configuration-nix.nix | 3 ++- pkgs/development/haskell-modules/generic-builder.nix | 5 +++-- pkgs/development/tools/haskell/iserv-proxy/default.nix | 6 +++--- 4 files changed, 12 insertions(+), 7 deletions(-) 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 f7603f5a088d..5f16c45e9118 100644 --- a/pkgs/development/haskell-modules/configuration-ghc-9.6.x.nix +++ b/pkgs/development/haskell-modules/configuration-ghc-9.6.x.nix @@ -38,7 +38,6 @@ in haskeline = null; hpc = null; integer-gmp = null; - libiserv = null; mtl = null; parsec = null; pretty = null; @@ -60,6 +59,10 @@ in xhtml = null; Win32 = null; + libiserv = doJailbreak (markUnbroken (doDistribute super.libiserv)); # ghci ==9.6.6 + + iserv-proxy = addBuildDepend self.libiserv super.iserv-proxy; + # Becomes a core package in GHC >= 9.8 semaphore-compat = doDistribute self.semaphore-compat_1_0_0; diff --git a/pkgs/development/haskell-modules/configuration-nix.nix b/pkgs/development/haskell-modules/configuration-nix.nix index 747738bf19b4..0c3a8e40410b 100644 --- a/pkgs/development/haskell-modules/configuration-nix.nix +++ b/pkgs/development/haskell-modules/configuration-nix.nix @@ -2239,8 +2239,9 @@ builtins.intersectAttrs super { enableExternalInterpreter = false; }; in - lib.mapAttrs (_: noExternalInterpreter) { inherit (super) iserv-proxy network; } + lib.mapAttrs (_: noExternalInterpreter) { inherit (super) libiserv iserv-proxy network; } ) + libiserv iserv-proxy network ; diff --git a/pkgs/development/haskell-modules/generic-builder.nix b/pkgs/development/haskell-modules/generic-builder.nix index e8d85a3e120b..e2c875508f01 100644 --- a/pkgs/development/haskell-modules/generic-builder.nix +++ b/pkgs/development/haskell-modules/generic-builder.nix @@ -26,8 +26,9 @@ let needsExternalInterpreterSetup = !stdenv.hostPlatform.isGhcjs; # JS backend already handles this canProxyTH = - # iserv-proxy currently does not build on GHC 9.6 - lib.versionAtLeast ghc.version "9.8" && stdenv.hostPlatform.emulatorAvailable buildPackages; + # Using iserv-proxy with 9.4 yields + # no location info>: error: Dynamic loading not supported + lib.versionAtLeast ghc.version "9.6" && stdenv.hostPlatform.emulatorAvailable buildPackages; iservWrapper = let diff --git a/pkgs/development/tools/haskell/iserv-proxy/default.nix b/pkgs/development/tools/haskell/iserv-proxy/default.nix index 63e312bfe3a5..c31d9e4cba64 100644 --- a/pkgs/development/tools/haskell/iserv-proxy/default.nix +++ b/pkgs/development/tools/haskell/iserv-proxy/default.nix @@ -15,14 +15,14 @@ }: mkDerivation { pname = "iserv-proxy"; - version = "9.3-unstable-2025-10-30"; + version = "9.3-unstable-2026-02-04"; # https://github.com/stable-haskell/iserv-proxy/pull/1 src = fetchFromGitHub { owner = "stable-haskell"; repo = "iserv-proxy"; - rev = "bbee090fc67bb5cc6ad4508fa5def560b7672591"; - hash = "sha256-2aCGboNCF602huvmbyTcfhe6s+D4/n/NlOefd0c0SC0="; + rev = "91ef7ffdeedfb141a4d69dcf9e550abe3e1160c6"; + hash = "sha256-x6QYupvHZM7rRpVO4AIC5gUWFprFQ59A95FPC7/Owjg"; }; isLibrary = true; From 8a5a110275962ad1fa8295f973797238399142fe Mon Sep 17 00:00:00 2001 From: Alexandre Esteves Date: Mon, 16 Mar 2026 03:13:28 +0000 Subject: [PATCH 04/52] haskellPackages.iserv-proxy: test on Hydra --- pkgs/top-level/release-haskell.nix | 1 + 1 file changed, 1 insertion(+) diff --git a/pkgs/top-level/release-haskell.nix b/pkgs/top-level/release-haskell.nix index 328581970fd4..3130fa3e65e3 100644 --- a/pkgs/top-level/release-haskell.nix +++ b/pkgs/top-level/release-haskell.nix @@ -543,6 +543,7 @@ let ] released; hpack = released; hsdns = released; + iserv-proxy = released; jailbreak-cabal = released; language-nix = released; nix-paths = released; From b388850ca4cf925e67ca757f599202288cebad60 Mon Sep 17 00:00:00 2001 From: Alexandre Esteves Date: Mon, 2 Feb 2026 17:30:38 +0000 Subject: [PATCH 05/52] haskellPackages: fix eval cycle when doCheck is enabled for cross --- .../haskell-modules/configuration-nix.nix | 29 +++++++++---------- .../haskell-modules/configuration-windows.nix | 17 ----------- 2 files changed, 14 insertions(+), 32 deletions(-) diff --git a/pkgs/development/haskell-modules/configuration-nix.nix b/pkgs/development/haskell-modules/configuration-nix.nix index 0c3a8e40410b..221b4d2e30ef 100644 --- a/pkgs/development/haskell-modules/configuration-nix.nix +++ b/pkgs/development/haskell-modules/configuration-nix.nix @@ -2230,21 +2230,20 @@ builtins.intersectAttrs super { botan-bindings = super.botan-bindings.override { botan = pkgs.botan3; }; - # Avoids a cycle by disabling use of the external interpreter for the packages that are dependencies of iserv-proxy. - # These in particular can't rely on template haskell for cross-compilation anyway as they can't rely on iserv-proxy. - inherit - ( - let - noExternalInterpreter = overrideCabal { - enableExternalInterpreter = false; - }; - in - lib.mapAttrs (_: noExternalInterpreter) { inherit (super) libiserv iserv-proxy network; } - ) - libiserv - iserv-proxy - network - ; + iserv-proxy = + let + # Avoid a cycle by disabling tests and the external interpreter for packages that are dependencies of iserv-proxy. + # These in particular can't rely on template haskell for cross-compilation anyway as they can't rely on iserv-proxy. + # Also disable tests during iserv-proxy bootstrap since test packages tend to rely on TH for discovering test cases + breakExternalInterpreterBootstrapCycle = overrideCabal { + doCheck = false; + enableExternalInterpreter = false; + }; + overlay = lib.mapAttrs ( + _: pkg: if (pkg ? isHaskellLibrary) then breakExternalInterpreterBootstrapCycle pkg else pkg + ); + in + super.iserv-proxy.overrideScope (_: overlay); # Workaround for flaky test: https://github.com/basvandijk/threads/issues/10 threads = appendPatch ./patches/threads-flaky-test.patch super.threads; diff --git a/pkgs/development/haskell-modules/configuration-windows.nix b/pkgs/development/haskell-modules/configuration-windows.nix index 5489c415f09c..735a55ca4068 100644 --- a/pkgs/development/haskell-modules/configuration-windows.nix +++ b/pkgs/development/haskell-modules/configuration-windows.nix @@ -37,21 +37,4 @@ with haskellLib; # Root cause seems to be undefined references to libffi as shown by linking errors if we instead use "-Wl,--disable-auto-import" # See https://github.com/rust-lang/rust/issues/132226#issuecomment-2445100058 iserv-proxy = appendConfigureFlag "--ghc-option=-optl=-Wl,--disable-runtime-pseudo-reloc" super.iserv-proxy; - - # Avoids a cycle by disabling use of the external interpreter for the packages that are dependencies of iserv-proxy. - # See configuration-nix.nix, where iserv-proxy and network are handled. - # On Windows, network depends on temporary (see above), which depends on random, which depends on splitmix. - inherit - ( - let - noExternalInterpreter = overrideCabal { - enableExternalInterpreter = false; - }; - in - lib.mapAttrs (_: noExternalInterpreter) { inherit (super) random splitmix temporary; } - ) - random - splitmix - temporary - ; }) From 4e91673453dd1c6e8ee3972134ded4f81d1d195c Mon Sep 17 00:00:00 2001 From: Alexandre Esteves Date: Tue, 17 Mar 2026 19:28:53 +0000 Subject: [PATCH 06/52] haskellPackages.nix-paths: relax platform equality to 'canExecute' check --- pkgs/development/haskell-modules/configuration-common.nix | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/pkgs/development/haskell-modules/configuration-common.nix b/pkgs/development/haskell-modules/configuration-common.nix index 7b4e159215e0..84bdd778c2bc 100644 --- a/pkgs/development/haskell-modules/configuration-common.nix +++ b/pkgs/development/haskell-modules/configuration-common.nix @@ -699,7 +699,7 @@ with haskellLib; # Pass in `pkgs.nix` for the required tools. This means that overriding # them sort of works, but only if you override all instances. nix-paths = - if pkgs.stdenv.hostPlatform == pkgs.stdenv.buildPlatform then + if with pkgs.stdenv; buildPlatform.canExecute hostPlatform then super.nix-paths.override { nix-build = pkgs.nix; nix-env = pkgs.nix; From d1bcc8d9e8b8c88662f633c719923edb5e734781 Mon Sep 17 00:00:00 2001 From: Alexandre Esteves Date: Mon, 23 Feb 2026 03:01:39 +0000 Subject: [PATCH 07/52] haskellPackages.*: fix build with Darwin sandbox enabled --- .../haskell-modules/configuration-darwin.nix | 20 +++++++++++++++++++ 1 file changed, 20 insertions(+) diff --git a/pkgs/development/haskell-modules/configuration-darwin.nix b/pkgs/development/haskell-modules/configuration-darwin.nix index 0c6c30554097..c6cc93310658 100644 --- a/pkgs/development/haskell-modules/configuration-darwin.nix +++ b/pkgs/development/haskell-modules/configuration-darwin.nix @@ -254,6 +254,14 @@ self: super: # Tests fail on macOS https://github.com/mrkkrp/zip/issues/112 zip = dontCheck super.zip; + dap = super.dap.overrideAttrs (drv: { + __darwinAllowLocalNetworking = true; + }); + + essence-of-live-coding-warp = super.essence-of-live-coding-warp.overrideAttrs (drv: { + __darwinAllowLocalNetworking = true; + }); + http-streams = super.http-streams.overrideAttrs (drv: { __darwinAllowLocalNetworking = true; }); @@ -266,10 +274,22 @@ self: super: __darwinAllowLocalNetworking = true; }); + jsaddle-warp = super.jsaddle-warp.overrideAttrs (drv: { + __darwinAllowLocalNetworking = true; + }); + openssl-streams = super.openssl-streams.overrideAttrs (drv: { __darwinAllowLocalNetworking = true; }); + servant-auth-client = super.servant-auth-client.overrideAttrs (drv: { + __darwinAllowLocalNetworking = true; + }); + + servant-client = super.servant-client.overrideAttrs (drv: { + __darwinAllowLocalNetworking = true; + }); + snap = super.snap.overrideAttrs (drv: { __darwinAllowLocalNetworking = true; }); From 55f167d8c13d56973a4be1f39997376bca46575f Mon Sep 17 00:00:00 2001 From: Alexandre Esteves Date: Wed, 11 Mar 2026 15:18:08 +0000 Subject: [PATCH 08/52] haskellPackages: use 'overrideCabal' instead of 'overrideAttrs' on darwin overrides --- .../haskell-modules/configuration-darwin.nix | 68 +++++++++---------- 1 file changed, 34 insertions(+), 34 deletions(-) diff --git a/pkgs/development/haskell-modules/configuration-darwin.nix b/pkgs/development/haskell-modules/configuration-darwin.nix index c6cc93310658..9d679a00f809 100644 --- a/pkgs/development/haskell-modules/configuration-darwin.nix +++ b/pkgs/development/haskell-modules/configuration-darwin.nix @@ -16,17 +16,17 @@ self: super: # see: https://github.com/psibi/shell-conduit/issues/12 shell-conduit = dontCheck super.shell-conduit; - conduit-extra = super.conduit-extra.overrideAttrs (drv: { + conduit-extra = overrideCabal (drv: { __darwinAllowLocalNetworking = true; - }); + }) super.conduit-extra; - spacecookie = super.spacecookie.overrideAttrs (_: { + spacecookie = overrideCabal (_: { __darwinAllowLocalNetworking = true; - }); + }) super.spacecookie; - streaming-commons = super.streaming-commons.overrideAttrs (_: { + streaming-commons = overrideCabal (_: { __darwinAllowLocalNetworking = true; - }); + }) super.streaming-commons; # Hakyll's tests are broken on Darwin (3 failures); and they require util-linux hakyll = overrideCabal { @@ -136,11 +136,11 @@ self: super: sym = markBroken super.sym; - yesod-core = super.yesod-core.overrideAttrs (drv: { + yesod-core = overrideCabal (drv: { # Allow access to local networking when the Darwin sandbox is enabled, so yesod-core can # run tests that access localhost. __darwinAllowLocalNetworking = true; - }); + }) super.yesod-core; hidapi = super.hidapi.override { systemd = null; }; @@ -236,11 +236,11 @@ self: super: # Otherwise impure gcc is used, which is Apple's weird wrapper c2hsc = addTestToolDepends [ pkgs.gcc ] super.c2hsc; - http2 = super.http2.overrideAttrs (drv: { + http2 = overrideCabal (drv: { # Allow access to local networking when the Darwin sandbox is enabled, so http2 can run tests # that access localhost. __darwinAllowLocalNetworking = true; - }); + }) super.http2; # https://hydra.nixos.org/build/230964714/nixlog/1 inline-c-cpp = appendPatch (pkgs.fetchpatch { @@ -254,49 +254,49 @@ self: super: # Tests fail on macOS https://github.com/mrkkrp/zip/issues/112 zip = dontCheck super.zip; - dap = super.dap.overrideAttrs (drv: { + dap = overrideCabal (drv: { __darwinAllowLocalNetworking = true; - }); + }) super.dap; - essence-of-live-coding-warp = super.essence-of-live-coding-warp.overrideAttrs (drv: { + essence-of-live-coding-warp = overrideCabal (drv: { __darwinAllowLocalNetworking = true; - }); + }) super.essence-of-live-coding-warp; - http-streams = super.http-streams.overrideAttrs (drv: { + http-streams = overrideCabal (drv: { __darwinAllowLocalNetworking = true; - }); + }) super.http-streams; - io-streams = super.io-streams.overrideAttrs (drv: { + io-streams = overrideCabal (drv: { __darwinAllowLocalNetworking = true; - }); + }) super.io-streams; - io-streams-haproxy = super.io-streams-haproxy.overrideAttrs (drv: { + io-streams-haproxy = overrideCabal (drv: { __darwinAllowLocalNetworking = true; - }); + }) super.io-streams-haproxy; - jsaddle-warp = super.jsaddle-warp.overrideAttrs (drv: { + jsaddle-warp = overrideCabal (drv: { __darwinAllowLocalNetworking = true; - }); + }) super.jsaddle-warp; - openssl-streams = super.openssl-streams.overrideAttrs (drv: { + openssl-streams = overrideCabal (drv: { __darwinAllowLocalNetworking = true; - }); + }) super.openssl-streams; - servant-auth-client = super.servant-auth-client.overrideAttrs (drv: { + servant-auth-client = overrideCabal (drv: { __darwinAllowLocalNetworking = true; - }); + }) super.servant-auth-client; - servant-client = super.servant-client.overrideAttrs (drv: { + servant-client = overrideCabal (drv: { __darwinAllowLocalNetworking = true; - }); + }) super.servant-client; - snap = super.snap.overrideAttrs (drv: { + snap = overrideCabal (drv: { __darwinAllowLocalNetworking = true; - }); + }) super.snap; - warp = super.warp.overrideAttrs (drv: { + warp = overrideCabal (drv: { __darwinAllowLocalNetworking = true; - }); + }) super.warp; ghcjs-dom-hello = overrideCabal (drv: { libraryHaskellDepends = with self; [ @@ -373,9 +373,9 @@ self: super: sysinfo = dontCheck super.sysinfo; - network = super.network.overrideAttrs (drv: { + network = overrideCabal (drv: { __darwinAllowLocalNetworking = true; - }); + }) super.network; } // lib.optionalAttrs pkgs.stdenv.hostPlatform.isAarch64 { # aarch64-darwin From f18788f08dd8177fb8a996d6b2ca96cd372c0335 Mon Sep 17 00:00:00 2001 From: sternenseemann Date: Sat, 28 Mar 2026 12:16:02 +0100 Subject: [PATCH 09/52] haskellPackages: hackage 2026-03-15T11:30:53Z -> 2026-03-27T12:41:48Z all-cabal-hashes: 2026-03-15T11:30:53Z -> 2026-03-27T12:41:48Z (generated by maintainers/scripts/haskell/update-package-set.sh) --- pkgs/data/misc/hackage/pin.json | 8 +- .../haskell-modules/hackage-packages.nix | 4589 +++++++++++++++-- 2 files changed, 4137 insertions(+), 460 deletions(-) diff --git a/pkgs/data/misc/hackage/pin.json b/pkgs/data/misc/hackage/pin.json index 0606e5f812e1..3fe343a926a9 100644 --- a/pkgs/data/misc/hackage/pin.json +++ b/pkgs/data/misc/hackage/pin.json @@ -1,6 +1,6 @@ { - "commit": "18df06fa5c94e82240afb89aafe72572abf4b4ef", - "url": "https://github.com/commercialhaskell/all-cabal-hashes/archive/18df06fa5c94e82240afb89aafe72572abf4b4ef.tar.gz", - "sha256": "1iikxr7z5qswp65kw08zwilj0n7gwr875f455mnd7ppm96cfgiid", - "msg": "Update from Hackage at 2026-03-15T11:30:53Z" + "commit": "2accd524b707ab1ad0c9eb4f1abf15a72054e876", + "url": "https://github.com/commercialhaskell/all-cabal-hashes/archive/2accd524b707ab1ad0c9eb4f1abf15a72054e876.tar.gz", + "sha256": "02vx70j037wppnmq7wybrh6rwai2nc0yh8fm5lxaaxq9sngzif0q", + "msg": "Update from Hackage at 2026-03-27T12:41:48Z" } diff --git a/pkgs/development/haskell-modules/hackage-packages.nix b/pkgs/development/haskell-modules/hackage-packages.nix index 3840e5f3c285..5d0ac2a5aa6e 100644 --- a/pkgs/development/haskell-modules/hackage-packages.nix +++ b/pkgs/development/haskell-modules/hackage-packages.nix @@ -144,8 +144,8 @@ self: { }: mkDerivation { pname = "A-gent"; - version = "0.11.0.5"; - sha256 = "0ydrdqya81nxv4zxqflciihl4khidm4ipqqhh1x3bbwyqmayhv5x"; + version = "0.11.0.6"; + sha256 = "0a6ll33b1m35ddg5wmmfxw0rq8vg1pzbpsdiy6a1h3pczkmyhizf"; libraryHaskellDepends = [ base containers @@ -2083,26 +2083,57 @@ self: { Aoide = callPackage ( { mkDerivation, + barbies, base, bytestring, + containers, + directory, + filepath, + generic-lens, + Kawaii-Parser, + lens, mtl, process, - template-haskell, + transformers, }: mkDerivation { pname = "Aoide"; - version = "0.1.0.2"; - sha256 = "1nldvg8fwgbvn50prar3vs1nh704s1603fikyg2lhpz754yp0qbc"; + version = "1.0.0.0"; + sha256 = "0xrdagpyzp0pxvbir1fipyn5kwsb3qkrwiriyaakj0kjwjs79x7y"; + isLibrary = true; + isExecutable = true; libraryHaskellDepends = [ + barbies base bytestring + containers + directory + filepath + generic-lens + Kawaii-Parser + lens mtl process - template-haskell + transformers ]; - description = "A simple music library with the capability of generating .ly and .mid files."; - license = lib.licenses.bsd3; + executableHaskellDepends = [ + barbies + base + bytestring + containers + directory + filepath + generic-lens + Kawaii-Parser + lens + mtl + process + transformers + ]; + description = "A simple music library that can generate Lilypond and MIDI files"; + license = lib.licensesSpdx."BSD-3-Clause"; hydraPlatforms = lib.platforms.none; + mainProgram = "Aoide"; broken = true; } ) { }; @@ -2619,6 +2650,73 @@ self: { } ) { }; + BNFC_2_9_6_3 = callPackage ( + { + mkDerivation, + alex, + array, + base, + containers, + deepseq, + directory, + filepath, + happy, + hspec, + hspec-discover, + HUnit, + mtl, + pretty, + QuickCheck, + string-qq, + temporary, + time, + }: + mkDerivation { + pname = "BNFC"; + version = "2.9.6.3"; + sha256 = "1iln92nxs90257ssi5gk0yqidg7yfhxyx3xag0kv28xhcmig1vln"; + isLibrary = true; + isExecutable = true; + libraryHaskellDepends = [ + array + base + containers + deepseq + directory + filepath + mtl + pretty + string-qq + time + ]; + libraryToolDepends = [ + alex + happy + ]; + executableHaskellDepends = [ base ]; + testHaskellDepends = [ + base + directory + filepath + hspec + HUnit + mtl + pretty + QuickCheck + temporary + ]; + testToolDepends = [ + alex + happy + hspec-discover + ]; + description = "A compiler front-end generator"; + license = lib.licenses.bsd3; + hydraPlatforms = lib.platforms.none; + mainProgram = "bnfc"; + } + ) { }; + BNFC-meta = callPackage ( { mkDerivation, @@ -6210,6 +6308,8 @@ self: { pname = "Cabal-syntax"; version = "3.14.2.0"; sha256 = "11armvlq5ygzrsn1k4vld8fr5li1vh9gd1l4al31kz7zvbm3jpwx"; + revision = "1"; + editedCabalFile = "1c4p88kcnrna0d31zdps3cy74mic56ip4f92a88z0in3c1ciflv6"; libraryHaskellDepends = [ array base @@ -6256,6 +6356,8 @@ self: { pname = "Cabal-syntax"; version = "3.16.1.0"; sha256 = "19xx6q5va5hv2c6khf5khgyv1l84nm6a65vfi6jar5jdkd263mbb"; + revision = "1"; + editedCabalFile = "1jh16xcdzbhwhdracim2b234nqg0irdvki1czphg30blgg91hvsj"; libraryHaskellDepends = [ array base @@ -17676,7 +17778,7 @@ self: { HDBC, mtl, time, - unixodbc, + unixODBC, utf8-string, }: mkDerivation { @@ -17694,11 +17796,11 @@ self: { time utf8-string ]; - librarySystemDepends = [ unixodbc ]; + librarySystemDepends = [ unixODBC ]; description = "ODBC driver for HDBC"; license = lib.licenses.bsd3; } - ) { inherit (pkgs) unixodbc; }; + ) { unixODBC = null; }; HDBC-postgresql = callPackage ( { @@ -26722,8 +26824,8 @@ self: { }: mkDerivation { pname = "Kawaii-Parser"; - version = "4.0.0"; - sha256 = "1m4mpvgp3kx8wabklxj73i0gh1zhqk5al16s41qbnsz14da3d3nx"; + version = "5.0.0"; + sha256 = "0731dihnjxi9fmwadgz7r3200zsbx28xzkl5sardh80snkjgsjsb"; libraryHaskellDepends = [ base containers @@ -35443,8 +35545,8 @@ self: { }: mkDerivation { pname = "PenroseKiteDart"; - version = "1.6.1"; - sha256 = "1250m14qlq43gv3k1xydab08vhfl44cyrcalkjpm9b3fk3p9vncq"; + version = "1.7"; + sha256 = "1gfgqs9v2yrhpppfikh9v9mgr0drp4r0w087h9cja13zmdk25pga"; libraryHaskellDepends = [ base containers @@ -49318,6 +49420,170 @@ self: { } ) { }; + a-piece-of-flake = callPackage ( + { + mkDerivation, + acid-state, + add-dependent-file, + aeson, + aeson-pretty, + base, + binary, + blaze-markup, + bytestring, + cryptohash-sha1, + deepseq, + either, + exceptions, + file-embed, + filepath, + full-text-search, + generics-sop, + hostname, + http-types, + lens, + list-t, + lrucaching, + memory, + monad-logger, + mtl, + network, + non-empty, + non-negative-time-diff, + optparse-applicative, + prettyprinter, + process, + psqueues, + QuickCheck, + ref-tf, + refined, + regex-tdfa, + relude, + req, + retry, + ring-buffer, + safecopy, + sop-core, + statistics, + stm, + stm-containers, + tagged, + tar, + tasty, + tasty-discover, + tasty-hunit, + tasty-quickcheck, + template-haskell, + text-zipper, + time, + time-units, + tokenize, + trace-embrace, + unliftio, + vector, + wai, + wai-extra, + warp, + warp-tls, + wl-pprint-text, + yesod-core, + }: + mkDerivation { + pname = "a-piece-of-flake"; + version = "0.0.1"; + sha256 = "00cfnpd1wxlm8csggv4i5r9cxyqrw24hnyq4jylkck943gz0r0ic"; + isLibrary = true; + isExecutable = true; + libraryHaskellDepends = [ + acid-state + add-dependent-file + aeson + aeson-pretty + base + binary + blaze-markup + bytestring + cryptohash-sha1 + deepseq + either + exceptions + file-embed + filepath + full-text-search + generics-sop + hostname + http-types + lens + list-t + lrucaching + memory + monad-logger + mtl + network + non-empty + non-negative-time-diff + optparse-applicative + prettyprinter + process + psqueues + ref-tf + refined + regex-tdfa + relude + req + retry + ring-buffer + safecopy + sop-core + statistics + stm + stm-containers + tagged + tar + template-haskell + text-zipper + time + time-units + tokenize + trace-embrace + unliftio + vector + wai + wai-extra + warp + warp-tls + wl-pprint-text + yesod-core + ]; + executableHaskellDepends = [ + base + optparse-applicative + relude + tagged + unliftio + yesod-core + ]; + testHaskellDepends = [ + aeson + base + optparse-applicative + QuickCheck + relude + tagged + tasty + tasty-discover + tasty-hunit + tasty-quickcheck + unliftio + yesod-core + ]; + testToolDepends = [ tasty-discover ]; + description = "Nix flake repository for everyone"; + license = lib.licensesSpdx."BSD-3-Clause"; + mainProgram = "a-piece-of-flake"; + } + ) { }; + a50 = callPackage ( { mkDerivation, @@ -58830,6 +59096,41 @@ self: { } ) { }; + alex_3_5_4_2 = callPackage ( + { + mkDerivation, + array, + base, + containers, + directory, + happy, + process, + }: + mkDerivation { + pname = "alex"; + version = "3.5.4.2"; + sha256 = "06248zzh03ijyaj98a54p1rqgvyl3w1kawsz74q9mig2c34isj6z"; + isLibrary = false; + isExecutable = true; + enableSeparateDataOutput = true; + executableHaskellDepends = [ + array + base + containers + directory + ]; + executableToolDepends = [ happy ]; + testHaskellDepends = [ + base + process + ]; + description = "Alex is a tool for generating lexical analysers in Haskell"; + license = lib.licenses.bsd3; + hydraPlatforms = lib.platforms.none; + mainProgram = "alex"; + } + ) { }; + alex-meta = callPackage ( { mkDerivation, @@ -59411,6 +59712,41 @@ self: { } ) { }; + algebraic-edge-graphs = callPackage ( + { + mkDerivation, + array, + base, + containers, + criterion, + extra, + QuickCheck, + }: + mkDerivation { + pname = "algebraic-edge-graphs"; + version = "0.1.0"; + sha256 = "1wx149smpf4v0ksspgzxj46pb3ar24kw0kcynapgyg33hc85gli8"; + libraryHaskellDepends = [ + array + base + containers + ]; + testHaskellDepends = [ + base + containers + extra + QuickCheck + ]; + benchmarkHaskellDepends = [ + base + containers + criterion + ]; + description = "A library for algebraic edge-graph construction and transformation"; + license = lib.licensesSpdx."MIT"; + } + ) { }; + algebraic-graph-duoids = callPackage ( { mkDerivation, @@ -85960,8 +86296,8 @@ self: { }: mkDerivation { pname = "asciidoc"; - version = "0.1.0.1"; - sha256 = "1wf0xvvx47myw41nc3dlm83rzw9pibzl6154zc7yll4cc0cfy5br"; + version = "0.1.0.2"; + sha256 = "0djdvr06xs77c5gp57s13r96zpgbdglb6ay53ql4mlm4120d1v4p"; isLibrary = true; isExecutable = true; libraryHaskellDepends = [ @@ -86976,6 +87312,48 @@ self: { } ) { }; + associative = callPackage ( + { + mkDerivation, + base, + containers, + doctest, + hashable, + lens, + mtl, + process, + profunctors, + selective, + semigroupoids, + unordered-containers, + witherable, + }: + mkDerivation { + pname = "associative"; + version = "0.0.3"; + sha256 = "1f2xn8zp97mhxww5sf2my1cl6d3yikdv8qxp2x7c6ri490g4c8cp"; + libraryHaskellDepends = [ + base + containers + hashable + lens + mtl + profunctors + selective + semigroupoids + unordered-containers + witherable + ]; + testHaskellDepends = [ + base + process + ]; + testToolDepends = [ doctest ]; + description = "Partial Semigroup and Semigroup operations"; + license = lib.licensesSpdx."BSD-3-Clause"; + } + ) { }; + assumpta = callPackage ( { mkDerivation, @@ -101617,6 +101995,66 @@ self: { } ) { }; + beam-migrate_0_5_4_0 = callPackage ( + { + mkDerivation, + aeson, + base, + beam-core, + bytestring, + containers, + deepseq, + dependent-map, + dependent-sum, + free, + hashable, + haskell-src-exts, + microlens, + mtl, + parallel, + pqueue, + pretty, + scientific, + text, + time, + unordered-containers, + uuid-types, + vector, + }: + mkDerivation { + pname = "beam-migrate"; + version = "0.5.4.0"; + sha256 = "1rmax5zj75gi90b02gz9rx7gzz08nf7s7bj8lchwxcib17ycq4x8"; + libraryHaskellDepends = [ + aeson + base + beam-core + bytestring + containers + deepseq + dependent-map + dependent-sum + free + hashable + haskell-src-exts + microlens + mtl + parallel + pqueue + pretty + scientific + text + time + unordered-containers + uuid-types + vector + ]; + description = "SQL DDL support and migrations support library for Beam"; + license = lib.licenses.mit; + hydraPlatforms = lib.platforms.none; + } + ) { }; + beam-mysql = callPackage ( { mkDerivation, @@ -101772,6 +102210,90 @@ self: { } ) { }; + beam-postgres_0_5_5_0 = callPackage ( + { + mkDerivation, + aeson, + attoparsec, + base, + beam-core, + beam-migrate, + bytestring, + case-insensitive, + conduit, + free, + hashable, + hedgehog, + lifted-base, + monad-control, + mtl, + network-uri, + postgresql-libpq, + postgresql-simple, + scientific, + tagged, + tasty, + tasty-hunit, + testcontainers, + text, + time, + transformers-base, + unordered-containers, + uuid, + uuid-types, + vector, + }: + mkDerivation { + pname = "beam-postgres"; + version = "0.5.5.0"; + sha256 = "1zxmy1g6z315il0vqi20pxv18jhvzzbrqfz0mdry3s27zza1ykfq"; + libraryHaskellDepends = [ + aeson + attoparsec + base + beam-core + beam-migrate + bytestring + case-insensitive + conduit + free + hashable + lifted-base + monad-control + mtl + network-uri + postgresql-libpq + postgresql-simple + scientific + tagged + text + time + transformers-base + unordered-containers + uuid-types + vector + ]; + testHaskellDepends = [ + aeson + base + beam-core + beam-migrate + bytestring + hedgehog + postgresql-simple + tasty + tasty-hunit + testcontainers + text + uuid + vector + ]; + description = "Connection layer between beam and postgres"; + license = lib.licenses.mit; + hydraPlatforms = lib.platforms.none; + } + ) { }; + beam-sqlite = callPackage ( { mkDerivation, @@ -101839,6 +102361,74 @@ self: { } ) { }; + beam-sqlite_0_5_7_0 = callPackage ( + { + mkDerivation, + aeson, + attoparsec, + base, + beam-core, + beam-migrate, + bytestring, + containers, + direct-sqlite, + dlist, + free, + hashable, + monad-control, + mtl, + network-uri, + scientific, + sqlite-simple, + tasty, + tasty-expected-failure, + tasty-hunit, + text, + time, + transformers-base, + }: + mkDerivation { + pname = "beam-sqlite"; + version = "0.5.7.0"; + sha256 = "0s27d3vwf4f7y1awdghjpp6dsciy9vwn3rfrb7gxhgn9cfsdz80r"; + libraryHaskellDepends = [ + aeson + attoparsec + base + beam-core + beam-migrate + bytestring + containers + direct-sqlite + dlist + free + hashable + monad-control + mtl + network-uri + scientific + sqlite-simple + text + time + transformers-base + ]; + testHaskellDepends = [ + base + beam-core + beam-migrate + sqlite-simple + tasty + tasty-expected-failure + tasty-hunit + text + time + ]; + description = "Beam driver for SQLite"; + license = lib.licenses.mit; + hydraPlatforms = lib.platforms.none; + } + ) { }; + beam-th = callPackage ( { mkDerivation, @@ -112640,6 +113230,8 @@ self: { pname = "blockio"; version = "0.1.1.1"; sha256 = "1w6b3gf9k5vkg92bx5kh85z4y9j74rcdalg22f3hifdhxycrfyyz"; + revision = "1"; + editedCabalFile = "1f635lkbcn9vdcb48b6c1jkgfmrgd3scjm3bkbiwsy10p7a48d6m"; libraryHaskellDepends = [ base blockio-uring @@ -113544,12 +114136,12 @@ self: { } ) { }; - bluefin_0_4_1_0 = callPackage ( + bluefin_0_4_3_0 = callPackage ( { mkDerivation, bluefin-internal }: mkDerivation { pname = "bluefin"; - version = "0.4.1.0"; - sha256 = "18k1iqfjggwv6l6fllchzhv8rhhy24q05knzzsgzyjw4z8gp38kf"; + version = "0.4.3.0"; + sha256 = "0hqnx9nfyd2wgrrbh23hyrhrpz9b6v8hwaw9gixnwy585xa2rpj3"; libraryHaskellDepends = [ bluefin-internal ]; description = "The Bluefin effect system"; license = lib.licensesSpdx."MIT"; @@ -113603,10 +114195,8 @@ self: { }: mkDerivation { pname = "bluefin-contrib"; - version = "0.2.0.0"; - sha256 = "0fqv8gjgxaa1jkfhvbcdwq18r1yhf0l8clr0w77vfizwj0425nqm"; - revision = "1"; - editedCabalFile = "0lkryncx38hpra2lc3a2djd5mj0n7yg73cgahhmvyc916vglw3lf"; + version = "0.2.1.0"; + sha256 = "0iniw62zcw97fwz94dv1rakhy59irw2hjcnwklmmap1gka843wcx"; libraryHaskellDepends = [ base bluefin @@ -113646,24 +114236,26 @@ self: { } ) { }; - bluefin-internal_0_4_1_0 = callPackage ( + bluefin-internal_0_4_3_0 = callPackage ( { mkDerivation, async, base, monad-control, + primitive, transformers, transformers-base, unliftio-core, }: mkDerivation { pname = "bluefin-internal"; - version = "0.4.1.0"; - sha256 = "03qyjjkphqf1z242vfz4pa9pdha602vmmsqd97z18p01m5yqd01f"; + version = "0.4.3.0"; + sha256 = "1nj9phqq8xpxfjh1n7xk9zxhmx6nyh9hblah6fs5cgpqfwwrsql7"; libraryHaskellDepends = [ async base monad-control + primitive transformers transformers-base unliftio-core @@ -116117,8 +116709,8 @@ self: { }: mkDerivation { pname = "botan-bindings"; - version = "0.2.0.0"; - sha256 = "13wh1m0znwj8waz2m9indwlrmg53a9ibb0pz72aig8vbnpgwrsdc"; + version = "0.3.0.0"; + sha256 = "1315xxzrk9qy3jba85sfzzcqwq9x0qbzp695h67l4wfbrlhspimn"; libraryHaskellDepends = [ base ]; libraryPkgconfigDepends = [ botan ]; description = "Raw Botan bindings"; @@ -116146,8 +116738,8 @@ self: { }: mkDerivation { pname = "botan-low"; - version = "0.1.0.0"; - sha256 = "0qvy7md3k4mql3zbjbfni8ff7maq93br17p66d7av0av6lggp6im"; + version = "0.2.0.0"; + sha256 = "1wqzaz983aa2drfh76kcicln2d8iq6cpxy866a5yhwza6gl2y92h"; libraryHaskellDepends = [ base botan-bindings @@ -117407,7 +117999,7 @@ self: { } ) { }; - brick_2_10 = callPackage ( + brick_2_11 = callPackage ( { mkDerivation, base, @@ -117440,10 +118032,8 @@ self: { }: mkDerivation { pname = "brick"; - version = "2.10"; - sha256 = "08byr2w0697bdlnpycnb73f33v2as6sy7q9w9r8a2nhilv49yhmq"; - revision = "1"; - editedCabalFile = "0676jxx939xwhaqzf8zjz9vdl5jsx2zqvpclg34b3435n142hy2d"; + version = "2.11"; + sha256 = "1x4pxq8yyrzvspngj7rs639b0wgrmv1m54mdgmp6xiqdk2k2fyb5"; isLibrary = true; isExecutable = true; libraryHaskellDepends = [ @@ -128284,8 +128874,8 @@ self: { }: mkDerivation { pname = "cabal2nix"; - version = "2.21.2"; - sha256 = "05janvispyh5sq77klzyhkwzqix4x2bf0mn7bvxb1qwsd02ygzxv"; + version = "2.21.3"; + sha256 = "0f7d2z0bd8ziswikhjrvbn4rlpigs3w1g4pvvv5cfnp2b7gwh37h"; isLibrary = true; isExecutable = true; libraryHaskellDepends = [ @@ -129121,8 +129711,8 @@ self: { }: mkDerivation { pname = "cachix"; - version = "1.10.0"; - sha256 = "1q2cbi8sfld1rjx7m4mlb064xvmrydr4sfglrw5sjvs9zj8ladjk"; + version = "1.11.0"; + sha256 = "1savyqj4azfhg33qj7fqbyyn1bld1jjdf6fw9cjbgcgr59p7azn2"; isLibrary = true; isExecutable = true; libraryHaskellDepends = [ @@ -129285,8 +129875,8 @@ self: { }: mkDerivation { pname = "cachix-api"; - version = "1.10.0"; - sha256 = "1zw2l23phxm292zl6xjppdv1mx1skk0zhif9rchcghk82m0rz0d4"; + version = "1.11.0"; + sha256 = "1fplakyrkm40m5ii964agbmaxvm108dg7yjkma59sa7k2f9aay68"; libraryHaskellDepends = [ aeson async @@ -130874,8 +131464,8 @@ self: { }: mkDerivation { pname = "canadian-income-tax"; - version = "2025.0"; - sha256 = "0k0v57dksww0c770jcp5wl1hl68w4vqilcw0sxjavcc43a228w9y"; + version = "2025.1"; + sha256 = "194h7csmxgdi2k5aaz02ykzidfx8ip3vw2kpbf9x1xnpaygs9k7x"; isLibrary = true; isExecutable = true; enableSeparateDataOutput = true; @@ -136965,8 +137555,8 @@ self: { }: mkDerivation { pname = "cfuture"; - version = "1.0"; - sha256 = "1ifi3bj254b0g8klyjqw7lhmvpmq7ws2sl19ndyvq7f6iq3sk33a"; + version = "2.0"; + sha256 = "1w4cnvz1cr87s41fdrhacf07c52k10igkqnl6xwpvj43zsksgws3"; libraryHaskellDepends = [ base base-prelude @@ -136975,7 +137565,7 @@ self: { base base-prelude ]; - description = "A Future type that is easy to represent and handle in C/C++"; + description = "A Future type that is interruptible anytime and exportable to C/C++"; license = lib.licensesSpdx."BSD-3-Clause"; hydraPlatforms = lib.platforms.none; broken = true; @@ -143591,6 +144181,103 @@ self: { } ) { }; + clash-ghc_1_8_5 = callPackage ( + { + mkDerivation, + array, + base, + bytestring, + Cabal, + clash-lib, + clash-prelude, + containers, + data-binary-ieee754, + deepseq, + directory, + exceptions, + extra, + filepath, + ghc, + ghc-bignum, + ghc-boot, + ghc-prim, + ghc-typelits-extra, + ghc-typelits-knownnat, + ghc-typelits-natnormalise, + ghci, + hashable, + haskeline, + lens, + mtl, + primitive, + process, + reflection, + split, + string-interpolate, + template-haskell, + text, + time, + transformers, + uniplate, + unix, + unordered-containers, + utf8-string, + vector, + }: + mkDerivation { + pname = "clash-ghc"; + version = "1.8.5"; + sha256 = "0b8h9gnhl7c87bc120n0385jxip6hyji28qkk9hxj7pgh724ws7d"; + isLibrary = true; + isExecutable = true; + libraryHaskellDepends = [ + array + base + bytestring + Cabal + clash-lib + clash-prelude + containers + data-binary-ieee754 + deepseq + directory + exceptions + extra + filepath + ghc + ghc-bignum + ghc-boot + ghc-prim + ghc-typelits-extra + ghc-typelits-knownnat + ghc-typelits-natnormalise + ghci + hashable + haskeline + lens + mtl + primitive + process + reflection + split + string-interpolate + template-haskell + text + time + transformers + uniplate + unix + unordered-containers + utf8-string + vector + ]; + executableHaskellDepends = [ base ]; + description = "Clash: a functional hardware description language - GHC frontend"; + license = lib.licensesSpdx."BSD-2-Clause"; + hydraPlatforms = lib.platforms.none; + } + ) { }; + clash-lib = callPackage ( { mkDerivation, @@ -143759,6 +144446,173 @@ self: { } ) { }; + clash-lib_1_8_5 = callPackage ( + { + mkDerivation, + aeson, + aeson-pretty, + ansi-terminal, + array, + async, + attoparsec, + attoparsec-aeson, + base, + base16-bytestring, + binary, + bytestring, + clash-prelude, + containers, + cryptohash-sha256, + data-binary-ieee754, + data-default, + deepseq, + directory, + dlist, + doctest-parallel, + exceptions, + extra, + filepath, + ghc, + ghc-bignum, + ghc-boot-th, + ghc-prim, + ghc-typelits-knownnat, + Glob, + hashable, + haskell-src-exts, + haskell-src-meta, + hint, + infinite-list, + lens, + mtl, + ordered-containers, + pretty-show, + prettyprinter, + prettyprinter-interp, + primitive, + quickcheck-text, + string-interpolate, + tasty, + tasty-hunit, + tasty-quickcheck, + tasty-th, + template-haskell, + temporary, + terminal-size, + text, + time, + transformers, + trifecta, + unordered-containers, + vector, + vector-binary-instances, + yaml, + }: + mkDerivation { + pname = "clash-lib"; + version = "1.8.5"; + sha256 = "001pqzyvfbyw0p61b6m9ym5mxmjvq3wfjicv485n9lxlrbvnllh5"; + isLibrary = true; + isExecutable = true; + enableSeparateDataOutput = true; + libraryHaskellDepends = [ + aeson + aeson-pretty + ansi-terminal + array + async + attoparsec + attoparsec-aeson + base + base16-bytestring + binary + bytestring + clash-prelude + containers + cryptohash-sha256 + data-binary-ieee754 + data-default + deepseq + directory + dlist + exceptions + extra + filepath + ghc + ghc-bignum + ghc-boot-th + ghc-prim + hashable + haskell-src-meta + hint + infinite-list + lens + mtl + ordered-containers + pretty-show + prettyprinter + prettyprinter-interp + primitive + string-interpolate + template-haskell + temporary + terminal-size + text + time + transformers + trifecta + unordered-containers + vector + vector-binary-instances + yaml + ]; + executableHaskellDepends = [ + aeson + attoparsec-aeson + base + bytestring + containers + deepseq + directory + Glob + text + yaml + ]; + testHaskellDepends = [ + aeson + aeson-pretty + attoparsec-aeson + base + base16-bytestring + bytestring + clash-prelude + containers + data-default + deepseq + doctest-parallel + filepath + ghc + ghc-typelits-knownnat + haskell-src-exts + lens + pretty-show + quickcheck-text + tasty + tasty-hunit + tasty-quickcheck + tasty-th + template-haskell + text + transformers + unordered-containers + ]; + description = "Clash: a functional hardware description language - As a library"; + license = lib.licensesSpdx."BSD-2-Clause"; + hydraPlatforms = lib.platforms.none; + mainProgram = "v16-upgrade-primitives"; + } + ) { }; + clash-lib-hedgehog = callPackage ( { mkDerivation, @@ -143781,8 +144635,8 @@ self: { }: mkDerivation { pname = "clash-lib-hedgehog"; - version = "1.8.4"; - sha256 = "1nl085y83vgljdh1pmgckvy5v5g6dafvmkjajc7m72s8ijj7g717"; + version = "1.8.5"; + sha256 = "01zf26hglas4v1hxg6amsv4ckbp09zl6jfw28v65dpwsjzzwwv5g"; libraryHaskellDepends = [ base clash-lib @@ -143961,6 +144815,139 @@ self: { } ) { }; + clash-prelude_1_8_5 = callPackage ( + { + mkDerivation, + array, + arrows, + base, + binary, + bytestring, + constraints, + containers, + criterion, + data-binary-ieee754, + data-default-class, + deepseq, + directory, + doctest-parallel, + extra, + filepath, + ghc-bignum, + ghc-prim, + ghc-typelits-extra, + ghc-typelits-knownnat, + ghc-typelits-natnormalise, + half, + hashable, + hedgehog, + hint, + infinite-list, + lens, + mmorph, + mtl, + QuickCheck, + quickcheck-classes-base, + recursion-schemes, + reflection, + singletons, + string-interpolate, + tagged, + tasty, + tasty-hedgehog, + tasty-hunit, + tasty-quickcheck, + tasty-th, + template-haskell, + text, + th-abstraction, + th-lift, + th-orphans, + time, + transformers, + type-errors, + uniplate, + vector, + }: + mkDerivation { + pname = "clash-prelude"; + version = "1.8.5"; + sha256 = "0a1w9yn710bi0hxdrx5g34wnr57dqxz2a797d78v9105vprhj1li"; + libraryHaskellDepends = [ + array + arrows + base + binary + bytestring + constraints + containers + data-binary-ieee754 + data-default-class + deepseq + extra + ghc-bignum + ghc-prim + ghc-typelits-extra + ghc-typelits-knownnat + ghc-typelits-natnormalise + half + hashable + infinite-list + lens + mtl + QuickCheck + recursion-schemes + reflection + singletons + string-interpolate + tagged + template-haskell + text + th-abstraction + th-lift + th-orphans + time + transformers + type-errors + uniplate + vector + ]; + testHaskellDepends = [ + base + binary + bytestring + containers + deepseq + doctest-parallel + filepath + ghc-typelits-extra + ghc-typelits-knownnat + ghc-typelits-natnormalise + hedgehog + hint + mmorph + quickcheck-classes-base + tasty + tasty-hedgehog + tasty-hunit + tasty-quickcheck + tasty-th + template-haskell + text + ]; + benchmarkHaskellDepends = [ + base + criterion + deepseq + directory + template-haskell + ]; + description = "Clash: a functional hardware description language - Prelude library"; + license = lib.licensesSpdx."BSD-2-Clause"; + hydraPlatforms = lib.platforms.none; + } + ) { }; + clash-prelude-hedgehog = callPackage ( { mkDerivation, @@ -143988,6 +144975,34 @@ self: { } ) { }; + clash-prelude-hedgehog_1_8_5 = callPackage ( + { + mkDerivation, + base, + clash-prelude, + ghc-typelits-knownnat, + ghc-typelits-natnormalise, + hedgehog, + text, + }: + mkDerivation { + pname = "clash-prelude-hedgehog"; + version = "1.8.5"; + sha256 = "1swy13hg5yvmlj61is91jrv8yqjlp4r79a21clwi7d88yx9nnpm1"; + libraryHaskellDepends = [ + base + clash-prelude + ghc-typelits-knownnat + ghc-typelits-natnormalise + hedgehog + text + ]; + description = "Hedgehog Generators for clash-prelude"; + license = lib.licensesSpdx."BSD-2-Clause"; + hydraPlatforms = lib.platforms.none; + } + ) { }; + clash-prelude-quickcheck = callPackage ( { mkDerivation, @@ -152367,6 +153382,38 @@ self: { } ) { }; + colour_2_3_7 = callPackage ( + { + mkDerivation, + base, + HUnit, + QuickCheck, + random, + test-framework, + test-framework-hunit, + test-framework-quickcheck2, + }: + mkDerivation { + pname = "colour"; + version = "2.3.7"; + sha256 = "104nprq14qajna16q7qsybyjvfdrgazwj340c8rlxgjscxai0fqz"; + enableSeparateDataOutput = true; + libraryHaskellDepends = [ base ]; + testHaskellDepends = [ + base + HUnit + QuickCheck + random + test-framework + test-framework-hunit + test-framework-quickcheck2 + ]; + description = "A model for human colour/color perception"; + license = lib.licenses.mit; + hydraPlatforms = lib.platforms.none; + } + ) { }; + colour-accelerate = callPackage ( { mkDerivation, @@ -165922,6 +166969,31 @@ self: { } ) { }; + core-of-name = callPackage ( + { + mkDerivation, + base, + ghc, + template-haskell, + }: + mkDerivation { + pname = "core-of-name"; + version = "0.1.0.0"; + sha256 = "0asdg62bn1bvjls3f2fwvngcq7x3bfy2dq854pjh7dvz1znjc5mw"; + isLibrary = true; + isExecutable = true; + libraryHaskellDepends = [ + base + ghc + template-haskell + ]; + executableHaskellDepends = [ base ]; + description = "Print the Core representation of a binding with a GHC plugin"; + license = lib.licensesSpdx."BSD-3-Clause"; + mainProgram = "core-of-name"; + } + ) { }; + core-program = callPackage ( { mkDerivation, @@ -166966,8 +168038,8 @@ self: { }: mkDerivation { pname = "countable-inflections"; - version = "0.3.0"; - sha256 = "1imi7csng0q6qmwz2ii4j33nwcmiyzi072nvgh36a3lgi0ja6q9x"; + version = "0.3.2"; + sha256 = "1rv4gxvrh0v6ar2zijqkfhn870hymzdf7xm6wskjxl3w8y3ksrg9"; libraryHaskellDepends = [ base bytestring @@ -167939,8 +169011,8 @@ self: { }: mkDerivation { pname = "cpsa"; - version = "4.4.7"; - sha256 = "131ri7wj5lsbsqm9rvcmrsdgb9mls24nf1rjcz9bylxxaizchm39"; + version = "4.4.8"; + sha256 = "0w26rhfs35b2ihhj9k1a2h0x709qqfr9vgcyr22wmlmkpzic73lb"; isLibrary = false; isExecutable = true; enableSeparateDataOutput = true; @@ -184513,7 +185585,7 @@ self: { } ) { }; - dataframe_0_7_0_0 = callPackage ( + dataframe_1_0_0_1 = callPackage ( { mkDerivation, aeson, @@ -184531,6 +185603,7 @@ self: { Glob, granite, hashable, + http-conduit, HUnit, mmap, parallel, @@ -184542,6 +185615,8 @@ self: { scientific, snappy-hs, stm, + streamly-bytestring, + streamly-core, template-haskell, text, these, @@ -184555,8 +185630,8 @@ self: { }: mkDerivation { pname = "dataframe"; - version = "0.7.0.0"; - sha256 = "1khnk687vz4n0m9v0p6dw5x45g9n5yjx6x21i0cx3lkv00wm2fbj"; + version = "1.0.0.1"; + sha256 = "0yvg1jl66x7y47swsgx8bfgfvxys10879phdv8n1z39b3d2165lq"; isLibrary = true; isExecutable = true; libraryHaskellDepends = [ @@ -184574,6 +185649,7 @@ self: { Glob granite hashable + http-conduit mmap parallel process @@ -184582,6 +185658,8 @@ self: { scientific snappy-hs stm + streamly-bytestring + streamly-core template-haskell text these @@ -190345,10 +191423,8 @@ self: { }: mkDerivation { pname = "dependent-enummap"; - version = "0.1.0.0"; - sha256 = "1i0p0yipihjm9p6mpag9zw1r8gfl7lwcg35w97gqfy4lbbx2rp4n"; - revision = "1"; - editedCabalFile = "1a8dxvlqk52l5qx3ybbcjm2m4py4ywnrlwpggxdbg98a1x188wxg"; + version = "0.2.0.0"; + sha256 = "0j1wijrxmxrrz0jvg9qrg3g4iza6vvpmzhq3c0a2ixkiygrydbfv"; libraryHaskellDepends = [ base containers @@ -195432,8 +196508,8 @@ self: { }: mkDerivation { pname = "diagrams-input"; - version = "0.1.5"; - sha256 = "011kvcx3py8dwjx10ddd0z6pm5k76lb2y4mzkfp1nbcy0imkkfyq"; + version = "0.1.5.1"; + sha256 = "1fy6fp9w3z6xn8s21xfq31qd67g5931bik5iv8r2z38ajbhpwm68"; libraryHaskellDepends = [ attoparsec base @@ -199733,8 +200809,8 @@ self: { pname = "discrimination"; version = "0.5"; sha256 = "1qq7fs1dsfqgf4969gksqcp3swcx0wbzdh66a89fv78k6y94g0pc"; - revision = "5"; - editedCabalFile = "1pbnj7jzxxrd7s7nqmwmmxhw4pyrwxnsdx7xpw63240jb9f1cg8f"; + revision = "6"; + editedCabalFile = "0bncwrlxh0sr2r7c6fw6yk570km5hddvba2jz0g4rrywv74qw7n9"; libraryHaskellDepends = [ array base @@ -202110,6 +203186,70 @@ self: { } ) { }; + djot_0_1_4 = callPackage ( + { + mkDerivation, + base, + bytestring, + containers, + directory, + doclayout, + filepath, + mtl, + tasty, + tasty-bench, + tasty-hunit, + tasty-quickcheck, + template-haskell, + text, + }: + mkDerivation { + pname = "djot"; + version = "0.1.4"; + sha256 = "03qlk8r62j6nsjbbyp8510gn29vg3i2s4vq0p0qyr2679y5i6v8h"; + isLibrary = true; + isExecutable = true; + libraryHaskellDepends = [ + base + bytestring + containers + doclayout + mtl + template-haskell + text + ]; + executableHaskellDepends = [ + base + bytestring + doclayout + text + ]; + testHaskellDepends = [ + base + bytestring + directory + doclayout + filepath + tasty + tasty-hunit + tasty-quickcheck + text + ]; + benchmarkHaskellDepends = [ + base + bytestring + directory + doclayout + filepath + tasty-bench + ]; + description = "Parser and renderer for djot light markup syntax"; + license = lib.licensesSpdx."MIT"; + hydraPlatforms = lib.platforms.none; + mainProgram = "djoths"; + } + ) { }; + dl-fedora = callPackage ( { mkDerivation, @@ -221374,8 +222514,8 @@ self: { }: mkDerivation { pname = "erebos"; - version = "0.2.0"; - sha256 = "1mqkr4znvbv6wyr14ajzkamj7c5v3qfzfnsigznvz4jjq9hsp8qs"; + version = "0.2.1"; + sha256 = "05h1vlgvspfk0pwb6l5fj7zqv8pixhqyjqhbk3yvabhmfwhw5p25"; isLibrary = true; isExecutable = true; libraryHaskellDepends = [ @@ -225829,8 +226969,8 @@ self: { { mkDerivation, base }: mkDerivation { pname = "eventlog-socket"; - version = "0.1.1.0"; - sha256 = "1y3hji0xcqqkkr5drm4nss3q3wvqlmcq870y6ggx3j0kz2sd2w32"; + version = "0.1.2.0"; + sha256 = "10dkiazyszkm33x2bqz6vvi4ldkbnfjcjh4zn314p2w56pw3b330"; libraryHaskellDepends = [ base ]; description = "Stream GHC eventlog events to external processes"; license = lib.licensesSpdx."BSD-3-Clause"; @@ -233792,7 +234932,7 @@ self: { } ) { }; - fbrnch_1_8 = callPackage ( + fbrnch_1_8_1 = callPackage ( { mkDerivation, aeson, @@ -233802,6 +234942,7 @@ self: { bugzilla-redhat, bytestring, config-ini, + containers, copr-api, directory, either, @@ -233835,8 +234976,8 @@ self: { }: mkDerivation { pname = "fbrnch"; - version = "1.8"; - sha256 = "0zl0b8h9mnk86fjq4dbdr5xjgav6ikx9whayvw3cmqdhrx29dw1y"; + version = "1.8.1"; + sha256 = "01sxsyb1xwcgk306hzchvkzmhvcws3dr14pvglaiw7xj6y8915pd"; isLibrary = false; isExecutable = true; executableHaskellDepends = [ @@ -233847,6 +234988,7 @@ self: { bugzilla-redhat bytestring config-ini + containers copr-api directory either @@ -237980,6 +239122,43 @@ self: { } ) { }; + filepath-bytestring_1_5_2_0_4 = callPackage ( + { + mkDerivation, + base, + bytestring, + criterion, + filepath, + QuickCheck, + unix, + }: + mkDerivation { + pname = "filepath-bytestring"; + version = "1.5.2.0.4"; + sha256 = "1b93nhxp7cm4s02ir7gz9qr2kfky6fkppncshqs4p4js78jbmy25"; + libraryHaskellDepends = [ + base + bytestring + filepath + unix + ]; + testHaskellDepends = [ + base + bytestring + filepath + QuickCheck + ]; + benchmarkHaskellDepends = [ + base + criterion + filepath + ]; + description = "Library for manipulating RawFilePaths in a cross platform way"; + license = lib.licenses.bsd3; + hydraPlatforms = lib.platforms.none; + } + ) { }; + filepath-crypto = callPackage ( { mkDerivation, @@ -239427,13 +240606,13 @@ self: { mkDerivation, aeson, base, + base64-bytestring, bytestring, containers, + crypton, http-client, http-client-tls, http-types, - jose, - lens, stm, text, time, @@ -239441,18 +240620,18 @@ self: { }: mkDerivation { pname = "firebase-hs"; - version = "0.1.1.0"; - sha256 = "0fkf42m9higfyqm3cjyhz1mscw768rplsc9ma2c5xj42n890n28d"; + version = "0.2.0.0"; + sha256 = "1496r4pm6k04vmlff9kf3klz6vxdjabgsfhb5j261ijkh966bh0j"; libraryHaskellDepends = [ aeson base + base64-bytestring bytestring containers + crypton http-client http-client-tls http-types - jose - lens stm text time @@ -239463,12 +240642,13 @@ self: { base bytestring containers + http-client http-types text time ]; description = "Firebase Auth, Firestore, and Servant integration for Haskell"; - license = lib.licensesSpdx."MIT"; + license = lib.licensesSpdx."BSD-3-Clause"; } ) { }; @@ -245058,8 +246238,8 @@ self: { }: mkDerivation { pname = "fontwhich"; - version = "0.2"; - sha256 = "0784d0i55wnrqr8ajd7lpw5cdw67gni430g3vhp45mx3ic9srm7c"; + version = "0.2.1"; + sha256 = "1ayzaxzcj80k6v1mwc0sgj65bwmpzzd6h33ssdrdd12972pvr4ja"; isLibrary = false; isExecutable = true; executableHaskellDepends = [ @@ -247494,6 +248674,67 @@ self: { } ) { }; + fractal-layer = callPackage ( + { + mkDerivation, + aeson, + base, + bytestring, + containers, + hashable, + hspec, + hspec-discover, + mtl, + profunctors, + QuickCheck, + resourcet, + selective, + text, + time, + transformers, + unliftio, + unordered-containers, + }: + mkDerivation { + pname = "fractal-layer"; + version = "0.1.0.0"; + sha256 = "0b6d36mdsg4xm3x2dvix2hh91ca3jhnfa51id5b4wrdqdmrzvbzx"; + libraryHaskellDepends = [ + aeson + base + containers + hashable + mtl + profunctors + resourcet + selective + text + time + transformers + unliftio + unordered-containers + ]; + testHaskellDepends = [ + aeson + base + bytestring + hspec + mtl + profunctors + QuickCheck + resourcet + selective + text + time + unliftio + unordered-containers + ]; + testToolDepends = [ hspec-discover ]; + description = "Composable resource management and dependency injection"; + license = lib.licensesSpdx."BSD-3-Clause"; + } + ) { }; + fractals = callPackage ( { mkDerivation, @@ -248223,8 +249464,8 @@ self: { }: mkDerivation { pname = "freckle-http"; - version = "0.3.1.0"; - sha256 = "0y6qbl0hb6nwcb843l0q0j7nvzdgpc5l5fq9xgdjgyxnnzbjkm6k"; + version = "0.4.0.0"; + sha256 = "1lha52l01yk2jldmkz9ka3icb4n7y5pf6b4792w2100fvgk8spr0"; libraryHaskellDepends = [ aeson annotated-exception @@ -248363,8 +249604,8 @@ self: { }: mkDerivation { pname = "freckle-memcached"; - version = "0.0.0.2"; - sha256 = "1qqjribjzmpfqqygvl4frxy447sjqs5fin22y9aq075yfvgjq75a"; + version = "0.0.0.3"; + sha256 = "1nsi3iq4k3qgz287qf0pn3akg871sh21prrx5zcjkb7kmrqnvkmq"; libraryHaskellDepends = [ aeson annotated-exception @@ -248404,7 +249645,7 @@ self: { text unliftio ]; - description = ".."; + description = "Some extensions to the memcache library"; license = lib.licenses.mit; hydraPlatforms = lib.platforms.none; } @@ -252290,8 +253531,8 @@ self: { }: mkDerivation { pname = "funcons-tools"; - version = "0.2.0.15"; - sha256 = "0yfl7rg7hwy8yyxq5axicd57lk650i5pmm0slnxqbsgl96iv8x24"; + version = "0.2.0.16"; + sha256 = "1p7lm45762xw5yds4xqqkz0mal0fndnz1k0xspi93v91cskyjq3y"; isLibrary = true; isExecutable = true; libraryHaskellDepends = [ @@ -253756,6 +254997,8 @@ self: { pname = "futhark"; version = "0.25.36"; sha256 = "1wyc7pakrd2rrql3bqww9xid5w26y9ll2c35kqnpx8fwv73918j1"; + revision = "1"; + editedCabalFile = "18r45jsyk48g3y37fa7m5a5lv7bym7qrp930brqags4fjnw3ngbv"; isLibrary = true; isExecutable = true; libraryHaskellDepends = [ @@ -255878,8 +257121,8 @@ self: { }: mkDerivation { pname = "gb-sprite"; - version = "0.4.0.0"; - sha256 = "1812fs30l05amj47kfcplgdjy34q5wabb59gyy1rzdldqki6yql0"; + version = "0.5.2.0"; + sha256 = "19m6xac9lww9z10n6d6i7m5rhaggkm4whkv01l9hgvzxxzfpidhj"; libraryHaskellDepends = [ base bytestring @@ -255890,7 +257133,7 @@ self: { bytestring directory ]; - description = "Procedural 2D sprite and VFX generation"; + description = "Pure Haskell 2D raster graphics engine"; license = lib.licensesSpdx."BSD-3-Clause"; } ) { }; @@ -263033,6 +264276,7 @@ self: { ghc-debug-brick = callPackage ( { mkDerivation, + async, base, brick, bytestring, @@ -263040,6 +264284,8 @@ self: { containers, contra-tracer, deepseq, + dependent-map, + dependent-sum-template, directory, exceptions, filepath, @@ -263048,6 +264294,8 @@ self: { ghc-debug-convention, microlens, microlens-platform, + safe-exceptions, + some, text, time, unordered-containers, @@ -263056,11 +264304,12 @@ self: { }: mkDerivation { pname = "ghc-debug-brick"; - version = "0.7.0.0"; - sha256 = "06lwx3j9cfyaffqwjmyvv53lhybnz1zyd7djaz2an99d2pp037bp"; - isLibrary = false; + version = "0.8.0.0"; + sha256 = "0msk2bq84vm0jicnnklri0wafp0dqwqnmnvi70gaw2ba2v7m78ks"; + isLibrary = true; isExecutable = true; - executableHaskellDepends = [ + libraryHaskellDepends = [ + async base brick bytestring @@ -263068,6 +264317,8 @@ self: { containers contra-tracer deepseq + dependent-map + dependent-sum-template directory exceptions filepath @@ -263076,12 +264327,15 @@ self: { ghc-debug-convention microlens microlens-platform + safe-exceptions + some text time unordered-containers vty vty-crossplatform ]; + executableHaskellDepends = [ base ]; description = "A simple TUI using ghc-debug"; license = lib.licensesSpdx."BSD-3-Clause"; mainProgram = "ghc-debug-brick"; @@ -263114,13 +264368,14 @@ self: { psqueues, stm, text, + transformers, unordered-containers, vector, }: mkDerivation { pname = "ghc-debug-client"; - version = "0.7.0.0"; - sha256 = "03gqzbms7iv06qbcmz2v2zpqz9rsz4in14jf37s574rj3kh1xw0m"; + version = "0.8.0.0"; + sha256 = "0rqrg9ddjqhv32r0h3fqbydrmama16l1m9wyljj29ldyndpwi85w"; libraryHaskellDepends = [ async base @@ -263144,6 +264399,7 @@ self: { psqueues stm text + transformers unordered-containers vector ]; @@ -263172,8 +264428,8 @@ self: { }: mkDerivation { pname = "ghc-debug-common"; - version = "0.7.0.0"; - sha256 = "0nb6d18lkynzas55inx7h60xygj1f5n2hzjiw3zl3j4yhs9pnq6k"; + version = "0.8.0.0"; + sha256 = "096bj03jyrg8320kmm11lxfdm7q6gwh91yvjvs3z7m1sw8zrzd8y"; libraryHaskellDepends = [ array base @@ -263204,8 +264460,8 @@ self: { }: mkDerivation { pname = "ghc-debug-convention"; - version = "0.7.0.0"; - sha256 = "19ir87s3n2k0ijwa0ax6d8p8gpbmf64a5h46k40dbs9h6waij0pa"; + version = "0.8.0.0"; + sha256 = "0nzbkd2cx4ryakh810xs3id1im8ayarfnb1m2bbk532qcfrwq5j6"; libraryHaskellDepends = [ base directory @@ -263227,8 +264483,8 @@ self: { }: mkDerivation { pname = "ghc-debug-stub"; - version = "0.7.0.0"; - sha256 = "0p7x3j5qwc1s4svqmxq1s5vcrjczwm86lml403mdg1xvd2scyn1z"; + version = "0.8.0.0"; + sha256 = "1axg67n0nyl9gwn3pqrpvq6qcykidcas5h96f4cckng8b75ab22b"; libraryHaskellDepends = [ base directory @@ -266922,26 +268178,31 @@ self: { } ) { }; - ghc-typelits-extra_0_5_2 = callPackage ( + ghc-typelits-extra_0_5_3 = callPackage ( { mkDerivation, base, containers, + directory, + filepath, ghc, ghc-bignum, ghc-prim, ghc-tcplugin-api, ghc-typelits-knownnat, ghc-typelits-natnormalise, + interpolate, + process, tasty, tasty-hunit, template-haskell, + temporary, transformers, }: mkDerivation { pname = "ghc-typelits-extra"; - version = "0.5.2"; - sha256 = "03l0gb3imz53pqnnqaqgxsvqxzv0jqv9syjfdvlfqah6kib6acii"; + version = "0.5.3"; + sha256 = "1azm03pz1rs0x6i7ywqckmrcs5n95ry0g4kj4c9asl8g0gnkvq8a"; libraryHaskellDepends = [ base containers @@ -266956,10 +268217,15 @@ self: { ]; testHaskellDepends = [ base + directory + filepath ghc-typelits-knownnat ghc-typelits-natnormalise + interpolate + process tasty tasty-hunit + temporary ]; description = "Additional type-level operations on GHC.TypeLits.Nat"; license = lib.licensesSpdx."BSD-2-Clause"; @@ -267006,7 +268272,7 @@ self: { } ) { }; - ghc-typelits-knownnat_0_8_2 = callPackage ( + ghc-typelits-knownnat_0_8_3 = callPackage ( { mkDerivation, base, @@ -267023,8 +268289,8 @@ self: { }: mkDerivation { pname = "ghc-typelits-knownnat"; - version = "0.8.2"; - sha256 = "0fljjj0n47wwxbg8kxpnn7kbf7vfdh91q3fhnk0jaq3nnlv05bdy"; + version = "0.8.3"; + sha256 = "13s0yya4q32v76ix0qlimvj14j9qiamxvqyjfw0lp2g42wdj67fz"; libraryHaskellDepends = [ base ghc @@ -267127,7 +268393,7 @@ self: { } ) { }; - ghc-typelits-natnormalise_0_9_3 = callPackage ( + ghc-typelits-natnormalise_0_9_5 = callPackage ( { mkDerivation, base, @@ -267136,15 +268402,17 @@ self: { ghc-bignum, ghc-prim, ghc-tcplugin-api, + interpolate, + process, tasty, tasty-hunit, - template-haskell, + temporary, transformers, }: mkDerivation { pname = "ghc-typelits-natnormalise"; - version = "0.9.3"; - sha256 = "0q5s6sz212xp88cwliizxz32jk1rk1b853riaypw7kvim7ssv90v"; + version = "0.9.5"; + sha256 = "1391bmh8460kybfp39v0c5njd7r4yxz6nyk28qvx70jry2pdysbq"; libraryHaskellDepends = [ base containers @@ -267156,9 +268424,11 @@ self: { testHaskellDepends = [ base ghc-prim + interpolate + process tasty tasty-hunit - template-haskell + temporary ]; description = "GHC typechecker plugin for types of kind GHC.TypeLits.Nat"; license = lib.licensesSpdx."BSD-2-Clause"; @@ -268444,6 +269714,21 @@ self: { } ) { }; + ghcjs-dom-jsaddle_0_9_9_1 = callPackage ( + { mkDerivation, jsaddle-dom }: + mkDerivation { + pname = "ghcjs-dom-jsaddle"; + version = "0.9.9.1"; + sha256 = "05spxlw1gjian9k4m0z72qv72sj8x491pjpj2vzh524jhg69hlb1"; + libraryHaskellDepends = [ jsaddle-dom ]; + doHaddock = false; + description = "DOM library that supports both GHCJS and GHC using jsaddle"; + license = lib.licensesSpdx."MIT"; + hydraPlatforms = lib.platforms.none; + maintainers = [ lib.maintainers.alexfmpe ]; + } + ) { }; + ghcjs-dom-jsffi = callPackage ( { mkDerivation }: mkDerivation { @@ -274035,8 +275320,8 @@ self: { }: mkDerivation { pname = "git-annex"; - version = "10.20260213"; - sha256 = "0makjv87hvxvljv2jw22g62z0xrrcdxd6gn888vj9h8yy9j32q61"; + version = "10.20260316"; + sha256 = "02ghaz5x4qq1n7dv8mr41hi4i1ywxf2hn1csnl5rbvcpm836xhsp"; configureFlags = [ "-fassistant" "-f-benchmark" @@ -276618,7 +277903,7 @@ self: { } ) { }; - gitlab-haskell_1_2_1_0 = callPackage ( + gitlab-haskell_1_3_0_0 = callPackage ( { mkDerivation, aeson, @@ -276644,8 +277929,8 @@ self: { }: mkDerivation { pname = "gitlab-haskell"; - version = "1.2.1.0"; - sha256 = "1x80hgf2q36xcdl0h7gw2qq56zlk0dps4i1msw5zk4ay2y4n8vsn"; + version = "1.3.0.0"; + sha256 = "1aa8hr6k4f7i6z0762zah10ija9f221f8yww0igbfmxm3g99sxnm"; enableSeparateDataOutput = true; libraryHaskellDepends = [ aeson @@ -278778,8 +280063,8 @@ self: { }: mkDerivation { pname = "gll"; - version = "0.4.1.1"; - sha256 = "061ypdd5y2ksa4kmij8b1xasr30rsqa97w18n0j142817ravhxi7"; + version = "0.4.1.2"; + sha256 = "0ck7l086rj827ipsmz106jxhn0gj2v6r4v0x6pw6yq911a57kpi6"; libraryHaskellDepends = [ array base @@ -288833,8 +290118,8 @@ self: { }: mkDerivation { pname = "graphwiz"; - version = "2.0.0"; - sha256 = "1lh6rggylnwsyadbiq895lnykjyiv230x8bp5fvww9vi0b2fjwyy"; + version = "3.0.0"; + sha256 = "07fh4c38367szpm42lr104vlwaz9m2mgyzklq6zkz7k4k1zjyvgx"; isLibrary = true; isExecutable = true; libraryHaskellDepends = [ @@ -295038,8 +296323,8 @@ self: { }: mkDerivation { pname = "haal"; - version = "0.3.0.0"; - sha256 = "1kllgy5q29xr1zh2xif1c7ixlhjkcr9cs5j3km90fr9sdd9hjjxl"; + version = "0.4.1.0"; + sha256 = "0f587n9qbyyr08sgrvkcam4ri2m1iri3sw4mb7y4ficwjar34p3d"; isLibrary = true; isExecutable = true; libraryHaskellDepends = [ @@ -295070,6 +296355,27 @@ self: { } ) { }; + haal-models = callPackage ( + { + mkDerivation, + base, + containers, + haal, + }: + mkDerivation { + pname = "haal-models"; + version = "0.1.0.0"; + sha256 = "19yhz0gp2axzy3hp7nk1k61ygfzhgplki3sidw5cppqxk3gi640g"; + libraryHaskellDepends = [ + base + containers + haal + ]; + description = "Pre-built Mealy automaton models for haal"; + license = lib.licensesSpdx."BSD-3-Clause"; + } + ) { }; + haar = callPackage ( { mkDerivation, @@ -310232,6 +311538,39 @@ self: { } ) { }; + haskell-list-builder = callPackage ( + { + mkDerivation, + base, + criterion, + dlist, + ghc-prim, + hedgehog, + primitive, + }: + mkDerivation { + pname = "haskell-list-builder"; + version = "0.1.0.0"; + sha256 = "02753zmb1zv5n5plz33zlzwvhp2x0n36d7mj3iik9kgnnskzw9rw"; + libraryHaskellDepends = [ + base + ghc-prim + primitive + ]; + testHaskellDepends = [ + base + hedgehog + ]; + benchmarkHaskellDepends = [ + base + criterion + dlist + ]; + description = "Fast Sequencing and Building Lists using Unsafe Primitives"; + license = lib.licenses.bsd3; + } + ) { }; + haskell-lsp = callPackage ( { mkDerivation, @@ -310789,8 +312128,8 @@ self: { }: mkDerivation { pname = "haskell-opentimestamps"; - version = "0.5.5.1"; - sha256 = "04dzai6q93gzqjx3jqhgnzsy6fmsalyamylqsnmxg09i0zgbyk66"; + version = "0.5.5.2"; + sha256 = "14gd70lrh27kkkg1jf4gqxm8ixnc7hj1j3csyvkplv7ayxffdl58"; libraryHaskellDepends = [ aeson base @@ -310856,8 +312195,8 @@ self: { }: mkDerivation { pname = "haskell-opentimestamps-client"; - version = "0.4.1.0"; - sha256 = "0w6avx3jsj875ljddc82pzqqckgbc113c1mj3ghp473palzjigni"; + version = "0.4.1.1"; + sha256 = "0f57pr1c8c8v67ni9jla8y5qrd9rhmsabq09nm6yqqshd67xhcyj"; isLibrary = true; isExecutable = true; libraryHaskellDepends = [ @@ -318528,8 +319867,8 @@ self: { }: mkDerivation { pname = "hasql-mapping"; - version = "0.1"; - sha256 = "1jppr5z54ca79smjyrk031swgxivz4mnhrli31x33fkyidi0xm8j"; + version = "0.1.0.1"; + sha256 = "01w5xr4yw18000nsm2fsr8l672dr7lksr6w6cj45i21x4i6cs5c0"; libraryHaskellDepends = [ aeson base @@ -325755,6 +327094,44 @@ self: { } ) { }; + hedgehog-utils = callPackage ( + { + mkDerivation, + base, + containers, + deepseq, + hedgehog, + hspec, + hspec-core, + hspec-discover, + hspec-hedgehog, + hspec-tidy-formatter, + }: + mkDerivation { + pname = "hedgehog-utils"; + version = "0.1.0.0"; + sha256 = "0q5qzg38jkrjkpqdmhdw7xlzz2dbgpgicpnr8h8sjzzf77m7c6c5"; + libraryHaskellDepends = [ + base + containers + deepseq + hedgehog + ]; + testHaskellDepends = [ + base + containers + hedgehog + hspec + hspec-core + hspec-hedgehog + hspec-tidy-formatter + ]; + testToolDepends = [ hspec-discover ]; + description = "Utilities for Hedgehog"; + license = lib.licensesSpdx."MIT"; + } + ) { }; + hedis = callPackage ( { mkDerivation, @@ -329211,10 +330588,8 @@ self: { }: mkDerivation { pname = "hermes-json"; - version = "0.7.0.0"; - sha256 = "1261sm969kwji4gwk474l41rk0f3i8isb5x4zd77l3y4d5hgz85b"; - revision = "1"; - editedCabalFile = "1dnk3gdhpr13m9y2j71ivjsbjkns9jvjpasf5vhlsz7w4v679zni"; + version = "0.8.0.0"; + sha256 = "0lcl2rsjaa3cvgcvdrkdyw7kv3bmrv31v0hhdmjppdwqjhx4jlvz"; libraryHaskellDepends = [ base bytestring @@ -338348,10 +339723,8 @@ self: { }: mkDerivation { pname = "hledger"; - version = "1.51.2"; - sha256 = "0bcb1dxlmi3h12wb7y4iqbi0p0wvzp23m0xkghiz5k5ydp3ixrv8"; - revision = "1"; - editedCabalFile = "082qb8n4lhgjab0829dgf7pchh1p8j8d0qq39sx8mcinyjwmm9gd"; + version = "1.52"; + sha256 = "10pj2y6a90awrvg982pmimx5j8sykghgpfx7xv1511jyj89g5ry1"; isLibrary = true; isExecutable = true; libraryHaskellDepends = [ @@ -338625,6 +339998,7 @@ self: { mkDerivation, base, containers, + directory, exceptions, filepath, foldl, @@ -338640,8 +340014,8 @@ self: { }: mkDerivation { pname = "hledger-flow"; - version = "0.16.1"; - sha256 = "0lf3ndx8p4f2mfq0d7hwansc2xvqazhn4ywr6q2z6ygki4jac99g"; + version = "0.16.3"; + sha256 = "08b52li78brqg6ny1m7vb1q1f0bg3jjkmp15z2j5gxs3ns01jx78"; isLibrary = true; isExecutable = true; libraryHaskellDepends = [ @@ -338668,12 +340042,14 @@ self: { testHaskellDepends = [ base containers + directory foldl HUnit path path-io stm text + time turtle ]; description = "An hledger workflow focusing on automated statement import and classification"; @@ -338713,8 +340089,8 @@ self: { pname = "hledger-iadd"; version = "1.3.22"; sha256 = "077v7jgqhmpkg8m68bg4qi0jxl4zkg17aqk5n58ni3s2h71lkwlv"; - revision = "2"; - editedCabalFile = "0jnczff457f3n4sgz16iiyfsdhr2dhxdvxpb3dls24n7452vf2mw"; + revision = "4"; + editedCabalFile = "06s2ik9zswywxjsz0wfc74hkw4sc3iyzlxyaz0vn6qhfln1bh5l4"; isLibrary = true; isExecutable = true; libraryHaskellDepends = [ @@ -338905,8 +340281,8 @@ self: { }: mkDerivation { pname = "hledger-lib"; - version = "1.51.2"; - sha256 = "03smy5xc817c797nkh5pjvrb2p41xdvxvwlkhzgkb9b7hrk9nic8"; + version = "1.52"; + sha256 = "0z7fi6qj009ab1p77cmhsy1pbxx6p9gqkbdgyiycwpkim6yv9awy"; libraryHaskellDepends = [ aeson aeson-pretty @@ -339172,8 +340548,10 @@ self: { }: mkDerivation { pname = "hledger-ui"; - version = "1.51.2"; - sha256 = "0wmqqr83zfz82qdw2pvqd937233brxa67wvjgaag7fqjhlbpd9qk"; + version = "1.52"; + sha256 = "09nhri3w1bzryiwsjydxnklwz10xl1x8mbfq5614q92msqnfcfks"; + revision = "1"; + editedCabalFile = "0xj3hckgvmfmjgy623h0cvv6dkhx576yrqjv87w3hb3w9nx27srq"; isLibrary = true; isExecutable = true; libraryHaskellDepends = [ @@ -339308,8 +340686,8 @@ self: { }: mkDerivation { pname = "hledger-web"; - version = "1.51.2"; - sha256 = "12k2sl9ll8lfxl194hin8c58gbipxh4yyzycbwn0lbb231agyjfg"; + version = "1.52"; + sha256 = "0948qyzbkxpg9hvpbia0xdzlcch3a72f6qkjszr7a8mv0179mfir"; isLibrary = true; isExecutable = true; libraryHaskellDepends = [ @@ -351163,6 +352541,8 @@ self: { pname = "hpqtypes-extras"; version = "1.19.0.0"; sha256 = "0i2rrmbhm35kpfr4w6w4hqkrb2plnyi4rz1l11gdy3mp9938rwgc"; + revision = "1"; + editedCabalFile = "10yaza7wwl1rcq44fhh2jbwil67081q069zlm8z2y7k5zl17kaba"; libraryHaskellDepends = [ base base16-bytestring @@ -356797,7 +358177,7 @@ self: { bytestring, c2hs, deepseq, - memory, + ram, tasty, tasty-discover, tasty-hunit, @@ -356805,21 +358185,19 @@ self: { }: mkDerivation { pname = "hsblst"; - version = "0.0.4"; - sha256 = "13dlz8am20np31bq31z596yam6w1rb0fdzlg3zwwvm6wyjh6b8sg"; - revision = "1"; - editedCabalFile = "1cwplg9k8pr6iy27gkc32ayxnwf63sbzdd660p1lm8dihvj9q1jy"; + version = "0.0.5"; + sha256 = "0xlb8q5dm0x0ih83v14jmawlaxyi3fgps4hv41fbakp6yg1x80q4"; libraryHaskellDepends = [ base deepseq - memory + ram ]; libraryToolDepends = [ c2hs ]; testHaskellDepends = [ base base16-bytestring bytestring - memory + ram tasty tasty-hunit text @@ -361723,6 +363101,29 @@ self: { } ) { }; + hsmrc-marc8 = callPackage ( + { + mkDerivation, + base, + bytestring, + hsmrc, + utf8-string, + }: + mkDerivation { + pname = "hsmrc-marc8"; + version = "0.0.1"; + sha256 = "11cikagla28ql84xcrmfqcl457c7fklq0an7026ygklkj8769rx1"; + libraryHaskellDepends = [ + base + bytestring + hsmrc + utf8-string + ]; + description = "MARC-8 charset decoding library for hsmrc"; + license = lib.licenses.bsd3; + } + ) { }; + hsmtpclient = callPackage ( { mkDerivation, @@ -364733,7 +366134,7 @@ self: { base, hsql, old-time, - unixodbc, + unixODBC, }: mkDerivation { pname = "hsql-odbc"; @@ -364744,12 +366145,12 @@ self: { hsql old-time ]; - librarySystemDepends = [ unixodbc ]; + librarySystemDepends = [ unixODBC ]; description = "A Haskell Interface to ODBC"; license = lib.licenses.bsd3; hydraPlatforms = lib.platforms.none; } - ) { inherit (pkgs) unixodbc; }; + ) { unixODBC = null; }; hsql-postgresql = callPackage ( { @@ -371294,6 +372695,8 @@ self: { pname = "http3"; version = "0.1.3"; sha256 = "0agb0cp5lh74vv47ryv38pk46mpiqpv659i9qqmgvigaxkl379sh"; + revision = "1"; + editedCabalFile = "0xhc36rfdcmwcp17ghfgqbv1k4ncanrf4gy9pz2g8w1sj9f2wnbs"; isLibrary = true; isExecutable = true; libraryHaskellDepends = [ @@ -382909,28 +384312,40 @@ self: { clientsession, conduit-extra, containers, + contravariant, cookie, countable-inflections, data-default, deepseq, directory, fast-logger, + filepath, ghc-prim, + hashable, haskell-src-exts, haskell-src-meta, + hasql, + hasql-dynamic-statements, + hasql-implicits, + hasql-mapping, + hasql-pool, + hasql-postgresql-types, + hasql-transaction, hspec, http-client, http-client-tls, http-media, http-types, + ihp-context, ihp-hsx, - ihp-postgresql-simple-extra, + ihp-imagemagick, + ihp-log, + ihp-modal, + ihp-pagehead, + ihp-pglistener, inflections, interpolate, - ip, lens, - mime-mail, - mime-mail-ses, mime-types, minio-hs, mono-traversable, @@ -382940,6 +384355,8 @@ self: { network-uri, parser-combinators, postgresql-simple, + postgresql-simple-postgresql-types, + postgresql-types, process, pwstore-fast, random, @@ -382949,9 +384366,11 @@ self: { resourcet, safe-exceptions, scientific, - smtp-mail, + slugger, split, + stm, string-conversions, + tasty-bench, template-haskell, temporary, text, @@ -382968,10 +384387,13 @@ self: { vector, wai, wai-app-static, + wai-asset-path, wai-cors, wai-extra, - wai-session, - wai-session-clientsession, + wai-flash-messages, + wai-request-params, + wai-session-clientsession-deferred, + wai-session-maybe, wai-util, wai-websockets, warp, @@ -382982,8 +384404,8 @@ self: { }: mkDerivation { pname = "ihp"; - version = "1.4.1"; - sha256 = "0d5hj8c8qvjqmdjy7dxibhq41qzbfqmrcgmfw84s6gfss9jbanlq"; + version = "1.5.0"; + sha256 = "1cx0pxw1mgky4fv2j059sijd01rgl681jbrgl9j07kfn0pw99bvb"; enableSeparateDataOutput = true; libraryHaskellDepends = [ aeson @@ -383002,28 +384424,40 @@ self: { clientsession conduit-extra containers + contravariant cookie countable-inflections data-default deepseq directory fast-logger + filepath ghc-prim + hashable haskell-src-exts haskell-src-meta + hasql + hasql-dynamic-statements + hasql-implicits + hasql-mapping + hasql-pool + hasql-postgresql-types + hasql-transaction hspec http-client http-client-tls http-media http-types + ihp-context ihp-hsx - ihp-postgresql-simple-extra + ihp-imagemagick + ihp-log + ihp-modal + ihp-pagehead + ihp-pglistener inflections interpolate - ip lens - mime-mail - mime-mail-ses mime-types minio-hs mono-traversable @@ -383033,6 +384467,8 @@ self: { network-uri parser-combinators postgresql-simple + postgresql-simple-postgresql-types + postgresql-types process pwstore-fast random @@ -383042,8 +384478,9 @@ self: { resourcet safe-exceptions scientific - smtp-mail + slugger split + stm string-conversions template-haskell temporary @@ -383061,10 +384498,226 @@ self: { vector wai wai-app-static + wai-asset-path wai-cors wai-extra - wai-session - wai-session-clientsession + wai-flash-messages + wai-request-params + wai-session-clientsession-deferred + wai-session-maybe + wai-util + wai-websockets + warp + warp-systemd + websockets + with-utf8 + wreq + ]; + testHaskellDepends = [ + aeson + async + attoparsec + base + basic-prelude + binary + blaze-html + blaze-markup + bytestring + case-insensitive + cereal + cereal-text + classy-prelude + clientsession + conduit-extra + containers + contravariant + cookie + countable-inflections + data-default + deepseq + directory + fast-logger + filepath + ghc-prim + hashable + haskell-src-exts + haskell-src-meta + hasql + hasql-dynamic-statements + hasql-implicits + hasql-mapping + hasql-pool + hasql-postgresql-types + hasql-transaction + hspec + http-client + http-client-tls + http-media + http-types + ihp-context + ihp-hsx + ihp-imagemagick + ihp-log + ihp-modal + ihp-pagehead + ihp-pglistener + inflections + interpolate + lens + mime-types + minio-hs + mono-traversable + mtl + neat-interpolation + network + network-uri + parser-combinators + postgresql-simple + postgresql-simple-postgresql-types + postgresql-types + process + pwstore-fast + random + random-strings + regex-tdfa + resource-pool + resourcet + safe-exceptions + scientific + slugger + split + stm + string-conversions + template-haskell + temporary + text + time + transformers + typerep-map + unagi-chan + unix + unliftio + unordered-containers + uri-encode + uuid + vault + vector + wai + wai-app-static + wai-asset-path + wai-cors + wai-extra + wai-flash-messages + wai-request-params + wai-session-clientsession-deferred + wai-session-maybe + wai-util + wai-websockets + warp + warp-systemd + websockets + with-utf8 + wreq + ]; + benchmarkHaskellDepends = [ + aeson + async + attoparsec + base + basic-prelude + binary + blaze-html + blaze-markup + bytestring + case-insensitive + cereal + cereal-text + classy-prelude + clientsession + conduit-extra + containers + contravariant + cookie + countable-inflections + data-default + deepseq + directory + fast-logger + filepath + ghc-prim + hashable + haskell-src-exts + haskell-src-meta + hasql + hasql-dynamic-statements + hasql-implicits + hasql-mapping + hasql-pool + hasql-postgresql-types + hasql-transaction + hspec + http-client + http-client-tls + http-media + http-types + ihp-context + ihp-hsx + ihp-imagemagick + ihp-log + ihp-modal + ihp-pagehead + ihp-pglistener + inflections + interpolate + lens + mime-types + minio-hs + mono-traversable + mtl + neat-interpolation + network + network-uri + parser-combinators + postgresql-simple + postgresql-simple-postgresql-types + postgresql-types + process + pwstore-fast + random + random-strings + regex-tdfa + resource-pool + resourcet + safe-exceptions + scientific + slugger + split + stm + string-conversions + tasty-bench + template-haskell + temporary + text + time + transformers + typerep-map + unagi-chan + unix + unliftio + unordered-containers + uri-encode + uuid + vault + vector + wai + wai-app-static + wai-asset-path + wai-cors + wai-extra + wai-flash-messages + wai-request-params + wai-session-clientsession-deferred + wai-session-maybe wai-util wai-websockets warp @@ -383079,6 +384732,305 @@ self: { } ) { }; + ihp-context = callPackage ( + { + mkDerivation, + base, + typerep-map, + }: + mkDerivation { + pname = "ihp-context"; + version = "1.0.0"; + sha256 = "0jz6vfzahi3imxpnx5wkizq1ihv7xahrg45gcvc9szli6i50i7lj"; + libraryHaskellDepends = [ + base + typerep-map + ]; + description = "Minimal typed context container for IHP"; + license = lib.licensesSpdx."MIT"; + } + ) { }; + + ihp-datasync = callPackage ( + { + mkDerivation, + aeson, + async, + attoparsec, + base, + bytestring, + case-insensitive, + classy-prelude, + containers, + deepseq, + haskell-src-exts, + haskell-src-meta, + hasql, + hasql-dynamic-statements, + hasql-mapping, + hasql-pool, + hasql-postgresql-types, + hasql-transaction, + hspec, + http-media, + http-types, + ihp, + ihp-hsx, + ihp-log, + interpolate, + mono-traversable, + mtl, + postgresql-types, + safe-exceptions, + scientific, + stm, + template-haskell, + text, + time, + transformers, + typerep-map, + unliftio, + unordered-containers, + uuid, + vault, + vector, + wai, + wai-websockets, + warp, + websockets, + }: + mkDerivation { + pname = "ihp-datasync"; + version = "1.5.0"; + sha256 = "1d6fi1g2qzdisyjgikzd2swfn7gcncmn92mvfmh83khwkgbq7jk1"; + libraryHaskellDepends = [ + aeson + async + attoparsec + base + bytestring + case-insensitive + classy-prelude + containers + deepseq + haskell-src-exts + haskell-src-meta + hasql + hasql-dynamic-statements + hasql-mapping + hasql-pool + hasql-postgresql-types + hasql-transaction + http-media + http-types + ihp + ihp-hsx + ihp-log + interpolate + mono-traversable + mtl + postgresql-types + safe-exceptions + scientific + stm + template-haskell + text + time + transformers + typerep-map + unliftio + unordered-containers + uuid + vault + vector + wai + wai-websockets + warp + websockets + ]; + testHaskellDepends = [ + aeson + async + attoparsec + base + bytestring + case-insensitive + classy-prelude + containers + deepseq + haskell-src-exts + haskell-src-meta + hasql + hasql-dynamic-statements + hasql-mapping + hasql-pool + hasql-postgresql-types + hasql-transaction + hspec + http-media + http-types + ihp + ihp-hsx + ihp-log + interpolate + mono-traversable + mtl + postgresql-types + safe-exceptions + scientific + stm + template-haskell + text + time + transformers + typerep-map + unliftio + unordered-containers + uuid + vault + vector + wai + wai-websockets + warp + websockets + ]; + description = "IHP DataSync Framework"; + license = lib.licensesSpdx."MIT"; + } + ) { }; + + ihp-datasync-typescript = callPackage ( + { + mkDerivation, + hspec, + ihp, + ihp-postgres-parser, + megaparsec, + neat-interpolation, + text, + with-utf8, + }: + mkDerivation { + pname = "ihp-datasync-typescript"; + version = "1.5.0"; + sha256 = "0y75qrjx8lsi8cs1n1k0x91sziq9ymnwv46awlmsgmg0fjdx787g"; + isLibrary = true; + isExecutable = true; + libraryHaskellDepends = [ + ihp + ihp-postgres-parser + neat-interpolation + ]; + executableHaskellDepends = [ + ihp + ihp-postgres-parser + neat-interpolation + text + with-utf8 + ]; + testHaskellDepends = [ + hspec + ihp + ihp-postgres-parser + megaparsec + neat-interpolation + ]; + description = "TypeScript code generation for IHP DataSync"; + license = lib.licensesSpdx."MIT"; + mainProgram = "generate-datasync-types"; + } + ) { }; + + ihp-graphql = callPackage ( + { + mkDerivation, + aeson, + attoparsec, + base, + bytestring, + countable-inflections, + hspec, + ihp, + ihp-postgres-parser, + megaparsec, + postgresql-simple, + scientific, + text, + unordered-containers, + }: + mkDerivation { + pname = "ihp-graphql"; + version = "1.5.0"; + sha256 = "1s1q8rxsjs8prckvd1dzc3fqg0kfa442cr4km16r0kc3rg2sdpnf"; + libraryHaskellDepends = [ + aeson + attoparsec + base + countable-inflections + ihp + ihp-postgres-parser + postgresql-simple + scientific + text + unordered-containers + ]; + testHaskellDepends = [ + aeson + attoparsec + base + bytestring + countable-inflections + hspec + ihp + ihp-postgres-parser + megaparsec + postgresql-simple + scientific + text + unordered-containers + ]; + description = "GraphQL support for IHP"; + license = lib.licensesSpdx."MIT"; + } + ) { }; + + ihp-hspec = callPackage ( + { + mkDerivation, + base, + hasql, + ihp, + ihp-ide, + ihp-log, + process, + text, + uuid, + vault, + wai, + wai-request-params, + }: + mkDerivation { + pname = "ihp-hspec"; + version = "1.5.0"; + sha256 = "1z4d121bn2d476lgd66li706i1jsmz28zvahzndixid54bvrd529"; + libraryHaskellDepends = [ + base + hasql + ihp + ihp-ide + ihp-log + process + text + uuid + vault + wai + wai-request-params + ]; + description = "Test helpers for IHP apps"; + license = lib.licensesSpdx."MIT"; + } + ) { }; + ihp-hsx = callPackage ( { mkDerivation, @@ -383159,10 +385111,21 @@ self: { cryptohash, data-default, directory, + filepath, fsnotify, + hasql, + hasql-dynamic-statements, + hasql-implicits, + hasql-pool, + hspec, http-types, ihp, ihp-hsx, + ihp-log, + ihp-migrate, + ihp-modal, + ihp-postgres-parser, + ihp-schema-compiler, inflections, interpolate, megaparsec, @@ -383170,8 +385133,6 @@ self: { neat-interpolation, network, network-uri, - parser-combinators, - postgresql-simple, process, safe-exceptions, split, @@ -383187,9 +385148,11 @@ self: { vault, wai, wai-app-static, + wai-asset-path, wai-extra, - wai-session, - wai-session-clientsession, + wai-request-params, + wai-session-clientsession-deferred, + wai-session-maybe, wai-util, wai-websockets, warp, @@ -383199,8 +385162,8 @@ self: { }: mkDerivation { pname = "ihp-ide"; - version = "1.4.0"; - sha256 = "0mglqbbmk7y94avmb2z4mqhrbcwrhabzicyjd0cgd49v9mz32p5n"; + version = "1.5.0"; + sha256 = "1r76ww4fd46lhjw5rnnjnbk22wgygy9vc2052dgvg6jl3shiivwl"; isLibrary = true; isExecutable = true; enableSeparateDataOutput = true; @@ -383222,10 +385185,20 @@ self: { cryptohash data-default directory + filepath fsnotify + hasql + hasql-dynamic-statements + hasql-implicits + hasql-pool http-types ihp ihp-hsx + ihp-log + ihp-migrate + ihp-modal + ihp-postgres-parser + ihp-schema-compiler inflections interpolate megaparsec @@ -383233,8 +385206,6 @@ self: { neat-interpolation network network-uri - parser-combinators - postgresql-simple process safe-exceptions split @@ -383251,8 +385222,9 @@ self: { wai wai-app-static wai-extra - wai-session - wai-session-clientsession + wai-request-params + wai-session-clientsession-deferred + wai-session-maybe wai-util wai-websockets warp @@ -383279,10 +385251,19 @@ self: { cryptohash data-default directory + filepath fsnotify + hasql + hasql-dynamic-statements + hasql-implicits + hasql-pool http-types ihp ihp-hsx + ihp-log + ihp-migrate + ihp-postgres-parser + ihp-schema-compiler inflections interpolate megaparsec @@ -383290,8 +385271,6 @@ self: { neat-interpolation network network-uri - parser-combinators - postgresql-simple process safe-exceptions split @@ -383308,8 +385287,75 @@ self: { wai wai-app-static wai-extra - wai-session - wai-session-clientsession + wai-session-clientsession-deferred + wai-session-maybe + wai-util + wai-websockets + warp + websockets + with-utf8 + wreq + ]; + testHaskellDepends = [ + aeson + async + attoparsec + auto-update + base + base16-bytestring + basic-prelude + blaze-html + blaze-markup + bytestring + classy-prelude + clientsession + containers + countable-inflections + cryptohash + data-default + directory + filepath + fsnotify + hasql + hasql-dynamic-statements + hasql-implicits + hasql-pool + hspec + http-types + ihp + ihp-hsx + ihp-log + ihp-migrate + ihp-modal + ihp-postgres-parser + ihp-schema-compiler + inflections + interpolate + megaparsec + mono-traversable + neat-interpolation + network + network-uri + process + safe-exceptions + split + string-conversions + text + time + transformers + unagi-chan + unix + unliftio + uri-encode + uuid + vault + wai + wai-app-static + wai-asset-path + wai-extra + wai-request-params + wai-session-clientsession-deferred + wai-session-maybe wai-util wai-websockets warp @@ -383323,6 +385369,148 @@ self: { } ) { }; + ihp-imagemagick = callPackage ( + { + mkDerivation, + base, + bytestring, + process, + temporary, + text, + wai-extra, + }: + mkDerivation { + pname = "ihp-imagemagick"; + version = "1.0.0"; + sha256 = "0sqyq2jasm56slpvndphayi0xh0x0zjkgc025ppmh7280rfsy7rr"; + libraryHaskellDepends = [ + base + bytestring + process + temporary + text + wai-extra + ]; + description = "ImageMagick preprocessing for IHP file uploads"; + license = lib.licensesSpdx."MIT"; + } + ) { }; + + ihp-job-dashboard = callPackage ( + { + mkDerivation, + base, + blaze-html, + blaze-markup, + hasql, + hasql-dynamic-statements, + hasql-implicits, + hasql-pool, + http-types, + ihp, + ihp-hsx, + mtl, + text, + wai, + wai-request-params, + }: + mkDerivation { + pname = "ihp-job-dashboard"; + version = "1.5.0"; + sha256 = "0izps7i1q1aifaqhzidr3sakzmiwin137naqsi2mblkw6d03jcn4"; + libraryHaskellDepends = [ + base + blaze-html + blaze-markup + hasql + hasql-dynamic-statements + hasql-implicits + hasql-pool + http-types + ihp + ihp-hsx + mtl + text + wai + wai-request-params + ]; + description = "Dashboard for IHP job runners"; + license = lib.licensesSpdx."MIT"; + } + ) { }; + + ihp-log = callPackage ( + { + mkDerivation, + base, + bytestring, + data-default, + fast-logger, + filepath, + text, + wai, + wai-extra, + }: + mkDerivation { + pname = "ihp-log"; + version = "1.0.0"; + sha256 = "16s17nyxkpdj07sycyzhv6zk84kh4gwn9kb1hqd0wnfjlldb6zcr"; + libraryHaskellDepends = [ + base + bytestring + data-default + fast-logger + filepath + text + wai + wai-extra + ]; + description = "Lightweight logging for IHP applications"; + license = lib.licensesSpdx."MIT"; + } + ) { }; + + ihp-mail = callPackage ( + { + mkDerivation, + base, + blaze-html, + bytestring, + http-client, + http-client-tls, + ihp, + mime-mail, + mime-mail-ses, + network, + smtp-mail, + string-conversions, + text, + typerep-map, + }: + mkDerivation { + pname = "ihp-mail"; + version = "1.5.0"; + sha256 = "146vk72lpafh4irnzwpw3asz3vnk6gkvjm8d3jb84i6xpxi4yq6r"; + libraryHaskellDepends = [ + base + blaze-html + bytestring + http-client + http-client-tls + ihp + mime-mail + mime-mail-ses + network + smtp-mail + string-conversions + text + typerep-map + ]; + description = "Email support for IHP"; + license = lib.licensesSpdx."MIT"; + } + ) { }; + ihp-migrate = callPackage ( { mkDerivation, @@ -383346,6 +385534,35 @@ self: { } ) { }; + ihp-modal = callPackage ( + { + mkDerivation, + base, + blaze-html, + ihp-context, + ihp-hsx, + text, + vault, + wai, + }: + mkDerivation { + pname = "ihp-modal"; + version = "1.0.0"; + sha256 = "04al79xq7ydfly9xp0ziyvv5f3fm6v7zn6v0l960idgdw2y1q04a"; + libraryHaskellDepends = [ + base + blaze-html + ihp-context + ihp-hsx + text + vault + wai + ]; + description = "Modal dialog support for IHP applications"; + license = lib.licensesSpdx."MIT"; + } + ) { }; + ihp-openai = callPackage ( { mkDerivation, @@ -383365,8 +385582,8 @@ self: { }: mkDerivation { pname = "ihp-openai"; - version = "1.4.0"; - sha256 = "0npcnqdfmqv979gfn7iyl5p76hkggblc9n82z056wppj0i9q0i86"; + version = "1.5.0"; + sha256 = "10afra79rsfigb15qwn9wbvdsnw05whvvk8nj3pdb079vpsdkh47"; libraryHaskellDepends = [ aeson attoparsec-aeson @@ -383393,6 +385610,139 @@ self: { } ) { }; + ihp-pagehead = callPackage ( + { + mkDerivation, + base, + blaze-html, + ihp-context, + ihp-hsx, + text, + vault, + wai, + }: + mkDerivation { + pname = "ihp-pagehead"; + version = "1.0.0"; + sha256 = "16mk412prgr95fdbiz5zh3g8vvqwmjr1i1rdyhs8ach1q999gdlm"; + libraryHaskellDepends = [ + base + blaze-html + ihp-context + ihp-hsx + text + vault + wai + ]; + description = "Page title and meta tags for IHP"; + license = lib.licensesSpdx."MIT"; + } + ) { }; + + ihp-pglistener = callPackage ( + { + mkDerivation, + aeson, + async, + base, + bytestring, + containers, + hashable, + hasql, + hasql-notifications, + hspec, + ihp-log, + safe-exceptions, + string-conversions, + text, + unagi-chan, + unordered-containers, + uuid, + }: + mkDerivation { + pname = "ihp-pglistener"; + version = "1.0.0"; + sha256 = "1nmkhm08wyycw4rcgnywqbn5ldj7h36lc39jkqzscxvb9sb030sj"; + libraryHaskellDepends = [ + aeson + async + base + bytestring + containers + hashable + hasql + hasql-notifications + ihp-log + safe-exceptions + string-conversions + text + unagi-chan + unordered-containers + uuid + ]; + testHaskellDepends = [ + aeson + async + base + bytestring + containers + hashable + hasql + hasql-notifications + hspec + ihp-log + safe-exceptions + string-conversions + text + unagi-chan + unordered-containers + uuid + ]; + description = "PostgreSQL LISTEN/NOTIFY channel manager for IHP"; + license = lib.licensesSpdx."MIT"; + } + ) { }; + + ihp-postgres-parser = callPackage ( + { + mkDerivation, + base, + bytestring, + filepath, + hspec, + megaparsec, + parser-combinators, + string-conversions, + text, + }: + mkDerivation { + pname = "ihp-postgres-parser"; + version = "1.0.0"; + sha256 = "0w4077h4wxm6qnjghcv6r0rfr8vnl4ki9m7mghd4bi8xah156lpp"; + libraryHaskellDepends = [ + base + bytestring + filepath + megaparsec + parser-combinators + string-conversions + text + ]; + testHaskellDepends = [ + base + bytestring + filepath + hspec + megaparsec + parser-combinators + string-conversions + text + ]; + description = "PostgreSQL DDL parser and compiler"; + license = lib.licensesSpdx."MIT"; + } + ) { }; + ihp-postgresql-simple-extra = callPackage ( { mkDerivation, @@ -383446,6 +385796,251 @@ self: { } ) { }; + ihp-schema-compiler = callPackage ( + { + mkDerivation, + base, + bytestring, + classy-prelude, + countable-inflections, + directory, + filepath, + ihp, + ihp-postgres-parser, + interpolate, + neat-interpolation, + split, + string-conversions, + text, + with-utf8, + }: + mkDerivation { + pname = "ihp-schema-compiler"; + version = "1.5.0"; + sha256 = "1lxfm0fgmg69hjmw3vdv2id9idyqjj1py60p7rlkafwwv0barcp6"; + isLibrary = true; + isExecutable = true; + enableSeparateDataOutput = true; + libraryHaskellDepends = [ + base + bytestring + classy-prelude + countable-inflections + directory + filepath + ihp + ihp-postgres-parser + interpolate + neat-interpolation + split + string-conversions + text + with-utf8 + ]; + executableHaskellDepends = [ + base + bytestring + classy-prelude + countable-inflections + directory + filepath + ihp + ihp-postgres-parser + interpolate + neat-interpolation + split + string-conversions + text + with-utf8 + ]; + description = "Lightweight schema compiler for IHP"; + license = lib.licensesSpdx."MIT"; + mainProgram = "build-generated-code"; + } + ) { }; + + ihp-sitemap = callPackage ( + { + mkDerivation, + base, + blaze-html, + blaze-markup, + hspec, + http-types, + ihp, + ihp-hsx, + ihp-log, + text, + wai, + wai-extra, + }: + mkDerivation { + pname = "ihp-sitemap"; + version = "1.5.0"; + sha256 = "1smkd53n6dkh9da4ns8ay2jjbnmi0vfxbc63sr9vc0wv3gwd5rzc"; + libraryHaskellDepends = [ + base + blaze-html + blaze-markup + ihp + text + wai + ]; + testHaskellDepends = [ + base + hspec + http-types + ihp + ihp-hsx + ihp-log + wai + wai-extra + ]; + description = "SEO"; + license = lib.licensesSpdx."MIT"; + } + ) { }; + + ihp-ssc = callPackage ( + { + mkDerivation, + aeson, + attoparsec, + base, + basic-prelude, + blaze-html, + bytestring, + ihp, + ihp-hsx, + ihp-log, + megaparsec, + string-conversions, + text, + wai, + wai-request-params, + websockets, + }: + mkDerivation { + pname = "ihp-ssc"; + version = "1.5.0"; + sha256 = "12haf557kg6r407rr10h841yhc6cfm29ipjgg6qh7sd9wn78s40x"; + libraryHaskellDepends = [ + aeson + attoparsec + base + basic-prelude + blaze-html + bytestring + ihp + ihp-hsx + ihp-log + megaparsec + string-conversions + text + wai + wai-request-params + websockets + ]; + description = "Server Side Components for IHP"; + license = lib.licensesSpdx."MIT"; + } + ) { }; + + ihp-typed-sql = callPackage ( + { + mkDerivation, + aeson, + base, + bytestring, + containers, + directory, + filepath, + haskell-src-meta, + hasql, + hasql-dynamic-statements, + hasql-mapping, + hasql-pool, + hspec, + ihp, + ihp-log, + postgresql-libpq, + postgresql-syntax, + postgresql-types, + process, + scientific, + string-conversions, + template-haskell, + temporary, + text, + }: + mkDerivation { + pname = "ihp-typed-sql"; + version = "1.5.0"; + sha256 = "0l431b3908mm81v9c376xwf0ak7zbbb47rk93k64n5nixql0l639"; + libraryHaskellDepends = [ + aeson + base + bytestring + containers + haskell-src-meta + hasql + hasql-dynamic-statements + hasql-mapping + hasql-pool + ihp + postgresql-libpq + postgresql-syntax + postgresql-types + scientific + string-conversions + template-haskell + text + ]; + testHaskellDepends = [ + base + containers + directory + filepath + hspec + ihp + ihp-log + process + string-conversions + temporary + text + ]; + description = "Compile-time typed SQL quasiquoter for IHP"; + license = lib.licensesSpdx."MIT"; + } + ) { }; + + ihp-welcome = callPackage ( + { + mkDerivation, + base, + blaze-html, + blaze-markup, + ihp, + ihp-hsx, + text, + }: + mkDerivation { + pname = "ihp-welcome"; + version = "1.5.0"; + sha256 = "1rnplvsm13y3y5bsm5lpcx4ifmr9jgzz7rhg69lah3nhxy5sym19"; + libraryHaskellDepends = [ + base + blaze-html + blaze-markup + ihp + ihp-hsx + text + ]; + description = "IHP Welcome Controller"; + license = lib.licensesSpdx."MIT"; + } + ) { }; + ihs = callPackage ( { mkDerivation, @@ -392319,8 +394914,8 @@ self: { pname = "io-sim"; version = "1.10.0.0"; sha256 = "02gk2xgiv9mrl1cvwqabi8rki7w15cj23s65h0qmw1dyf29rbb9q"; - revision = "1"; - editedCabalFile = "1qmnvisf3r4n2ji4z0k3fskbwk8ys9p84mrhapa8ymsray2ccwz4"; + revision = "2"; + editedCabalFile = "14cqb4h00a80k4fvgpv5plzriyr17xa6pdgg369h0n1xbjssjr90"; libraryHaskellDepends = [ base containers @@ -394590,6 +397185,31 @@ self: { } ) { }; + is-list = callPackage ( + { + mkDerivation, + base, + containers, + hashable, + lens, + unordered-containers, + }: + mkDerivation { + pname = "is-list"; + version = "0.0.3"; + sha256 = "15dm24zbjd2dmhr6vnj9389svjj9arccahvds30lcvzc7fbq331s"; + libraryHaskellDepends = [ + base + containers + hashable + lens + unordered-containers + ]; + description = "Fix IsList"; + license = lib.licenses.bsd3; + } + ) { }; + isbn = callPackage ( { mkDerivation, @@ -396939,8 +399559,8 @@ self: { }: mkDerivation { pname = "jacinda"; - version = "3.3.0.5"; - sha256 = "0msadmd9d7syjzr2lnxfa2gsplwdc17kgdxrh61h6i0k9crlgbdp"; + version = "3.3.0.6"; + sha256 = "0jc1hsq7fh4nbdhr36pzzl5gc5sqzqizjw29y26hf95mrk8avpfk"; isLibrary = false; isExecutable = true; enableSeparateDataOutput = true; @@ -400532,6 +403152,75 @@ self: { } ) { }; + jsaddle_0_9_9_4 = callPackage ( + { + mkDerivation, + aeson, + attoparsec, + base, + base-compat, + base64-bytestring, + bytestring, + containers, + deepseq, + exceptions, + filepath, + ghc-prim, + http-types, + kan-extensions, + lens, + primitive, + process, + random, + ref-tf, + scientific, + stm, + text, + time, + transformers, + unliftio-core, + unordered-containers, + vector, + }: + mkDerivation { + pname = "jsaddle"; + version = "0.9.9.4"; + sha256 = "0a27sb18yx0j7kby4f79wr7djr0l37y3607qfl82w52sbncp5fd1"; + libraryHaskellDepends = [ + aeson + attoparsec + base + base-compat + base64-bytestring + bytestring + containers + deepseq + exceptions + filepath + ghc-prim + http-types + kan-extensions + lens + primitive + process + random + ref-tf + scientific + stm + text + time + transformers + unliftio-core + unordered-containers + vector + ]; + description = "Interface for JavaScript that works with GHCJS and GHC"; + license = lib.licenses.mit; + hydraPlatforms = lib.platforms.none; + maintainers = [ lib.maintainers.alexfmpe ]; + } + ) { }; + jsaddle-clib = callPackage ( { mkDerivation, @@ -400545,8 +403234,8 @@ self: { }: mkDerivation { pname = "jsaddle-clib"; - version = "0.9.9.3"; - sha256 = "08l6a8yvkcngcz6sv8smwpbd9j0a0xxnw3s7dwix1mww0ghq0zfd"; + version = "0.9.9.4"; + sha256 = "0a9afqwshqrxqb1clznbbar8431blkmb7yvd2xmnvy8vp9l362h5"; libraryHaskellDepends = [ aeson base @@ -400592,6 +403281,37 @@ self: { } ) { }; + jsaddle-dom_0_9_9_3 = callPackage ( + { + mkDerivation, + base, + base-compat, + exceptions, + jsaddle, + lens, + text, + transformers, + }: + mkDerivation { + pname = "jsaddle-dom"; + version = "0.9.9.3"; + sha256 = "04ywzmbzd54v94g7wgh5qpzz5jipl1wp3diqdkd9898y4ql1bggb"; + libraryHaskellDepends = [ + base + base-compat + exceptions + jsaddle + lens + text + transformers + ]; + description = "DOM library that uses jsaddle to support both GHCJS and GHC"; + license = lib.licensesSpdx."MIT"; + hydraPlatforms = lib.platforms.none; + maintainers = [ lib.maintainers.alexfmpe ]; + } + ) { }; + jsaddle-hello = callPackage ( { mkDerivation, @@ -400695,6 +403415,75 @@ self: { } ) { }; + jsaddle-warp_0_9_9_6 = callPackage ( + { + mkDerivation, + aeson, + base, + bytestring, + containers, + directory, + foreign-store, + hspec, + http-types, + jsaddle, + lens, + mtl, + process, + stm, + text, + time, + transformers, + wai, + wai-websockets, + warp, + websockets, + }: + mkDerivation { + pname = "jsaddle-warp"; + version = "0.9.9.6"; + sha256 = "05dwhshnhdw4k1ccp1sr630pxps19n9vjrrzf5jn2r9vr75vn48j"; + enableSeparateDataOutput = true; + libraryHaskellDepends = [ + aeson + base + bytestring + containers + foreign-store + http-types + jsaddle + stm + text + time + transformers + wai + wai-websockets + warp + websockets + ]; + testHaskellDepends = [ + base + bytestring + directory + hspec + jsaddle + lens + mtl + process + text + warp + websockets + ]; + description = "Interface for JavaScript that works with GHCJS and GHC"; + license = lib.licensesSpdx."MIT"; + hydraPlatforms = lib.platforms.none; + maintainers = [ + lib.maintainers.alexfmpe + lib.maintainers.maralorn + ]; + } + ) { }; + jsaddle-wasm = callPackage ( { mkDerivation, @@ -407623,8 +410412,8 @@ self: { }: mkDerivation { pname = "kb-text-shape"; - version = "0.1.0.0"; - sha256 = "1kgqpnbfxg30dawg5dkfv4i6chaf4zr29g4iq2cwcqz3qd1sp7as"; + version = "0.1.0.1"; + sha256 = "0pd6wffy7mi9gsj0faydyp30lfg39yv5vrpgp5rpmi0bjb6n8fvr"; libraryHaskellDepends = [ base bytestring @@ -409508,7 +412297,7 @@ self: { } ) { }; - keter_2_3_2 = callPackage ( + keter_2_3_3 = callPackage ( { mkDerivation, aeson, @@ -409570,8 +412359,8 @@ self: { }: mkDerivation { pname = "keter"; - version = "2.3.2"; - sha256 = "01m5pqrfyznmmc4ms94dqpgnsrl5b0mf4ihmnljr2bvnknp2dk7v"; + version = "2.3.3"; + sha256 = "1538641m3c74mgz8p2jsypiw258h94rhcdjrzkll4b7af8z3q4yy"; isLibrary = true; isExecutable = true; libraryHaskellDepends = [ @@ -412694,6 +415483,41 @@ self: { } ) { }; + ktx-font = callPackage ( + { + mkDerivation, + aeson, + base, + bytestring, + containers, + kb-text-shape, + ktx-codec, + msdf-atlas, + text, + vector, + zstd, + }: + mkDerivation { + pname = "ktx-font"; + version = "0.1.0.1"; + sha256 = "0i0dqa6dq8jcpv17x54r1v5k91w70xwqz7hf3y87av4gann9n5h6"; + libraryHaskellDepends = [ + aeson + base + bytestring + containers + kb-text-shape + ktx-codec + msdf-atlas + text + vector + zstd + ]; + description = "GPU-ready rasterized fonts"; + license = lib.licensesSpdx."BSD-3-Clause"; + } + ) { }; + kubernetes-api = callPackage ( { mkDerivation, @@ -413870,6 +416694,37 @@ self: { } ) { }; + lager = callPackage ( + { + mkDerivation, + async, + base, + prettyprinter, + prettyprinter-ansi-terminal, + stm, + text, + }: + mkDerivation { + pname = "lager"; + version = "1.0.0.0"; + sha256 = "1cfsq5ap8lwsq9s4qppp9vag5w9wqvaw9nhiq4xl0hbj6756z924"; + libraryHaskellDepends = [ + async + base + prettyprinter + prettyprinter-ansi-terminal + stm + text + ]; + testHaskellDepends = [ + async + base + ]; + description = "Concurrent logging"; + license = lib.licensesSpdx."MIT"; + } + ) { }; + lagrangian = callPackage ( { mkDerivation, @@ -425783,8 +428638,8 @@ self: { { mkDerivation, zlib-clib }: mkDerivation { pname = "libarchive-clib"; - version = "3.8.5"; - sha256 = "0v2l84ay1mhc4b86ddzyk0fl2ahc4y2fnkw8jyvzdia4g2mg08jr"; + version = "3.8.6.2"; + sha256 = "1yx7j413x3wkjwkq7bjglc8rz9xfsx253mw6r9gxdb51721via0q"; libraryHaskellDepends = [ zlib-clib ]; doHaddock = false; description = "Haskell interface to libarchive (C sources)"; @@ -431360,6 +434215,42 @@ self: { } ) { }; + link-canonical-effectful = callPackage ( + { + mkDerivation, + base, + containers, + effectful-core, + http-types, + link-canonical, + modern-uri, + tasty, + tasty-hunit, + }: + mkDerivation { + pname = "link-canonical-effectful"; + version = "0.1.0.0"; + sha256 = "1h4xiv0vbbam0v8cny7i5inqiq5k62kj25jagbxj5bmgasb4bjbp"; + libraryHaskellDepends = [ + base + effectful-core + link-canonical + modern-uri + ]; + testHaskellDepends = [ + base + containers + effectful-core + http-types + link-canonical + tasty + tasty-hunit + ]; + description = "Effectful integration for link-canonical"; + license = lib.licensesSpdx."MIT"; + } + ) { }; + link-relations = callPackage ( { mkDerivation, @@ -441065,6 +443956,8 @@ self: { pname = "lsm-tree"; version = "1.0.0.1"; sha256 = "1b7w7w4i9ylsvi7ww5d9xry0r2gpr7i17r79fpizpgv11rz2lzvh"; + revision = "1"; + editedCabalFile = "0afrhwz2x7046554cdi4bkw747057pv06hdyz4vsnqwr369a0fnh"; libraryHaskellDepends = [ base binary @@ -453693,10 +456586,8 @@ self: { }: mkDerivation { pname = "megastore"; - version = "0.1.1.1"; - sha256 = "0i34jla7v5fsqcnpy8h7iqy413p6qcqnc1z1yi933kdwsh6srdyj"; - isLibrary = true; - isExecutable = true; + version = "0.1.1.2"; + sha256 = "1ssl3yfjj7pa03nmzjjqjmz3jfrhy2pv1mp0r7g63mllk43h3jvk"; libraryHaskellDepends = [ adjunctions base @@ -453715,28 +456606,9 @@ self: { vector zlib ]; - executableHaskellDepends = [ - adjunctions - base - binary - bytestring - containers - directory - ghc - hashable - JuicyPixels - lens - mtl - random - text - text-show - vector - zlib - ]; description = "Bulk image or strict bytestring storage"; license = lib.licenses.bsd3; hydraPlatforms = lib.platforms.none; - mainProgram = "megastore"; broken = true; } ) { }; @@ -458744,8 +461616,8 @@ self: { }: mkDerivation { pname = "mighttpd2"; - version = "4.0.9"; - sha256 = "1qd43hlyvhnslxrvy4h0rj5qs6nbxnz8d23myqjspa9jl8rzb1bg"; + version = "4.0.10"; + sha256 = "1nsphcg0fc1mc56d27b96ba9ds6lddngzcbca9zm65w5fikzj4km"; isLibrary = true; isExecutable = true; enableSeparateDataOutput = true; @@ -462023,14 +464895,14 @@ self: { mkDerivation, aeson, base, - basement, bytestring, criterion, - cryptonite, + crypton, deepseq, directory, - memory, + primitive, process, + ram, tasty, tasty-hunit, tasty-quickcheck, @@ -462039,27 +464911,25 @@ self: { }: mkDerivation { pname = "mlkem"; - version = "0.1.1.0"; - sha256 = "1l77dqysiq797ci3168z708qz7i986yvmvisssfdr36rwnsz7nrl"; - revision = "1"; - editedCabalFile = "18nzz4gg1cb2275k3qqfi3y9d05kfm9fqh4z4aarliv6hbs0nvvd"; + version = "0.2.0.0"; + sha256 = "0ryq0mwlics4kqjqh05y33y4qmj2j2z0r4p2jaw6mhs41qyj346z"; libraryHaskellDepends = [ base - basement - cryptonite + crypton deepseq - memory + primitive + ram ]; testHaskellDepends = [ aeson base - basement bytestring - cryptonite + crypton deepseq directory - memory + primitive process + ram tasty tasty-hunit tasty-quickcheck @@ -462068,11 +464938,11 @@ self: { ]; benchmarkHaskellDepends = [ base - basement criterion - cryptonite + crypton deepseq - memory + primitive + ram ]; description = "Module-Lattice-based Key-Encapsulation Mechanism"; license = lib.licensesSpdx."BSD-3-Clause"; @@ -462925,8 +465795,8 @@ self: { }: mkDerivation { pname = "mmzk-env"; - version = "0.2.1.0"; - sha256 = "0fxilcn5y4fvafq681jphagirm6kk94f3i6rdxjxfam1d8sv4r4r"; + version = "0.3.0.0"; + sha256 = "013yw7n4jjsdmh29kbd73fggbi7r4jkx5qwhl60d4xddhylcls16"; isLibrary = true; isExecutable = true; libraryHaskellDepends = [ @@ -462973,8 +465843,8 @@ self: { }: mkDerivation { pname = "mmzk-typeid"; - version = "0.7.0.2"; - sha256 = "0zkyxyzc4dgp3d7jr806jwplagw7m0y0pjysagcw9b76lrw229r5"; + version = "0.7.1.0"; + sha256 = "1jvxkdvah8xip4q7mf66hx6vaa9hcv3417y5bmwaz1lmai4ngzv1"; libraryHaskellDepends = [ aeson array @@ -465514,6 +468384,7 @@ self: { lens, monad-effect, monad-logger, + optparse-applicative, primitive, stm, template-haskell, @@ -465522,8 +468393,8 @@ self: { }: mkDerivation { pname = "monad-effect-logging"; - version = "0.1.0.0"; - sha256 = "1xaaa76icrm39c6xw7y8gamajsa2q480f6djml32jgy6zq7q876a"; + version = "0.3.0.0"; + sha256 = "18dgyzy277ncwyyj9img188qnyc5hf7h03lbw8zql682aa6nqj5b"; libraryHaskellDepends = [ aeson base @@ -465533,6 +468404,7 @@ self: { lens monad-effect monad-logger + optparse-applicative primitive stm template-haskell @@ -466912,6 +469784,43 @@ self: { } ) { }; + monad-rail = callPackage ( + { + mkDerivation, + aeson, + base, + bytestring, + hspec, + hspec-discover, + mtl, + QuickCheck, + text, + }: + mkDerivation { + pname = "monad-rail"; + version = "0.1.0.0"; + sha256 = "1ww8l7cq6chjrz0bf0vmcz59ykb8qrg7cbg9cl6rfk503rz20idi"; + libraryHaskellDepends = [ + aeson + base + mtl + text + ]; + testHaskellDepends = [ + aeson + base + bytestring + hspec + mtl + QuickCheck + text + ]; + testToolDepends = [ hspec-discover ]; + description = "Railway-oriented error handling for Haskell"; + license = lib.licensesSpdx."BSD-3-Clause"; + } + ) { }; + monad-ran = callPackage ( { mkDerivation, @@ -467406,8 +470315,8 @@ self: { }: mkDerivation { pname = "monad-time-effectful"; - version = "1.0.0.0"; - sha256 = "1gxmgr8vrpdncrnw9q5i3vqbi7llrah34gpfyq3qcb15sqi44gk9"; + version = "1.0.1.0"; + sha256 = "166y7g9g0ycdcpxrw42m9k3p9dvlgkcrgymmi897kc6fxwrq92kn"; libraryHaskellDepends = [ base effectful-core @@ -473935,8 +476844,8 @@ self: { }: mkDerivation { pname = "msdf-atlas"; - version = "0.1.0.0"; - sha256 = "1kc2hirz07rrz1wfarpfzw3vcyihndwj84jjjy0scki211qbhxzc"; + version = "0.1.1.0"; + sha256 = "0c2s6jp0lbh8mrnl62cwvjkqhyv348igh79w7iw0dv6jfjrix9h4"; libraryHaskellDepends = [ aeson base @@ -480355,7 +483264,6 @@ self: { filepath, http-types, io-streams, - memory, monad-loops, network, pem, @@ -480377,8 +483285,8 @@ self: { }: mkDerivation { pname = "mysql-haskell"; - version = "1.2.0"; - sha256 = "1ilqva74p8kl2x5pb1wf8bv3pb3f0k5njjzd2pa90lzy812w5h2g"; + version = "1.2.1"; + sha256 = "0liw714g0jp4www7jp3v6ngsazi3fvbi685lgg49w7zm5yvfxlha"; libraryHaskellDepends = [ base binary @@ -480392,7 +483300,6 @@ self: { data-default-class deepseq io-streams - memory monad-loops network pem @@ -489869,8 +492776,8 @@ self: { }: mkDerivation { pname = "ngx-export"; - version = "1.7.11"; - sha256 = "1r8cj7hqyfnadcq2lyh16bczfcv3c2cpw63hyxdzkfg315yjnhmb"; + version = "1.7.11.1"; + sha256 = "1p98r1y1g54lyzgl53kj186087pdh7l1p3fs56dd66mrjs969fdq"; libraryHaskellDepends = [ async base @@ -490047,7 +492954,6 @@ self: { { mkDerivation, aeson, - array, async, base, base64, @@ -490069,7 +492975,6 @@ self: { pcre-light, prettyprinter, resolv, - safe, safe-exceptions, snap-core, snap-server, @@ -490081,11 +492986,10 @@ self: { }: mkDerivation { pname = "ngx-export-tools-extra"; - version = "1.2.12.2"; - sha256 = "1k37qdi1mp3b1qxyv7fxdn9i3b1r7hd8991588zjywakdsnk9y2w"; + version = "1.2.13"; + sha256 = "1rr4if1b8fj2154jkp3khx874khka1ym1zfsgfybifpnxgjwpqs1"; libraryHaskellDepends = [ aeson - array async base base64 @@ -490107,7 +493011,6 @@ self: { pcre-light prettyprinter resolv - safe safe-exceptions snap-core snap-server @@ -494558,8 +497461,8 @@ self: { }: mkDerivation { pname = "nova-cache"; - version = "0.3.1.0"; - sha256 = "1ir4xd3x92cs84yavlv0sk32qrw86bv83c13nbhxnkczcswx7ynn"; + version = "0.3.2.1"; + sha256 = "13k4g6msfcf40hizba1sdl4h59839jajs909phcn0h6yhw2v3cn9"; isLibrary = true; isExecutable = true; libraryHaskellDepends = [ @@ -494607,8 +497510,8 @@ self: { }: mkDerivation { pname = "nova-net"; - version = "0.1.0.0"; - sha256 = "0qjpzvs9ldbkyqgzg7vsq0k8wl7k9gv36vbn0x5kc32g4nq0rrmg"; + version = "0.3.0.0"; + sha256 = "00ybcyrz0b7jh2izqnihn1lxq1hk6m7hn2rc0cyhnzfp8lpflqn7"; libraryHaskellDepends = [ base bytestring @@ -494622,6 +497525,8 @@ self: { testHaskellDepends = [ base bytestring + containers + network QuickCheck ]; benchmarkHaskellDepends = [ @@ -499183,7 +502088,7 @@ self: { text, time, transformers, - unixodbc, + unixODBC, unliftio-core, weigh, }: @@ -499210,7 +502115,7 @@ self: { transformers unliftio-core ]; - librarySystemDepends = [ unixodbc ]; + librarySystemDepends = [ unixODBC ]; executableHaskellDepends = [ base bytestring @@ -499237,7 +502142,7 @@ self: { license = lib.licenses.bsd3; mainProgram = "odbc"; } - ) { inherit (pkgs) unixodbc; }; + ) { unixODBC = null; }; odd-jobs = callPackage ( { @@ -499571,6 +502476,45 @@ self: { } ) { }; + oeis_0_3_10_2 = callPackage ( + { + mkDerivation, + base, + http-client, + http-client-tls, + http-types, + HUnit, + network, + network-uri, + test-framework, + test-framework-hunit, + utf8-string, + }: + mkDerivation { + pname = "oeis"; + version = "0.3.10.2"; + sha256 = "1bmalcq0jp8nqx7gp0h0bz6sps978lddmwkk193sic42m2lkngqc"; + libraryHaskellDepends = [ + base + http-client + http-client-tls + http-types + network + network-uri + utf8-string + ]; + testHaskellDepends = [ + base + HUnit + test-framework + test-framework-hunit + ]; + description = "Interface to the Online Encyclopedia of Integer Sequences (OEIS)"; + license = lib.licenses.bsd3; + hydraPlatforms = lib.platforms.none; + } + ) { }; + oeis2 = callPackage ( { mkDerivation, @@ -499708,7 +502652,7 @@ self: { } ) { }; - ogma-cli_1_12_0 = callPackage ( + ogma-cli_1_13_0 = callPackage ( { mkDerivation, aeson, @@ -499725,8 +502669,8 @@ self: { }: mkDerivation { pname = "ogma-cli"; - version = "1.12.0"; - sha256 = "1qj6lvjdcj77gfzyavr8rf4g2ywfq4maq38m9xvl7mqa9as235d2"; + version = "1.13.0"; + sha256 = "07x7ac06pji09fsv7z0r5a7zp9v789gx1jmza3ccj1l1qjaxgkk5"; isLibrary = false; isExecutable = true; executableHaskellDepends = [ @@ -499824,16 +502768,20 @@ self: { } ) { }; - ogma-core_1_12_0 = callPackage ( + ogma-core_1_13_0 = callPackage ( { mkDerivation, aeson, base, bytestring, containers, + copilot-core, + copilot-language, + copilot-theorem, directory, filepath, graphviz, + hint, HUnit, megaparsec, mtl, @@ -499856,17 +502804,21 @@ self: { }: mkDerivation { pname = "ogma-core"; - version = "1.12.0"; - sha256 = "1pg9ikal0dd6b7kxs3rxbcv0hfiqb32lazzihpvivyngybb3wh3b"; + version = "1.13.0"; + sha256 = "05pg97plq3nwv5x1qsfi4hy7zcwm4680nyz7an2n82ggdj8dagc9"; enableSeparateDataOutput = true; libraryHaskellDepends = [ aeson base bytestring containers + copilot-core + copilot-language + copilot-theorem directory filepath graphviz + hint megaparsec mtl ogma-extra @@ -499937,7 +502889,7 @@ self: { } ) { }; - ogma-extra_1_12_0 = callPackage ( + ogma-extra_1_13_0 = callPackage ( { mkDerivation, aeson, @@ -499954,8 +502906,8 @@ self: { }: mkDerivation { pname = "ogma-extra"; - version = "1.12.0"; - sha256 = "0qkxnmhb2lj0g5vi7bwybib56m3p4malqiiwgv8jqc1p7c4j7phg"; + version = "1.13.0"; + sha256 = "02nzxh64sjzx18q372rj9vg4q1gwxwxk7ni1dd1xkdfpnxrfskj2"; libraryHaskellDepends = [ aeson base @@ -500021,7 +502973,7 @@ self: { } ) { }; - ogma-language-c_1_12_0 = callPackage ( + ogma-language-c_1_13_0 = callPackage ( { mkDerivation, alex, @@ -500037,8 +502989,8 @@ self: { }: mkDerivation { pname = "ogma-language-c"; - version = "1.12.0"; - sha256 = "07wgqwp0lmmj3klfn0kzhzkr8b2f74ffi1g9hdrzfd38dax0lccz"; + version = "1.13.0"; + sha256 = "10r06yl8pygnahzv3cf9j31f22l1jfbrcwba222x3m7gx6q5dsxk"; setupHaskellDepends = [ base Cabal @@ -500116,12 +503068,12 @@ self: { } ) { }; - ogma-language-copilot_1_12_0 = callPackage ( + ogma-language-copilot_1_13_0 = callPackage ( { mkDerivation, base }: mkDerivation { pname = "ogma-language-copilot"; - version = "1.12.0"; - sha256 = "1xcjf704lmwi94f4gbq1a9fcllphkqhv28kwgxsskazwkb65ql7z"; + version = "1.13.0"; + sha256 = "1ibaf4ic2yc3i9mhg0f97iyvxxqwws8h5x5n6r8n8wmsrn7k9isp"; libraryHaskellDepends = [ base ]; description = "Ogma: Runtime Monitor translator: Copilot Language Endpoints"; license = lib.licenses.asl20; @@ -500158,7 +503110,7 @@ self: { } ) { }; - ogma-language-csv_1_12_0 = callPackage ( + ogma-language-csv_1_13_0 = callPackage ( { mkDerivation, base, @@ -500171,8 +503123,8 @@ self: { }: mkDerivation { pname = "ogma-language-csv"; - version = "1.12.0"; - sha256 = "0cwfzpnlb1m9vphkzq3w7mxkby6vp1cda9iaz62364khglixzk61"; + version = "1.13.0"; + sha256 = "0zx4wawgngr6377x3a288pmlbbgi6nvq15lfpx49qc46ys8af05c"; libraryHaskellDepends = [ base bytestring @@ -500293,7 +503245,7 @@ self: { } ) { }; - ogma-language-jsonspec_1_12_0 = callPackage ( + ogma-language-jsonspec_1_13_0 = callPackage ( { mkDerivation, aeson, @@ -500307,8 +503259,8 @@ self: { }: mkDerivation { pname = "ogma-language-jsonspec"; - version = "1.12.0"; - sha256 = "1hr7a7pjwm52njnrg8ps9pwqgq88ls3vsr0nms49lz92xlnx150x"; + version = "1.13.0"; + sha256 = "0gjbn5ggpjirx2hfy8w77y0pfcpjsjmbmvdk9sx24ma1wbmbg34b"; libraryHaskellDepends = [ aeson base @@ -500368,7 +503320,7 @@ self: { } ) { }; - ogma-language-lustre_1_12_0 = callPackage ( + ogma-language-lustre_1_13_0 = callPackage ( { mkDerivation, alex, @@ -500384,8 +503336,8 @@ self: { }: mkDerivation { pname = "ogma-language-lustre"; - version = "1.12.0"; - sha256 = "0rw6nd91lwjd8mx79vx1fd9k7lv520x7ii8a8j3acgpmg736x5cc"; + version = "1.13.0"; + sha256 = "1f260y8qwqvx9ny9jjpkc7xhyhi89zk413kjabz7c7nsrlqb07y3"; setupHaskellDepends = [ base Cabal @@ -500455,7 +503407,7 @@ self: { } ) { }; - ogma-language-smv_1_12_0 = callPackage ( + ogma-language-smv_1_13_0 = callPackage ( { mkDerivation, alex, @@ -500471,8 +503423,8 @@ self: { }: mkDerivation { pname = "ogma-language-smv"; - version = "1.12.0"; - sha256 = "0xw93x9i2xdydwmnbm55jjx1l7ibavr5bd9dkamyhwanc3mr828x"; + version = "1.13.0"; + sha256 = "0l1ikxp8dasjlx16s8xmii1d1qla88hk03wdi5jlhxz9zgs25khs"; setupHaskellDepends = [ base Cabal @@ -500524,7 +503476,7 @@ self: { } ) { }; - ogma-language-xlsx_1_12_0 = callPackage ( + ogma-language-xlsx_1_13_0 = callPackage ( { mkDerivation, base, @@ -500535,8 +503487,8 @@ self: { }: mkDerivation { pname = "ogma-language-xlsx"; - version = "1.12.0"; - sha256 = "1y4nwwaqqsr2dsw5zixvfjqfphhbxmacdid6z6kw16lng7dwksfg"; + version = "1.13.0"; + sha256 = "0v9m2fzi5crl7scwscpxf3y7spq7qx97jl34hc605xl4dgg1s2wm"; libraryHaskellDepends = [ base bytestring @@ -500579,7 +503531,7 @@ self: { } ) { }; - ogma-language-xmlspec_1_12_0 = callPackage ( + ogma-language-xmlspec_1_13_0 = callPackage ( { mkDerivation, base, @@ -500592,8 +503544,8 @@ self: { }: mkDerivation { pname = "ogma-language-xmlspec"; - version = "1.12.0"; - sha256 = "0p6dzvy445330zl1kiz46jfd6kapkvaddsl6sp549d3zd29db2rr"; + version = "1.13.0"; + sha256 = "198p0910rgs0bgwz7n3v3h05yx91h22np2hdhxvr4rv8mdx5iznk"; libraryHaskellDepends = [ base hxt @@ -500621,12 +503573,12 @@ self: { } ) { }; - ogma-spec_1_12_0 = callPackage ( + ogma-spec_1_13_0 = callPackage ( { mkDerivation, base }: mkDerivation { pname = "ogma-spec"; - version = "1.12.0"; - sha256 = "1da8sq40zj22grc34qfnlchys70ai3n5plfjq1b8w47x83cww51q"; + version = "1.13.0"; + sha256 = "0f1yr25391mdchk0m06ybwpsjhw2bmmc5bmljr6gj6abz4vvxsrd"; libraryHaskellDepends = [ base ]; description = "Ogma: Runtime Monitor translator: JSON Frontend"; license = lib.licenses.asl20; @@ -502166,6 +505118,42 @@ self: { } ) { }; + one = callPackage ( + { + mkDerivation, + base, + bytestring, + containers, + doctest, + hashable, + lens, + process, + text, + unordered-containers, + }: + mkDerivation { + pname = "one"; + version = "0.0.1"; + sha256 = "13a97d6d76ahw29gg26yw2jdc4vh6wk1swqziczmyjn3i2hfr72l"; + libraryHaskellDepends = [ + base + bytestring + containers + hashable + lens + text + unordered-containers + ]; + testHaskellDepends = [ + base + process + ]; + testToolDepends = [ doctest ]; + description = "One"; + license = lib.licensesSpdx."BSD-3-Clause"; + } + ) { }; + one-line-aeson-text = callPackage ( { mkDerivation, @@ -502239,6 +505227,8 @@ self: { pname = "one-liner-instances"; version = "0.1.3.0"; sha256 = "0qkvbrxgnr51a0hdd2ap6fndipgfplsdy4lh841h8hda5d4dhabg"; + revision = "1"; + editedCabalFile = "1qwc28z55vqhyr04l0imsb7s3dzaa35rmsi9mfs8jmyz4d92808n"; libraryHaskellDepends = [ base one-liner @@ -504000,8 +506990,8 @@ self: { }: mkDerivation { pname = "opencascade-hs"; - version = "0.6.1.0"; - sha256 = "16ird3yvscnjfnpfjxsvzlc7g2h7frylw7dqqf10xr2d0hx1icpw"; + version = "0.6.2.0"; + sha256 = "09921dkzba0kinh3dficw0apa7q4wxhj6kmcj1al1gwpbrpnf1kc"; libraryHaskellDepends = [ base resourcet @@ -506712,7 +509702,7 @@ self: { } ) { }; - opt-env-conf_0_13_0_0 = callPackage ( + opt-env-conf_0_15_0_1 = callPackage ( { mkDerivation, aeson, @@ -506737,8 +509727,8 @@ self: { }: mkDerivation { pname = "opt-env-conf"; - version = "0.13.0.0"; - sha256 = "0s7g5h3z0if85pgxcm1dshyqhnsrvjvfwgdf65jyhdhmnlkxws4a"; + version = "0.15.0.1"; + sha256 = "15d6vn1c9ci26h9jh9ghw0m45j890y9kh4y140rs0gda8hxa6nq7"; libraryHaskellDepends = [ aeson autodocodec @@ -512768,7 +515758,7 @@ self: { } ) { }; - pandoc_3_9 = callPackage ( + pandoc_3_9_0_2 = callPackage ( { mkDerivation, aeson, @@ -512855,8 +515845,8 @@ self: { }: mkDerivation { pname = "pandoc"; - version = "3.9"; - sha256 = "0y8nr10lmp0bsx2lsr8lcnlw8aj15fq9zq5bpfx0h1sd5z74932s"; + version = "3.9.0.2"; + sha256 = "0v1b3n9sn25kblhnzn1p0l5pv0raj93byx75jqbssnj854qshik4"; configureFlags = [ "-f-trypandoc" ]; enableSeparateDataOutput = true; libraryHaskellDepends = [ @@ -513187,7 +516177,7 @@ self: { } ) { }; - pandoc-cli_3_9 = callPackage ( + pandoc-cli_3_9_0_2 = callPackage ( { mkDerivation, base, @@ -513203,8 +516193,8 @@ self: { }: mkDerivation { pname = "pandoc-cli"; - version = "3.9"; - sha256 = "1a94m8hdljqjh19753qph75xikd1y3bl79i1bbbi5vx07p2h0vnx"; + version = "3.9.0.2"; + sha256 = "084q8f3y9p2a4vjaqir56r35fjb277i6pkwn1kl3r7xgqjw3a1bj"; isLibrary = false; isExecutable = true; executableHaskellDepends = [ @@ -514099,7 +517089,7 @@ self: { } ) { }; - pandoc-lua-engine_0_5_1 = callPackage ( + pandoc-lua-engine_0_5_2 = callPackage ( { mkDerivation, aeson, @@ -514136,8 +517126,8 @@ self: { }: mkDerivation { pname = "pandoc-lua-engine"; - version = "0.5.1"; - sha256 = "12p9f7x9bs3yark9k4nfx43c2pbgq9l1w69c60j1m7hpzh0w3ik2"; + version = "0.5.2"; + sha256 = "08lg5qsacgll5yvbh28r4x79hzhl7vm6jn8xw5wrqf9wgd7rbblk"; libraryHaskellDepends = [ aeson base @@ -517785,6 +520775,88 @@ self: { } ) { }; + parquet-haskell = callPackage ( + { + mkDerivation, + aeson, + base, + binary, + binary-conduit, + bytestring, + conduit, + conduit-extra, + containers, + filepath, + generic-lens, + hspec, + http-client, + http-conduit, + http-types, + lens, + lifted-async, + monad-logger, + mtl, + pinch, + pretty-simple, + process, + QuickCheck, + relude, + safe, + serialise, + text, + unordered-containers, + vector, + }: + mkDerivation { + pname = "parquet-haskell"; + version = "0.1.1.0"; + sha256 = "07hr3prv5849c3jf1dpk8qnka5084h6xfbgllfxmqcfmg4gjgzw0"; + libraryHaskellDepends = [ + aeson + base + binary + binary-conduit + bytestring + conduit + conduit-extra + containers + generic-lens + http-client + http-conduit + http-types + lens + lifted-async + monad-logger + mtl + pinch + pretty-simple + relude + safe + serialise + text + unordered-containers + vector + ]; + testHaskellDepends = [ + aeson + base + binary + bytestring + conduit + filepath + hspec + monad-logger + mtl + pretty-simple + process + QuickCheck + text + ]; + description = "Streaming Parquet reader"; + license = lib.licenses.bsd3; + } + ) { }; + parquet-hs = callPackage ( { mkDerivation, @@ -519847,6 +522919,104 @@ self: { } ) { }; + password_3_1_0_2 = callPackage ( + { + mkDerivation, + base, + base-compat, + base64, + bytestring, + Cabal, + cabal-doctest, + crypton, + doctest, + memory, + password-types, + QuickCheck, + quickcheck-instances, + scrypt, + tasty, + tasty-golden, + tasty-hunit, + tasty-quickcheck, + template-haskell, + text, + }: + mkDerivation { + pname = "password"; + version = "3.1.0.2"; + sha256 = "0l4w8fyl32abyyrfb1ihnwa45bm8g8wvh5vk51iqg61pizjs7k7j"; + setupHaskellDepends = [ + base + Cabal + cabal-doctest + ]; + libraryHaskellDepends = [ + base + base64 + bytestring + crypton + memory + password-types + template-haskell + text + ]; + testHaskellDepends = [ + base + base-compat + base64 + bytestring + crypton + doctest + memory + password-types + QuickCheck + quickcheck-instances + scrypt + tasty + tasty-golden + tasty-hunit + tasty-quickcheck + template-haskell + text + ]; + description = "Hashing and checking of passwords"; + license = lib.licenses.bsd3; + hydraPlatforms = lib.platforms.none; + maintainers = [ lib.maintainers.cdepillabout ]; + } + ) { }; + + password-cli = callPackage ( + { + mkDerivation, + base, + bytestring, + optparse-applicative, + password, + password-types, + text, + }: + mkDerivation { + pname = "password-cli"; + version = "0.1.1.0"; + sha256 = "1lrr15w65h3gb33qhr42gv1dklbm9mg7brz6y25yhy862kwwk9xj"; + isLibrary = false; + isExecutable = true; + executableHaskellDepends = [ + base + bytestring + optparse-applicative + password + password-types + text + ]; + description = "use password from your CLI"; + license = lib.licensesSpdx."BSD-3-Clause"; + mainProgram = "password-cli"; + } + ) { }; + password-instances = callPackage ( { mkDerivation, @@ -528390,6 +531560,88 @@ self: { } ) { }; + pg-schema = callPackage ( + { + mkDerivation, + aeson, + base, + bytestring, + case-insensitive, + containers, + deepseq, + directory, + exceptions, + hashable, + hedgehog, + mtl, + postgresql-simple, + resource-pool, + scientific, + singletons, + singletons-th, + tasty, + tasty-hedgehog, + text, + time, + unordered-containers, + uuid-types, + vector, + }: + mkDerivation { + pname = "pg-schema"; + version = "0.5.2.0"; + sha256 = "06v2rbzkz4cl8ngfdv703yy9xiihk3mjxw8cgzsk30a0i552vy4v"; + isLibrary = true; + isExecutable = true; + libraryHaskellDepends = [ + aeson + base + bytestring + case-insensitive + containers + directory + exceptions + mtl + postgresql-simple + scientific + singletons + singletons-th + text + time + uuid-types + ]; + executableHaskellDepends = [ + base + bytestring + directory + postgresql-simple + ]; + testHaskellDepends = [ + aeson + base + bytestring + case-insensitive + deepseq + hashable + hedgehog + postgresql-simple + resource-pool + scientific + singletons + tasty + tasty-hedgehog + text + time + unordered-containers + uuid-types + vector + ]; + description = "Type-level definition of database schema and safe DML for PostgreSQL"; + license = lib.licensesSpdx."BSD-3-Clause"; + mainProgram = "test-gen"; + } + ) { }; + pg-store = callPackage ( { mkDerivation, @@ -529315,8 +532567,8 @@ self: { }: mkDerivation { pname = "phino"; - version = "0.0.0.65"; - sha256 = "1abm32pm9zfqyg68pmnswf447mlrzdzjcg4a9risqwaj8jyx56sn"; + version = "0.0.0.66"; + sha256 = "11rzwnrnnkmj10v5fmna1x48mqikdjgywcjsi1plk159fh5ip54n"; isLibrary = true; isExecutable = true; libraryHaskellDepends = [ @@ -562769,6 +566021,59 @@ self: { } ) { }; + pusher-http-haskell_2_1_0_22 = callPackage ( + { + mkDerivation, + aeson, + base, + base16-bytestring, + bytestring, + crypton, + hashable, + hspec, + http-client, + http-client-tls, + http-types, + QuickCheck, + ram, + text, + time, + unordered-containers, + }: + mkDerivation { + pname = "pusher-http-haskell"; + version = "2.1.0.22"; + sha256 = "0kymmgajm3a8qrz489dwhbq3pqzqvjh1m1ciid09xsny9bziplyn"; + libraryHaskellDepends = [ + aeson + base + base16-bytestring + bytestring + crypton + hashable + http-client + http-client-tls + http-types + ram + text + time + unordered-containers + ]; + testHaskellDepends = [ + aeson + base + bytestring + hspec + QuickCheck + text + unordered-containers + ]; + description = "Haskell client library for the Pusher Channels HTTP API"; + license = lib.licenses.mit; + hydraPlatforms = lib.platforms.none; + } + ) { }; + pusher-ws = callPackage ( { mkDerivation, @@ -564582,8 +567887,8 @@ self: { }: mkDerivation { pname = "qtah-generator"; - version = "0.9.0"; - sha256 = "1ajpibrvlada2savl3ihn1hgwgikmmlif8gpxbfi92cgvf17j3gw"; + version = "0.9.1"; + sha256 = "0g9kayqi8gpa89r3fnd80jvkwlkgzwdwsw50xf51qxi6v9v7jwz0"; isLibrary = true; isExecutable = true; libraryHaskellDepends = [ @@ -569975,10 +573280,8 @@ self: { }: mkDerivation { pname = "ralist"; - version = "0.4.0.0"; - sha256 = "1axn2mh1jiz5d39ygf0hg7a0bkywnld4j8jjkflycks1yr7mxha1"; - revision = "1"; - editedCabalFile = "10i40p8xp4zm50lq3g0k6crsqg4rrwq12wkjpqqin9dsppw5085n"; + version = "0.4.1.0"; + sha256 = "0rlxr0p8v44f19p9mk3p6v7cg8j3qcv4c34iv0qf90g3khq8ybf3"; libraryHaskellDepends = [ base deepseq @@ -584472,8 +587775,8 @@ self: { pname = "repa"; version = "3.4.2.0"; sha256 = "1rqwmpslwqhrwgkpsqhx3hm4z41vfl35h7qkdxds44125d54kwcq"; - revision = "1"; - editedCabalFile = "1hihmk2flpwjpy0mbrg2c40iv4vp2zp5ygw4fqbcqr3cjq8jkibz"; + revision = "2"; + editedCabalFile = "0mz21phd96rm9gkzvnwzsbxdzf1gx51kna5b9nqj7990nzvxkryi"; libraryHaskellDepends = [ base bytestring @@ -585695,8 +588998,8 @@ self: { pname = "req"; version = "3.13.4"; sha256 = "0s80kl29b7d35v044yvkfa6ja40k4sm3wh26qpnscqzv2n6w8zzk"; - revision = "7"; - editedCabalFile = "0m0ba98f0fykda9258m8xr2g7gx9l251gj3csipyrk52m1kb53lx"; + revision = "8"; + editedCabalFile = "0jb09p3kxvnkpn9s3am2kwaz4z4hx461ixlp79fkhcpfzakziis0"; enableSeparateDataOutput = true; libraryHaskellDepends = [ aeson @@ -601837,7 +605140,7 @@ self: { } ) { }; - sbp_6_3_2 = callPackage ( + sbp_6_3_3 = callPackage ( { mkDerivation, aeson, @@ -601866,8 +605169,8 @@ self: { }: mkDerivation { pname = "sbp"; - version = "6.3.2"; - sha256 = "0fvdmflixagy971pv302aq9hfdjlphgvjymrnqkwndzjv2znldrh"; + version = "6.3.3"; + sha256 = "0y8bp4cnm3kqc64qgmkvpj1gvln197sprbm9hchdzychnp54mx8i"; isLibrary = true; isExecutable = true; libraryHaskellDepends = [ @@ -606065,24 +609368,24 @@ self: { { mkDerivation, base, + directory, filepath, process, tasty, tasty-hunit, - temporary, text, }: mkDerivation { pname = "scripths"; - version = "0.2.0.2"; - sha256 = "1jy61b2w27x3k2jcfwns6f9jnj8x3cfvbgvm3xzca3s5w05wfxjp"; + version = "0.3.0.0"; + sha256 = "1mmzfr7sfx5jm8jd9w4qd05zx87xklpanbj3ym9ysz95ywwhvl27"; isLibrary = true; isExecutable = true; libraryHaskellDepends = [ base + directory filepath process - temporary text ]; executableHaskellDepends = [ @@ -623490,6 +626793,44 @@ self: { } ) { }; + shared-resource-cache = callPackage ( + { + mkDerivation, + base, + list-t, + resourcet, + stm, + stm-containers, + text, + time, + }: + mkDerivation { + pname = "shared-resource-cache"; + version = "0.1.0.3"; + sha256 = "11j8nh68z05fslp87r25zz411ljmijm4nfm1720h9m8fjcf5w9am"; + libraryHaskellDepends = [ + base + list-t + resourcet + stm + stm-containers + text + time + ]; + testHaskellDepends = [ + base + list-t + resourcet + stm + stm-containers + text + time + ]; + description = "A thread-safe cache for sharing resources across threads with automatic expiry"; + license = lib.licenses.mit; + } + ) { }; + sharedio = callPackage ( { mkDerivation, base }: mkDerivation { @@ -626044,69 +629385,6 @@ self: { } ) { }; - sigmacord = callPackage ( - { - mkDerivation, - aeson, - async, - base, - base64-bytestring, - bytestring, - containers, - data-default, - emoji, - http-api-data, - http-client, - iso8601-time, - MonadRandom, - mtl, - network, - req, - safe-exceptions, - scientific, - text, - time, - unliftio, - unordered-containers, - websockets, - wuss, - }: - mkDerivation { - pname = "sigmacord"; - version = "1.0.0"; - sha256 = "0y6v35b7sx93nx3jccglylzzax6axb83yrv18h79zhjwh18vl9ch"; - libraryHaskellDepends = [ - aeson - async - base - base64-bytestring - bytestring - containers - data-default - emoji - http-api-data - http-client - iso8601-time - MonadRandom - mtl - network - req - safe-exceptions - scientific - text - time - unliftio - unordered-containers - websockets - wuss - ]; - description = "Write Discord Bots in Haskell"; - license = "GPL"; - hydraPlatforms = lib.platforms.none; - broken = true; - } - ) { }; - sign = callPackage ( { mkDerivation, @@ -629422,8 +632700,8 @@ self: { }: mkDerivation { pname = "simplest-sqlite"; - version = "0.1.0.9"; - sha256 = "1kf619q0j24i0s9zzh148fk3h0avjngs73k5y08ml983bpb1wg9f"; + version = "0.1.1.1"; + sha256 = "1ha7pda01i8scj3scwz0wrv0x5csj48ljn5z7f5v4islfxyllfch"; libraryHaskellDepends = [ base bytestring @@ -638952,11 +642230,12 @@ self: { mkDerivation, base, bytestring, + time, }: mkDerivation { pname = "snappy-hs"; - version = "0.1.0.5"; - sha256 = "0pclgy7jj7p569sdsa0qhvgpqp2k2x8qdbrybgwgg6adv7axgihx"; + version = "0.1.1.0"; + sha256 = "11d693qpqqlsl3gfd1ms68falcw5gx4h2bd72qrm5ld8z83gmfij"; isLibrary = true; isExecutable = true; libraryHaskellDepends = [ @@ -638966,11 +642245,14 @@ self: { executableHaskellDepends = [ base bytestring + time + ]; + testHaskellDepends = [ + base + bytestring ]; - testHaskellDepends = [ base ]; description = "Snappy compression library"; license = lib.licensesSpdx."MIT"; - mainProgram = "snappy-hs"; } ) { }; @@ -646199,7 +649481,7 @@ self: { logging, text, transformers, - unixodbc, + unixODBC, }: mkDerivation { pname = "sqlcli"; @@ -646211,13 +649493,13 @@ self: { text transformers ]; - librarySystemDepends = [ unixodbc ]; + librarySystemDepends = [ unixODBC ]; description = "Bindings for SQL/CLI (ODBC) C API"; license = lib.licenses.bsd3; hydraPlatforms = lib.platforms.none; broken = true; } - ) { inherit (pkgs) unixodbc; }; + ) { unixODBC = null; }; sqlcli-odbc = callPackage ( { @@ -675145,8 +678427,8 @@ self: { }: mkDerivation { pname = "syntactic"; - version = "3.8.4"; - sha256 = "13hsv7yr35jaimag4v0c0l56clcdcny4b1m0q6h83qcidcrqxcfc"; + version = "3.8.5"; + sha256 = "122cws8ac3rxb2g8m459rbmy4pqabkgdjqdbpzk4h8z8zd82jrvj"; libraryHaskellDepends = [ base constraints @@ -679501,37 +682783,48 @@ self: { { mkDerivation, base, - cabal-doctest, - doctest, + directory, + filepath, finitary, finite-typelits, hspec, microlens, MonadRandom, nonempty-containers, + optparse-applicative, QuickCheck, quickcheck-classes, + random, + tasty, + tasty-hunit, text, }: mkDerivation { pname = "taiwan-id"; - version = "0.1.0.0"; - sha256 = "1b9ysrmcv8npp1fhsxhpv205m7kv44y760gbfv6983nhd3hr1m7a"; - setupHaskellDepends = [ - base - cabal-doctest - ]; + version = "0.1.1.0"; + sha256 = "14cfzhbb2y76dk3fdwcj8fvkal4zlhc0wfy5j540b7v8pz0yr3yz"; + isLibrary = true; + isExecutable = true; libraryHaskellDepends = [ base finitary finite-typelits MonadRandom nonempty-containers + optparse-applicative + QuickCheck + random + text + ]; + executableHaskellDepends = [ + base + MonadRandom text ]; testHaskellDepends = [ base - doctest + directory + filepath finitary hspec microlens @@ -679539,11 +682832,16 @@ self: { nonempty-containers QuickCheck quickcheck-classes + random + tasty + tasty-hunit text ]; + doHaddock = false; description = "Implementation of Taiwan's uniform ID number format"; license = lib.licensesSpdx."BSD-3-Clause"; hydraPlatforms = lib.platforms.none; + mainProgram = "taiwan-id"; broken = true; } ) { }; @@ -681383,6 +684681,39 @@ self: { } ) { }; + tasty_1_5_4 = callPackage ( + { + mkDerivation, + ansi-terminal, + base, + containers, + optparse-applicative, + stm, + tagged, + transformers, + unix, + }: + mkDerivation { + pname = "tasty"; + version = "1.5.4"; + sha256 = "1iy6aagi6813anzdf4pygka8ch89wdgzqppdncc4876n3ca20qf7"; + libraryHaskellDepends = [ + ansi-terminal + base + containers + optparse-applicative + stm + tagged + transformers + unix + ]; + description = "Modern and extensible testing framework"; + license = lib.licenses.mit; + hydraPlatforms = lib.platforms.none; + maintainers = [ lib.maintainers.maralorn ]; + } + ) { }; + tasty-ant-xml = callPackage ( { mkDerivation, @@ -690041,7 +693372,7 @@ self: { } ) { }; - texmath_0_13_1 = callPackage ( + texmath_0_13_1_1 = callPackage ( { mkDerivation, base, @@ -690064,8 +693395,8 @@ self: { }: mkDerivation { pname = "texmath"; - version = "0.13.1"; - sha256 = "0lxk76f23qirxv1h7fw6al3246g4f0mghnzlkx7d3ln4czkmk73g"; + version = "0.13.1.1"; + sha256 = "0ws4zqzd5n63mf6622gvimgj23gr4khicx655dcjjm18ypfd9886"; isLibrary = true; isExecutable = true; libraryHaskellDepends = [ @@ -690286,8 +693617,8 @@ self: { pname = "text-ansi"; version = "0.3.0.1"; sha256 = "0iiq5zlcjh25mf9b4vlhyc1dwglwh8b03qj1wasbngzvmphvcy00"; - revision = "2"; - editedCabalFile = "1bjri84hc9qqp03zjmbrgrwgk989253x7jj2xzwbq579q5yxpj8h"; + revision = "3"; + editedCabalFile = "1blqfkv7fizm57jlrlq7cjsbcryck67gwmi2a8c6jq8pxns4ygl1"; libraryHaskellDepends = [ base text @@ -710442,6 +713773,68 @@ self: { } ) { }; + tui-launcher = callPackage ( + { + mkDerivation, + base, + brick, + containers, + directory, + filepath, + optparse-applicative, + process, + tasty, + tasty-hunit, + text, + tomland, + tuispec, + unix, + vty, + vty-crossplatform, + }: + mkDerivation { + pname = "tui-launcher"; + version = "0.0.1"; + sha256 = "0rg5zdgswvppibk2q195pm75q65c5i7fa3qdsrx7wjv026xi9jib"; + isLibrary = false; + isExecutable = true; + executableHaskellDepends = [ + base + brick + containers + directory + filepath + optparse-applicative + process + text + tomland + unix + vty + vty-crossplatform + ]; + testHaskellDepends = [ + base + brick + containers + directory + filepath + optparse-applicative + process + tasty + tasty-hunit + text + tomland + tuispec + unix + vty + vty-crossplatform + ]; + description = "Small Brick-based terminal launcher"; + license = lib.licensesSpdx."MIT"; + mainProgram = "tui-launcher"; + } + ) { }; + tuispec = callPackage ( { mkDerivation, @@ -716659,7 +720052,7 @@ self: { } ) { }; - typst_0_9 = callPackage ( + typst_0_9_0_1 = callPackage ( { mkDerivation, aeson, @@ -716689,10 +720082,8 @@ self: { }: mkDerivation { pname = "typst"; - version = "0.9"; - sha256 = "11np3g5l6yqm33j4vkl65pfdcjs2dj7302lyyp9pq2i6lsi7kxmn"; - revision = "1"; - editedCabalFile = "1qyhvyfz9dizkclmc5jkq5cmdjms8qmsppy66qn7il2dz7aggbj2"; + version = "0.9.0.1"; + sha256 = "013li974rqm125k8kj12mc1j84pzqx4k9rf3nci57mfv4z6wb36v"; isLibrary = true; isExecutable = true; libraryHaskellDepends = [ @@ -720125,8 +723516,8 @@ self: { }: mkDerivation { pname = "uniform-error"; - version = "0.1.5.1"; - sha256 = "0fj8p4s5np1irc7j7i39a1i8a94bp1cjf9nqng74x6nwj139hs4i"; + version = "0.1.5.2"; + sha256 = "1kw9chik6gk8w7d471ri5q861cl7n3scjg57s72n5jbw07blwdv1"; libraryHaskellDepends = [ base data-default @@ -720175,8 +723566,8 @@ self: { }: mkDerivation { pname = "uniform-fileio"; - version = "0.1.5.1"; - sha256 = "1y92wxzgnj25v06mlx3a6dhkqxhbdr4d6dxa71n9g04zzcp2ghk6"; + version = "0.1.5.2"; + sha256 = "0w53ixsash6g9fzxlyglx3ghx3nsmjl0a0n36562gj421b3qvz2z"; libraryHaskellDepends = [ base bytestring @@ -720618,8 +724009,8 @@ self: { }: mkDerivation { pname = "uniformBase"; - version = "0.1.5.1"; - sha256 = "0nxz5c28jjfnfcx4dwl1kk6vpkz1yzhhfxd73457xxfc3z7sfg82"; + version = "0.1.5.2"; + sha256 = "0dl5p9avpjbvsnl7ybap55bcpnk5dz4x4z3544fd6x95bidjdw6p"; libraryHaskellDepends = [ base data-default @@ -723881,8 +727272,8 @@ self: { }: mkDerivation { pname = "unwitch"; - version = "2.1.0"; - sha256 = "020jlm0jrnxfrnaw5dp5fa0hn52m9lyq6aqcyv2zjih3dz6867yn"; + version = "2.2.0"; + sha256 = "0wp3g67fvqrybsl833rpll24nkxc40izq3xcfj78xi1aw6lq8mln"; libraryHaskellDepends = [ base bytestring @@ -728521,6 +731912,56 @@ self: { } ) { }; + valuations = callPackage ( + { + mkDerivation, + adjunctions, + base, + bifunctors, + comonad, + containers, + contravariant, + distributive, + doctest, + lens, + mtl, + process, + profunctors, + selective, + semigroupoids, + unordered-containers, + witherable, + }: + mkDerivation { + pname = "valuations"; + version = "0.0.6"; + sha256 = "0nadv6ipri3gby1g2s1kdhccysvpwn0wc97gvfjaz8gcg8l4d6fs"; + libraryHaskellDepends = [ + adjunctions + base + bifunctors + comonad + containers + contravariant + distributive + lens + mtl + profunctors + selective + semigroupoids + unordered-containers + witherable + ]; + testHaskellDepends = [ + base + process + ]; + testToolDepends = [ doctest ]; + description = "Valuations"; + license = lib.licensesSpdx."BSD-3-Clause"; + } + ) { }; + value-supply = callPackage ( { mkDerivation, base }: mkDerivation { @@ -735732,6 +739173,29 @@ self: { } ) { }; + wai-asset-path = callPackage ( + { + mkDerivation, + base, + text, + vault, + wai, + }: + mkDerivation { + pname = "wai-asset-path"; + version = "1.0.0"; + sha256 = "12c2yz6vbf90xql2f9ga5blk62jy4mgdbsdfpbwd6vkxql8n0jd0"; + libraryHaskellDepends = [ + base + text + vault + wai + ]; + description = "assetPath function for WAI"; + license = lib.licensesSpdx."MIT"; + } + ) { }; + wai-cli = callPackage ( { mkDerivation, @@ -736351,6 +739815,37 @@ self: { } ) { }; + wai-flash-messages = callPackage ( + { + mkDerivation, + base, + bytestring, + cereal, + cereal-text, + text, + vault, + wai, + wai-session, + }: + mkDerivation { + pname = "wai-flash-messages"; + version = "1.0.0"; + sha256 = "1k7wdx2shkv3bdaam9ayajp6vl13k8sx8zs647rcf31ph1ykingk"; + libraryHaskellDepends = [ + base + bytestring + cereal + cereal-text + text + vault + wai + wai-session + ]; + description = "Flash messages for wai apps"; + license = lib.licensesSpdx."MIT"; + } + ) { }; + wai-frontend-monadcgi = callPackage ( { mkDerivation, @@ -739123,6 +742618,67 @@ self: { } ) { }; + wai-request-params = callPackage ( + { + mkDerivation, + aeson, + attoparsec, + base, + bytestring, + deepseq, + hspec, + http-types, + scientific, + string-conversions, + text, + time, + uuid, + vault, + vector, + wai, + wai-extra, + }: + mkDerivation { + pname = "wai-request-params"; + version = "1.0.0"; + sha256 = "1r0rapyscvq5vikbj0vfwrzyrm71fi10g1fgynka4islfql94dyn"; + libraryHaskellDepends = [ + aeson + attoparsec + base + bytestring + deepseq + http-types + scientific + string-conversions + text + time + uuid + vault + vector + wai + wai-extra + ]; + testHaskellDepends = [ + aeson + base + bytestring + hspec + http-types + scientific + string-conversions + text + time + uuid + vault + wai + wai-extra + ]; + description = "Generic parameter parsing for WAI requests"; + license = lib.licensesSpdx."MIT"; + } + ) { }; + wai-request-spec = callPackage ( { mkDerivation, @@ -739742,6 +743298,74 @@ self: { } ) { }; + wai-session-clientsession-deferred = callPackage ( + { + mkDerivation, + base, + bytestring, + cereal, + clientsession, + transformers, + wai-session-maybe, + }: + mkDerivation { + pname = "wai-session-clientsession-deferred"; + version = "1.0.0"; + sha256 = "05s7bv409rd7clrggq4f9wwbzrzq9ykc6qzcwdav47xkx2kk8p1l"; + libraryHaskellDepends = [ + base + bytestring + cereal + clientsession + transformers + wai-session-maybe + ]; + description = "Session store based on clientsession with deferred decryption"; + license = "unknown"; + } + ) { }; + + wai-session-maybe = callPackage ( + { + mkDerivation, + base, + blaze-builder, + bytestring, + bytestring-builder, + containers, + cookie, + entropy, + http-types, + StateVar, + time, + transformers, + vault, + wai, + }: + mkDerivation { + pname = "wai-session-maybe"; + version = "1.0.0"; + sha256 = "0bb8sm399dsl6ngqc4d7wabp41pny3rlld02l50lwknhnwazhs6b"; + libraryHaskellDepends = [ + base + blaze-builder + bytestring + bytestring-builder + containers + cookie + entropy + http-types + StateVar + time + transformers + vault + wai + ]; + description = "Flexible session middleware for WAI"; + license = "unknown"; + } + ) { }; + wai-session-mysql = callPackage ( { mkDerivation, @@ -741677,8 +745301,8 @@ self: { }: mkDerivation { pname = "waterfall-cad"; - version = "0.6.1.0"; - sha256 = "1hhybkznqrp4ziab2ww6ai4xmr8p3h75s1kkngk1a81dpkn76a31"; + version = "0.6.2.0"; + sha256 = "03sgz90f53ib2c6sz4m3jg7lj6xndmh7dlim3sbpy4zjc2fv3x0s"; libraryHaskellDepends = [ base filepath @@ -741712,8 +745336,8 @@ self: { }: mkDerivation { pname = "waterfall-cad-examples"; - version = "0.6.1.0"; - sha256 = "06hqfgxn6x9k4g389zvpb5ll58j0lshn25qqz4n9r36pqr7yqa7a"; + version = "0.6.2.0"; + sha256 = "0f3ypgmd9dy4qrnq4s9yigcc2m42dh327bbgvrq7xmwdrphhl8a7"; isLibrary = true; isExecutable = true; libraryHaskellDepends = [ @@ -741766,8 +745390,8 @@ self: { }: mkDerivation { pname = "waterfall-cad-svg"; - version = "0.6.1.0"; - sha256 = "1i8jna60yf4vzipgfxl5zpgb4ig54cym2v3p966gixqw24kc57qb"; + version = "0.6.2.0"; + sha256 = "17nq8sqhzr22pa5nd778nmmq124wrg86xbllcb69whn5vb2sjirm"; libraryHaskellDepends = [ attoparsec base @@ -745205,8 +748829,8 @@ self: { pname = "webgear-core"; version = "1.5.0"; sha256 = "1f5dy707rcb25n0w5ld210vczaa3az2y6xvg5jn7gwsxs23a8b3k"; - revision = "1"; - editedCabalFile = "0yrwdb3cnfqkhfasi7c5hhsaw44xvvsm0nmrkjyhz3fy2h9xpn4d"; + revision = "2"; + editedCabalFile = "072av65fzm4fpmsaqjc2d7h3h523w73phpx4nhxwkw9vzvvsg0qy"; libraryHaskellDepends = [ arrows base @@ -745285,6 +748909,8 @@ self: { pname = "webgear-openapi"; version = "1.5.0"; sha256 = "0amwhdbb1va8c7ham34zbjpd5azwvwsl5d4i7xyfkq8gzry9vji6"; + revision = "1"; + editedCabalFile = "1zgpwzqgxj690qgyasxybzl5s7hy4zs2ihnsq9xmh6ylp0h95cf3"; libraryHaskellDepends = [ arrows base @@ -745407,8 +749033,8 @@ self: { pname = "webgear-server"; version = "1.5.0"; sha256 = "1srr5kblk1b59jyrkidh9js4yax8dvjyici283z25yk2lnqijc2y"; - revision = "1"; - editedCabalFile = "0wx2qlwkk6yxnpfxy9261fwn7xkykcll7636ls6kxvc5ybwyn5h6"; + revision = "2"; + editedCabalFile = "13vcrl4rspbgv37fila9b6x2xhqnj0smi8fmdrp2ypn4148wfj44"; libraryHaskellDepends = [ aeson arrows @@ -745500,6 +749126,8 @@ self: { pname = "webgear-swagger"; version = "1.5.0"; sha256 = "0vgd506yqfj02l6a25wfwi03xxf6nyg9gkh2phq85g88v22brwpf"; + revision = "1"; + editedCabalFile = "1lb6q57drmixijnkq4hzn27y4xshn5ls8i06cqs2qhkkj7gcjsf3"; libraryHaskellDepends = [ arrows base @@ -745561,6 +749189,8 @@ self: { pname = "webgear-swagger-ui"; version = "1.5.0"; sha256 = "02larl8s6b9i1rkbw6gflyz0pn8ba80yd0i6w73mifkma7m39zxi"; + revision = "1"; + editedCabalFile = "1b6rarcx1my050nr51p73wak9d4jqkyjv46apnidzl58czj602bc"; libraryHaskellDepends = [ base bytestring @@ -754035,7 +757665,7 @@ self: { } ) { }; - x509-ocsp_0_5_1_0 = callPackage ( + x509-ocsp_0_5_2_0 = callPackage ( { mkDerivation, base, @@ -754051,8 +757681,8 @@ self: { }: mkDerivation { pname = "x509-ocsp"; - version = "0.5.1.0"; - sha256 = "1zmiz7pssxqk2zpcyh68c6yinl31k4021lcm7myyz71s5b3akcri"; + version = "0.5.2.0"; + sha256 = "007qwdp7r11s7787i4ligmwnsj9927ayglinp95658rl4kpijrw2"; enableSeparateDataOutput = true; libraryHaskellDepends = [ base @@ -754744,6 +758374,53 @@ self: { } ) { }; + xdg-desktop-entry_0_1_1_4 = callPackage ( + { + mkDerivation, + base, + directory, + either, + filepath, + hspec, + ini, + multimap, + safe, + temporary, + text, + transformers, + unix, + unordered-containers, + }: + mkDerivation { + pname = "xdg-desktop-entry"; + version = "0.1.1.4"; + sha256 = "199jbayp6ng2hdjkgwp3ng3111r6abiw9rar4ngx3mr9d06dyb67"; + libraryHaskellDepends = [ + base + directory + either + filepath + ini + multimap + safe + text + transformers + unix + unordered-containers + ]; + testHaskellDepends = [ + base + filepath + hspec + temporary + unix + ]; + description = "Parse files conforming to the xdg desktop entry spec"; + license = lib.licensesSpdx."BSD-3-Clause"; + hydraPlatforms = lib.platforms.none; + } + ) { }; + xdg-userdirs = callPackage ( { mkDerivation, From d15d59cc0afcc46e5bb1ed44595c3febc4cda8b7 Mon Sep 17 00:00:00 2001 From: Wolfgang Walther Date: Mon, 30 Mar 2026 09:26:47 +0200 Subject: [PATCH 10/52] haskellPackages.ghc-debug-client: remove jailbreak Has been updated upstream. --- pkgs/development/haskell-modules/configuration-common.nix | 5 ----- 1 file changed, 5 deletions(-) diff --git a/pkgs/development/haskell-modules/configuration-common.nix b/pkgs/development/haskell-modules/configuration-common.nix index e362b0c6b297..a81f925362be 100644 --- a/pkgs/development/haskell-modules/configuration-common.nix +++ b/pkgs/development/haskell-modules/configuration-common.nix @@ -482,11 +482,6 @@ with haskellLib; # 2025-02-10: Too strict bounds on bytestring < 0.12 ghc-debug-common = doJailbreak super.ghc-debug-common; - ghc-debug-client = lib.pipe super.ghc-debug-client [ - (warnAfterVersion "0.7.0.0") - # 2025-09-18: Too strict bounds on containers < 0.7 - doJailbreak - ]; # https://github.com/agrafix/superbuffer/issues/4 # Too strict bounds on bytestring < 0.12 From e8fe63b46b5a07cdd0d533bba71053e06bb116d8 Mon Sep 17 00:00:00 2001 From: Wolfgang Walther Date: Mon, 30 Mar 2026 09:27:09 +0200 Subject: [PATCH 11/52] haskellPackages.ghc-debug-common: remove jailbreak Has been updated upstream. --- pkgs/development/haskell-modules/configuration-common.nix | 3 --- 1 file changed, 3 deletions(-) diff --git a/pkgs/development/haskell-modules/configuration-common.nix b/pkgs/development/haskell-modules/configuration-common.nix index a81f925362be..2baba597336f 100644 --- a/pkgs/development/haskell-modules/configuration-common.nix +++ b/pkgs/development/haskell-modules/configuration-common.nix @@ -480,9 +480,6 @@ with haskellLib; sha256 = "1c7knpvxr7p8c159jkyk6w29653z5yzgjjqj11130bbb8mk9qhq7"; }) super.c2hsc; - # 2025-02-10: Too strict bounds on bytestring < 0.12 - ghc-debug-common = doJailbreak super.ghc-debug-common; - # https://github.com/agrafix/superbuffer/issues/4 # Too strict bounds on bytestring < 0.12 superbuffer = doJailbreak super.superbuffer; From 6f194951975464c3208dc0f6781d23fb6a0a360d Mon Sep 17 00:00:00 2001 From: Wolfgang Walther Date: Mon, 30 Mar 2026 09:46:06 +0200 Subject: [PATCH 12/52] maintainers/scripts/haskell/update-stackage.sh: fix cassava replacement Unescaped & create backreferences for me, resulting in a broken replacement. --- maintainers/scripts/haskell/update-stackage.sh | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/maintainers/scripts/haskell/update-stackage.sh b/maintainers/scripts/haskell/update-stackage.sh index 598f4663f909..13f8913a048a 100755 --- a/maintainers/scripts/haskell/update-stackage.sh +++ b/maintainers/scripts/haskell/update-stackage.sh @@ -114,6 +114,6 @@ sed -r \ # Work around Stackage LTS including a bogus version of cassava which has been deprecated on Hackage. # See . # TODO(@sternenseemann): drop this once the situation has been resolved in Stackage LTS -sed -e 's/cassava ==0.5.5.0/cassava >= 0.5.4.0 && (> 0.5.5.0 || < 0.5.5.0) && < 0.6.0.0/' -i "$stackage_config" +sed -e 's/cassava ==0.5.5.0/cassava >= 0.5.4.0 \&\& (> 0.5.5.0 || < 0.5.5.0) \&\& < 0.6.0.0/' -i "$stackage_config" echo "$old_version -> $version" From 7bc7b47410aa92f920838b0603c6e80ebbd7955a Mon Sep 17 00:00:00 2001 From: Wolfgang Walther Date: Mon, 30 Mar 2026 09:47:24 +0200 Subject: [PATCH 13/52] haskellPackages: stackage LTS 24.34 -> LTS 24.35 all-cabal-hashes: 2026-03-27T12:41:48Z -> 2026-03-30T06:52:34Z (generated by maintainers/scripts/haskell/update-package-set.sh) --- pkgs/data/misc/hackage/pin.json | 8 +- .../configuration-hackage2nix/stackage.yaml | 54 +- .../haskell-modules/hackage-packages.nix | 1959 +++++------------ 3 files changed, 544 insertions(+), 1477 deletions(-) diff --git a/pkgs/data/misc/hackage/pin.json b/pkgs/data/misc/hackage/pin.json index 3fe343a926a9..51d7ba78a886 100644 --- a/pkgs/data/misc/hackage/pin.json +++ b/pkgs/data/misc/hackage/pin.json @@ -1,6 +1,6 @@ { - "commit": "2accd524b707ab1ad0c9eb4f1abf15a72054e876", - "url": "https://github.com/commercialhaskell/all-cabal-hashes/archive/2accd524b707ab1ad0c9eb4f1abf15a72054e876.tar.gz", - "sha256": "02vx70j037wppnmq7wybrh6rwai2nc0yh8fm5lxaaxq9sngzif0q", - "msg": "Update from Hackage at 2026-03-27T12:41:48Z" + "commit": "7c90adee4a21c129dfe6b4b9d2d63c0d704d11ef", + "url": "https://github.com/commercialhaskell/all-cabal-hashes/archive/7c90adee4a21c129dfe6b4b9d2d63c0d704d11ef.tar.gz", + "sha256": "1l0lk9ifzby749w9wj1v8cp048ndpf6qznlpdjkmmz5f8fvlr53z", + "msg": "Update from Hackage at 2026-03-30T06:52:34Z" } diff --git a/pkgs/development/haskell-modules/configuration-hackage2nix/stackage.yaml b/pkgs/development/haskell-modules/configuration-hackage2nix/stackage.yaml index 87bbe230daa6..13647054de09 100644 --- a/pkgs/development/haskell-modules/configuration-hackage2nix/stackage.yaml +++ b/pkgs/development/haskell-modules/configuration-hackage2nix/stackage.yaml @@ -1,4 +1,4 @@ -# Stackage LTS 24.34 +# Stackage LTS 24.35 # This file is auto-generated by # maintainers/scripts/haskell/update-stackage.sh default-package-overrides: @@ -41,7 +41,7 @@ default-package-overrides: - agda2lagda ==0.2023.6.9 - agreeing ==0.2.2.0 - alarmclock ==0.7.0.7 - - alex ==3.5.4.0 + - alex ==3.5.4.2 - alex-meta ==0.3.0.13 - alex-tools ==0.6.1 - alfred-margaret ==2.1.0.2 @@ -81,7 +81,7 @@ default-package-overrides: - apportionment ==0.0.0.4 - approximate ==0.3.5 - approximate-equality ==1.1.0.2 - - arithmoi ==0.13.2.0 + - arithmoi ==0.13.3.0 - array-chunks ==0.1.4.2 - array-memoize ==0.6.0 - arrow-extras ==0.1.0.1 @@ -166,9 +166,9 @@ default-package-overrides: - bcp47-orphans ==0.1.3.0 - bcrypt ==0.0.11 - beam-core ==0.10.4.0 - - beam-migrate ==0.5.3.2 - - beam-postgres ==0.5.4.4 - - beam-sqlite ==0.5.6.0 + - beam-migrate ==0.5.4.0 + - beam-postgres ==0.5.5.0 + - beam-sqlite ==0.5.7.0 - bech32 ==1.1.10 - bech32-th ==1.1.10 - bench ==1.0.13 @@ -229,7 +229,7 @@ default-package-overrides: - bm ==0.2.0.0 - bmp ==1.2.6.4 - bnb-staking-csvs ==0.2.2.0 - - BNFC ==2.9.6.2 + - BNFC ==2.9.6.3 - BNFC-meta ==0.6.1 - board-games ==0.4.0.1 - bodhi ==0.1.0 @@ -374,10 +374,10 @@ default-package-overrides: - circle-packing ==0.1.0.6 - circular ==0.4.0.3 - citeproc ==0.9.0.1 - - clash-ghc ==1.8.4 - - clash-lib ==1.8.4 - - clash-prelude ==1.8.4 - - clash-prelude-hedgehog ==1.8.4 + - clash-ghc ==1.8.5 + - clash-lib ==1.8.5 + - clash-prelude ==1.8.5 + - clash-prelude-hedgehog ==1.8.5 - classy-prelude ==1.5.0.3 - classy-prelude-conduit ==1.5.0 - classy-prelude-yesod ==1.5.0 @@ -407,7 +407,7 @@ default-package-overrides: - Color ==0.4.1 - colorful-monoids ==0.2.1.3 - colorize-haskell ==1.0.1 - - colour ==2.3.6 + - colour ==2.3.7 - colourista ==0.1.0.2 - columnar ==1.0.0.0 - combinatorial ==0.1.1 @@ -667,7 +667,7 @@ default-package-overrides: - distribution-opensuse ==1.1.4 - distributive ==0.6.3 - djinn-lib ==0.0.1.4 - - djot ==0.1.3 + - djot ==0.1.4 - dl-fedora ==2.0.1 - dlist ==1.0 - dlist-instances ==0.1.1.1 @@ -704,7 +704,7 @@ default-package-overrides: - drifter-postgresql ==0.2.1 - drifter-sqlite ==0.1.0.0 - dsp ==0.2.5.2 - - dual-tree ==0.2.3.1 + - dual-tree ==0.2.3.2 - dublincore-xml-conduit ==0.1.0.3 - dunai ==0.14.1 - duration ==0.2.0.0 @@ -845,7 +845,7 @@ default-package-overrides: - filecache ==0.5.3 - filelock ==0.1.1.9 - filemanip ==0.3.6.3 - - filepath-bytestring ==1.5.2.0.3 + - filepath-bytestring ==1.5.2.0.4 - filepattern ==0.1.3 - fileplow ==0.1.0.0 - filter-logger ==0.6.0.0 @@ -1008,7 +1008,7 @@ default-package-overrides: - ghcid ==0.8.9 - ghcjs-codemirror ==0.0.0.2 - ghcjs-dom ==0.9.9.2 - - ghcjs-dom-jsaddle ==0.9.9.0 + - ghcjs-dom-jsaddle ==0.9.9.1 - ghcjs-perch ==0.3.3.3 - ghost-buster ==0.1.1.0 - ghostscript-parallel ==0.0.1 @@ -1190,7 +1190,7 @@ default-package-overrides: - hackage-security-HTTP ==0.1.1.3 - haddock-library ==1.11.0 - haha ==0.3.1.1 - - hakyll ==4.16.7.1 + - hakyll ==4.16.8.0 - hakyll-convert ==0.3.0.5 - hal ==1.1 - half ==0.3.3 @@ -1555,9 +1555,9 @@ default-package-overrides: - js-dgtable ==0.5.2 - js-flot ==0.8.3 - js-jquery ==3.7.1 - - jsaddle ==0.9.9.3 - - jsaddle-dom ==0.9.9.2 - - jsaddle-warp ==0.9.9.5 + - jsaddle ==0.9.9.4 + - jsaddle-dom ==0.9.9.3 + - jsaddle-warp ==0.9.9.6 - json ==0.11 - json-feed ==2.0.0.18 - json-rpc ==1.1.2 @@ -2002,7 +2002,7 @@ default-package-overrides: - oblivious-transfer ==0.1.0 - odbc ==0.3.0 - ods2csv ==0.1.0.2 - - oeis ==0.3.10.1 + - oeis ==0.3.10.2 - oeis2 ==1.0.9 - ofx ==0.4.4.0 - ogma-cli ==1.7.0 @@ -2105,7 +2105,7 @@ default-package-overrides: - partial-handler ==1.0.3 - partial-isomorphisms ==0.2.4.0 - partialord ==0.1.1 - - password ==3.1.0.1 + - password ==3.1.0.2 - password-instances ==3.0.0.0 - password-types ==1.0.0.0 - patch ==0.0.8.4 @@ -2538,10 +2538,10 @@ default-package-overrides: - sequenceTools ==1.6.0.0 - serialise ==0.2.6.1 - servant ==0.20.3.0 - - servant-auth ==0.4.2.0 - - servant-auth-client ==0.4.2.0 + - servant-auth ==0.4.9.2 + - servant-auth-client ==0.4.9.2 - servant-auth-docs ==0.2.11.0 - - servant-auth-server ==0.4.9.1 + - servant-auth-server ==0.4.9.2 - servant-auth-swagger ==0.2.11.0 - servant-blaze ==0.9.1 - servant-checked-exceptions ==2.2.0.1 @@ -2833,7 +2833,7 @@ default-package-overrides: - tar ==0.6.4.0 - tar-conduit ==0.4.1 - tardis ==0.5.0.1 - - tasty ==1.5.3 + - tasty ==1.5.4 - tasty-ant-xml ==1.1.9 - tasty-autocollect ==0.4.4 - tasty-bench ==0.4.1 @@ -3280,7 +3280,7 @@ default-package-overrides: - x11-xim ==0.0.9.0 - Xauth ==0.1 - xdg-basedir ==0.2.2 - - xdg-desktop-entry ==0.1.1.3 + - xdg-desktop-entry ==0.1.1.4 - xdg-userdirs ==0.1.0.2 - xeno ==0.6 - xls ==0.1.3 diff --git a/pkgs/development/haskell-modules/hackage-packages.nix b/pkgs/development/haskell-modules/hackage-packages.nix index 5d0ac2a5aa6e..9b7f0414dd0c 100644 --- a/pkgs/development/haskell-modules/hackage-packages.nix +++ b/pkgs/development/haskell-modules/hackage-packages.nix @@ -2585,72 +2585,6 @@ self: { ) { }; BNFC = callPackage ( - { - mkDerivation, - alex, - array, - base, - containers, - deepseq, - directory, - filepath, - happy, - hspec, - hspec-discover, - HUnit, - mtl, - pretty, - QuickCheck, - string-qq, - temporary, - time, - }: - mkDerivation { - pname = "BNFC"; - version = "2.9.6.2"; - sha256 = "12cap3xqsa06bkhq46qazaqvpcckh0p7cnyacr4p1klr1nvlxkcr"; - isLibrary = true; - isExecutable = true; - libraryHaskellDepends = [ - array - base - containers - deepseq - directory - filepath - mtl - pretty - string-qq - time - ]; - libraryToolDepends = [ - alex - happy - ]; - executableHaskellDepends = [ base ]; - testHaskellDepends = [ - base - directory - filepath - hspec - HUnit - mtl - pretty - QuickCheck - temporary - ]; - testToolDepends = [ - alex - happy - hspec-discover - ]; - description = "A compiler front-end generator"; - license = lib.licenses.bsd3; - mainProgram = "bnfc"; - } - ) { }; - - BNFC_2_9_6_3 = callPackage ( { mkDerivation, alex, @@ -2712,7 +2646,6 @@ self: { ]; description = "A compiler front-end generator"; license = lib.licenses.bsd3; - hydraPlatforms = lib.platforms.none; mainProgram = "bnfc"; } ) { }; @@ -59063,40 +58996,6 @@ self: { ) { }; alex = callPackage ( - { - mkDerivation, - array, - base, - containers, - directory, - happy, - process, - }: - mkDerivation { - pname = "alex"; - version = "3.5.4.0"; - sha256 = "1plasa0h85dfcga2h4yd1bqfi8smx4ghscyg299nh3lhqkr71sm9"; - isLibrary = false; - isExecutable = true; - enableSeparateDataOutput = true; - executableHaskellDepends = [ - array - base - containers - directory - ]; - executableToolDepends = [ happy ]; - testHaskellDepends = [ - base - process - ]; - description = "Alex is a tool for generating lexical analysers in Haskell"; - license = lib.licenses.bsd3; - mainProgram = "alex"; - } - ) { }; - - alex_3_5_4_2 = callPackage ( { mkDerivation, array, @@ -59126,7 +59025,6 @@ self: { ]; description = "Alex is a tool for generating lexical analysers in Haskell"; license = lib.licenses.bsd3; - hydraPlatforms = lib.platforms.none; mainProgram = "alex"; } ) { }; @@ -84274,93 +84172,6 @@ self: { ) { }; arithmoi = callPackage ( - { - mkDerivation, - base, - bitvec, - chimera, - constraints, - containers, - deepseq, - exact-pi, - ghc-bignum, - infinite-list, - integer-logarithms, - integer-roots, - mod, - QuickCheck, - quickcheck-classes, - random, - semirings, - smallcheck, - tasty, - tasty-bench, - tasty-hunit, - tasty-quickcheck, - tasty-rerun, - tasty-smallcheck, - transformers, - vector, - }: - mkDerivation { - pname = "arithmoi"; - version = "0.13.2.0"; - sha256 = "0kb7x4nh21vhiqy2l08k4dg49ffp022bj86vkpy9icgsaskh7b4i"; - configureFlags = [ "-f-llvm" ]; - libraryHaskellDepends = [ - base - bitvec - chimera - constraints - containers - deepseq - exact-pi - ghc-bignum - infinite-list - integer-logarithms - integer-roots - mod - random - semirings - transformers - vector - ]; - testHaskellDepends = [ - base - containers - exact-pi - infinite-list - integer-roots - mod - QuickCheck - quickcheck-classes - semirings - smallcheck - tasty - tasty-hunit - tasty-quickcheck - tasty-rerun - tasty-smallcheck - vector - ]; - benchmarkHaskellDepends = [ - base - constraints - containers - infinite-list - integer-logarithms - mod - random - semirings - tasty-bench - vector - ]; - description = "Efficient basic number-theoretic functions"; - license = lib.licenses.mit; - } - ) { }; - - arithmoi_0_13_3_0 = callPackage ( { mkDerivation, array, @@ -84446,7 +84257,6 @@ self: { ]; description = "Efficient basic number-theoretic functions"; license = lib.licenses.mit; - hydraPlatforms = lib.platforms.none; } ) { }; @@ -87330,8 +87140,8 @@ self: { }: mkDerivation { pname = "associative"; - version = "0.0.3"; - sha256 = "1f2xn8zp97mhxww5sf2my1cl6d3yikdv8qxp2x7c6ri490g4c8cp"; + version = "0.0.4"; + sha256 = "126f2fm2jfr82ji1wgkz75s9q5n2z0vgbrwkqx539l7sz04pvz7d"; libraryHaskellDepends = [ base containers @@ -101935,67 +101745,6 @@ self: { ) { }; beam-migrate = callPackage ( - { - mkDerivation, - aeson, - base, - beam-core, - bytestring, - containers, - deepseq, - dependent-map, - dependent-sum, - free, - hashable, - haskell-src-exts, - microlens, - mtl, - parallel, - pqueue, - pretty, - scientific, - text, - time, - unordered-containers, - uuid-types, - vector, - }: - mkDerivation { - pname = "beam-migrate"; - version = "0.5.3.2"; - sha256 = "05cz2gh9r00dr6knigq9v7zcdmpk2b19z0pg79wimkcxa2fblb5z"; - revision = "4"; - editedCabalFile = "1xafh4qb225w32ls2c89cdk13fvfjn69052ja9fm43vgvhxrjjbs"; - libraryHaskellDepends = [ - aeson - base - beam-core - bytestring - containers - deepseq - dependent-map - dependent-sum - free - hashable - haskell-src-exts - microlens - mtl - parallel - pqueue - pretty - scientific - text - time - unordered-containers - uuid-types - vector - ]; - description = "SQL DDL support and migrations support library for Beam"; - license = lib.licenses.mit; - } - ) { }; - - beam-migrate_0_5_4_0 = callPackage ( { mkDerivation, aeson, @@ -102051,7 +101800,6 @@ self: { ]; description = "SQL DDL support and migrations support library for Beam"; license = lib.licenses.mit; - hydraPlatforms = lib.platforms.none; } ) { }; @@ -102128,89 +101876,6 @@ self: { ) { }; beam-postgres = callPackage ( - { - mkDerivation, - aeson, - attoparsec, - base, - beam-core, - beam-migrate, - bytestring, - case-insensitive, - conduit, - free, - hashable, - hedgehog, - lifted-base, - monad-control, - mtl, - network-uri, - postgresql-libpq, - postgresql-simple, - scientific, - tagged, - tasty, - tasty-hunit, - testcontainers, - text, - time, - transformers-base, - unordered-containers, - uuid, - uuid-types, - vector, - }: - mkDerivation { - pname = "beam-postgres"; - version = "0.5.4.4"; - sha256 = "03llbfl1rlpghl0adf9ynd4wx4jbl707ll7cn3bcq16za2sc20fd"; - libraryHaskellDepends = [ - aeson - attoparsec - base - beam-core - beam-migrate - bytestring - case-insensitive - conduit - free - hashable - lifted-base - monad-control - mtl - network-uri - postgresql-libpq - postgresql-simple - scientific - tagged - text - time - transformers-base - unordered-containers - uuid-types - vector - ]; - testHaskellDepends = [ - aeson - base - beam-core - beam-migrate - bytestring - hedgehog - postgresql-simple - tasty - tasty-hunit - testcontainers - text - uuid - vector - ]; - description = "Connection layer between beam and postgres"; - license = lib.licenses.mit; - } - ) { }; - - beam-postgres_0_5_5_0 = callPackage ( { mkDerivation, aeson, @@ -102290,78 +101955,10 @@ self: { ]; description = "Connection layer between beam and postgres"; license = lib.licenses.mit; - hydraPlatforms = lib.platforms.none; } ) { }; beam-sqlite = callPackage ( - { - mkDerivation, - aeson, - attoparsec, - base, - beam-core, - beam-migrate, - bytestring, - containers, - direct-sqlite, - dlist, - free, - hashable, - monad-control, - mtl, - network-uri, - scientific, - sqlite-simple, - tasty, - tasty-expected-failure, - tasty-hunit, - text, - time, - transformers-base, - }: - mkDerivation { - pname = "beam-sqlite"; - version = "0.5.6.0"; - sha256 = "0iv94115aw1imbbcy6lbiqsr699215x15j1snyzypzbkqca0khi6"; - libraryHaskellDepends = [ - aeson - attoparsec - base - beam-core - beam-migrate - bytestring - containers - direct-sqlite - dlist - free - hashable - monad-control - mtl - network-uri - scientific - sqlite-simple - text - time - transformers-base - ]; - testHaskellDepends = [ - base - beam-core - beam-migrate - sqlite-simple - tasty - tasty-expected-failure - tasty-hunit - text - time - ]; - description = "Beam driver for SQLite"; - license = lib.licenses.mit; - } - ) { }; - - beam-sqlite_0_5_7_0 = callPackage ( { mkDerivation, aeson, @@ -102425,7 +102022,6 @@ self: { ]; description = "Beam driver for SQLite"; license = lib.licenses.mit; - hydraPlatforms = lib.platforms.none; } ) { }; @@ -104091,8 +103687,8 @@ self: { pname = "bhoogle"; version = "0.1.4.4"; sha256 = "1z19h0jgnipj16rqbrflcjnqaslafq9bvwkyg8q0il76q7s4wyxa"; - revision = "6"; - editedCabalFile = "1k302sip83cq06b82hv7sxy4vv2wjap8f07rqg7nnswl40gwkv8r"; + revision = "7"; + editedCabalFile = "1d16b9kz0bsk7hbk4x8hj1qf0rlfz9azdkg6i1qcap0w6p77gwpp"; isLibrary = false; isExecutable = true; executableHaskellDepends = [ @@ -114136,12 +113732,12 @@ self: { } ) { }; - bluefin_0_4_3_0 = callPackage ( + bluefin_0_5_0_0 = callPackage ( { mkDerivation, bluefin-internal }: mkDerivation { pname = "bluefin"; - version = "0.4.3.0"; - sha256 = "0hqnx9nfyd2wgrrbh23hyrhrpz9b6v8hwaw9gixnwy585xa2rpj3"; + version = "0.5.0.0"; + sha256 = "0yvqp9mvwpqqqwfa8nzvcscai3ajm04l7frsh0pba43rnbvq1fng"; libraryHaskellDepends = [ bluefin-internal ]; description = "The Bluefin effect system"; license = lib.licensesSpdx."MIT"; @@ -114164,8 +113760,8 @@ self: { pname = "bluefin-algae"; version = "0.1.0.2"; sha256 = "02g513vqn052qd41zm9brw8lf1ic4135mi8kr3s4w0721vm4nkhh"; - revision = "4"; - editedCabalFile = "02hx8g5kyx26znb145d55w6wm50lyjb5cx0y6d9dxnf11b2i21dj"; + revision = "5"; + editedCabalFile = "1wj4f5bd3vbrv2gxhspp3zs0c147m9k0kxm7z7jy1h7g59ckvpaz"; libraryHaskellDepends = [ base bluefin @@ -114197,6 +113793,8 @@ self: { pname = "bluefin-contrib"; version = "0.2.1.0"; sha256 = "0iniw62zcw97fwz94dv1rakhy59irw2hjcnwklmmap1gka843wcx"; + revision = "1"; + editedCabalFile = "1ky487alnlj5zpdv8y7lr6vprg89d55i6yywgall1hfap5vcfwki"; libraryHaskellDepends = [ base bluefin @@ -114236,7 +113834,7 @@ self: { } ) { }; - bluefin-internal_0_4_3_0 = callPackage ( + bluefin-internal_0_5_0_0 = callPackage ( { mkDerivation, async, @@ -114249,8 +113847,8 @@ self: { }: mkDerivation { pname = "bluefin-internal"; - version = "0.4.3.0"; - sha256 = "1nj9phqq8xpxfjh1n7xk9zxhmx6nyh9hblah6fs5cgpqfwwrsql7"; + version = "0.5.0.0"; + sha256 = "0asl1y892j69vq57myfl2dipf0ig6dscvcch1pjn3lg0g4w7ynj8"; libraryHaskellDepends = [ async base @@ -114334,8 +113932,8 @@ self: { pname = "bluefin-random"; version = "0.2.0.0"; sha256 = "1kvhcz84gdpv0x4jmqi75i2l85kfkmsyp8vqpl39hgxwy1d8fmyf"; - revision = "2"; - editedCabalFile = "0b10d9af349q7pj4qs0q05f9xc34mlfbvpdy4vqm4jfw1kg0ddg7"; + revision = "3"; + editedCabalFile = "01hkawxx5pl0i7qf5dypq6xvxf28skf8vasjsp217wvy61ag3ihn"; libraryHaskellDepends = [ base bluefin @@ -119542,6 +119140,158 @@ self: { } ) { }; + brush-strokes = callPackage ( + { + mkDerivation, + acts, + base, + bifunctors, + code-page, + containers, + deepseq, + directory, + eigen, + falsify, + filepath, + fp-ieee, + generic-lens, + ghc-prim, + groups, + groups-generic, + hspray, + optparse-applicative, + parallel, + primitive, + rounded-hw, + system-cxx-std-lib, + tasty, + template-haskell, + time, + transformers, + tree-view, + unordered-containers, + }: + mkDerivation { + pname = "brush-strokes"; + version = "0.1.0.0"; + sha256 = "0qbdg64iy3z15ynzz1w2lpmi8lia6kmclg4152v4m0lcm9xxqigs"; + revision = "1"; + editedCabalFile = "1spniyqxr693m6pkqpcg0d1w639p0nc5prh5w68aly2z0a4a5s55"; + libraryHaskellDepends = [ + acts + base + bifunctors + code-page + containers + deepseq + directory + eigen + filepath + fp-ieee + generic-lens + ghc-prim + groups + groups-generic + parallel + primitive + rounded-hw + system-cxx-std-lib + template-haskell + time + transformers + tree-view + ]; + testHaskellDepends = [ + base + code-page + containers + deepseq + falsify + hspray + optparse-applicative + parallel + primitive + tasty + tree-view + unordered-containers + ]; + benchmarkHaskellDepends = [ + base + code-page + containers + deepseq + primitive + tree-view + ]; + doHaddock = false; + description = "Toolkit for Bézier curves and brush stroking"; + license = lib.licensesSpdx."BSD-3-Clause"; + } + ) { }; + + brush-stroking = callPackage ( + { + mkDerivation, + acts, + aeson, + aeson-pretty, + atomic-file-ops, + base, + brush-strokes, + bytestring, + containers, + deepseq, + directory, + filepath, + generic-lens, + gi-cairo-connector, + gi-cairo-render, + groups, + hashable, + hermes-json, + lens, + mtl, + scientific, + stm, + text, + transformers, + unordered-containers, + }: + mkDerivation { + pname = "brush-stroking"; + version = "0.1.0.0"; + sha256 = "1zm67c1689vg3iqdiri3sc50j5jaaym7m023ibs7zyxm5v7wadhh"; + libraryHaskellDepends = [ + acts + aeson + aeson-pretty + atomic-file-ops + base + brush-strokes + bytestring + containers + deepseq + directory + filepath + generic-lens + gi-cairo-connector + gi-cairo-render + groups + hashable + hermes-json + lens + mtl + scientific + stm + text + transformers + unordered-containers + ]; + description = "Brush strokes document model and renderer"; + license = lib.licensesSpdx."BSD-3-Clause"; + } + ) { }; + bsb-http-chunked = callPackage ( { mkDerivation, @@ -144084,104 +143834,6 @@ self: { ) { }; clash-ghc = callPackage ( - { - mkDerivation, - array, - base, - bytestring, - Cabal, - clash-lib, - clash-prelude, - containers, - data-binary-ieee754, - deepseq, - directory, - exceptions, - extra, - filepath, - ghc, - ghc-bignum, - ghc-boot, - ghc-prim, - ghc-typelits-extra, - ghc-typelits-knownnat, - ghc-typelits-natnormalise, - ghci, - hashable, - haskeline, - lens, - mtl, - primitive, - process, - reflection, - split, - string-interpolate, - template-haskell, - text, - time, - transformers, - uniplate, - unix, - unordered-containers, - utf8-string, - vector, - }: - mkDerivation { - pname = "clash-ghc"; - version = "1.8.4"; - sha256 = "1dgmqy5nm8fn55lmgd05akpkal46cydvbk0w6ian2z3979q4w4gb"; - revision = "1"; - editedCabalFile = "0pq4j5v7z94mr2v5gnivmcm03jr3z7xg16cz0hjqkrk2z2awrr2s"; - isLibrary = true; - isExecutable = true; - libraryHaskellDepends = [ - array - base - bytestring - Cabal - clash-lib - clash-prelude - containers - data-binary-ieee754 - deepseq - directory - exceptions - extra - filepath - ghc - ghc-bignum - ghc-boot - ghc-prim - ghc-typelits-extra - ghc-typelits-knownnat - ghc-typelits-natnormalise - ghci - hashable - haskeline - lens - mtl - primitive - process - reflection - split - string-interpolate - template-haskell - text - time - transformers - uniplate - unix - unordered-containers - utf8-string - vector - ]; - executableHaskellDepends = [ base ]; - description = "Clash: a functional hardware description language - GHC frontend"; - license = lib.licensesSpdx."BSD-2-Clause"; - } - ) { }; - - clash-ghc_1_8_5 = callPackage ( { mkDerivation, array, @@ -144274,179 +143926,10 @@ self: { executableHaskellDepends = [ base ]; description = "Clash: a functional hardware description language - GHC frontend"; license = lib.licensesSpdx."BSD-2-Clause"; - hydraPlatforms = lib.platforms.none; } ) { }; clash-lib = callPackage ( - { - mkDerivation, - aeson, - aeson-pretty, - ansi-terminal, - array, - async, - attoparsec, - attoparsec-aeson, - base, - base16-bytestring, - binary, - bytestring, - clash-prelude, - containers, - cryptohash-sha256, - data-binary-ieee754, - data-default, - deepseq, - directory, - dlist, - doctest-parallel, - exceptions, - extra, - filepath, - ghc, - ghc-bignum, - ghc-boot-th, - ghc-prim, - ghc-typelits-knownnat, - Glob, - hashable, - haskell-src-exts, - haskell-src-meta, - hint, - infinite-list, - lens, - mtl, - ordered-containers, - pretty-show, - prettyprinter, - prettyprinter-interp, - primitive, - quickcheck-text, - string-interpolate, - tasty, - tasty-hunit, - tasty-quickcheck, - tasty-th, - template-haskell, - temporary, - terminal-size, - text, - time, - transformers, - trifecta, - unordered-containers, - vector, - vector-binary-instances, - yaml, - }: - mkDerivation { - pname = "clash-lib"; - version = "1.8.4"; - sha256 = "1pria81l325zdh8ccpkig5sp9lv4k819sk7pgkjf1s8hjknlsv9x"; - revision = "1"; - editedCabalFile = "0iif62zqbzxkmvgfbqmagxkrx5k6y97p1qamrcnqa544gxcrj4c0"; - isLibrary = true; - isExecutable = true; - enableSeparateDataOutput = true; - libraryHaskellDepends = [ - aeson - aeson-pretty - ansi-terminal - array - async - attoparsec - attoparsec-aeson - base - base16-bytestring - binary - bytestring - clash-prelude - containers - cryptohash-sha256 - data-binary-ieee754 - data-default - deepseq - directory - dlist - exceptions - extra - filepath - ghc - ghc-bignum - ghc-boot-th - ghc-prim - hashable - haskell-src-meta - hint - infinite-list - lens - mtl - ordered-containers - pretty-show - prettyprinter - prettyprinter-interp - primitive - string-interpolate - template-haskell - temporary - terminal-size - text - time - transformers - trifecta - unordered-containers - vector - vector-binary-instances - yaml - ]; - executableHaskellDepends = [ - aeson - attoparsec-aeson - base - bytestring - containers - deepseq - directory - Glob - text - yaml - ]; - testHaskellDepends = [ - aeson - aeson-pretty - attoparsec-aeson - base - base16-bytestring - bytestring - clash-prelude - containers - data-default - deepseq - doctest-parallel - filepath - ghc - ghc-typelits-knownnat - haskell-src-exts - lens - pretty-show - quickcheck-text - tasty - tasty-hunit - tasty-quickcheck - tasty-th - template-haskell - text - transformers - unordered-containers - ]; - description = "Clash: a functional hardware description language - As a library"; - license = lib.licensesSpdx."BSD-2-Clause"; - mainProgram = "v16-upgrade-primitives"; - } - ) { }; - - clash-lib_1_8_5 = callPackage ( { mkDerivation, aeson, @@ -144608,7 +144091,6 @@ self: { ]; description = "Clash: a functional hardware description language - As a library"; license = lib.licensesSpdx."BSD-2-Clause"; - hydraPlatforms = lib.platforms.none; mainProgram = "v16-upgrade-primitives"; } ) { }; @@ -144687,135 +144169,6 @@ self: { ) { }; clash-prelude = callPackage ( - { - mkDerivation, - array, - arrows, - base, - binary, - bytestring, - constraints, - containers, - criterion, - data-binary-ieee754, - data-default-class, - deepseq, - directory, - doctest-parallel, - extra, - filepath, - ghc-bignum, - ghc-prim, - ghc-typelits-extra, - ghc-typelits-knownnat, - ghc-typelits-natnormalise, - half, - hashable, - hedgehog, - hint, - infinite-list, - lens, - mtl, - QuickCheck, - quickcheck-classes-base, - recursion-schemes, - reflection, - singletons, - string-interpolate, - tagged, - tasty, - tasty-hedgehog, - tasty-hunit, - tasty-quickcheck, - tasty-th, - template-haskell, - text, - th-abstraction, - th-lift, - th-orphans, - time, - transformers, - type-errors, - uniplate, - vector, - }: - mkDerivation { - pname = "clash-prelude"; - version = "1.8.4"; - sha256 = "0vc9vcqbh0i8xkm833nwxfmwxi47kzcajrh8nywymal2nsid1gby"; - revision = "2"; - editedCabalFile = "0y3czgr1rvnbrnh8y15wga0qpjbh8dih55qq376x6qm8pij9a78q"; - libraryHaskellDepends = [ - array - arrows - base - binary - bytestring - constraints - containers - data-binary-ieee754 - data-default-class - deepseq - extra - ghc-bignum - ghc-prim - ghc-typelits-extra - ghc-typelits-knownnat - ghc-typelits-natnormalise - half - hashable - infinite-list - lens - mtl - QuickCheck - recursion-schemes - reflection - singletons - string-interpolate - tagged - template-haskell - text - th-abstraction - th-lift - th-orphans - time - transformers - type-errors - uniplate - vector - ]; - testHaskellDepends = [ - base - bytestring - deepseq - doctest-parallel - filepath - ghc-typelits-extra - ghc-typelits-knownnat - ghc-typelits-natnormalise - hedgehog - hint - quickcheck-classes-base - tasty - tasty-hedgehog - tasty-hunit - tasty-quickcheck - tasty-th - template-haskell - ]; - benchmarkHaskellDepends = [ - base - criterion - deepseq - directory - template-haskell - ]; - description = "Clash: a functional hardware description language - Prelude library"; - license = lib.licensesSpdx."BSD-2-Clause"; - } - ) { }; - - clash-prelude_1_8_5 = callPackage ( { mkDerivation, array, @@ -144944,38 +144297,10 @@ self: { ]; description = "Clash: a functional hardware description language - Prelude library"; license = lib.licensesSpdx."BSD-2-Clause"; - hydraPlatforms = lib.platforms.none; } ) { }; clash-prelude-hedgehog = callPackage ( - { - mkDerivation, - base, - clash-prelude, - ghc-typelits-knownnat, - ghc-typelits-natnormalise, - hedgehog, - text, - }: - mkDerivation { - pname = "clash-prelude-hedgehog"; - version = "1.8.4"; - sha256 = "15jf4vr1p42s5pvs417y917j82m69df4prlgs3jl3l2h43psh3y5"; - libraryHaskellDepends = [ - base - clash-prelude - ghc-typelits-knownnat - ghc-typelits-natnormalise - hedgehog - text - ]; - description = "Hedgehog Generators for clash-prelude"; - license = lib.licensesSpdx."BSD-2-Clause"; - } - ) { }; - - clash-prelude-hedgehog_1_8_5 = callPackage ( { mkDerivation, base, @@ -144999,7 +144324,6 @@ self: { ]; description = "Hedgehog Generators for clash-prelude"; license = lib.licensesSpdx."BSD-2-Clause"; - hydraPlatforms = lib.platforms.none; } ) { }; @@ -153356,33 +152680,6 @@ self: { ) { }; colour = callPackage ( - { - mkDerivation, - base, - QuickCheck, - random, - test-framework, - test-framework-quickcheck2, - }: - mkDerivation { - pname = "colour"; - version = "2.3.6"; - sha256 = "0wgqj64mh2y2zk77kv59k3xb3dk4wmgfp988y74sp9a4d76mvlrc"; - enableSeparateDataOutput = true; - libraryHaskellDepends = [ base ]; - testHaskellDepends = [ - base - QuickCheck - random - test-framework - test-framework-quickcheck2 - ]; - description = "A model for human colour/color perception"; - license = lib.licenses.mit; - } - ) { }; - - colour_2_3_7 = callPackage ( { mkDerivation, base, @@ -153410,7 +152707,6 @@ self: { ]; description = "A model for human colour/color perception"; license = lib.licenses.mit; - hydraPlatforms = lib.platforms.none; } ) { }; @@ -174321,7 +173617,7 @@ self: { } ) { }; - crypton_1_1_1 = callPackage ( + crypton_1_1_2 = callPackage ( { mkDerivation, base, @@ -174341,8 +173637,8 @@ self: { }: mkDerivation { pname = "crypton"; - version = "1.1.1"; - sha256 = "04200abr2wavnkq73kch9wwnl5lcnd4n69jdfzg6mngz6pzby0sf"; + version = "1.1.2"; + sha256 = "17ndb7zi05gbkkf153xdwxznlqq14masaj9acv4n44hcgzdamk41"; libraryHaskellDepends = [ base base16 @@ -175969,6 +175265,50 @@ self: { } ) { }; + css-class-bindings = callPackage ( + { + mkDerivation, + base, + containers, + css-syntax, + directory, + filepath, + QuickCheck, + tasty, + tasty-discover, + tasty-hunit, + tasty-quickcheck, + template-haskell, + text, + }: + mkDerivation { + pname = "css-class-bindings"; + version = "0.0.2"; + sha256 = "1pz2wimhy0f28c9zdkkfws18ayci2d744fd0hnq76s0sxsml6hxf"; + libraryHaskellDepends = [ + base + containers + css-syntax + directory + filepath + template-haskell + text + ]; + testHaskellDepends = [ + base + QuickCheck + tasty + tasty-discover + tasty-hunit + tasty-quickcheck + template-haskell + ]; + testToolDepends = [ tasty-discover ]; + description = "generates Haskell bindings for CSS classes"; + license = lib.licensesSpdx."BSD-3-Clause"; + } + ) { }; + css-easings = callPackage ( { mkDerivation, @@ -185585,7 +184925,7 @@ self: { } ) { }; - dataframe_1_0_0_1 = callPackage ( + dataframe_1_1_0_0 = callPackage ( { mkDerivation, aeson, @@ -185605,8 +184945,6 @@ self: { hashable, http-conduit, HUnit, - mmap, - parallel, process, QuickCheck, random, @@ -185630,8 +184968,8 @@ self: { }: mkDerivation { pname = "dataframe"; - version = "1.0.0.1"; - sha256 = "0yvg1jl66x7y47swsgx8bfgfvxys10879phdv8n1z39b3d2165lq"; + version = "1.1.0.0"; + sha256 = "07n21b7b9mn35cbhj5hqx2p3pj31493q2i916882nxdpmgbvwc82"; isLibrary = true; isExecutable = true; libraryHaskellDepends = [ @@ -185650,8 +184988,6 @@ self: { granite hashable http-conduit - mmap - parallel process random regex-tdfa @@ -185687,7 +185023,6 @@ self: { base bytestring containers - directory HUnit QuickCheck random @@ -195362,8 +194697,8 @@ self: { }: mkDerivation { pname = "dhscanner-ast"; - version = "1.1.4"; - sha256 = "021gwh23vndd88av6f0daycnvx83pbacwrnavyd46f9mrjnygqwm"; + version = "1.1.5"; + sha256 = "1bgil53any94bhy3cwiakai5vs445mkv7x3sr98lzv24791yhxzs"; libraryHaskellDepends = [ aeson base @@ -203124,69 +202459,6 @@ self: { ) { }; djot = callPackage ( - { - mkDerivation, - base, - bytestring, - containers, - directory, - doclayout, - filepath, - mtl, - tasty, - tasty-bench, - tasty-hunit, - tasty-quickcheck, - template-haskell, - text, - }: - mkDerivation { - pname = "djot"; - version = "0.1.3"; - sha256 = "1066rgzb9lf2fa9bi3i7rdln9yn7kkjwx31gfhljqsryxqqr9prn"; - isLibrary = true; - isExecutable = true; - libraryHaskellDepends = [ - base - bytestring - containers - doclayout - mtl - template-haskell - text - ]; - executableHaskellDepends = [ - base - bytestring - doclayout - text - ]; - testHaskellDepends = [ - base - bytestring - directory - doclayout - filepath - tasty - tasty-hunit - tasty-quickcheck - text - ]; - benchmarkHaskellDepends = [ - base - bytestring - directory - doclayout - filepath - tasty-bench - ]; - description = "Parser and renderer for djot light markup syntax"; - license = lib.licensesSpdx."MIT"; - mainProgram = "djoths"; - } - ) { }; - - djot_0_1_4 = callPackage ( { mkDerivation, base, @@ -203245,7 +202517,6 @@ self: { ]; description = "Parser and renderer for djot light markup syntax"; license = lib.licensesSpdx."MIT"; - hydraPlatforms = lib.platforms.none; mainProgram = "djoths"; } ) { }; @@ -209551,10 +208822,8 @@ self: { }: mkDerivation { pname = "dual-tree"; - version = "0.2.3.1"; - sha256 = "19nm34d166fhlkk7npx0iq9kbx7300a82bg75q1sx98jqfa4nffh"; - revision = "5"; - editedCabalFile = "0ihx1l9s864z4pvqkahy0ch6k4fqrz4yzb0dqwrnagsa2akbz9c4"; + version = "0.2.3.2"; + sha256 = "12k22x4264x0g0rvv4bdz22bi10fdim9h512ibi59wzvkbb6pkl5"; libraryHaskellDepends = [ base monoid-extras @@ -239087,42 +238356,6 @@ self: { ) { }; filepath-bytestring = callPackage ( - { - mkDerivation, - base, - bytestring, - criterion, - filepath, - QuickCheck, - unix, - }: - mkDerivation { - pname = "filepath-bytestring"; - version = "1.5.2.0.3"; - sha256 = "0jz6mpr6fvxijvkib9500x25np7j836wrvy8jd23l16r4rhnhmxy"; - libraryHaskellDepends = [ - base - bytestring - filepath - unix - ]; - testHaskellDepends = [ - base - bytestring - filepath - QuickCheck - ]; - benchmarkHaskellDepends = [ - base - criterion - filepath - ]; - description = "Library for manipulating RawFilePaths in a cross platform way"; - license = lib.licenses.bsd3; - } - ) { }; - - filepath-bytestring_1_5_2_0_4 = callPackage ( { mkDerivation, base, @@ -239155,7 +238388,6 @@ self: { ]; description = "Library for manipulating RawFilePaths in a cross platform way"; license = lib.licenses.bsd3; - hydraPlatforms = lib.platforms.none; } ) { }; @@ -246238,8 +245470,8 @@ self: { }: mkDerivation { pname = "fontwhich"; - version = "0.2.1"; - sha256 = "1ayzaxzcj80k6v1mwc0sgj65bwmpzzd6h33ssdrdd12972pvr4ja"; + version = "0.3"; + sha256 = "12g1qh6lrhbh6rx2xk1r3zn9iqqrrwdb9mglz1iw2mfld8yqfrjj"; isLibrary = false; isExecutable = true; executableHaskellDepends = [ @@ -255655,8 +254887,8 @@ self: { }: mkDerivation { pname = "fuzzySets"; - version = "1.0.1"; - sha256 = "1snj86p40p8abjhiqqblqi2qz35w3mnsbzq7x70rbc76hp6qyvw1"; + version = "1.0.2"; + sha256 = "1fkwaklnjmf720j3gkqgl146vgg4aa0m71scbd0jqgb61xa9app4"; libraryHaskellDepends = [ base ]; testHaskellDepends = [ base @@ -269701,20 +268933,6 @@ self: { ) { }; ghcjs-dom-jsaddle = callPackage ( - { mkDerivation, jsaddle-dom }: - mkDerivation { - pname = "ghcjs-dom-jsaddle"; - version = "0.9.9.0"; - sha256 = "0r9xkp23j3w8c6qwsx4zyd8g8a3pryx073rw84k7fl8nfsjb0b7m"; - libraryHaskellDepends = [ jsaddle-dom ]; - doHaddock = false; - description = "DOM library that supports both GHCJS and GHC using jsaddle"; - license = lib.licensesSpdx."MIT"; - maintainers = [ lib.maintainers.alexfmpe ]; - } - ) { }; - - ghcjs-dom-jsaddle_0_9_9_1 = callPackage ( { mkDerivation, jsaddle-dom }: mkDerivation { pname = "ghcjs-dom-jsaddle"; @@ -269724,7 +268942,6 @@ self: { doHaddock = false; description = "DOM library that supports both GHCJS and GHC using jsaddle"; license = lib.licensesSpdx."MIT"; - hydraPlatforms = lib.platforms.none; maintainers = [ lib.maintainers.alexfmpe ]; } ) { }; @@ -292258,8 +291475,8 @@ self: { pname = "groups-generic"; version = "0.3.1.0"; sha256 = "1v9mw478x6kfv38m13kypfmz9w8vn3xkvff3gy9g7x29aq5bvjfy"; - revision = "1"; - editedCabalFile = "1fsniqwyinpj9fmavdy915pl9f39bcyqbppk3iilml02yjrg73kg"; + revision = "2"; + editedCabalFile = "0zzr205mm4d68d13x934rpqfs0wflb79yqgkhg6dvnkkn1jj8bxk"; libraryHaskellDepends = [ base groups @@ -300470,6 +299687,7 @@ self: { blaze-html, bytestring, containers, + contravariant, data-default, deepseq, directory, @@ -300511,10 +299729,8 @@ self: { }: mkDerivation { pname = "hakyll"; - version = "4.16.7.1"; - sha256 = "18wg5ay6l3ngsmqq00g6y7djmg4f8285kwdi47g0rg70mq6sn0py"; - revision = "3"; - editedCabalFile = "185panz8k3wqiy1hpzaa9p38v1n7vwcj2r6ij2pwqs7qrrwqr6dw"; + version = "4.16.8.0"; + sha256 = "0hndp8y0rn4i534jgb2j08jps36x33ywxxy0iibxicsvc3y07l5p"; isLibrary = true; isExecutable = true; enableSeparateDataOutput = true; @@ -300525,6 +299741,7 @@ self: { blaze-html bytestring containers + contravariant data-default deepseq directory @@ -326687,6 +325904,8 @@ self: { pname = "hedgehog-extras"; version = "0.10.1.0"; sha256 = "04m51s11485war8ngyhywjnrb60fsn8fikrxz3bqzlib6k4mb7yz"; + revision = "1"; + editedCabalFile = "0rz162nj37v6472favc9rimczg3s6f54arwgjcxflz4qdna8d67p"; libraryHaskellDepends = [ aeson aeson-pretty @@ -363014,6 +362233,48 @@ self: { inherit (pkgs) zlib; }; + hsmin = callPackage ( + { + mkDerivation, + base, + directory, + filepath, + ghc-lib-parser, + optparse-applicative, + process, + tasty, + tasty-hunit, + temporary, + }: + mkDerivation { + pname = "hsmin"; + version = "0.1.0"; + sha256 = "0niqzyl5kw7jpgiw8b6jxf64g9xrlsck4j5999aq04bll9ag1nk1"; + isLibrary = true; + isExecutable = true; + libraryHaskellDepends = [ + base + ghc-lib-parser + ]; + executableHaskellDepends = [ + base + optparse-applicative + ]; + testHaskellDepends = [ + base + directory + filepath + process + tasty + tasty-hunit + temporary + ]; + description = "Haskell source code minifier for LLM token reduction"; + license = lib.licensesSpdx."MIT"; + mainProgram = "hsmin"; + } + ) { }; + hsmisc = callPackage ( { mkDerivation, @@ -378226,8 +377487,8 @@ self: { }: mkDerivation { pname = "hwm"; - version = "0.4.0"; - sha256 = "1b8xbwp3qwzdnidc9511kn54fzyaf9smpw3r5jqyf1d42yxzl17z"; + version = "0.5.0"; + sha256 = "08ljwsia33wb7ba5ndfhhws28h91y7mqhdyay3qwhyy3jsfcmnw0"; isLibrary = true; isExecutable = true; libraryHaskellDepends = [ @@ -379423,11 +378684,11 @@ self: { filepath, hspec, hspec-discover, - HsYAML, HUnit, mtl, process, QuickCheck, + regex-tdfa, scientific, split, text, @@ -379436,8 +378697,8 @@ self: { }: mkDerivation { pname = "hydra"; - version = "0.13.0"; - sha256 = "0pr8wd73jbk40d8ks6gryivj9n1i81qbrcq9vzzmz27402730ihw"; + version = "0.14.0"; + sha256 = "1ajds9p3z324w04nijfn4pjiilmdavyi2zi9ly51k1bgz0kpq3k2"; isLibrary = true; isExecutable = true; libraryHaskellDepends = [ @@ -379448,7 +378709,7 @@ self: { containers directory filepath - HsYAML + regex-tdfa scientific split text @@ -379463,7 +378724,7 @@ self: { directory filepath hspec - HsYAML + regex-tdfa scientific split text @@ -379479,11 +378740,11 @@ self: { filepath hspec hspec-discover - HsYAML HUnit mtl process QuickCheck + regex-tdfa scientific split text @@ -403087,72 +402348,6 @@ self: { ) { }; jsaddle = callPackage ( - { - mkDerivation, - aeson, - attoparsec, - base, - base-compat, - base64-bytestring, - bytestring, - containers, - deepseq, - exceptions, - filepath, - ghc-prim, - http-types, - lens, - primitive, - process, - random, - ref-tf, - scientific, - stm, - text, - time, - transformers, - unliftio-core, - unordered-containers, - vector, - }: - mkDerivation { - pname = "jsaddle"; - version = "0.9.9.3"; - sha256 = "0k784bcvqhnsd771pa3k1s8gv25adwwyxk1dzwyqvnp2jpl4djcc"; - libraryHaskellDepends = [ - aeson - attoparsec - base - base-compat - base64-bytestring - bytestring - containers - deepseq - exceptions - filepath - ghc-prim - http-types - lens - primitive - process - random - ref-tf - scientific - stm - text - time - transformers - unliftio-core - unordered-containers - vector - ]; - description = "Interface for JavaScript that works with GHCJS and GHC"; - license = lib.licenses.mit; - maintainers = [ lib.maintainers.alexfmpe ]; - } - ) { }; - - jsaddle_0_9_9_4 = callPackage ( { mkDerivation, aeson, @@ -403216,7 +402411,6 @@ self: { ]; description = "Interface for JavaScript that works with GHCJS and GHC"; license = lib.licenses.mit; - hydraPlatforms = lib.platforms.none; maintainers = [ lib.maintainers.alexfmpe ]; } ) { }; @@ -403252,36 +402446,6 @@ self: { ) { }; jsaddle-dom = callPackage ( - { - mkDerivation, - base, - base-compat, - exceptions, - jsaddle, - lens, - text, - transformers, - }: - mkDerivation { - pname = "jsaddle-dom"; - version = "0.9.9.2"; - sha256 = "0f2c95hagrabyb8s5bdyn1x6sbg5dzvzp23qhmyygi9cgp89nmf4"; - libraryHaskellDepends = [ - base - base-compat - exceptions - jsaddle - lens - text - transformers - ]; - description = "DOM library that uses jsaddle to support both GHCJS and GHC"; - license = lib.licensesSpdx."MIT"; - maintainers = [ lib.maintainers.alexfmpe ]; - } - ) { }; - - jsaddle-dom_0_9_9_3 = callPackage ( { mkDerivation, base, @@ -403307,7 +402471,6 @@ self: { ]; description = "DOM library that uses jsaddle to support both GHCJS and GHC"; license = lib.licensesSpdx."MIT"; - hydraPlatforms = lib.platforms.none; maintainers = [ lib.maintainers.alexfmpe ]; } ) { }; @@ -403348,74 +402511,6 @@ self: { ) { }; jsaddle-warp = callPackage ( - { - mkDerivation, - aeson, - base, - bytestring, - containers, - directory, - foreign-store, - hspec, - http-types, - jsaddle, - lens, - mtl, - process, - stm, - text, - time, - transformers, - wai, - wai-websockets, - warp, - websockets, - }: - mkDerivation { - pname = "jsaddle-warp"; - version = "0.9.9.5"; - sha256 = "1w7i64aaqisvk25f7p1qgxk1krqdh8ii9phapw0wyk7jcn6ybar2"; - enableSeparateDataOutput = true; - libraryHaskellDepends = [ - aeson - base - bytestring - containers - foreign-store - http-types - jsaddle - stm - text - time - transformers - wai - wai-websockets - warp - websockets - ]; - testHaskellDepends = [ - base - bytestring - directory - hspec - jsaddle - lens - mtl - process - text - warp - websockets - ]; - description = "Interface for JavaScript that works with GHCJS and GHC"; - license = lib.licensesSpdx."MIT"; - maintainers = [ - lib.maintainers.alexfmpe - lib.maintainers.maralorn - ]; - } - ) { }; - - jsaddle-warp_0_9_9_6 = callPackage ( { mkDerivation, aeson, @@ -403476,7 +402571,6 @@ self: { ]; description = "Interface for JavaScript that works with GHCJS and GHC"; license = lib.licensesSpdx."MIT"; - hydraPlatforms = lib.platforms.none; maintainers = [ lib.maintainers.alexfmpe lib.maintainers.maralorn @@ -465232,8 +464326,8 @@ self: { pname = "mmorph"; version = "1.2.2"; sha256 = "1bwzgd0xwvlxcgn86lvm26lnq0d4kd693zpyqr7m8xk77cmjsvyx"; - revision = "1"; - editedCabalFile = "093280asv0ni2yz0nn6zbvl7650b5wddfq3b521vi8vi16zizf9s"; + revision = "2"; + editedCabalFile = "0kvgdpmj3328ll3kp7wm9mvrr8vvw1fp7vzd701z8pm99319f359"; libraryHaskellDepends = [ base mtl @@ -485803,41 +484897,30 @@ self: { natural = callPackage ( { mkDerivation, + aeson, base, - checkers, - hedgehog, + doctest, lens, - QuickCheck, + process, semigroupoids, - tasty, - tasty-hedgehog, - tasty-hunit, - tasty-quickcheck, - transformers, }: mkDerivation { pname = "natural"; - version = "0.3.0.7"; - sha256 = "0g39s1pimcfp4agxfa823x0crbnwlx825zpzf675bdjnczdn18jy"; + version = "0.4.0.0"; + sha256 = "11a72y49d3kz6hy638b0g21gbwhpdk8x3yg62rxqa4ks78qisqnr"; libraryHaskellDepends = [ + aeson base lens semigroupoids ]; testHaskellDepends = [ base - checkers - hedgehog - lens - QuickCheck - tasty - tasty-hedgehog - tasty-hunit - tasty-quickcheck - transformers + process ]; + testToolDepends = [ doctest ]; description = "Natural number"; - license = lib.licenses.bsd3; + license = lib.licensesSpdx."BSD-3-Clause"; hydraPlatforms = lib.platforms.none; broken = true; } @@ -497132,6 +496215,7 @@ self: { http-api-data, http-client, http-client-tls, + scientific, servant, servant-client, servant-multipart-api, @@ -497146,8 +496230,8 @@ self: { }: mkDerivation { pname = "notion-client"; - version = "0.1.0.0"; - sha256 = "1q1l6ls0dk5wfbc7q8d357ahw4ia0f450q6a6kdk755ax5c8c75k"; + version = "0.5.0.0"; + sha256 = "0fzvyzfl44nnm43gqdd7qpfg530ga2yjyqs6v9dqlnwlxd0080m2"; isLibrary = true; isExecutable = true; libraryHaskellDepends = [ @@ -497160,6 +496244,7 @@ self: { filepath http-api-data http-client-tls + scientific servant servant-client servant-multipart-api @@ -497174,6 +496259,7 @@ self: { aeson base containers + scientific text unordered-containers vector @@ -497181,12 +496267,16 @@ self: { testHaskellDepends = [ aeson base + bytestring + containers http-client http-client-tls + scientific servant-client tasty tasty-hunit text + vector ]; description = "Type-safe Haskell client for the Notion API"; license = lib.licensesSpdx."MIT"; @@ -502439,44 +501529,6 @@ self: { ) { }; oeis = callPackage ( - { - mkDerivation, - base, - http-client, - http-client-tls, - http-types, - HUnit, - network, - network-uri, - test-framework, - test-framework-hunit, - utf8-string, - }: - mkDerivation { - pname = "oeis"; - version = "0.3.10.1"; - sha256 = "0m7h1pbiy2xpagvggsp6a8rvafdgzr84222bp8rl4yh57lz3wmw4"; - libraryHaskellDepends = [ - base - http-client - http-client-tls - http-types - network - network-uri - utf8-string - ]; - testHaskellDepends = [ - base - HUnit - test-framework - test-framework-hunit - ]; - description = "Interface to the Online Encyclopedia of Integer Sequences (OEIS)"; - license = lib.licenses.bsd3; - } - ) { }; - - oeis_0_3_10_2 = callPackage ( { mkDerivation, base, @@ -502511,7 +501563,6 @@ self: { ]; description = "Interface to the Online Encyclopedia of Integer Sequences (OEIS)"; license = lib.licenses.bsd3; - hydraPlatforms = lib.platforms.none; } ) { }; @@ -510600,6 +509651,46 @@ self: { } ) { }; + optparse-generic_1_5_3 = callPackage ( + { + mkDerivation, + base, + bytestring, + filepath, + Only, + optparse-applicative, + text, + time, + transformers, + transformers-compat, + void, + }: + mkDerivation { + pname = "optparse-generic"; + version = "1.5.3"; + sha256 = "1ikkq0dkyz7phrzm5dazibmabixmx72lf0xgy8p5pjdlwq70fn9i"; + isLibrary = true; + isExecutable = true; + libraryHaskellDepends = [ + base + bytestring + filepath + Only + optparse-applicative + text + time + transformers + transformers-compat + void + ]; + executableHaskellDepends = [ base ]; + description = "Auto-generate a command-line parser for your datatype"; + license = lib.licenses.bsd3; + hydraPlatforms = lib.platforms.none; + maintainers = [ lib.maintainers.Gabriella439 ]; + } + ) { }; + optparse-helper = callPackage ( { mkDerivation, @@ -522853,73 +521944,6 @@ self: { ) { }; password = callPackage ( - { - mkDerivation, - base, - base-compat, - base64, - bytestring, - Cabal, - cabal-doctest, - crypton, - doctest, - memory, - password-types, - QuickCheck, - quickcheck-instances, - scrypt, - tasty, - tasty-golden, - tasty-hunit, - tasty-quickcheck, - template-haskell, - text, - }: - mkDerivation { - pname = "password"; - version = "3.1.0.1"; - sha256 = "11vy7i86dwks1zx4bw7nnp0wj0a1cz2zs1ir4psjcvq9ayhl9fpp"; - setupHaskellDepends = [ - base - Cabal - cabal-doctest - ]; - libraryHaskellDepends = [ - base - base64 - bytestring - crypton - memory - password-types - template-haskell - text - ]; - testHaskellDepends = [ - base - base-compat - base64 - bytestring - crypton - doctest - memory - password-types - QuickCheck - quickcheck-instances - scrypt - tasty - tasty-golden - tasty-hunit - tasty-quickcheck - template-haskell - text - ]; - description = "Hashing and checking of passwords"; - license = lib.licenses.bsd3; - maintainers = [ lib.maintainers.cdepillabout ]; - } - ) { }; - - password_3_1_0_2 = callPackage ( { mkDerivation, base, @@ -522982,7 +522006,6 @@ self: { ]; description = "Hashing and checking of passwords"; license = lib.licenses.bsd3; - hydraPlatforms = lib.platforms.none; maintainers = [ lib.maintainers.cdepillabout ]; } ) { }; @@ -559792,6 +558815,8 @@ self: { pname = "prometheus-client"; version = "1.1.1"; sha256 = "1j248vy67j0wqfbh5wgqxa4l99ynsf9r2651wghqc7b5973rww3a"; + revision = "1"; + editedCabalFile = "0x2b7bq2k7k8ww6aza330xpamgy1accabljan7fz0f78v32pm1js"; libraryHaskellDepends = [ atomic-primops base @@ -560994,6 +560019,8 @@ self: { pname = "proto-lens"; version = "0.7.1.6"; sha256 = "13jwrqynj0yq5j5gb4z84b7j5jr0d862cqyyqsdix673wvhsw7dx"; + revision = "1"; + editedCabalFile = "1rcrlmh2svn6fg5x0jcn51nd732ihs14fj3q880ip9scl7yiwks0"; enableSeparateDataOutput = true; libraryHaskellDepends = [ base @@ -561039,6 +560066,8 @@ self: { pname = "proto-lens-arbitrary"; version = "0.1.2.14"; sha256 = "1a80kr9l05q5isfqx5ya9yi0rwybjdnjl0hmdxfd2x7gpvv4rlza"; + revision = "1"; + editedCabalFile = "0xr6pc2gkyp061z0bxk0wykakjr48kxfrbd0sz3jnns8xma3462b"; libraryHaskellDepends = [ base bytestring @@ -561210,6 +560239,8 @@ self: { pname = "proto-lens-optparse"; version = "0.1.1.13"; sha256 = "1v9xm0zd8gc63hsxs3gz44v2mvgl998878c9yijf25fk3rg4d9mi"; + revision = "1"; + editedCabalFile = "0ykpfvyprm91pram9k52wwb158h0p7fk1ra78rsyjjrvq74zaijp"; libraryHaskellDepends = [ base optparse-applicative @@ -561238,6 +560269,8 @@ self: { pname = "proto-lens-protobuf-types"; version = "0.7.2.2"; sha256 = "1k0idwvscsbyrlfz1fz5zvhdbi7l7i1qa6qnh1clhgp04avkwsk4"; + revision = "1"; + editedCabalFile = "1hbylr6fxbds3mnsn6984bzwrkf3306bz0ps0yp7khi6r42mflp1"; setupHaskellDepends = [ base Cabal @@ -561280,6 +560313,8 @@ self: { pname = "proto-lens-protoc"; version = "0.9.0.0"; sha256 = "077cwkznz9yg2lsha5gywalam4s0ccqpfplansvk5yvcajdqprmc"; + revision = "1"; + editedCabalFile = "18n9zbxj01dqm2jsxw4apxngmd20wqbg83hakzbaaa0f1d43i8fv"; isLibrary = true; isExecutable = true; libraryHaskellDepends = [ @@ -561324,6 +560359,8 @@ self: { pname = "proto-lens-runtime"; version = "0.7.0.7"; sha256 = "09gdpgsyf58h1xhbw2hzcxsv25yqhmmvp0z63fxcd20zr0fykxnh"; + revision = "1"; + editedCabalFile = "09rdbim4a66835l0waz2zsh9azdyy60zffi8x105hvphsg667fh4"; libraryHaskellDepends = [ base bytestring @@ -561359,6 +560396,8 @@ self: { pname = "proto-lens-setup"; version = "0.4.0.9"; sha256 = "1j1cq7bdv0lgi9hzx9ncmn0vy5gykmfqg51cwzykri2k8623dcaw"; + revision = "1"; + editedCabalFile = "037zj963xfl4skfmbq47rzkmlvgx3smsgy5m5hyhz714s80lxd5p"; libraryHaskellDepends = [ base bytestring @@ -566021,7 +565060,7 @@ self: { } ) { }; - pusher-http-haskell_2_1_0_22 = callPackage ( + pusher-http-haskell_2_1_0_23 = callPackage ( { mkDerivation, aeson, @@ -566042,8 +565081,8 @@ self: { }: mkDerivation { pname = "pusher-http-haskell"; - version = "2.1.0.22"; - sha256 = "0kymmgajm3a8qrz489dwhbq3pqzqvjh1m1ciid09xsny9bziplyn"; + version = "2.1.0.23"; + sha256 = "0khqarh5jsn7ha7byrlhmg4wj105iy2b6nf2xbk9pgvvkisgixa8"; libraryHaskellDepends = [ aeson base @@ -573337,8 +572376,8 @@ self: { }: mkDerivation { pname = "ram"; - version = "0.21.1"; - sha256 = "0gkr63maq8z15306l5qq8h0j1yaxrldn5ih8fncpppd1q37nwxj8"; + version = "0.22.0"; + sha256 = "05ax0g99h0rngw8hl2vz1wrjz5p1jbka8ybh7fgrs0kfqc8l0zig"; libraryHaskellDepends = [ base bytestring @@ -588353,8 +587392,8 @@ self: { }: mkDerivation { pname = "repl-alliance"; - version = "0.1.0.0"; - sha256 = "09jnk151s9phvrif2kg97m7p983qhb41bp72f31qk0pcxvj3l48m"; + version = "0.1.0.1"; + sha256 = "1wwa12i3dyf68mvnz0918jwns5mwjhmpxs66bm5ryrnsg343rzwd"; libraryHaskellDepends = [ auto-export auto-extract @@ -606458,6 +605497,36 @@ self: { } ) { }; + scfg = callPackage ( + { + mkDerivation, + base, + hspec, + megaparsec, + temporary, + text, + }: + mkDerivation { + pname = "scfg"; + version = "1.0.0"; + sha256 = "1gv9va64hwmx90q8z44vksn58wnha6hfkdmvsnh6bdb2804092w9"; + libraryHaskellDepends = [ + base + megaparsec + text + ]; + testHaskellDepends = [ + base + hspec + megaparsec + temporary + text + ]; + description = "SCFG parser for Haskell"; + license = lib.licensesSpdx."MIT"; + } + ) { }; + scgi = callPackage ( { mkDerivation, @@ -609377,8 +608446,8 @@ self: { }: mkDerivation { pname = "scripths"; - version = "0.3.0.0"; - sha256 = "1mmzfr7sfx5jm8jd9w4qd05zx87xklpanbj3ym9ysz95ywwhvl27"; + version = "0.3.0.1"; + sha256 = "1pkby75rz9sdd1bgxxv6lw416iy2jds2cq47xfm4khwc35f232bw"; isLibrary = true; isExecutable = true; libraryHaskellDepends = [ @@ -614978,8 +614047,8 @@ self: { pname = "servant"; version = "0.20.3.0"; sha256 = "00k6pwqxpyjp5qm5pjl8qb75iqmpql5iv3ac43xdvikcixffcwzj"; - revision = "2"; - editedCabalFile = "0wvq6jj6js7sxq1rrn4v6749zfwkz3cl8dsypf5cvbpkz1qp4d7j"; + revision = "3"; + editedCabalFile = "15qvrb3kx5z0m2yzp4870hmdfykynd3il5747j4433y29v8vxcvc"; libraryHaskellDepends = [ aeson attoparsec @@ -615267,10 +614336,8 @@ self: { }: mkDerivation { pname = "servant-auth"; - version = "0.4.2.0"; - sha256 = "0h71v9n3vd1ca9kav2b6w53wnk950hxlgp3hcnhyk7yd9aph4nwx"; - revision = "1"; - editedCabalFile = "1nzarwir9sncdi2fgsjl6yvq83mx0gj9z3l5d47nl15yzmblgyx4"; + version = "0.4.9.2"; + sha256 = "0f7gv1p8b2g87r507df1l876vrfdbrgmba6l9v1rim3bhqy2ysay"; libraryHaskellDepends = [ aeson base @@ -615312,10 +614379,8 @@ self: { }: mkDerivation { pname = "servant-auth-client"; - version = "0.4.2.0"; - sha256 = "1pvqiygnwnkj6y4mi03qnpjlp305cjmpzp7nrqmc2p6qwnl2l4q9"; - revision = "2"; - editedCabalFile = "1cbsy3kpbwqliyc59fcwxgl5x31gigawl8zb4zhlv5afnq6inm3q"; + version = "0.4.9.2"; + sha256 = "0wfpg3l46qpxbbl3zdfwg6jbc89dk3pqh215s2l87ng4pmwg8ry4"; libraryHaskellDepends = [ base bytestring @@ -615644,10 +614709,8 @@ self: { }: mkDerivation { pname = "servant-auth-server"; - version = "0.4.9.1"; - sha256 = "04sy2g81pp0pr31xi6h1hqm199z6r4xv3fy2x307dlydxmdm8qb3"; - revision = "1"; - editedCabalFile = "0n29r1359vs9pl5rk7d7yh33i821qn9bcmrbfd4ddxl4n3sy27v1"; + version = "0.4.9.2"; + sha256 = "1qwzfqgfrs59q9m63ikqvam745jbz8206617r5blhgsds95m6jsp"; libraryHaskellDepends = [ aeson base @@ -620738,8 +619801,8 @@ self: { pname = "servant-server"; version = "0.20.3.0"; sha256 = "05crwklbncd393zq00gi04zgnfyy2wk31s0xf5hy6yjrsbshlmih"; - revision = "1"; - editedCabalFile = "1z2h1gmxphwd76chyah405ww4ciyxq7rvggghr6lh0z1m3p2k90h"; + revision = "3"; + editedCabalFile = "0ydamm9ljkj55y3yraahsccx8r3hwvfhzjy67k0kimgagdbz3alc"; isLibrary = true; isExecutable = true; libraryHaskellDepends = [ @@ -621640,8 +620703,8 @@ self: { pname = "servant-swagger-ui-core"; version = "0.3.5"; sha256 = "0ckvrwrb3x39hfl2hixcj3fhibh0vqsh6y7n1lsm25yvzfrg02zd"; - revision = "12"; - editedCabalFile = "1fl9g99iaiibh4355h8l2vk3xsmv7gb9fpg9s6i5a7f12as8lw5q"; + revision = "13"; + editedCabalFile = "1s6klk85hzvg337hyxgfi1764j2138rnb8b8kkhs36xz9g5jd75m"; libraryHaskellDepends = [ aeson base @@ -626797,6 +625860,7 @@ self: { { mkDerivation, base, + hashable, list-t, resourcet, stm, @@ -626806,10 +625870,11 @@ self: { }: mkDerivation { pname = "shared-resource-cache"; - version = "0.1.0.3"; - sha256 = "11j8nh68z05fslp87r25zz411ljmijm4nfm1720h9m8fjcf5w9am"; + version = "0.2.0.1"; + sha256 = "0grl87vbv3l72b6kkyrgbkl4gm69q119lgdvwvls857salkviy6s"; libraryHaskellDepends = [ base + hashable list-t resourcet stm @@ -626819,6 +625884,7 @@ self: { ]; testHaskellDepends = [ base + hashable list-t resourcet stm @@ -648964,10 +648030,13 @@ self: { sq = callPackage ( { mkDerivation, + adjunctions, aeson, async, async-pool, attoparsec, + attoparsec-aeson, + attoparsec-iso8601, base, binary, bytestring, @@ -648985,13 +648054,18 @@ self: { exceptions, filepath, foldl, + generics-sop, hedgehog, + integer-logarithms, + network-uri, profunctors, ref-tf, resource-pool, resourcet, resourcet-extra, safe-exceptions, + scientific, + sop-core, stm, streaming, tasty, @@ -649001,15 +648075,18 @@ self: { text, time, transformers, + uuid-types, }: mkDerivation { pname = "sq"; - version = "0.0.2"; - sha256 = "0ar5ga9n390r8jc5njm6mdrag73xx25xd02ld76zybjd2y78v8w4"; + version = "0.1"; + sha256 = "06gykqsfqdfpxnffjksf4ghy43qcraqyivmsyc4k2ysxmywgq8ry"; libraryHaskellDepends = [ + adjunctions aeson - async attoparsec + attoparsec-aeson + attoparsec-iso8601 base binary bytestring @@ -649024,18 +648101,24 @@ self: { exceptions filepath foldl + generics-sop + integer-logarithms + network-uri profunctors ref-tf resource-pool resourcet resourcet-extra safe-exceptions + scientific + sop-core stm streaming template-haskell text time transformers + uuid-types ]; testHaskellDepends = [ aeson @@ -649051,11 +648134,14 @@ self: { resourcet resourcet-extra safe-exceptions + scientific + sop-core tasty tasty-hedgehog tasty-hunit text time + uuid-types ]; benchmarkHaskellDepends = [ async @@ -682801,8 +681887,8 @@ self: { }: mkDerivation { pname = "taiwan-id"; - version = "0.1.1.0"; - sha256 = "14cfzhbb2y76dk3fdwcj8fvkal4zlhc0wfy5j540b7v8pz0yr3yz"; + version = "0.1.1.1"; + sha256 = "17l1c4knwcqpzb82dvxcy6c6sb4cdqgjl8r91jr9ykqj0qc6slz2"; isLibrary = true; isExecutable = true; libraryHaskellDepends = [ @@ -682838,7 +681924,7 @@ self: { text ]; doHaddock = false; - description = "Implementation of Taiwan's uniform ID number format"; + description = "Library and CLI for working with ID numbers issued in Taiwan"; license = lib.licensesSpdx."BSD-3-Clause"; hydraPlatforms = lib.platforms.none; mainProgram = "taiwan-id"; @@ -684648,40 +683734,6 @@ self: { ) { }; tasty = callPackage ( - { - mkDerivation, - ansi-terminal, - base, - containers, - optparse-applicative, - stm, - tagged, - transformers, - unix, - }: - mkDerivation { - pname = "tasty"; - version = "1.5.3"; - sha256 = "10076vlklbcyiz7plakrihava5sy3dvwhskjldqzhfl18jvcg82l"; - revision = "2"; - editedCabalFile = "04llcf1i3gawdik0bjhxdgls2wkiqlx0gi76nfh784nv2qzxlpbb"; - libraryHaskellDepends = [ - ansi-terminal - base - containers - optparse-applicative - stm - tagged - transformers - unix - ]; - description = "Modern and extensible testing framework"; - license = lib.licenses.mit; - maintainers = [ lib.maintainers.maralorn ]; - } - ) { }; - - tasty_1_5_4 = callPackage ( { mkDerivation, ansi-terminal, @@ -684709,7 +683761,6 @@ self: { ]; description = "Modern and extensible testing framework"; license = lib.licenses.mit; - hydraPlatforms = lib.platforms.none; maintainers = [ lib.maintainers.maralorn ]; } ) { }; @@ -720243,8 +719294,8 @@ self: { pname = "tz"; version = "0.1.3.6"; sha256 = "1vqnfk656i6j3j1bf9lc36adziv52x1b2ccq6afp8cka1nay2mcd"; - revision = "9"; - editedCabalFile = "0a2i820w6zpf0vi4ammi4jsq80h072abd5czsxjmisjkwz2rrajp"; + revision = "10"; + editedCabalFile = "113bkiafhsadq056yzj96xfp3x6zjk1r5p0v7jl3ck56q259nzw3"; libraryHaskellDepends = [ base binary @@ -720301,6 +719352,8 @@ self: { pname = "tzdata"; version = "0.2.20250115.0"; sha256 = "1h9sn9rngmvk2lqljcmysq9m7nwxlscm65rbzjqik8apsnb9qa53"; + revision = "1"; + editedCabalFile = "1dwdvsn34sf9y66ply1vh6cs1j9mz4q60nmwiq66nhmlixk9rnjx"; enableSeparateDataOutput = true; libraryHaskellDepends = [ base @@ -746362,6 +745415,71 @@ self: { } ) { }; + web-rep_0_14_1_0 = callPackage ( + { + mkDerivation, + async, + base, + bifunctors, + box, + box-socket, + bytestring, + flatparse, + markup-parse, + mtl, + optics-core, + optics-extra, + optparse-applicative, + profunctors, + scotty, + text, + transformers, + unordered-containers, + wai-middleware-static, + wai-websockets, + websockets, + }: + mkDerivation { + pname = "web-rep"; + version = "0.14.1.0"; + sha256 = "19lpn31y7q8ckrhpybksf77xvvnn4agynl3zfz39f3rqqanbbmv4"; + isLibrary = true; + isExecutable = true; + libraryHaskellDepends = [ + async + base + bifunctors + box + box-socket + bytestring + flatparse + markup-parse + mtl + optics-core + optics-extra + profunctors + scotty + text + transformers + unordered-containers + wai-middleware-static + wai-websockets + websockets + ]; + executableHaskellDepends = [ + base + box + markup-parse + optics-core + optparse-applicative + ]; + description = "representations of a web page"; + license = lib.licensesSpdx."BSD-3-Clause"; + hydraPlatforms = lib.platforms.none; + mainProgram = "web-rep-example"; + } + ) { }; + web-routes = callPackage ( { mkDerivation, @@ -757418,13 +756536,11 @@ self: { HUnit, MissingH, optparse-applicative, - text, - unordered-containers, }: mkDerivation { pname = "wyvern-diagrams"; - version = "0.4.1.0"; - sha256 = "06vgmv4r9spq4q94paawyklm2h45aj330z75l7vkh889wma8g8jx"; + version = "0.4.2.0"; + sha256 = "0nb9pc2cq0kx54m20544ss7ii0a3wn1d6n48ng3hrlhzx7zgvzk0"; isLibrary = true; isExecutable = true; libraryHaskellDepends = [ @@ -757436,8 +756552,6 @@ self: { diagrams-svg MissingH optparse-applicative - text - unordered-containers ]; executableHaskellDepends = [ base @@ -758329,52 +757443,6 @@ self: { ) { }; xdg-desktop-entry = callPackage ( - { - mkDerivation, - base, - directory, - either, - filepath, - hspec, - ini, - multimap, - safe, - temporary, - text, - transformers, - unix, - unordered-containers, - }: - mkDerivation { - pname = "xdg-desktop-entry"; - version = "0.1.1.3"; - sha256 = "0kbj76fxmkk4wc0rvw916kw6lryzjiw4m74cz9jhrwmgaap38z4b"; - libraryHaskellDepends = [ - base - directory - either - filepath - ini - multimap - safe - text - transformers - unix - unordered-containers - ]; - testHaskellDepends = [ - base - filepath - hspec - temporary - unix - ]; - description = "Parse files conforming to the xdg desktop entry spec"; - license = lib.licensesSpdx."BSD-3-Clause"; - } - ) { }; - - xdg-desktop-entry_0_1_1_4 = callPackage ( { mkDerivation, base, @@ -758417,7 +757485,6 @@ self: { ]; description = "Parse files conforming to the xdg desktop entry spec"; license = lib.licensesSpdx."BSD-3-Clause"; - hydraPlatforms = lib.platforms.none; } ) { }; From 17caee69418e62fa34ee185ba3ec764e4841ee5b Mon Sep 17 00:00:00 2001 From: Alexandre Esteves Date: Sun, 29 Mar 2026 23:23:23 +0100 Subject: [PATCH 14/52] haskellPackages.hell: unbreak --- .../haskell-modules/configuration-hackage2nix/broken.yaml | 1 - pkgs/development/haskell-modules/hackage-packages.nix | 2 -- 2 files changed, 3 deletions(-) diff --git a/pkgs/development/haskell-modules/configuration-hackage2nix/broken.yaml b/pkgs/development/haskell-modules/configuration-hackage2nix/broken.yaml index 60df5d516cc9..a2d80067cf0d 100644 --- a/pkgs/development/haskell-modules/configuration-hackage2nix/broken.yaml +++ b/pkgs/development/haskell-modules/configuration-hackage2nix/broken.yaml @@ -2720,7 +2720,6 @@ broken-packages: - helisp # failure in job https://hydra.nixos.org/build/233221194 at 2023-09-02 - helium-overture # failure in job https://hydra.nixos.org/build/295094176 at 2025-04-22 - helix # failure in job https://hydra.nixos.org/build/233254335 at 2023-09-02 - - hell # failure in job https://hydra.nixos.org/build/295094172 at 2025-04-22 - helm # failure in job https://hydra.nixos.org/build/233251620 at 2023-09-02 - help-esb # failure in job https://hydra.nixos.org/build/233202622 at 2023-09-02 - hemkay # failure in job https://hydra.nixos.org/build/233227889 at 2023-09-02 diff --git a/pkgs/development/haskell-modules/hackage-packages.nix b/pkgs/development/haskell-modules/hackage-packages.nix index 5d0ac2a5aa6e..49f3bb329218 100644 --- a/pkgs/development/haskell-modules/hackage-packages.nix +++ b/pkgs/development/haskell-modules/hackage-packages.nix @@ -328766,9 +328766,7 @@ self: { ]; description = "Haskell-based shell scripting language"; license = lib.licenses.bsd3; - hydraPlatforms = lib.platforms.none; mainProgram = "hell"; - broken = true; } ) { }; From 23f5520c3b8a9a3ef3bcbb9b1485c0951e41baf4 Mon Sep 17 00:00:00 2001 From: Wolfgang Walther Date: Mon, 30 Mar 2026 12:52:01 +0200 Subject: [PATCH 15/52] haskellPackages: regenerate hackage-packages.nix --- .../transitive-broken.yaml | 22 +++++++++++++++++++ .../haskell-modules/hackage-packages.nix | 22 +++++++++++++++++++ 2 files changed, 44 insertions(+) diff --git a/pkgs/development/haskell-modules/configuration-hackage2nix/transitive-broken.yaml b/pkgs/development/haskell-modules/configuration-hackage2nix/transitive-broken.yaml index 222d6b70953c..067e27c54e79 100644 --- a/pkgs/development/haskell-modules/configuration-hackage2nix/transitive-broken.yaml +++ b/pkgs/development/haskell-modules/configuration-hackage2nix/transitive-broken.yaml @@ -5,6 +5,7 @@ dont-distribute-packages: - 4Blocks + - a-piece-of-flake - a50 - abcBridge - AbortT-monadstf @@ -331,6 +332,8 @@ dont-distribute-packages: - bricks-syntax - brillo-examples - bronyradiogermany-streaming + - brush-strokes + - brush-stroking - btc-lsp - btree - buchhaltung @@ -1242,6 +1245,7 @@ dont-distribute-packages: - GuiHaskell - GuiTV - h3spec + - haal-models - habit - hablo - Hach @@ -1657,6 +1661,7 @@ dont-distribute-packages: - HSHHelpers - hsinspect-lsp - hslogstash + - hsmrc-marc8 - HSoundFile - HsParrot - hspec-dirstream @@ -1771,6 +1776,20 @@ dont-distribute-packages: - igrf - ihaskell-rlangqq - ihaskell-symtegration + - ihp + - ihp-datasync + - ihp-datasync-typescript + - ihp-graphql + - ihp-hspec + - ihp-ide + - ihp-job-dashboard + - ihp-mail + - ihp-migrate + - ihp-schema-compiler + - ihp-sitemap + - ihp-ssc + - ihp-typed-sql + - ihp-welcome - ihttp - imap - imbib @@ -1960,6 +1979,7 @@ dont-distribute-packages: - koji-tool - korfu - ks-test + - ktx-font - kubernetes-client - kure-your-boilerplate - kurita @@ -2533,6 +2553,7 @@ dont-distribute-packages: - parco-attoparsec - parco-parsec - parconc-examples + - parquet-haskell - parquet-hs - parse-help - parsestar @@ -3521,6 +3542,7 @@ dont-distribute-packages: - trurl - tsession-happstack - tsweb + - tui-launcher - tuntap-simple - tup-functor - tuple-gen diff --git a/pkgs/development/haskell-modules/hackage-packages.nix b/pkgs/development/haskell-modules/hackage-packages.nix index 41044a6ff85a..1beae3013ab3 100644 --- a/pkgs/development/haskell-modules/hackage-packages.nix +++ b/pkgs/development/haskell-modules/hackage-packages.nix @@ -49513,6 +49513,7 @@ self: { testToolDepends = [ tasty-discover ]; description = "Nix flake repository for everyone"; license = lib.licensesSpdx."BSD-3-Clause"; + hydraPlatforms = lib.platforms.none; mainProgram = "a-piece-of-flake"; } ) { }; @@ -119226,6 +119227,7 @@ self: { doHaddock = false; description = "Toolkit for Bézier curves and brush stroking"; license = lib.licensesSpdx."BSD-3-Clause"; + hydraPlatforms = lib.platforms.none; } ) { }; @@ -119289,6 +119291,7 @@ self: { ]; description = "Brush strokes document model and renderer"; license = lib.licensesSpdx."BSD-3-Clause"; + hydraPlatforms = lib.platforms.none; } ) { }; @@ -295590,6 +295593,7 @@ self: { ]; description = "Pre-built Mealy automaton models for haal"; license = lib.licensesSpdx."BSD-3-Clause"; + hydraPlatforms = lib.platforms.none; } ) { }; @@ -362380,6 +362384,7 @@ self: { ]; description = "MARC-8 charset decoding library for hsmrc"; license = lib.licenses.bsd3; + hydraPlatforms = lib.platforms.none; } ) { }; @@ -383987,6 +383992,7 @@ self: { ]; description = "Haskell Web Framework"; license = lib.licensesSpdx."MIT"; + hydraPlatforms = lib.platforms.none; maintainers = [ lib.maintainers.mpscholten ]; } ) { }; @@ -384155,6 +384161,7 @@ self: { ]; description = "IHP DataSync Framework"; license = lib.licensesSpdx."MIT"; + hydraPlatforms = lib.platforms.none; } ) { }; @@ -384196,6 +384203,7 @@ self: { ]; description = "TypeScript code generation for IHP DataSync"; license = lib.licensesSpdx."MIT"; + hydraPlatforms = lib.platforms.none; mainProgram = "generate-datasync-types"; } ) { }; @@ -384250,6 +384258,7 @@ self: { ]; description = "GraphQL support for IHP"; license = lib.licensesSpdx."MIT"; + hydraPlatforms = lib.platforms.none; } ) { }; @@ -384287,6 +384296,7 @@ self: { ]; description = "Test helpers for IHP apps"; license = lib.licensesSpdx."MIT"; + hydraPlatforms = lib.platforms.none; } ) { }; @@ -384624,6 +384634,7 @@ self: { ]; description = "Dev tools for IHP"; license = lib.licensesSpdx."MIT"; + hydraPlatforms = lib.platforms.none; maintainers = [ lib.maintainers.mpscholten ]; } ) { }; @@ -384695,6 +384706,7 @@ self: { ]; description = "Dashboard for IHP job runners"; license = lib.licensesSpdx."MIT"; + hydraPlatforms = lib.platforms.none; } ) { }; @@ -384767,6 +384779,7 @@ self: { ]; description = "Email support for IHP"; license = lib.licensesSpdx."MIT"; + hydraPlatforms = lib.platforms.none; } ) { }; @@ -384788,6 +384801,7 @@ self: { ]; description = "Provides the IHP migrate binary"; license = lib.licensesSpdx."MIT"; + hydraPlatforms = lib.platforms.none; mainProgram = "migrate"; maintainers = [ lib.maintainers.mpscholten ]; } @@ -385114,6 +385128,7 @@ self: { ]; description = "Lightweight schema compiler for IHP"; license = lib.licensesSpdx."MIT"; + hydraPlatforms = lib.platforms.none; mainProgram = "build-generated-code"; } ) { }; @@ -385157,6 +385172,7 @@ self: { ]; description = "SEO"; license = lib.licensesSpdx."MIT"; + hydraPlatforms = lib.platforms.none; } ) { }; @@ -385202,6 +385218,7 @@ self: { ]; description = "Server Side Components for IHP"; license = lib.licensesSpdx."MIT"; + hydraPlatforms = lib.platforms.none; } ) { }; @@ -385270,6 +385287,7 @@ self: { ]; description = "Compile-time typed SQL quasiquoter for IHP"; license = lib.licensesSpdx."MIT"; + hydraPlatforms = lib.platforms.none; } ) { }; @@ -385297,6 +385315,7 @@ self: { ]; description = "IHP Welcome Controller"; license = lib.licensesSpdx."MIT"; + hydraPlatforms = lib.platforms.none; } ) { }; @@ -414607,6 +414626,7 @@ self: { ]; description = "GPU-ready rasterized fonts"; license = lib.licensesSpdx."BSD-3-Clause"; + hydraPlatforms = lib.platforms.none; } ) { }; @@ -519943,6 +519963,7 @@ self: { ]; description = "Streaming Parquet reader"; license = lib.licenses.bsd3; + hydraPlatforms = lib.platforms.none; } ) { }; @@ -712880,6 +712901,7 @@ self: { ]; description = "Small Brick-based terminal launcher"; license = lib.licensesSpdx."MIT"; + hydraPlatforms = lib.platforms.none; mainProgram = "tui-launcher"; } ) { }; From 89bca40b71fc8e531976814daf427cfe89154b18 Mon Sep 17 00:00:00 2001 From: Ai-Ya-Ya Date: Tue, 6 Jan 2026 16:05:29 +0000 Subject: [PATCH 16/52] haskellPackages.geojson: enable tests This issue has been resolved upstream. --- pkgs/development/haskell-modules/configuration-common.nix | 4 ---- 1 file changed, 4 deletions(-) diff --git a/pkgs/development/haskell-modules/configuration-common.nix b/pkgs/development/haskell-modules/configuration-common.nix index 01adce84a872..c487be42f071 100644 --- a/pkgs/development/haskell-modules/configuration-common.nix +++ b/pkgs/development/haskell-modules/configuration-common.nix @@ -2519,10 +2519,6 @@ with haskellLib; doJailbreak ]; - # Test suite doesn't support hspec 2.8 - # https://github.com/zellige/hs-geojson/issues/29 - geojson = dontCheck super.geojson; - # Test data missing from sdist # https://github.com/ngless-toolkit/ngless/issues/152 NGLess = dontCheck super.NGLess; From eb0717565cf096353a978b511eae04e1f2237727 Mon Sep 17 00:00:00 2001 From: Ai-Ya-Ya Date: Tue, 6 Jan 2026 16:20:26 +0000 Subject: [PATCH 17/52] haskellPackages.reanimate-svg: unbreak see https://github.com/reanimate/reanimate-svg/pull/48 for more details --- .../haskell-modules/configuration-common.nix | 47 +++++++++++++++++++ .../configuration-hackage2nix/broken.yaml | 1 - .../transitive-broken.yaml | 2 - .../haskell-modules/configuration-nix.nix | 9 ++++ .../haskell-modules/hackage-packages.nix | 4 -- 5 files changed, 56 insertions(+), 7 deletions(-) diff --git a/pkgs/development/haskell-modules/configuration-common.nix b/pkgs/development/haskell-modules/configuration-common.nix index c487be42f071..f31006a543f8 100644 --- a/pkgs/development/haskell-modules/configuration-common.nix +++ b/pkgs/development/haskell-modules/configuration-common.nix @@ -2519,6 +2519,53 @@ with haskellLib; doJailbreak ]; + # 2026-01-06: unbreak and modernize to GHC 9.10.3 + reanimate-svg = overrideCabal (drv: { + # patching doesn't actually move files, need to do manually + prePatch = '' + # Move tests marked good due to previous librsvg failures + for f in \ + animate-elem-32-t.svg \ + fonts-desc-02-t.svg \ + shapes-ellipse-02-t.svg \ + shapes-intro-01-t.svg \ + styling-css-06-b.svg \ + text-intro-05-t.svg \ + ; do + mv test/good/$f test/bad/$f + done + + # Move tests previously marked bad but now fixed from new changes + for f in \ + filters-displace-02-f.svg \ + filters-gauss-01-b.svg \ + masking-mask-01-b.svg \ + painting-render-01-b.svg \ + pservers-grad-04-b.svg \ + pservers-grad-05-b.svg \ + pservers-grad-07-b.svg \ + pservers-grad-08-b.svg \ + pservers-grad-09-b.svg \ + pservers-grad-10-b.svg \ + pservers-grad-11-b.svg \ + pservers-grad-12-b.svg \ + pservers-grad-14-b.svg \ + pservers-grad-15-b.svg \ + pservers-grad-16-b.svg \ + pservers-grad-22-b.svg \ + ; do + mv test/bad/$f test/good/$f + done + ''; + patches = (drv.patches or [ ]) ++ [ + (pkgs.fetchpatch2 { + name = "modernize-to-ghc-9.10.3-and-regress-tests-wrt-librsvg"; + url = "https://github.com/reanimate/reanimate-svg/commit/3f2fab8eb08b7f35b03f5fa17819e43e3879ea80.patch"; + sha256 = "sha256-Em10QyAAiIwHId3CZuByKJ4Fv9W6MII4go5rychg07Y="; + }) + ]; + }) super.reanimate-svg; + # Test data missing from sdist # https://github.com/ngless-toolkit/ngless/issues/152 NGLess = dontCheck super.NGLess; diff --git a/pkgs/development/haskell-modules/configuration-hackage2nix/broken.yaml b/pkgs/development/haskell-modules/configuration-hackage2nix/broken.yaml index a2d80067cf0d..9ac9f1a7a1c3 100644 --- a/pkgs/development/haskell-modules/configuration-hackage2nix/broken.yaml +++ b/pkgs/development/haskell-modules/configuration-hackage2nix/broken.yaml @@ -5274,7 +5274,6 @@ broken-packages: - readme-lhs # failure in job https://hydra.nixos.org/build/233248229 at 2023-09-02 - readshp # failure in job https://hydra.nixos.org/build/233197835 at 2023-09-02 - really-simple-xml-parser # failure in job https://hydra.nixos.org/build/233195945 at 2023-09-02 - - reanimate-svg # failure in job https://hydra.nixos.org/build/233242271 at 2023-09-02 - reason-export # failure in job https://hydra.nixos.org/build/233212942 at 2023-09-02 - reasonable-lens # failure in job https://hydra.nixos.org/build/233233111 at 2023-09-02 - rebound # failure in job https://hydra.nixos.org/build/311055152 at 2025-11-02 diff --git a/pkgs/development/haskell-modules/configuration-hackage2nix/transitive-broken.yaml b/pkgs/development/haskell-modules/configuration-hackage2nix/transitive-broken.yaml index 067e27c54e79..d699e541caf3 100644 --- a/pkgs/development/haskell-modules/configuration-hackage2nix/transitive-broken.yaml +++ b/pkgs/development/haskell-modules/configuration-hackage2nix/transitive-broken.yaml @@ -2874,7 +2874,6 @@ dont-distribute-packages: - reactor - readline-in-other-words - readpyc - - reanimate - record-aeson - record-gl - record-preprocessor @@ -3383,7 +3382,6 @@ dont-distribute-packages: - sv-svfactor - SVG2Q - svg2q - - svgone - swapper - switch - syb-with-class-instances-text diff --git a/pkgs/development/haskell-modules/configuration-nix.nix b/pkgs/development/haskell-modules/configuration-nix.nix index 8c440508d42a..06463f06bff8 100644 --- a/pkgs/development/haskell-modules/configuration-nix.nix +++ b/pkgs/development/haskell-modules/configuration-nix.nix @@ -932,6 +932,15 @@ builtins.intersectAttrs super { # https://github.com/plow-technologies/servant-streaming/issues/12 servant-streaming-server = dontCheck super.servant-streaming-server; + reanimate-svg = overrideCabal (drv: { + buildTools = (drv.buildTools or [ ]) ++ [ + # needed for testsuite + pkgs.freefont_ttf + pkgs.librsvg + pkgs.pango + ]; + }) super.reanimate-svg; + # https://github.com/haskell-servant/servant/pull/1238 servant-client-core = if (pkgs.lib.getVersion super.servant-client-core) == "0.16" then diff --git a/pkgs/development/haskell-modules/hackage-packages.nix b/pkgs/development/haskell-modules/hackage-packages.nix index 1beae3013ab3..19b994b5e9c1 100644 --- a/pkgs/development/haskell-modules/hackage-packages.nix +++ b/pkgs/development/haskell-modules/hackage-packages.nix @@ -577709,7 +577709,6 @@ self: { ]; description = "Animation library based on SVGs"; license = lib.licenses.publicDomain; - hydraPlatforms = lib.platforms.none; } ) { }; @@ -577790,8 +577789,6 @@ self: { ]; description = "SVG file loader and serializer"; license = lib.licensesSpdx."BSD-3-Clause"; - hydraPlatforms = lib.platforms.none; - broken = true; } ) { }; @@ -673016,7 +673013,6 @@ self: { ]; description = "Optimise SVGs"; license = lib.licensesSpdx."BSD-3-Clause"; - hydraPlatforms = lib.platforms.none; mainProgram = "svgone"; } ) { }; From d4f018a21efec4509febbdb5b00e67f02341a31b Mon Sep 17 00:00:00 2001 From: Ai-Ya-Ya Date: Tue, 6 Jan 2026 17:58:24 +0000 Subject: [PATCH 18/52] haskellPackages.reanimate: unbreak see https://github.com/reanimate/reanimate/pull/317 for more details --- .../haskell-modules/configuration-common.nix | 18 ++++++++++++++++++ .../haskell-modules/configuration-nix.nix | 9 +++++++++ 2 files changed, 27 insertions(+) diff --git a/pkgs/development/haskell-modules/configuration-common.nix b/pkgs/development/haskell-modules/configuration-common.nix index f31006a543f8..f7d4168f56bc 100644 --- a/pkgs/development/haskell-modules/configuration-common.nix +++ b/pkgs/development/haskell-modules/configuration-common.nix @@ -2566,6 +2566,24 @@ with haskellLib; ]; }) super.reanimate-svg; + # 2026-01-06: modernize to GHC 9.10.3 + reanimate = overrideCabal (drv: { + # file in Hackage but not on github, need to remove here + # test relies on hegometry but that was removed as a dependency + # https://github.com/reanimate/reanimate/commit/f58a00e + prePatch = drv.prePatch or "" + '' + rm -f examples/decompose.hs + ''; + patches = (drv.patches or [ ]) ++ [ + # variant of PR https://github.com/reanimate/reanimate/pull/317 + (pkgs.fetchpatch2 { + name = "modernize-to-ghc-9.10.3"; + url = "https://github.com/reanimate/reanimate/commit/273f48c2b82dcfa027481133a6a606e73a22461b.patch"; + sha256 = "sha256-aibbIoc54I4Ibg6t2o8vykL8MqzmxLvayUNa8MiibEw="; + }) + ]; + }) super.reanimate; + # Test data missing from sdist # https://github.com/ngless-toolkit/ngless/issues/152 NGLess = dontCheck super.NGLess; diff --git a/pkgs/development/haskell-modules/configuration-nix.nix b/pkgs/development/haskell-modules/configuration-nix.nix index 06463f06bff8..d35cb985c947 100644 --- a/pkgs/development/haskell-modules/configuration-nix.nix +++ b/pkgs/development/haskell-modules/configuration-nix.nix @@ -932,6 +932,15 @@ builtins.intersectAttrs super { # https://github.com/plow-technologies/servant-streaming/issues/12 servant-streaming-server = dontCheck super.servant-streaming-server; + reanimate = overrideCabal (drv: { + buildTools = (drv.buildTools or [ ]) ++ [ + # needed for testsuite + pkgs.ffmpeg + pkgs.librsvg + pkgs.texliveFull + ]; + }) super.reanimate; + reanimate-svg = overrideCabal (drv: { buildTools = (drv.buildTools or [ ]) ++ [ # needed for testsuite From 9ddef6a598613121516b940325092b02ac45de3c Mon Sep 17 00:00:00 2001 From: Ai-Ya-Ya Date: Tue, 27 Jan 2026 13:18:12 +0000 Subject: [PATCH 19/52] haskellPackages.svgone: jailbreak https://github.com/georgefst/svgone/pull/3 --- pkgs/development/haskell-modules/configuration-common.nix | 4 ++++ 1 file changed, 4 insertions(+) diff --git a/pkgs/development/haskell-modules/configuration-common.nix b/pkgs/development/haskell-modules/configuration-common.nix index f7d4168f56bc..56e039e8176b 100644 --- a/pkgs/development/haskell-modules/configuration-common.nix +++ b/pkgs/development/haskell-modules/configuration-common.nix @@ -2519,6 +2519,10 @@ with haskellLib; doJailbreak ]; + # too strict bounds on extra < 1.8 + # https://github.com/georgefst/svgone/pull/3 + svgone = doJailbreak super.svgone; + # 2026-01-06: unbreak and modernize to GHC 9.10.3 reanimate-svg = overrideCabal (drv: { # patching doesn't actually move files, need to do manually From 6a3e5410eb4ec9396eb2b9ce4b69ef5107dfe9f5 Mon Sep 17 00:00:00 2001 From: Ai-Ya-Ya Date: Thu, 26 Feb 2026 20:41:02 +0000 Subject: [PATCH 20/52] maintainers: add Ai-Ya-Ya --- maintainers/maintainer-list.nix | 7 +++++++ 1 file changed, 7 insertions(+) diff --git a/maintainers/maintainer-list.nix b/maintainers/maintainer-list.nix index 79912e3c2ab9..06c3f80417e2 100644 --- a/maintainers/maintainer-list.nix +++ b/maintainers/maintainer-list.nix @@ -843,6 +843,13 @@ githubId = 209175; name = "Alesya Huzik"; }; + Ai-Ya-Ya = { + email = "spg2500@gmail.com"; + github = "Ai-Ya-Ya"; + githubId = 72513839; + matrix = "aiya:catgirl.cloud"; + name = "aiya"; + }; aij = { email = "aij+git@mrph.org"; github = "aij"; From 4b7174296d5929928e666f05a4b25bcd3b6fd37b Mon Sep 17 00:00:00 2001 From: Ai-Ya-Ya Date: Mon, 30 Mar 2026 11:48:02 +0200 Subject: [PATCH 21/52] haskellPackages.reanimate{,-svg}: add Ai-Ya-Ya as maintainer --- .../haskell-modules/configuration-hackage2nix/main.yaml | 3 +++ pkgs/development/haskell-modules/hackage-packages.nix | 2 ++ 2 files changed, 5 insertions(+) diff --git a/pkgs/development/haskell-modules/configuration-hackage2nix/main.yaml b/pkgs/development/haskell-modules/configuration-hackage2nix/main.yaml index 7aa716d6ce31..dbe9d2a8223a 100644 --- a/pkgs/development/haskell-modules/configuration-hackage2nix/main.yaml +++ b/pkgs/development/haskell-modules/configuration-hackage2nix/main.yaml @@ -127,6 +127,9 @@ extra-packages: # keep-sorted start skip_lines=1 case=no package-maintainers: + Ai-Ya-Ya: + - reanimate + - reanimate-svg alexfmpe: - basic-sop - commutative-semigroups diff --git a/pkgs/development/haskell-modules/hackage-packages.nix b/pkgs/development/haskell-modules/hackage-packages.nix index 19b994b5e9c1..dc64bf115c4b 100644 --- a/pkgs/development/haskell-modules/hackage-packages.nix +++ b/pkgs/development/haskell-modules/hackage-packages.nix @@ -577709,6 +577709,7 @@ self: { ]; description = "Animation library based on SVGs"; license = lib.licenses.publicDomain; + maintainers = [ lib.maintainers.Ai-Ya-Ya ]; } ) { }; @@ -577789,6 +577790,7 @@ self: { ]; description = "SVG file loader and serializer"; license = lib.licensesSpdx."BSD-3-Clause"; + maintainers = [ lib.maintainers.Ai-Ya-Ya ]; } ) { }; From 4a40724685a0a0b3583c9c024b2eaba55ff6305e Mon Sep 17 00:00:00 2001 From: Marc Scholten Date: Tue, 31 Mar 2026 09:22:29 +0200 Subject: [PATCH 22/52] haskellPackages.ptr-peeker: unbreak ptr-peeker 0.2.0.1 (released 2026-03-13) fixes the overly tight test-dependency bounds on tasty-quickcheck (< 0.11) and tasty-hunit (< 0.11) that caused the previous Hydra failure. https://github.com/nikita-volkov/ptr-peeker/issues/10 Co-Authored-By: Claude Opus 4.6 (1M context) --- .../haskell-modules/configuration-hackage2nix/broken.yaml | 1 - pkgs/development/haskell-modules/hackage-packages.nix | 2 -- 2 files changed, 3 deletions(-) diff --git a/pkgs/development/haskell-modules/configuration-hackage2nix/broken.yaml b/pkgs/development/haskell-modules/configuration-hackage2nix/broken.yaml index a2d80067cf0d..c8d96f4a2a06 100644 --- a/pkgs/development/haskell-modules/configuration-hackage2nix/broken.yaml +++ b/pkgs/development/haskell-modules/configuration-hackage2nix/broken.yaml @@ -5120,7 +5120,6 @@ broken-packages: - psx # failure in job https://hydra.nixos.org/build/233199666 at 2023-09-02 - ptera-core # failure in job https://hydra.nixos.org/build/295096340 at 2025-04-22 - PTQ # failure in job https://hydra.nixos.org/build/233202571 at 2023-09-02 - - ptr-peeker # failure in job https://hydra.nixos.org/build/307521316 at 2025-09-19 - pub # failure in job https://hydra.nixos.org/build/233255415 at 2023-09-02 - publicsuffix # failure in job https://hydra.nixos.org/build/233241572 at 2023-09-02 - publicsuffixlistcreate # failure in job https://hydra.nixos.org/build/233251430 at 2023-09-02 diff --git a/pkgs/development/haskell-modules/hackage-packages.nix b/pkgs/development/haskell-modules/hackage-packages.nix index 41044a6ff85a..511aeddfd134 100644 --- a/pkgs/development/haskell-modules/hackage-packages.nix +++ b/pkgs/development/haskell-modules/hackage-packages.nix @@ -562241,8 +562241,6 @@ self: { ]; description = "High-performance composable binary data deserializers"; license = lib.licensesSpdx."MIT"; - hydraPlatforms = lib.platforms.none; - broken = true; } ) { }; From 887ea1604a57df5f39260bc6080938346e10d9b2 Mon Sep 17 00:00:00 2001 From: Wolfgang Walther Date: Tue, 31 Mar 2026 17:52:18 +0200 Subject: [PATCH 23/52] haskellPackages.jsaddle{,-warp}: drop applied patches --- .../haskell-modules/configuration-common.nix | 14 -------------- 1 file changed, 14 deletions(-) diff --git a/pkgs/development/haskell-modules/configuration-common.nix b/pkgs/development/haskell-modules/configuration-common.nix index 723bce0cd6ee..649b64ec18f3 100644 --- a/pkgs/development/haskell-modules/configuration-common.nix +++ b/pkgs/development/haskell-modules/configuration-common.nix @@ -1725,20 +1725,6 @@ with haskellLib; reflex-localize-dom = dontDistribute super.reflex-localize-dom; trasa-reflex = dontDistribute super.trasa-reflex; - # https://github.com/ghcjs/jsaddle/pull/160/ - jsaddle = appendPatch (fetchpatch { - name = "fix-on-firefox.patch"; - url = "https://github.com/ghcjs/jsaddle/commit/71ef7f0cbc60a380ba0dc299e758c8f90cc4b526.patch"; - relative = "jsaddle"; - sha256 = "sha256-IBOX74r+lyywVWp0ZucoseeevFrGiInkq7V6RoWADNU="; - }) super.jsaddle; - jsaddle-warp = appendPatch (fetchpatch { - name = "fix-on-firefox.patch"; - url = "https://github.com/ghcjs/jsaddle/commit/71ef7f0cbc60a380ba0dc299e758c8f90cc4b526.patch"; - relative = "jsaddle-warp"; - sha256 = "sha256-jYEUOkP4Kv3yBjo3SbN7sruV+T5R5XWbRFcCUAa6HvE="; - }) super.jsaddle-warp; - # https://github.com/ghcjs/jsaddle/issues/151 jsaddle-webkit2gtk = overrideCabal From 4a2f25da5dd9962b414b71ddae48a86c4d5be95f Mon Sep 17 00:00:00 2001 From: sternenseemann Date: Thu, 2 Apr 2026 20:20:29 +0200 Subject: [PATCH 24/52] haskellPackages.criterion: fix test race condition with tasty 1.5.4 --- .../development/haskell-modules/configuration-common.nix | 9 +++++++++ 1 file changed, 9 insertions(+) diff --git a/pkgs/development/haskell-modules/configuration-common.nix b/pkgs/development/haskell-modules/configuration-common.nix index 649b64ec18f3..52b192c4bad6 100644 --- a/pkgs/development/haskell-modules/configuration-common.nix +++ b/pkgs/development/haskell-modules/configuration-common.nix @@ -375,6 +375,15 @@ with haskellLib; ''; }) super.streamly-core; + # Work around tasty >= 1.5.4 parallelism breaking the test suite + criterion = appendPatches [ + (pkgs.fetchpatch { + name = "criterion-tasty-1.5.4.patch"; + url = "https://github.com/haskell/criterion/commit/d555422d1779434432489efbc19d75011226c3e6.patch"; + hash = "sha256-VRSfdzT/mzdRSMQmmIeycuChvRN/VDhYsHJQb0bRMaA="; + }) + ] super.criterion; + # Expected failures are fixed as of GHC-9.10, # but the tests haven't been updated yet. # https://github.com/ocharles/weeder/issues/198 From 540f1e4f84858d684120c29d17a3d0c4e0c86a20 Mon Sep 17 00:00:00 2001 From: sternenseemann Date: Thu, 2 Apr 2026 20:34:34 +0200 Subject: [PATCH 25/52] haskellPackages.socket: avoid test race condition with tasty >= 1.5.4 --- .../haskell-modules/configuration-common.nix | 10 ++++++++++ 1 file changed, 10 insertions(+) diff --git a/pkgs/development/haskell-modules/configuration-common.nix b/pkgs/development/haskell-modules/configuration-common.nix index 52b192c4bad6..ccb135b8700b 100644 --- a/pkgs/development/haskell-modules/configuration-common.nix +++ b/pkgs/development/haskell-modules/configuration-common.nix @@ -384,6 +384,16 @@ with haskellLib; }) ] super.criterion; + # Avoid rebinding to the same port with tasty >= 1.5.4 parallelism + # https://github.com/lpeterse/haskell-socket/pull/73 + socket = appendPatches [ + (pkgs.fetchpatch { + name = "socket-tasty-1.5.4.patch"; + url = "https://github.com/lpeterse/haskell-socket/commit/a2687d9f1a60cfb72f85962c501a68d110ed6de0.patch"; + hash = "sha256-21qkRFnRF6nuM1BILps8o5A/QvaVQ6SkKxO0u2goXos="; + }) + ] super.socket; + # Expected failures are fixed as of GHC-9.10, # but the tests haven't been updated yet. # https://github.com/ocharles/weeder/issues/198 From c5c3522cf9af5840338be99a843ca634a674a412 Mon Sep 17 00:00:00 2001 From: sternenseemann Date: Mon, 6 Apr 2026 15:54:08 +0200 Subject: [PATCH 26/52] haskellPackages.socket-unix: avoid race condition due to tasty-1.5.4 --- pkgs/development/haskell-modules/configuration-common.nix | 4 ++++ 1 file changed, 4 insertions(+) diff --git a/pkgs/development/haskell-modules/configuration-common.nix b/pkgs/development/haskell-modules/configuration-common.nix index ccb135b8700b..86f9249ddf9e 100644 --- a/pkgs/development/haskell-modules/configuration-common.nix +++ b/pkgs/development/haskell-modules/configuration-common.nix @@ -393,6 +393,10 @@ with haskellLib; hash = "sha256-21qkRFnRF6nuM1BILps8o5A/QvaVQ6SkKxO0u2goXos="; }) ] super.socket; + # https://github.com/flip111/haskell-socket-unix/issues/1 + socket-unix = overrideCabal (drv: { + testFlags = drv.testFlags or [ ] ++ [ "-j1" ]; + }) super.socket-unix; # Expected failures are fixed as of GHC-9.10, # but the tests haven't been updated yet. From a9605c1498818bd3a9b43f104095625a7d635587 Mon Sep 17 00:00:00 2001 From: sternenseemann Date: Mon, 6 Apr 2026 16:34:29 +0200 Subject: [PATCH 27/52] pandoc: work around test suite race condition due to tasty 1.5.4 Note that I was not able to ascertain the diagnosis and workaround with complete certainty since I've had trouble reproducing the issue reliably on the machines I have access to. It does seem like the most likely explanation, though. --- .../haskell-modules/configuration-common.nix | 38 +++++++++++-------- 1 file changed, 22 insertions(+), 16 deletions(-) diff --git a/pkgs/development/haskell-modules/configuration-common.nix b/pkgs/development/haskell-modules/configuration-common.nix index 86f9249ddf9e..300ecf5f1c9b 100644 --- a/pkgs/development/haskell-modules/configuration-common.nix +++ b/pkgs/development/haskell-modules/configuration-common.nix @@ -948,22 +948,28 @@ with haskellLib; )) ]; - pandoc = appendPatches [ - # Adjust test fixtures for djot >= 0.1.2.3, patch extracted from unrelated change. - (pkgs.fetchpatch { - name = "pandoc-djot-0.1.2.3.patch"; - url = "https://github.com/jgm/pandoc/commit/643712ca70b924c0edcc059699aa1ee42234be34.patch"; - hash = "sha256-khDkb1PzC0fTaWTq3T04UvgoI+XefOJMaTV1d3Du8BU="; - includes = [ "test/djot-reader.native" ]; - }) - # Adjust tests for skylighting-format-blaze-html >= 0.1.2 - (pkgs.fetchpatch { - name = "pandoc-skylighting-format-blaze-html-0.1.2.patch"; - url = "https://github.com/jgm/pandoc/commit/cab682ba58f2eb7e940d1af508e196ff6b1c1112.patch"; - hash = "sha256-lpddKGa8xs+Lhi62HhBgV04fUq2kkippA1xX2/b2ukM="; - includes = [ "test/Tests/Writers/HTML.hs" ]; - }) - ] super.pandoc; + pandoc = overrideCabal (drv: { + # Work around test suite race condition(s) due to tasty >= 1.5.4 + # https://github.com/jgm/pandoc/issues/11566 + testFlags = drv.testFlags or [ ] ++ [ "-j1" ]; + + patches = drv.patches or [ ] ++ [ + # Adjust test fixtures for djot >= 0.1.2.3, patch extracted from unrelated change. + (pkgs.fetchpatch { + name = "pandoc-djot-0.1.2.3.patch"; + url = "https://github.com/jgm/pandoc/commit/643712ca70b924c0edcc059699aa1ee42234be34.patch"; + hash = "sha256-khDkb1PzC0fTaWTq3T04UvgoI+XefOJMaTV1d3Du8BU="; + includes = [ "test/djot-reader.native" ]; + }) + # Adjust tests for skylighting-format-blaze-html >= 0.1.2 + (pkgs.fetchpatch { + name = "pandoc-skylighting-format-blaze-html-0.1.2.patch"; + url = "https://github.com/jgm/pandoc/commit/cab682ba58f2eb7e940d1af508e196ff6b1c1112.patch"; + hash = "sha256-lpddKGa8xs+Lhi62HhBgV04fUq2kkippA1xX2/b2ukM="; + includes = [ "test/Tests/Writers/HTML.hs" ]; + }) + ]; + }) super.pandoc; # Too strict upper bound on data-default-class (< 0.2) # https://github.com/stackbuilders/dotenv-hs/issues/203 From 5da5e2581f043a947da26b2639e3a0708c8c469c Mon Sep 17 00:00:00 2001 From: sternenseemann Date: Mon, 6 Apr 2026 16:53:48 +0200 Subject: [PATCH 28/52] haskellPackages.mighttpd2: pin to 4.0.9 for Stackage LTS compat 4.0.10 doesn't have consequential changes to us since it just allows some wider bounds, but also introduces a lower bound on tls-session-manager >= 0.1.0 which will pull in ram instead of memory, a change we are likely not ready for yet. --- .../configuration-hackage2nix/main.yaml | 2 + .../haskell-modules/hackage-packages.nix | 111 +++++++++++++++++- 2 files changed, 110 insertions(+), 3 deletions(-) diff --git a/pkgs/development/haskell-modules/configuration-hackage2nix/main.yaml b/pkgs/development/haskell-modules/configuration-hackage2nix/main.yaml index 3a2f8fafce2c..5aa084ff5f2c 100644 --- a/pkgs/development/haskell-modules/configuration-hackage2nix/main.yaml +++ b/pkgs/development/haskell-modules/configuration-hackage2nix/main.yaml @@ -55,6 +55,8 @@ default-package-overrides: - lsp-types < 2.4 # Needs to match microlens == 0.4.* in Stackage LTS 24 - microlens-pro < 0.2.0.4 + # 2026-04-06: 4.0.10 merely adjusts to dependencies that are incompatible with our LTS + - mighttpd2 < 4.0.10 # We currently use pandoc-crossref with a patch to revert it to pandoc == 3.7.*, # this no longer works with later versions. - pandoc-crossref == 0.3.21 diff --git a/pkgs/development/haskell-modules/hackage-packages.nix b/pkgs/development/haskell-modules/hackage-packages.nix index 13fa65a3ed55..c039f744ed72 100644 --- a/pkgs/development/haskell-modules/hackage-packages.nix +++ b/pkgs/development/haskell-modules/hackage-packages.nix @@ -277017,9 +277017,7 @@ self: { ]; description = "Wiki using happstack, git or darcs, and pandoc"; license = "GPL"; - maintainers = [ - lib.maintainers.sternenseemann - ]; + maintainers = [ lib.maintainers.sternenseemann ]; } ) { }; @@ -460688,6 +460686,112 @@ self: { ) { }; mighttpd2 = callPackage ( + { + mkDerivation, + array, + async, + auto-update, + base, + byteorder, + bytestring, + case-insensitive, + conduit, + conduit-extra, + directory, + filepath, + hspec, + hspec-discover, + http-client, + http-date, + http-types, + http2, + network, + old-locale, + parsec, + resourcet, + split, + streaming-commons, + text, + time, + time-manager, + transformers, + unix, + unix-time, + unordered-containers, + wai, + wai-app-file-cgi, + wai-logger, + warp, + }: + mkDerivation { + pname = "mighttpd2"; + version = "4.0.9"; + sha256 = "1qd43hlyvhnslxrvy4h0rj5qs6nbxnz8d23myqjspa9jl8rzb1bg"; + isLibrary = true; + isExecutable = true; + enableSeparateDataOutput = true; + libraryHaskellDepends = [ + array + async + auto-update + base + byteorder + bytestring + case-insensitive + conduit + conduit-extra + directory + filepath + http-date + http-types + http2 + network + parsec + resourcet + split + streaming-commons + text + unix + unix-time + unordered-containers + wai + wai-app-file-cgi + warp + ]; + executableHaskellDepends = [ + base + bytestring + conduit-extra + directory + filepath + http-client + http-date + http-types + network + old-locale + streaming-commons + time + time-manager + transformers + unix + wai + wai-app-file-cgi + wai-logger + warp + ]; + testHaskellDepends = [ + base + hspec + http-client + ]; + testToolDepends = [ hspec-discover ]; + description = "High performance web server on WAI/warp"; + license = lib.licenses.bsd3; + maintainers = [ lib.maintainers.sternenseemann ]; + } + ) { }; + + mighttpd2_4_0_10 = callPackage ( { mkDerivation, array, @@ -460789,6 +460893,7 @@ self: { testToolDepends = [ hspec-discover ]; description = "High performance web server on WAI/warp"; license = lib.licenses.bsd3; + hydraPlatforms = lib.platforms.none; maintainers = [ lib.maintainers.sternenseemann ]; } ) { }; From 85a70fc119fe424e182ae17bd88ad3ee275f2f8d Mon Sep 17 00:00:00 2001 From: sternenseemann Date: Mon, 6 Apr 2026 16:58:08 +0200 Subject: [PATCH 29/52] hledger-web: allow building against yesod-static 1.6.1.2 --- .../haskell-modules/configuration-common.nix | 13 +++++++++++++ 1 file changed, 13 insertions(+) diff --git a/pkgs/development/haskell-modules/configuration-common.nix b/pkgs/development/haskell-modules/configuration-common.nix index 300ecf5f1c9b..ff6175c03894 100644 --- a/pkgs/development/haskell-modules/configuration-common.nix +++ b/pkgs/development/haskell-modules/configuration-common.nix @@ -1684,6 +1684,19 @@ with haskellLib; ''; }) super.hledger-flow; + # hledger-web abuses the regular bounds to exclude yesod-static 1.6.1.2 since + # it builds to fail in some build plans. This doesn't affect us at all. + hledger-web = appendPatches [ + (pkgs.fetchpatch { + name = "hledger-allow-yesod-static-1.6.1.2.patch"; + url = "https://github.com/simonmichael/hledger/commit/b06eb8b68222f48024cf02d0718039a20e070201.patch"; + hash = "sha256-IzDyAqaiqnH3d8d+ikkEpJJufgMB+ZF/1ntUJVyQyws="; + revert = true; + relative = "hledger-web"; + excludes = [ "package.yaml" ]; + }) + ] super.hledger-web; + # Chart-tests needs and compiles some modules from Chart itself Chart-tests = overrideCabal (old: { # 2025-02-13: Too strict bounds on lens < 5.3 and vector < 0.13 From 3481640d1832b3494512e62cb872be53bc388dfe Mon Sep 17 00:00:00 2001 From: sternenseemann Date: Mon, 6 Apr 2026 17:05:00 +0200 Subject: [PATCH 30/52] hledger-interest: allow hledger 1.52 by jailbreaking --- pkgs/development/haskell-modules/configuration-common.nix | 4 ++++ 1 file changed, 4 insertions(+) diff --git a/pkgs/development/haskell-modules/configuration-common.nix b/pkgs/development/haskell-modules/configuration-common.nix index ff6175c03894..678187c1b610 100644 --- a/pkgs/development/haskell-modules/configuration-common.nix +++ b/pkgs/development/haskell-modules/configuration-common.nix @@ -1697,6 +1697,10 @@ with haskellLib; }) ] super.hledger-web; + # Allow hledger 1.52 + # https://github.com/peti/hledger-interest/issues/27 + hledger-interest = doJailbreak super.hledger-interest; + # Chart-tests needs and compiles some modules from Chart itself Chart-tests = overrideCabal (old: { # 2025-02-13: Too strict bounds on lens < 5.3 and vector < 0.13 From 0feac0d32b97c0bf033ae7068bd5a811d56bcdd4 Mon Sep 17 00:00:00 2001 From: sternenseemann Date: Mon, 6 Apr 2026 17:16:01 +0200 Subject: [PATCH 31/52] hledger-check-fancyassertions: update hash for 1.52 --- pkgs/by-name/hl/hledger-check-fancyassertions/package.nix | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/pkgs/by-name/hl/hledger-check-fancyassertions/package.nix b/pkgs/by-name/hl/hledger-check-fancyassertions/package.nix index 15854a71717b..6918907b2785 100644 --- a/pkgs/by-name/hl/hledger-check-fancyassertions/package.nix +++ b/pkgs/by-name/hl/hledger-check-fancyassertions/package.nix @@ -13,7 +13,7 @@ stdenvNoCC.mkDerivation rec { src = fetchurl { name = "hledger-check-fancyassertion-${version}.hs"; url = "https://raw.githubusercontent.com/simonmichael/hledger/hledger-lib-${version}/bin/hledger-check-fancyassertions.hs"; - hash = "sha256-Zokrrcy9CfVV2tNI1DDsjqC+PcTdlMdit4O4Y1gP1O4="; + hash = "sha256-ISA7ED0HgyWOxfaufaFpNb1dHfE+1+Xh4SRCZ64yM6E="; }; dontUnpack = true; From a160adce1e80c5517a5a78d6374b7fba6ca54e6e Mon Sep 17 00:00:00 2001 From: sternenseemann Date: Wed, 25 Feb 2026 12:57:16 +0100 Subject: [PATCH 32/52] haskellPackages.cabal2nix-unstable: 2026-01-25 -> 2026-03-07 (cherry picked from commit a1ea284f74f0a86d54d519b88c3f768bbcf8fb76) --- .../haskell-modules/cabal2nix-unstable/cabal2nix.nix | 6 +++--- .../cabal2nix-unstable/distribution-nixpkgs.nix | 6 +++--- .../haskell-modules/cabal2nix-unstable/hackage-db.nix | 8 +++----- .../haskell-modules/cabal2nix-unstable/language-nix.nix | 6 +++--- 4 files changed, 12 insertions(+), 14 deletions(-) diff --git a/pkgs/development/haskell-modules/cabal2nix-unstable/cabal2nix.nix b/pkgs/development/haskell-modules/cabal2nix-unstable/cabal2nix.nix index afa2ab7a079a..1368246c3fa8 100644 --- a/pkgs/development/haskell-modules/cabal2nix-unstable/cabal2nix.nix +++ b/pkgs/development/haskell-modules/cabal2nix-unstable/cabal2nix.nix @@ -35,10 +35,10 @@ }: mkDerivation { pname = "cabal2nix"; - version = "2.21.0-unstable-2026-01-25"; + version = "2.21.2-unstable-2026-03-07"; src = fetchzip { - url = "https://github.com/NixOS/cabal2nix/archive/751a8eccfc92f8ce3ca9d517c554e7dcb3f409bd.tar.gz"; - sha256 = "1i9ifxmh5bqgpa7a6l46lqkzpr7z3zfm7bdkllq56hz1nmj4gbqx"; + url = "https://github.com/NixOS/cabal2nix/archive/977a1c199f7f8092ce9eef7d322b0eecebde22a2.tar.gz"; + sha256 = "0nl5502mpwhmav7qxx051zzyx8ag9mibwhh33bf4aj07ywziza4c"; }; postUnpack = "sourceRoot+=/cabal2nix; echo source root reset to $sourceRoot"; isLibrary = true; diff --git a/pkgs/development/haskell-modules/cabal2nix-unstable/distribution-nixpkgs.nix b/pkgs/development/haskell-modules/cabal2nix-unstable/distribution-nixpkgs.nix index 8a5382ee2ac3..495a3849544b 100644 --- a/pkgs/development/haskell-modules/cabal2nix-unstable/distribution-nixpkgs.nix +++ b/pkgs/development/haskell-modules/cabal2nix-unstable/distribution-nixpkgs.nix @@ -18,10 +18,10 @@ }: mkDerivation { pname = "distribution-nixpkgs"; - version = "1.7.1.1-unstable-2026-01-25"; + version = "1.7.1.1-unstable-2026-03-07"; src = fetchzip { - url = "https://github.com/NixOS/cabal2nix/archive/751a8eccfc92f8ce3ca9d517c554e7dcb3f409bd.tar.gz"; - sha256 = "1i9ifxmh5bqgpa7a6l46lqkzpr7z3zfm7bdkllq56hz1nmj4gbqx"; + url = "https://github.com/NixOS/cabal2nix/archive/977a1c199f7f8092ce9eef7d322b0eecebde22a2.tar.gz"; + sha256 = "0nl5502mpwhmav7qxx051zzyx8ag9mibwhh33bf4aj07ywziza4c"; }; postUnpack = "sourceRoot+=/distribution-nixpkgs; echo source root reset to $sourceRoot"; enableSeparateDataOutput = true; diff --git a/pkgs/development/haskell-modules/cabal2nix-unstable/hackage-db.nix b/pkgs/development/haskell-modules/cabal2nix-unstable/hackage-db.nix index c0363bea2617..eeb10e513e7a 100644 --- a/pkgs/development/haskell-modules/cabal2nix-unstable/hackage-db.nix +++ b/pkgs/development/haskell-modules/cabal2nix-unstable/hackage-db.nix @@ -13,14 +13,13 @@ lib, tar, time, - utf8-string, }: mkDerivation { pname = "hackage-db"; - version = "2.1.3-unstable-2026-01-25"; + version = "2.1.3-unstable-2026-03-07"; src = fetchzip { - url = "https://github.com/NixOS/cabal2nix/archive/751a8eccfc92f8ce3ca9d517c554e7dcb3f409bd.tar.gz"; - sha256 = "1i9ifxmh5bqgpa7a6l46lqkzpr7z3zfm7bdkllq56hz1nmj4gbqx"; + url = "https://github.com/NixOS/cabal2nix/archive/977a1c199f7f8092ce9eef7d322b0eecebde22a2.tar.gz"; + sha256 = "0nl5502mpwhmav7qxx051zzyx8ag9mibwhh33bf4aj07ywziza4c"; }; postUnpack = "sourceRoot+=/hackage-db; echo source root reset to $sourceRoot"; isLibrary = true; @@ -36,7 +35,6 @@ mkDerivation { filepath tar time - utf8-string ]; homepage = "https://github.com/NixOS/cabal2nix/tree/master/hackage-db#readme"; description = "Access cabal-install's Hackage database via Data.Map"; diff --git a/pkgs/development/haskell-modules/cabal2nix-unstable/language-nix.nix b/pkgs/development/haskell-modules/cabal2nix-unstable/language-nix.nix index 53130dcbc60d..13509f8cd37c 100644 --- a/pkgs/development/haskell-modules/cabal2nix-unstable/language-nix.nix +++ b/pkgs/development/haskell-modules/cabal2nix-unstable/language-nix.nix @@ -14,10 +14,10 @@ }: mkDerivation { pname = "language-nix"; - version = "2.3.0-unstable-2026-01-25"; + version = "2.3.0-unstable-2026-03-07"; src = fetchzip { - url = "https://github.com/NixOS/cabal2nix/archive/751a8eccfc92f8ce3ca9d517c554e7dcb3f409bd.tar.gz"; - sha256 = "1i9ifxmh5bqgpa7a6l46lqkzpr7z3zfm7bdkllq56hz1nmj4gbqx"; + url = "https://github.com/NixOS/cabal2nix/archive/977a1c199f7f8092ce9eef7d322b0eecebde22a2.tar.gz"; + sha256 = "0nl5502mpwhmav7qxx051zzyx8ag9mibwhh33bf4aj07ywziza4c"; }; postUnpack = "sourceRoot+=/language-nix; echo source root reset to $sourceRoot"; libraryHaskellDepends = [ From 2a56eea3be9d3538c82e5cccb49b05d5bb7700fd Mon Sep 17 00:00:00 2001 From: Wolfgang Walther Date: Mon, 30 Mar 2026 12:06:57 +0200 Subject: [PATCH 33/52] haskellPackages.cabal2nix-unstable: 2.21.2-unstable-2026-03-07 -> 2.21.3-unstable-2026-03-30 (cherry picked from commit 99395f95a5b285ed9b594cc8f73a2097f4fd8643) --- .../cabal2nix-unstable/cabal2nix.nix | 8 +- .../distribution-nixpkgs.nix | 8 +- .../cabal2nix-unstable/hackage-db.nix | 8 +- .../cabal2nix-unstable/language-nix.nix | 8 +- .../haskell-modules/hackage-packages.nix | 7830 ++++++++--------- 5 files changed, 3931 insertions(+), 3931 deletions(-) diff --git a/pkgs/development/haskell-modules/cabal2nix-unstable/cabal2nix.nix b/pkgs/development/haskell-modules/cabal2nix-unstable/cabal2nix.nix index 1368246c3fa8..395fb195ee38 100644 --- a/pkgs/development/haskell-modules/cabal2nix-unstable/cabal2nix.nix +++ b/pkgs/development/haskell-modules/cabal2nix-unstable/cabal2nix.nix @@ -35,10 +35,10 @@ }: mkDerivation { pname = "cabal2nix"; - version = "2.21.2-unstable-2026-03-07"; + version = "2.21.3-unstable-2026-03-30"; src = fetchzip { - url = "https://github.com/NixOS/cabal2nix/archive/977a1c199f7f8092ce9eef7d322b0eecebde22a2.tar.gz"; - sha256 = "0nl5502mpwhmav7qxx051zzyx8ag9mibwhh33bf4aj07ywziza4c"; + url = "https://github.com/NixOS/cabal2nix/archive/41239bcc0622a0975c6705a03a44dfeffeb56f23.tar.gz"; + sha256 = "01qj6cvaif0810v83r6izcj1bbfpcqqxw4wybq04qsq92sqybpw2"; }; postUnpack = "sourceRoot+=/cabal2nix; echo source root reset to $sourceRoot"; isLibrary = true; @@ -106,5 +106,5 @@ mkDerivation { ''; homepage = "https://github.com/nixos/cabal2nix#readme"; description = "Convert Cabal files into Nix build instructions"; - license = lib.licenses.bsd3; + license = lib.licensesSpdx."BSD-3-Clause"; } diff --git a/pkgs/development/haskell-modules/cabal2nix-unstable/distribution-nixpkgs.nix b/pkgs/development/haskell-modules/cabal2nix-unstable/distribution-nixpkgs.nix index 495a3849544b..8a2bb2d4cfe1 100644 --- a/pkgs/development/haskell-modules/cabal2nix-unstable/distribution-nixpkgs.nix +++ b/pkgs/development/haskell-modules/cabal2nix-unstable/distribution-nixpkgs.nix @@ -18,10 +18,10 @@ }: mkDerivation { pname = "distribution-nixpkgs"; - version = "1.7.1.1-unstable-2026-03-07"; + version = "1.7.1.1-unstable-2026-03-30"; src = fetchzip { - url = "https://github.com/NixOS/cabal2nix/archive/977a1c199f7f8092ce9eef7d322b0eecebde22a2.tar.gz"; - sha256 = "0nl5502mpwhmav7qxx051zzyx8ag9mibwhh33bf4aj07ywziza4c"; + url = "https://github.com/NixOS/cabal2nix/archive/41239bcc0622a0975c6705a03a44dfeffeb56f23.tar.gz"; + sha256 = "01qj6cvaif0810v83r6izcj1bbfpcqqxw4wybq04qsq92sqybpw2"; }; postUnpack = "sourceRoot+=/distribution-nixpkgs; echo source root reset to $sourceRoot"; enableSeparateDataOutput = true; @@ -49,5 +49,5 @@ mkDerivation { ]; homepage = "https://github.com/NixOS/cabal2nix/tree/master/distribution-nixpkgs#readme"; description = "Types and functions to manipulate the Nixpkgs distribution"; - license = lib.licenses.bsd3; + license = lib.licensesSpdx."BSD-3-Clause"; } diff --git a/pkgs/development/haskell-modules/cabal2nix-unstable/hackage-db.nix b/pkgs/development/haskell-modules/cabal2nix-unstable/hackage-db.nix index eeb10e513e7a..170a502afe9b 100644 --- a/pkgs/development/haskell-modules/cabal2nix-unstable/hackage-db.nix +++ b/pkgs/development/haskell-modules/cabal2nix-unstable/hackage-db.nix @@ -16,10 +16,10 @@ }: mkDerivation { pname = "hackage-db"; - version = "2.1.3-unstable-2026-03-07"; + version = "2.1.3-unstable-2026-03-30"; src = fetchzip { - url = "https://github.com/NixOS/cabal2nix/archive/977a1c199f7f8092ce9eef7d322b0eecebde22a2.tar.gz"; - sha256 = "0nl5502mpwhmav7qxx051zzyx8ag9mibwhh33bf4aj07ywziza4c"; + url = "https://github.com/NixOS/cabal2nix/archive/41239bcc0622a0975c6705a03a44dfeffeb56f23.tar.gz"; + sha256 = "01qj6cvaif0810v83r6izcj1bbfpcqqxw4wybq04qsq92sqybpw2"; }; postUnpack = "sourceRoot+=/hackage-db; echo source root reset to $sourceRoot"; isLibrary = true; @@ -38,5 +38,5 @@ mkDerivation { ]; homepage = "https://github.com/NixOS/cabal2nix/tree/master/hackage-db#readme"; description = "Access cabal-install's Hackage database via Data.Map"; - license = lib.licenses.bsd3; + license = lib.licensesSpdx."BSD-3-Clause"; } diff --git a/pkgs/development/haskell-modules/cabal2nix-unstable/language-nix.nix b/pkgs/development/haskell-modules/cabal2nix-unstable/language-nix.nix index 13509f8cd37c..85c20c7d927f 100644 --- a/pkgs/development/haskell-modules/cabal2nix-unstable/language-nix.nix +++ b/pkgs/development/haskell-modules/cabal2nix-unstable/language-nix.nix @@ -14,10 +14,10 @@ }: mkDerivation { pname = "language-nix"; - version = "2.3.0-unstable-2026-03-07"; + version = "2.3.0-unstable-2026-03-30"; src = fetchzip { - url = "https://github.com/NixOS/cabal2nix/archive/977a1c199f7f8092ce9eef7d322b0eecebde22a2.tar.gz"; - sha256 = "0nl5502mpwhmav7qxx051zzyx8ag9mibwhh33bf4aj07ywziza4c"; + url = "https://github.com/NixOS/cabal2nix/archive/41239bcc0622a0975c6705a03a44dfeffeb56f23.tar.gz"; + sha256 = "01qj6cvaif0810v83r6izcj1bbfpcqqxw4wybq04qsq92sqybpw2"; }; postUnpack = "sourceRoot+=/language-nix; echo source root reset to $sourceRoot"; libraryHaskellDepends = [ @@ -39,5 +39,5 @@ mkDerivation { ]; homepage = "https://github.com/NixOS/cabal2nix/tree/master/language-nix#readme"; description = "Data types and functions to represent the Nix language"; - license = lib.licenses.bsd3; + license = lib.licensesSpdx."BSD-3-Clause"; } diff --git a/pkgs/development/haskell-modules/hackage-packages.nix b/pkgs/development/haskell-modules/hackage-packages.nix index c039f744ed72..f4093355977d 100644 --- a/pkgs/development/haskell-modules/hackage-packages.nix +++ b/pkgs/development/haskell-modules/hackage-packages.nix @@ -536,7 +536,7 @@ self: { vector ]; description = "Efficient, high-level dynamic programming"; - license = lib.licensesSpdx."BSD-3-Clause"; + license = lib.meta.getLicenseFromSpdxId "BSD-3-Clause"; hydraPlatforms = lib.platforms.none; } ) { }; @@ -1638,7 +1638,7 @@ self: { ]; executableToolDepends = [ emacs ]; description = "A dependently typed functional programming language and proof assistant"; - license = lib.licensesSpdx."MIT"; + license = lib.meta.getLicenseFromSpdxId "MIT"; maintainers = [ lib.maintainers.iblech lib.maintainers.ncfavier @@ -1701,7 +1701,7 @@ self: { tasty-hunit ]; description = "Aho-Corasick string matching algorithm"; - license = lib.licensesSpdx."BSD-3-Clause"; + license = lib.meta.getLicenseFromSpdxId "BSD-3-Clause"; hydraPlatforms = lib.platforms.none; broken = true; } @@ -1952,7 +1952,7 @@ self: { text ]; description = "Near-future Sci-Fi roguelike and tactical squad combat game"; - license = lib.licensesSpdx."AGPL-3.0-or-later"; + license = lib.meta.getLicenseFromSpdxId "AGPL-3.0-or-later"; badPlatforms = lib.platforms.darwin; mainProgram = "Allure"; } @@ -2131,7 +2131,7 @@ self: { transformers ]; description = "A simple music library that can generate Lilypond and MIDI files"; - license = lib.licensesSpdx."BSD-3-Clause"; + license = lib.meta.getLicenseFromSpdxId "BSD-3-Clause"; hydraPlatforms = lib.platforms.none; mainProgram = "Aoide"; broken = true; @@ -2264,7 +2264,7 @@ self: { requirements ]; description = "First-class Attribute Grammars implemented using type-level programming"; - license = lib.licensesSpdx."GPL-2.0-or-later"; + license = lib.meta.getLicenseFromSpdxId "GPL-2.0-or-later"; } ) { }; @@ -2491,7 +2491,7 @@ self: { COrdering ]; description = "Balanced binary trees using the AVL algorithm"; - license = lib.licensesSpdx."BSD-3-Clause"; + license = lib.meta.getLicenseFromSpdxId "BSD-3-Clause"; } ) { }; @@ -3074,7 +3074,7 @@ self: { tasty-hunit ]; description = "Bessel J-function, Anger J-function, Weber E-function, and Anger-Weber function"; - license = lib.licensesSpdx."BSD-3-Clause"; + license = lib.meta.getLicenseFromSpdxId "BSD-3-Clause"; hydraPlatforms = lib.platforms.none; } ) { }; @@ -3450,7 +3450,7 @@ self: { vector-th-unbox ]; description = "European Nucleotide Archive data"; - license = lib.licensesSpdx."BSD-3-Clause"; + license = lib.meta.getLicenseFromSpdxId "BSD-3-Clause"; hydraPlatforms = lib.platforms.none; } ) { }; @@ -3600,7 +3600,7 @@ self: { text ]; description = "streaming FASTA parser"; - license = lib.licensesSpdx."BSD-3-Clause"; + license = lib.meta.getLicenseFromSpdxId "BSD-3-Clause"; hydraPlatforms = lib.platforms.none; mainProgram = "fastaextract"; } @@ -4091,7 +4091,7 @@ self: { vector-th-unbox ]; description = "Collection of types for bioinformatics"; - license = lib.licensesSpdx."BSD-3-Clause"; + license = lib.meta.getLicenseFromSpdxId "BSD-3-Clause"; hydraPlatforms = lib.platforms.none; } ) { }; @@ -4270,7 +4270,7 @@ self: { vector-th-unbox ]; description = "Efficient RNA/DNA/Protein Primary/Secondary Structure"; - license = lib.licensesSpdx."BSD-3-Clause"; + license = lib.meta.getLicenseFromSpdxId "BSD-3-Clause"; hydraPlatforms = lib.platforms.none; mainProgram = "SubOptDistance"; } @@ -5487,7 +5487,7 @@ self: { parsec ]; description = "An interpreter of Hagino's Categorical Programming Language (CPL)"; - license = lib.licensesSpdx."BSD-3-Clause"; + license = lib.meta.getLicenseFromSpdxId "BSD-3-Clause"; mainProgram = "cpl"; } ) { }; @@ -5869,7 +5869,7 @@ self: { ]; doCheck = false; description = "A framework for packaging Haskell software"; - license = lib.licensesSpdx."BSD-3-Clause"; + license = lib.meta.getLicenseFromSpdxId "BSD-3-Clause"; hydraPlatforms = lib.platforms.none; } ) { }; @@ -5920,7 +5920,7 @@ self: { ]; doCheck = false; description = "A framework for packaging Haskell software"; - license = lib.licensesSpdx."BSD-3-Clause"; + license = lib.meta.getLicenseFromSpdxId "BSD-3-Clause"; hydraPlatforms = lib.platforms.none; } ) { }; @@ -5973,7 +5973,7 @@ self: { ]; doCheck = false; description = "A framework for packaging Haskell software"; - license = lib.licensesSpdx."BSD-3-Clause"; + license = lib.meta.getLicenseFromSpdxId "BSD-3-Clause"; hydraPlatforms = lib.platforms.none; } ) { }; @@ -6024,7 +6024,7 @@ self: { ]; doCheck = false; description = "A framework for packaging Haskell software"; - license = lib.licensesSpdx."BSD-3-Clause"; + license = lib.meta.getLicenseFromSpdxId "BSD-3-Clause"; hydraPlatforms = lib.platforms.none; } ) { }; @@ -6050,7 +6050,7 @@ self: { transformers ]; description = "API for the Hooks build-type"; - license = lib.licensesSpdx."BSD-3-Clause"; + license = lib.meta.getLicenseFromSpdxId "BSD-3-Clause"; hydraPlatforms = lib.platforms.none; broken = true; } @@ -6167,7 +6167,7 @@ self: { unix ]; description = "A library for working with .cabal files"; - license = lib.licensesSpdx."BSD-3-Clause"; + license = lib.meta.getLicenseFromSpdxId "BSD-3-Clause"; hydraPlatforms = lib.platforms.none; } ) { }; @@ -6213,7 +6213,7 @@ self: { ]; libraryToolDepends = [ alex ]; description = "A library for working with .cabal files"; - license = lib.licensesSpdx."BSD-3-Clause"; + license = lib.meta.getLicenseFromSpdxId "BSD-3-Clause"; hydraPlatforms = lib.platforms.none; } ) { }; @@ -6261,7 +6261,7 @@ self: { ]; libraryToolDepends = [ alex ]; description = "A library for working with .cabal files"; - license = lib.licensesSpdx."BSD-3-Clause"; + license = lib.meta.getLicenseFromSpdxId "BSD-3-Clause"; hydraPlatforms = lib.platforms.none; } ) { }; @@ -6309,7 +6309,7 @@ self: { ]; libraryToolDepends = [ alex ]; description = "A library for working with .cabal files"; - license = lib.licensesSpdx."BSD-3-Clause"; + license = lib.meta.getLicenseFromSpdxId "BSD-3-Clause"; hydraPlatforms = lib.platforms.none; } ) { }; @@ -6425,7 +6425,7 @@ self: { tasty-hunit ]; description = "An implementation and DSL for the Carneades argumentation model"; - license = lib.licensesSpdx."BSD-3-Clause"; + license = lib.meta.getLicenseFromSpdxId "BSD-3-Clause"; hydraPlatforms = lib.platforms.none; broken = true; } @@ -6471,7 +6471,7 @@ self: { tasty-hunit ]; description = "A translation from the Carneades argumentation model into Dung's AFs"; - license = lib.licensesSpdx."BSD-3-Clause"; + license = lib.meta.getLicenseFromSpdxId "BSD-3-Clause"; hydraPlatforms = lib.platforms.none; mainProgram = "caell"; } @@ -6812,7 +6812,7 @@ self: { vector ]; description = "A backend for the Chart library for FLTKHS"; - license = lib.licensesSpdx."BSD-3-Clause"; + license = lib.meta.getLicenseFromSpdxId "BSD-3-Clause"; hydraPlatforms = lib.platforms.none; } ) { }; @@ -7313,7 +7313,7 @@ self: { text ]; description = "Typified Tailwind for Rapid Development"; - license = lib.licensesSpdx."MIT"; + license = lib.meta.getLicenseFromSpdxId "MIT"; hydraPlatforms = lib.platforms.none; broken = true; } @@ -7386,7 +7386,7 @@ self: { wide-word ]; description = "ClickHouse driver"; - license = lib.licensesSpdx."BSD-3-Clause"; + license = lib.meta.getLicenseFromSpdxId "BSD-3-Clause"; } ) { }; @@ -7411,7 +7411,7 @@ self: { tls ]; description = "ClickHaskell TLS extension"; - license = lib.licensesSpdx."BSD-3-Clause"; + license = lib.meta.getLicenseFromSpdxId "BSD-3-Clause"; } ) { }; @@ -8171,7 +8171,7 @@ self: { text ]; description = "Simple CLI user input library"; - license = lib.licensesSpdx."MIT"; + license = lib.meta.getLicenseFromSpdxId "MIT"; } ) { }; @@ -9303,7 +9303,7 @@ self: { vector ]; description = "utilities for DP"; - license = lib.licensesSpdx."BSD-3-Clause"; + license = lib.meta.getLicenseFromSpdxId "BSD-3-Clause"; } ) { }; @@ -10939,7 +10939,7 @@ self: { tasty-quickcheck ]; description = "An implementation of the Dung argumentation frameworks"; - license = lib.licensesSpdx."BSD-3-Clause"; + license = lib.meta.getLicenseFromSpdxId "BSD-3-Clause"; hydraPlatforms = lib.platforms.none; mainProgram = "dungell"; broken = true; @@ -11419,7 +11419,7 @@ self: { text ]; description = "Environment Variable Parser"; - license = lib.licensesSpdx."BSD-3-Clause"; + license = lib.meta.getLicenseFromSpdxId "BSD-3-Clause"; hydraPlatforms = lib.platforms.none; broken = true; } @@ -13447,7 +13447,7 @@ self: { WeakSets ]; description = "Finite categories and usual categorical constructions on them"; - license = lib.licensesSpdx."GPL-3.0-or-later"; + license = lib.meta.getLicenseFromSpdxId "GPL-3.0-or-later"; hydraPlatforms = lib.platforms.none; } ) { }; @@ -13498,7 +13498,7 @@ self: { WeakSets ]; description = "Transform objects of the package FiniteCategories into graphs using GraphViz"; - license = lib.licensesSpdx."GPL-3.0-or-later"; + license = lib.meta.getLicenseFromSpdxId "GPL-3.0-or-later"; hydraPlatforms = lib.platforms.none; broken = true; } @@ -13554,7 +13554,7 @@ self: { sha256 = "0cpkklm4dqv023ywb2qh49pndbsj2vz7rd2892vnsd9idd34aj6w"; libraryHaskellDepends = [ base ]; description = "A version of Prelude suitable for teaching"; - license = lib.licensesSpdx."BSD-3-Clause"; + license = lib.meta.getLicenseFromSpdxId "BSD-3-Clause"; } ) { }; @@ -13904,7 +13904,7 @@ self: { criterion ]; description = "Tree- and forest structures"; - license = lib.licensesSpdx."BSD-3-Clause"; + license = lib.meta.getLicenseFromSpdxId "BSD-3-Clause"; } ) { }; @@ -14059,7 +14059,7 @@ self: { vector ]; description = "(Context-free) grammars in formal language theory"; - license = lib.licensesSpdx."GPL-3.0-only"; + license = lib.meta.getLicenseFromSpdxId "GPL-3.0-only"; hydraPlatforms = lib.platforms.none; } ) { }; @@ -14495,7 +14495,7 @@ self: { vinyl ]; description = "Frames wrapper for map-reduce-folds and some extra folds helpers"; - license = lib.licensesSpdx."BSD-3-Clause"; + license = lib.meta.getLicenseFromSpdxId "BSD-3-Clause"; hydraPlatforms = lib.platforms.none; } ) { }; @@ -14610,7 +14610,7 @@ self: { vinyl ]; description = "A streamly layer for Frames I/O"; - license = lib.licensesSpdx."BSD-3-Clause"; + license = lib.meta.getLicenseFromSpdxId "BSD-3-Clause"; hydraPlatforms = lib.platforms.none; mainProgram = "Demo"; broken = true; @@ -15236,7 +15236,7 @@ self: { utf8-string ]; description = "Bindings to the GOST R 34.11-2012 hashing implementation"; - license = lib.licensesSpdx."BSD-2-Clause"; + license = lib.meta.getLicenseFromSpdxId "BSD-2-Clause"; } ) { }; @@ -15826,7 +15826,7 @@ self: { random ]; description = "Automatic SMS message generator"; - license = lib.licensesSpdx."BSD-3-Clause"; + license = lib.meta.getLicenseFromSpdxId "BSD-3-Clause"; hydraPlatforms = lib.platforms.none; mainProgram = "GenSmsPdu"; broken = true; @@ -17711,7 +17711,7 @@ self: { HDBC, mtl, time, - unixODBC, + unixodbc, utf8-string, }: mkDerivation { @@ -17729,11 +17729,11 @@ self: { time utf8-string ]; - librarySystemDepends = [ unixODBC ]; + librarySystemDepends = [ unixodbc ]; description = "ODBC driver for HDBC"; license = lib.licenses.bsd3; } - ) { unixODBC = null; }; + ) { inherit (pkgs) unixodbc; }; HDBC-postgresql = callPackage ( { @@ -19398,7 +19398,7 @@ self: { unliftio ]; description = "A flexible mock framework for testing effectful code"; - license = lib.licensesSpdx."BSD-3-Clause"; + license = lib.meta.getLicenseFromSpdxId "BSD-3-Clause"; hydraPlatforms = lib.platforms.none; } ) { }; @@ -19921,7 +19921,7 @@ self: { gauge ]; description = "quantitative finance library"; - license = lib.licensesSpdx."MIT"; + license = lib.meta.getLicenseFromSpdxId "MIT"; platforms = lib.platforms.x86; hydraPlatforms = lib.platforms.none; } @@ -19961,7 +19961,7 @@ self: { HROOT-tree ]; description = "Haskell binding to the ROOT data analysis framework"; - license = lib.licensesSpdx."LGPL-2.1-or-later"; + license = lib.meta.getLicenseFromSpdxId "LGPL-2.1-or-later"; hydraPlatforms = lib.platforms.none; } ) { }; @@ -19992,7 +19992,7 @@ self: { template-haskell ]; description = "Haskell binding to ROOT Core modules"; - license = lib.licensesSpdx."LGPL-2.1-or-later"; + license = lib.meta.getLicenseFromSpdxId "LGPL-2.1-or-later"; hydraPlatforms = lib.platforms.none; broken = true; } @@ -20028,7 +20028,7 @@ self: { template-haskell ]; description = "Haskell binding to ROOT Graf modules"; - license = lib.licensesSpdx."LGPL-2.1-or-later"; + license = lib.meta.getLicenseFromSpdxId "LGPL-2.1-or-later"; hydraPlatforms = lib.platforms.none; } ) { }; @@ -20061,7 +20061,7 @@ self: { template-haskell ]; description = "Haskell binding to ROOT Hist modules"; - license = lib.licensesSpdx."LGPL-2.1-or-later"; + license = lib.meta.getLicenseFromSpdxId "LGPL-2.1-or-later"; hydraPlatforms = lib.platforms.none; } ) { }; @@ -20094,7 +20094,7 @@ self: { template-haskell ]; description = "Haskell binding to ROOT IO modules"; - license = lib.licensesSpdx."LGPL-2.1-or-later"; + license = lib.meta.getLicenseFromSpdxId "LGPL-2.1-or-later"; hydraPlatforms = lib.platforms.none; } ) { }; @@ -20127,7 +20127,7 @@ self: { template-haskell ]; description = "Haskell binding to ROOT Math modules"; - license = lib.licensesSpdx."LGPL-2.1-or-later"; + license = lib.meta.getLicenseFromSpdxId "LGPL-2.1-or-later"; hydraPlatforms = lib.platforms.none; } ) { }; @@ -20164,7 +20164,7 @@ self: { ]; librarySystemDepends = [ RHTTP ]; description = "Haskell binding to ROOT Net modules"; - license = lib.licensesSpdx."LGPL-2.1-or-later"; + license = lib.meta.getLicenseFromSpdxId "LGPL-2.1-or-later"; hydraPlatforms = lib.platforms.none; } ) { RHTTP = null; }; @@ -20197,7 +20197,7 @@ self: { template-haskell ]; description = "Haskell binding to ROOT Tree modules"; - license = lib.licensesSpdx."LGPL-2.1-or-later"; + license = lib.meta.getLicenseFromSpdxId "LGPL-2.1-or-later"; hydraPlatforms = lib.platforms.none; } ) { }; @@ -20659,7 +20659,7 @@ self: { containers ]; description = "Haskell Bindings for libsvm"; - license = lib.licensesSpdx."BSD-3-Clause"; + license = lib.meta.getLicenseFromSpdxId "BSD-3-Clause"; } ) { }; @@ -20874,7 +20874,7 @@ self: { test-framework-hunit ]; description = "A library for client-side HTTP"; - license = lib.licensesSpdx."BSD-3-Clause"; + license = lib.meta.getLicenseFromSpdxId "BSD-3-Clause"; hydraPlatforms = lib.platforms.none; } ) { }; @@ -20931,7 +20931,7 @@ self: { strict ]; description = "Tableau based theorem prover for hybrid logics"; - license = lib.licensesSpdx."BSD-3-Clause"; + license = lib.meta.getLicenseFromSpdxId "BSD-3-Clause"; hydraPlatforms = lib.platforms.none; mainProgram = "htab"; } @@ -21878,7 +21878,7 @@ self: { isExecutable = true; executableHaskellDepends = [ base ]; description = "The classic game of Hangman"; - license = lib.licensesSpdx."MIT"; + license = lib.meta.getLicenseFromSpdxId "MIT"; hydraPlatforms = lib.platforms.none; mainProgram = "Hangman"; broken = true; @@ -22171,7 +22171,7 @@ self: { transformers ]; description = "Functional choreographic programming in Haskell"; - license = lib.licensesSpdx."BSD-3-Clause"; + license = lib.meta.getLicenseFromSpdxId "BSD-3-Clause"; hydraPlatforms = lib.platforms.none; broken = true; } @@ -22398,7 +22398,7 @@ self: { random ]; description = "Combinatorics, group theory, commutative algebra, non-commutative algebra"; - license = lib.licensesSpdx."BSD-3-Clause"; + license = lib.meta.getLicenseFromSpdxId "BSD-3-Clause"; hydraPlatforms = lib.platforms.none; broken = true; } @@ -22883,7 +22883,7 @@ self: { yaml ]; description = "Cashflow modeling library for structured finance"; - license = lib.licensesSpdx."BSD-3-Clause"; + license = lib.meta.getLicenseFromSpdxId "BSD-3-Clause"; mainProgram = "Hastructure-exe"; } ) { }; @@ -24483,7 +24483,7 @@ self: { vector ]; description = "JSON to YAML Adapter"; - license = lib.licensesSpdx."GPL-2.0-or-later"; + license = lib.meta.getLicenseFromSpdxId "GPL-2.0-or-later"; } ) { }; @@ -24751,7 +24751,7 @@ self: { MemoTrie ]; description = "A package for solving dynamic programming problems in Haskell"; - license = lib.licensesSpdx."BSD-3-Clause"; + license = lib.meta.getLicenseFromSpdxId "BSD-3-Clause"; hydraPlatforms = lib.platforms.none; broken = true; } @@ -25097,7 +25097,7 @@ self: { template-haskell ]; description = "String Interpolation of Haskell expressions using #{expr} syntax"; - license = lib.licensesSpdx."MIT"; + license = lib.meta.getLicenseFromSpdxId "MIT"; } ) { }; @@ -25253,7 +25253,7 @@ self: { ]; testHaskellDepends = [ base ]; description = "Imperative approach to testing stateful applications. ImpSpec is built on top of HSpec and QuickCheck."; - license = lib.licensesSpdx."Apache-2.0"; + license = lib.meta.getLicenseFromSpdxId "Apache-2.0"; hydraPlatforms = lib.platforms.none; } ) { }; @@ -25355,7 +25355,7 @@ self: { random ]; description = "Infinitely deep trees for lazy stateless memoization"; - license = lib.licensesSpdx."AGPL-3.0-or-later"; + license = lib.meta.getLicenseFromSpdxId "AGPL-3.0-or-later"; hydraPlatforms = lib.platforms.none; broken = true; } @@ -26420,7 +26420,7 @@ self: { JuicyPixels ]; description = "Efficiently scale, crop, flip images with JuicyPixels"; - license = lib.licensesSpdx."BSD-3-Clause"; + license = lib.meta.getLicenseFromSpdxId "BSD-3-Clause"; } ) { }; @@ -26458,7 +26458,7 @@ self: { ]; testToolDepends = [ tasty-discover ]; description = "JuicyPixels wrappers for libjpeg-turbo"; - license = lib.licensesSpdx."BSD-3-Clause"; + license = lib.meta.getLicenseFromSpdxId "BSD-3-Clause"; } ) { }; @@ -26767,7 +26767,7 @@ self: { transformers ]; description = "A simple parsing library and some additional utilities"; - license = lib.licensesSpdx."BSD-3-Clause"; + license = lib.meta.getLicenseFromSpdxId "BSD-3-Clause"; } ) { }; @@ -27241,7 +27241,7 @@ self: { text-short ]; description = "Lightweight Directory Access Protocol (LDAP) version 3"; - license = lib.licensesSpdx."GPL-2.0-or-later"; + license = lib.meta.getLicenseFromSpdxId "GPL-2.0-or-later"; hydraPlatforms = lib.platforms.none; } ) { }; @@ -27489,7 +27489,7 @@ self: { happy ]; description = "LALR(1) parsetable generator and interpreter"; - license = lib.licensesSpdx."BSD-3-Clause"; + license = lib.meta.getLicenseFromSpdxId "BSD-3-Clause"; mainProgram = "lr-demo"; } ) { }; @@ -27793,7 +27793,7 @@ self: { vector ]; description = "A game engine library for tactical squad ASCII roguelike dungeon crawlers"; - license = lib.licensesSpdx."BSD-3-Clause"; + license = lib.meta.getLicenseFromSpdxId "BSD-3-Clause"; badPlatforms = lib.platforms.darwin; mainProgram = "LambdaHack"; } @@ -28212,7 +28212,7 @@ self: { sha256 = "1rj5n931370nxrnqj1728p38mcqbpswmxc73c5g1mlh66k0gqqk4"; libraryHaskellDepends = [ base ]; description = "European option implied vol calculation"; - license = lib.licensesSpdx."MIT"; + license = lib.meta.getLicenseFromSpdxId "MIT"; } ) { }; @@ -28710,7 +28710,7 @@ self: { testHaskellDepends = [ base ]; doHaddock = false; description = "Converter to convert from .lhs to .md and vice versa."; - license = lib.licensesSpdx."MIT"; + license = lib.meta.getLicenseFromSpdxId "MIT"; hydraPlatforms = lib.platforms.none; mainProgram = "lhsc"; broken = true; @@ -29769,7 +29769,7 @@ self: { hspec ]; description = "Reals in the interval [0,1), as machine words"; - license = lib.licensesSpdx."BSD-3-Clause"; + license = lib.meta.getLicenseFromSpdxId "BSD-3-Clause"; } ) { }; @@ -30215,7 +30215,7 @@ self: { process ]; description = "A partial Cabal replacement"; - license = lib.licensesSpdx."Apache-2.0"; + license = lib.meta.getLicenseFromSpdxId "Apache-2.0"; mainProgram = "mcabal"; } ) { }; @@ -30269,7 +30269,7 @@ self: { time ]; description = "A small compiler for Haskell"; - license = lib.licensesSpdx."Apache-2.0"; + license = lib.meta.getLicenseFromSpdxId "Apache-2.0"; mainProgram = "mhs"; } ) { }; @@ -30359,7 +30359,7 @@ self: { ]; testToolDepends = [ goldplate ]; description = "A toy dependently typed programming language with type-based termination"; - license = lib.licensesSpdx."MIT"; + license = lib.meta.getLicenseFromSpdxId "MIT"; hydraPlatforms = lib.platforms.none; mainProgram = "miniagda"; broken = true; @@ -31325,7 +31325,7 @@ self: { warp ]; description = "Type-safe and efficient choreographies with location-set polymorphism"; - license = lib.licensesSpdx."BSD-3-Clause"; + license = lib.meta.getLicenseFromSpdxId "BSD-3-Clause"; hydraPlatforms = lib.platforms.none; broken = true; } @@ -32356,7 +32356,7 @@ self: { split ]; description = "Instances of NcStore for hypercuboids"; - license = lib.licensesSpdx."BSD-3-Clause"; + license = lib.meta.getLicenseFromSpdxId "BSD-3-Clause"; hydraPlatforms = lib.platforms.none; mainProgram = "Main"; } @@ -32447,7 +32447,7 @@ self: { vector ]; description = "Simple scoring schemes for word alignments"; - license = lib.licensesSpdx."BSD-3-Clause"; + license = lib.meta.getLicenseFromSpdxId "BSD-3-Clause"; hydraPlatforms = lib.platforms.none; broken = true; } @@ -33374,7 +33374,7 @@ self: { OGDF ]; description = "Haskell binding to OGDF"; - license = lib.licensesSpdx."BSD-2-Clause"; + license = lib.meta.getLicenseFromSpdxId "BSD-2-Clause"; hydraPlatforms = lib.platforms.none; broken = true; } @@ -34492,7 +34492,7 @@ self: { criterion ]; description = "Efficient ordered (by popcount) enumeration of bits"; - license = lib.licensesSpdx."BSD-3-Clause"; + license = lib.meta.getLicenseFromSpdxId "BSD-3-Clause"; platforms = lib.platforms.x86; } ) { }; @@ -36135,7 +36135,7 @@ self: { vector-th-unbox ]; description = "Efficient multidimensional arrays"; - license = lib.licensesSpdx."BSD-3-Clause"; + license = lib.meta.getLicenseFromSpdxId "BSD-3-Clause"; hydraPlatforms = lib.platforms.none; broken = true; } @@ -36333,7 +36333,7 @@ self: { QuickCheck ]; description = "Property-based testing framework for testing asynchronous FRP programs"; - license = lib.licensesSpdx."BSD-3-Clause"; + license = lib.meta.getLicenseFromSpdxId "BSD-3-Clause"; hydraPlatforms = lib.platforms.none; } ) { }; @@ -36742,7 +36742,7 @@ self: { time ]; description = "Quasiquotations for a python like interpolated string formatter"; - license = lib.licensesSpdx."BSD-3-Clause"; + license = lib.meta.getLicenseFromSpdxId "BSD-3-Clause"; } ) { }; @@ -37061,7 +37061,7 @@ self: { transformers ]; description = "A GenT monad transformer for QuickCheck library"; - license = lib.licensesSpdx."MIT"; + license = lib.meta.getLicenseFromSpdxId "MIT"; } ) { }; @@ -37961,7 +37961,7 @@ self: { time ]; description = "A puzzle game written in Haskell with a cat in lead role"; - license = lib.licensesSpdx."BSD-3-Clause"; + license = lib.meta.getLicenseFromSpdxId "BSD-3-Clause"; badPlatforms = lib.platforms.darwin; hydraPlatforms = lib.platforms.none; mainProgram = "raincat"; @@ -38845,7 +38845,7 @@ self: { libraryHaskellDepends = [ base ]; testHaskellDepends = [ base ]; description = "rounding variants floor, ceil and truncate for floating point operations +-*/√…"; - license = lib.licensesSpdx."MIT"; + license = lib.meta.getLicenseFromSpdxId "MIT"; } ) { }; @@ -38896,7 +38896,7 @@ self: { vector ]; description = "Haskell wrapper for RtMidi, the lightweight, cross-platform MIDI I/O library"; - license = lib.licensesSpdx."MIT"; + license = lib.meta.getLicenseFromSpdxId "MIT"; hydraPlatforms = lib.platforms.none; broken = true; } @@ -38970,7 +38970,7 @@ self: { X ]; description = "Library for accessing S3 compatible storage services"; - license = lib.licensesSpdx."GPL-3.0-or-later"; + license = lib.meta.getLicenseFromSpdxId "GPL-3.0-or-later"; hydraPlatforms = lib.platforms.none; } ) { }; @@ -39562,7 +39562,7 @@ self: { time ]; description = "The Simple Javascript Wrench"; - license = lib.licensesSpdx."BSD-3-Clause"; + license = lib.meta.getLicenseFromSpdxId "BSD-3-Clause"; hydraPlatforms = lib.platforms.none; mainProgram = "sjw"; broken = true; @@ -40254,7 +40254,7 @@ self: { vector-th-unbox ]; description = "Base types and classes for statistics, sciences and humanities"; - license = lib.licensesSpdx."BSD-3-Clause"; + license = lib.meta.getLicenseFromSpdxId "BSD-3-Clause"; } ) { }; @@ -40453,7 +40453,7 @@ self: { bytestring ]; description = "simple static linked SHA3 using private symbols and the ref impl"; - license = lib.licensesSpdx."BSD-2-Clause"; + license = lib.meta.getLicenseFromSpdxId "BSD-2-Clause"; hydraPlatforms = lib.platforms.none; broken = true; } @@ -40688,7 +40688,7 @@ self: { util ]; description = "See README for more info"; - license = lib.licensesSpdx."MPL-2.0"; + license = lib.meta.getLicenseFromSpdxId "MPL-2.0"; hydraPlatforms = lib.platforms.none; broken = true; } @@ -41083,7 +41083,7 @@ self: { warp ]; description = "A programming model for declarative, high performance user interface"; - license = lib.licensesSpdx."BSD-3-Clause"; + license = lib.meta.getLicenseFromSpdxId "BSD-3-Clause"; hydraPlatforms = lib.platforms.none; broken = true; } @@ -41128,7 +41128,7 @@ self: { unliftio ]; description = "A Virtual Dom in pure Haskell, based on Html as an Alignable Functor"; - license = lib.licensesSpdx."BSD-3-Clause"; + license = lib.meta.getLicenseFromSpdxId "BSD-3-Clause"; hydraPlatforms = lib.platforms.none; } ) { }; @@ -41168,7 +41168,7 @@ self: { unliftio ]; description = "Use the high-performance Snabbdom virtual dom library written in JavaScript"; - license = lib.licensesSpdx."BSD-3-Clause"; + license = lib.meta.getLicenseFromSpdxId "BSD-3-Clause"; hydraPlatforms = lib.platforms.none; } ) { }; @@ -41192,7 +41192,7 @@ self: { text ]; description = "A backend for rendering Shpadoinkle as Text"; - license = lib.licensesSpdx."BSD-3-Clause"; + license = lib.meta.getLicenseFromSpdxId "BSD-3-Clause"; hydraPlatforms = lib.platforms.none; } ) { }; @@ -41220,7 +41220,7 @@ self: { unliftio ]; description = "Support for the native browser console"; - license = lib.licensesSpdx."BSD-3-Clause"; + license = lib.meta.getLicenseFromSpdxId "BSD-3-Clause"; hydraPlatforms = lib.platforms.none; broken = true; } @@ -41306,7 +41306,7 @@ self: { unliftio ]; description = "Chrome extension to aide in development"; - license = lib.licensesSpdx."BSD-3-Clause"; + license = lib.meta.getLicenseFromSpdxId "BSD-3-Clause"; hydraPlatforms = lib.platforms.none; mainProgram = "devtools"; } @@ -41343,7 +41343,7 @@ self: { unliftio ]; description = "Shpadoinkle as a static site"; - license = lib.licensesSpdx."BSD-3-Clause"; + license = lib.meta.getLicenseFromSpdxId "BSD-3-Clause"; hydraPlatforms = lib.platforms.none; } ) { }; @@ -41489,7 +41489,7 @@ self: { unliftio ]; description = "A typed, template generated Html DSL, and helpers"; - license = lib.licensesSpdx."BSD-3-Clause"; + license = lib.meta.getLicenseFromSpdxId "BSD-3-Clause"; hydraPlatforms = lib.platforms.none; } ) { }; @@ -41547,7 +41547,7 @@ self: { warp ]; description = "Isreal Swan will make a snowman for you!"; - license = lib.licensesSpdx."GPL-3.0-or-later"; + license = lib.meta.getLicenseFromSpdxId "GPL-3.0-or-later"; hydraPlatforms = lib.platforms.none; mainProgram = "isreal"; broken = true; @@ -41573,7 +41573,7 @@ self: { text ]; description = "Lens combinators for Shpadoinkle applications"; - license = lib.licensesSpdx."BSD-3-Clause"; + license = lib.meta.getLicenseFromSpdxId "BSD-3-Clause"; hydraPlatforms = lib.platforms.none; } ) { }; @@ -41641,7 +41641,7 @@ self: { warp ]; description = "A single page application rounter for Shpadoinkle based on Servant"; - license = lib.licensesSpdx."BSD-3-Clause"; + license = lib.meta.getLicenseFromSpdxId "BSD-3-Clause"; hydraPlatforms = lib.platforms.none; } ) { }; @@ -41667,7 +41667,7 @@ self: { text ]; description = "Integration of the streaming library with Shpadoinkle continuations"; - license = lib.licensesSpdx."BSD-3-Clause"; + license = lib.meta.getLicenseFromSpdxId "BSD-3-Clause"; hydraPlatforms = lib.platforms.none; } ) { }; @@ -41714,7 +41714,7 @@ self: { text ]; description = "Read standard file formats into Shpadoinkle with Template Haskell"; - license = lib.licensesSpdx."BSD-3-Clause"; + license = lib.meta.getLicenseFromSpdxId "BSD-3-Clause"; hydraPlatforms = lib.platforms.none; } ) { }; @@ -41780,7 +41780,7 @@ self: { quickcheck-classes-base ]; description = "A collection of common reusable types and components"; - license = lib.licensesSpdx."BSD-3-Clause"; + license = lib.meta.getLicenseFromSpdxId "BSD-3-Clause"; hydraPlatforms = lib.platforms.none; } ) { }; @@ -43558,7 +43558,7 @@ self: { sha256 = "0nxk4a997sibj8nl1b1r6mcn0r7qbyz68jnirv29lq2yyh6lbja4"; doHaddock = false; description = "Svg Icons and more"; - license = lib.licensesSpdx."BSD-3-Clause"; + license = lib.meta.getLicenseFromSpdxId "BSD-3-Clause"; } ) { }; @@ -43621,7 +43621,7 @@ self: { random ]; description = "Synapse is a machine learning library written in pure Haskell"; - license = lib.licensesSpdx."MIT"; + license = lib.meta.getLicenseFromSpdxId "MIT"; hydraPlatforms = lib.platforms.none; } ) { }; @@ -43906,7 +43906,7 @@ self: { template-haskell ]; description = "A \"noDSL\" approach to mixing shell scripting with Haskell programs using Template Haskell"; - license = lib.licensesSpdx."MIT"; + license = lib.meta.getLicenseFromSpdxId "MIT"; mainProgram = "thsh"; } ) { }; @@ -45280,7 +45280,7 @@ self: { editedCabalFile = "06dzrj9ksla1x108rbcf716zbgmwv2pjc4d5ng504bn7q4vhvs6l"; libraryHaskellDepends = [ base ]; description = "Trivial monad with Unit type"; - license = lib.licensesSpdx."BSD-2-Clause"; + license = lib.meta.getLicenseFromSpdxId "BSD-2-Clause"; } ) { }; @@ -45987,7 +45987,7 @@ self: { parsec ]; description = "A Valve Value-keyvalue parser for Haskell made with Parsec"; - license = lib.licensesSpdx."MIT"; + license = lib.meta.getLicenseFromSpdxId "MIT"; hydraPlatforms = lib.platforms.none; broken = true; } @@ -46409,7 +46409,7 @@ self: { vulkan ]; description = "Bindings to the VulkanMemoryAllocator library"; - license = lib.licensesSpdx."BSD-3-Clause"; + license = lib.meta.getLicenseFromSpdxId "BSD-3-Clause"; badPlatforms = [ "i686-linux" "armv7l-linux" @@ -46778,7 +46778,7 @@ self: { libraryHaskellDepends = [ base ]; testHaskellDepends = [ base ]; description = "Simple set types. Useful to create sets of arbitrary types and nested sets."; - license = lib.licensesSpdx."LGPL-3.0-or-later"; + license = lib.meta.getLicenseFromSpdxId "LGPL-3.0-or-later"; hydraPlatforms = lib.platforms.none; broken = true; } @@ -48052,7 +48052,7 @@ self: { ]; libraryPkgconfigDepends = [ libxft ]; description = "Bindings to the Xft and some Xrender parts"; - license = lib.licensesSpdx."BSD-3-Clause"; + license = lib.meta.getLicenseFromSpdxId "BSD-3-Clause"; maintainers = [ lib.maintainers.slotThe ]; } ) { inherit (pkgs) libxft; }; @@ -48904,7 +48904,7 @@ self: { Z-IO ]; description = "Crypto for Haskell"; - license = lib.licensesSpdx."BSD-3-Clause"; + license = lib.meta.getLicenseFromSpdxId "BSD-3-Clause"; hydraPlatforms = lib.platforms.none; } ) { }; @@ -48975,7 +48975,7 @@ self: { ]; testToolDepends = [ hspec-discover ]; description = "Array, vector and text"; - license = lib.licensesSpdx."BSD-3-Clause"; + license = lib.meta.getLicenseFromSpdxId "BSD-3-Clause"; hydraPlatforms = lib.platforms.none; broken = true; } @@ -49038,7 +49038,7 @@ self: { ]; testToolDepends = [ hspec-discover ]; description = "Simple and high performance IO toolkit for Haskell"; - license = lib.licensesSpdx."BSD-3-Clause"; + license = lib.meta.getLicenseFromSpdxId "BSD-3-Clause"; hydraPlatforms = lib.platforms.none; } ) { }; @@ -49136,7 +49136,7 @@ self: { Z-Data ]; description = "YAML tools"; - license = lib.licensesSpdx."BSD-3-Clause"; + license = lib.meta.getLicenseFromSpdxId "BSD-3-Clause"; hydraPlatforms = lib.platforms.none; } ) { }; @@ -49262,7 +49262,7 @@ self: { syz ]; description = "An implementation of Attribute Grammars using Functional Zippers"; - license = lib.licensesSpdx."BSD-3-Clause"; + license = lib.meta.getLicenseFromSpdxId "BSD-3-Clause"; } ) { }; @@ -49512,7 +49512,7 @@ self: { ]; testToolDepends = [ tasty-discover ]; description = "Nix flake repository for everyone"; - license = lib.licensesSpdx."BSD-3-Clause"; + license = lib.meta.getLicenseFromSpdxId "BSD-3-Clause"; hydraPlatforms = lib.platforms.none; mainProgram = "a-piece-of-flake"; } @@ -49580,7 +49580,7 @@ self: { text ]; description = "Convert distfix precedence grammars to unambiguous context-free grammars"; - license = lib.licensesSpdx."Apache-2.0"; + license = lib.meta.getLicenseFromSpdxId "Apache-2.0"; hydraPlatforms = lib.platforms.none; broken = true; } @@ -49962,7 +49962,7 @@ self: { sha256 = "1vcmiq2gk8v87dx1gsxlyq6mn42pnz643rpy89kvpxrvr8qmri2b"; libraryHaskellDepends = [ base ]; description = "Manage the implicit parameter namespace dynamically at compile time"; - license = lib.licensesSpdx."Apache-2.0"; + license = lib.meta.getLicenseFromSpdxId "Apache-2.0"; } ) { }; @@ -50090,7 +50090,7 @@ self: { wide-word ]; description = "Data structures and algorithms"; - license = lib.licensesSpdx."CC0-1.0"; + license = lib.meta.getLicenseFromSpdxId "CC0-1.0"; mainProgram = "example-lazy-segtree"; } ) { }; @@ -50178,7 +50178,7 @@ self: { rerebase ]; description = "Sequence optimized for monoidal construction and folding"; - license = lib.licensesSpdx."MIT"; + license = lib.meta.getLicenseFromSpdxId "MIT"; } ) { }; @@ -52495,7 +52495,7 @@ self: { wreq ]; description = "implements ACME clients (rfc-8555)"; - license = lib.licensesSpdx."BSD-3-Clause"; + license = lib.meta.getLicenseFromSpdxId "BSD-3-Clause"; hydraPlatforms = lib.platforms.none; broken = true; } @@ -52926,7 +52926,7 @@ self: { text ]; description = "AcousticBrainz API client"; - license = lib.licensesSpdx."CC0-1.0"; + license = lib.meta.getLicenseFromSpdxId "CC0-1.0"; hydraPlatforms = lib.platforms.none; broken = true; } @@ -52949,7 +52949,7 @@ self: { transformers ]; description = "Abstraction over management of resources"; - license = lib.licensesSpdx."MIT"; + license = lib.meta.getLicenseFromSpdxId "MIT"; } ) { }; @@ -53215,7 +53215,7 @@ self: { ]; doHaddock = false; description = "Semigroup actions and torsors"; - license = lib.licensesSpdx."BSD-3-Clause"; + license = lib.meta.getLicenseFromSpdxId "BSD-3-Clause"; } ) { }; @@ -53321,7 +53321,7 @@ self: { sha256 = "07zi06qqmrn14awz7vxn5rx1j62fc9xp2qx52s1j91kh9zy8pzxn"; libraryHaskellDepends = [ base ]; description = "Multidimensional integration"; - license = lib.licensesSpdx."GPL-3.0-only"; + license = lib.meta.getLicenseFromSpdxId "GPL-3.0-only"; } ) { }; @@ -53455,7 +53455,7 @@ self: { template-haskell ]; description = "Safer TH addDependentFile wrapper"; - license = lib.licensesSpdx."BSD-3-Clause"; + license = lib.meta.getLicenseFromSpdxId "BSD-3-Clause"; hydraPlatforms = lib.platforms.none; broken = true; } @@ -53535,7 +53535,7 @@ self: { validation-selective ]; description = "A full-featured library for parsing, validating, and rendering email addresses"; - license = lib.licensesSpdx."BSD-2-Clause"; + license = lib.meta.getLicenseFromSpdxId "BSD-2-Clause"; hydraPlatforms = lib.platforms.none; broken = true; } @@ -53570,7 +53570,7 @@ self: { ]; testToolDepends = [ hspec-discover ]; description = "Manage fine grained fixtures"; - license = lib.licensesSpdx."ISC"; + license = lib.meta.getLicenseFromSpdxId "ISC"; } ) { }; @@ -53606,7 +53606,7 @@ self: { ]; testToolDepends = [ hspec-discover ]; description = "Manage fine grained fixtures"; - license = lib.licensesSpdx."ISC"; + license = lib.meta.getLicenseFromSpdxId "ISC"; hydraPlatforms = lib.platforms.none; broken = true; } @@ -53729,7 +53729,7 @@ self: { hs-functors ]; description = "See README for more info"; - license = lib.licensesSpdx."BSD-3-Clause"; + license = lib.meta.getLicenseFromSpdxId "BSD-3-Clause"; hydraPlatforms = lib.platforms.none; broken = true; } @@ -54273,7 +54273,7 @@ self: { tasty-hunit ]; description = "AES Galois/Counter Mode (GCM) AEAD Cipher"; - license = lib.licensesSpdx."GPL-2.0-or-later"; + license = lib.meta.getLicenseFromSpdxId "GPL-2.0-or-later"; } ) { inherit (pkgs) openssl; }; @@ -54411,7 +54411,7 @@ self: { vector ]; description = "Fast JSON parsing and encoding"; - license = lib.licensesSpdx."BSD-3-Clause"; + license = lib.meta.getLicenseFromSpdxId "BSD-3-Clause"; } ) { }; @@ -54815,7 +54815,7 @@ self: { vector ]; description = "Easy functions for converting from Aeson.Value"; - license = lib.licensesSpdx."Apache-2.0"; + license = lib.meta.getLicenseFromSpdxId "Apache-2.0"; hydraPlatforms = lib.platforms.none; broken = true; } @@ -54892,7 +54892,7 @@ self: { ]; testToolDepends = [ tasty-discover ]; description = "JSON encoding/decoding for dependent-sum"; - license = lib.licensesSpdx."GPL-3.0-or-later"; + license = lib.meta.getLicenseFromSpdxId "GPL-3.0-or-later"; hydraPlatforms = lib.platforms.none; broken = true; } @@ -55379,7 +55379,7 @@ self: { text ]; description = "Type-level default fields for aeson Generic FromJSON parser"; - license = lib.licensesSpdx."BSD-3-Clause"; + license = lib.meta.getLicenseFromSpdxId "BSD-3-Clause"; hydraPlatforms = lib.platforms.none; broken = true; } @@ -55433,7 +55433,7 @@ self: { time ]; description = "Generates TypeScript definitions that match Generic Aeson encodings"; - license = lib.licensesSpdx."BSD-3-Clause"; + license = lib.meta.getLicenseFromSpdxId "BSD-3-Clause"; hydraPlatforms = lib.platforms.none; mainProgram = "tests"; broken = true; @@ -55821,7 +55821,7 @@ self: { QuickCheck ]; description = "Encode and decode Haskell records as JSON tuples"; - license = lib.licensesSpdx."MPL-2.0"; + license = lib.meta.getLicenseFromSpdxId "MPL-2.0"; } ) { }; @@ -55976,7 +55976,7 @@ self: { tasty-quickcheck-laws ]; description = "Possible values for aeson"; - license = lib.licensesSpdx."BSD-3-Clause"; + license = lib.meta.getLicenseFromSpdxId "BSD-3-Clause"; } ) { }; @@ -56425,7 +56425,7 @@ self: { ]; testToolDepends = [ markdown-unlit ]; description = "Conveniently wrap a single value in a record when encoding to and from JSON"; - license = lib.licensesSpdx."MIT"; + license = lib.meta.getLicenseFromSpdxId "MIT"; hydraPlatforms = lib.platforms.none; broken = true; } @@ -56557,7 +56557,7 @@ self: { vector ]; description = "Aeson instances for the Tiled map editor"; - license = lib.licensesSpdx."BSD-3-Clause"; + license = lib.meta.getLicenseFromSpdxId "BSD-3-Clause"; } ) { }; @@ -56674,7 +56674,7 @@ self: { vector ]; description = "Aliases to \"aeson\" AST making it importable unqualified"; - license = lib.licensesSpdx."MIT"; + license = lib.meta.getLicenseFromSpdxId "MIT"; } ) { }; @@ -56744,7 +56744,7 @@ self: { vector ]; description = "API for parsing \"aeson\" JSON tree into Haskell types"; - license = lib.licensesSpdx."MIT"; + license = lib.meta.getLicenseFromSpdxId "MIT"; } ) { }; @@ -57137,7 +57137,7 @@ self: { uniqueness-periods-vector-stats ]; description = "An AFTOVolio implementation for creating texts with special phonetic / prosodic properties"; - license = lib.licensesSpdx."MIT"; + license = lib.meta.getLicenseFromSpdxId "MIT"; } ) { }; @@ -57453,7 +57453,7 @@ self: { text ]; description = "Check for unused code in an Agda project"; - license = lib.licensesSpdx."MIT"; + license = lib.meta.getLicenseFromSpdxId "MIT"; hydraPlatforms = lib.platforms.none; mainProgram = "agda-unused"; broken = true; @@ -57506,7 +57506,7 @@ self: { yaml ]; description = "Compiling Agda code to readable Haskell"; - license = lib.licensesSpdx."BSD-3-Clause"; + license = lib.meta.getLicenseFromSpdxId "BSD-3-Clause"; mainProgram = "agda2hs"; maintainers = [ lib.maintainers.ncfavier ]; } @@ -57631,7 +57631,7 @@ self: { ]; doHaddock = false; description = "Agda backend to generate training data for machine learning purposes"; - license = lib.licensesSpdx."BSD-3-Clause"; + license = lib.meta.getLicenseFromSpdxId "BSD-3-Clause"; hydraPlatforms = lib.platforms.none; mainProgram = "agda2train"; broken = true; @@ -57696,7 +57696,7 @@ self: { text ]; description = "Actually Good Encryption"; - license = lib.licensesSpdx."MIT"; + license = lib.meta.getLicenseFromSpdxId "MIT"; hydraPlatforms = lib.platforms.none; } ) { }; @@ -58232,7 +58232,7 @@ self: { unordered-containers ]; description = "Automatically generate a GraphQL API for an SQLite database"; - license = lib.licensesSpdx."AGPL-3.0-or-later"; + license = lib.meta.getLicenseFromSpdxId "AGPL-3.0-or-later"; hydraPlatforms = lib.platforms.none; mainProgram = "airgql"; broken = true; @@ -59642,7 +59642,7 @@ self: { criterion ]; description = "A library for algebraic edge-graph construction and transformation"; - license = lib.licensesSpdx."MIT"; + license = lib.meta.getLicenseFromSpdxId "MIT"; } ) { }; @@ -59725,7 +59725,7 @@ self: { transformers ]; description = "A library for algebraic graph construction and transformation"; - license = lib.licensesSpdx."MIT"; + license = lib.meta.getLicenseFromSpdxId "MIT"; } ) { }; @@ -59763,7 +59763,7 @@ self: { transformers ]; description = "A library for algebraic graph construction and transformation"; - license = lib.licensesSpdx."MIT"; + license = lib.meta.getLicenseFromSpdxId "MIT"; hydraPlatforms = lib.platforms.none; } ) { }; @@ -59873,7 +59873,7 @@ self: { ]; doHaddock = false; description = "Flexible and simple path manipulation library"; - license = lib.licensesSpdx."MIT"; + license = lib.meta.getLicenseFromSpdxId "MIT"; } ) { }; @@ -60350,7 +60350,7 @@ self: { utility-ht ]; description = "Find relative time displacement of two recordings of the same music"; - license = lib.licensesSpdx."BSD-3-Clause"; + license = lib.meta.getLicenseFromSpdxId "BSD-3-Clause"; mainProgram = "align-audio"; maintainers = [ lib.maintainers.thielema ]; } @@ -60386,7 +60386,7 @@ self: { text ]; description = "Aligns text prefixes before '=' for consistent formatting"; - license = lib.licensesSpdx."MIT"; + license = lib.meta.getLicenseFromSpdxId "MIT"; hydraPlatforms = lib.platforms.none; mainProgram = "align-equal"; broken = true; @@ -61143,7 +61143,7 @@ self: { ]; libraryPkgconfigDepends = [ alsa-lib ]; description = "Binding to the ALSA Library API (MIDI sequencer)"; - license = lib.licensesSpdx."BSD-3-Clause"; + license = lib.meta.getLicenseFromSpdxId "BSD-3-Clause"; platforms = lib.platforms.linux; maintainers = [ lib.maintainers.thielema ]; } @@ -61432,7 +61432,7 @@ self: { version = "0.1"; sha256 = "15fwq1pmb3d46cgsj59q3iz2qs0lgvq5b9d6gxfysnjlm3sp0ivw"; description = "provides a typeclass that is always satisfied"; - license = lib.licensesSpdx."BSD-3-Clause"; + license = lib.meta.getLicenseFromSpdxId "BSD-3-Clause"; } ) { }; @@ -61623,7 +61623,7 @@ self: { uuid ]; description = "Comprehensive Amazon Web Services SDK"; - license = lib.licensesSpdx."MPL-2.0"; + license = lib.meta.getLicenseFromSpdxId "MPL-2.0"; maintainers = [ lib.maintainers.mpscholten ]; } ) { }; @@ -61665,7 +61665,7 @@ self: { unordered-containers ]; description = "Amazon Access Analyzer SDK"; - license = lib.licensesSpdx."MPL-2.0"; + license = lib.meta.getLicenseFromSpdxId "MPL-2.0"; } ) { }; @@ -61706,7 +61706,7 @@ self: { unordered-containers ]; description = "Amazon Account SDK"; - license = lib.licensesSpdx."MPL-2.0"; + license = lib.meta.getLicenseFromSpdxId "MPL-2.0"; } ) { }; @@ -61747,7 +61747,7 @@ self: { unordered-containers ]; description = "Amazon Alexa For Business SDK"; - license = lib.licensesSpdx."MPL-2.0"; + license = lib.meta.getLicenseFromSpdxId "MPL-2.0"; } ) { }; @@ -61788,7 +61788,7 @@ self: { unordered-containers ]; description = "Amazon Prometheus Service SDK"; - license = lib.licensesSpdx."MPL-2.0"; + license = lib.meta.getLicenseFromSpdxId "MPL-2.0"; } ) { }; @@ -61829,7 +61829,7 @@ self: { unordered-containers ]; description = "Amazon Amplify SDK"; - license = lib.licensesSpdx."MPL-2.0"; + license = lib.meta.getLicenseFromSpdxId "MPL-2.0"; } ) { }; @@ -61870,7 +61870,7 @@ self: { unordered-containers ]; description = "Amazon AmplifyBackend SDK"; - license = lib.licensesSpdx."MPL-2.0"; + license = lib.meta.getLicenseFromSpdxId "MPL-2.0"; } ) { }; @@ -61911,7 +61911,7 @@ self: { unordered-containers ]; description = "Amazon Amplify UI Builder SDK"; - license = lib.licensesSpdx."MPL-2.0"; + license = lib.meta.getLicenseFromSpdxId "MPL-2.0"; } ) { }; @@ -61952,7 +61952,7 @@ self: { unordered-containers ]; description = "Amazon API Gateway SDK"; - license = lib.licensesSpdx."MPL-2.0"; + license = lib.meta.getLicenseFromSpdxId "MPL-2.0"; } ) { }; @@ -61993,7 +61993,7 @@ self: { unordered-containers ]; description = "Amazon ApiGatewayManagementApi SDK"; - license = lib.licensesSpdx."MPL-2.0"; + license = lib.meta.getLicenseFromSpdxId "MPL-2.0"; } ) { }; @@ -62034,7 +62034,7 @@ self: { unordered-containers ]; description = "Amazon ApiGatewayV2 SDK"; - license = lib.licensesSpdx."MPL-2.0"; + license = lib.meta.getLicenseFromSpdxId "MPL-2.0"; } ) { }; @@ -62075,7 +62075,7 @@ self: { unordered-containers ]; description = "Amazon AppConfig SDK"; - license = lib.licensesSpdx."MPL-2.0"; + license = lib.meta.getLicenseFromSpdxId "MPL-2.0"; } ) { }; @@ -62116,7 +62116,7 @@ self: { unordered-containers ]; description = "Amazon AppConfig Data SDK"; - license = lib.licensesSpdx."MPL-2.0"; + license = lib.meta.getLicenseFromSpdxId "MPL-2.0"; } ) { }; @@ -62157,7 +62157,7 @@ self: { unordered-containers ]; description = "Amazon Appflow SDK"; - license = lib.licensesSpdx."MPL-2.0"; + license = lib.meta.getLicenseFromSpdxId "MPL-2.0"; } ) { }; @@ -62198,7 +62198,7 @@ self: { unordered-containers ]; description = "Amazon AppIntegrations Service SDK"; - license = lib.licensesSpdx."MPL-2.0"; + license = lib.meta.getLicenseFromSpdxId "MPL-2.0"; } ) { }; @@ -62239,7 +62239,7 @@ self: { unordered-containers ]; description = "Amazon Application Auto Scaling SDK"; - license = lib.licensesSpdx."MPL-2.0"; + license = lib.meta.getLicenseFromSpdxId "MPL-2.0"; } ) { }; @@ -62280,7 +62280,7 @@ self: { unordered-containers ]; description = "Amazon CloudWatch Application Insights SDK"; - license = lib.licensesSpdx."MPL-2.0"; + license = lib.meta.getLicenseFromSpdxId "MPL-2.0"; } ) { }; @@ -62321,7 +62321,7 @@ self: { unordered-containers ]; description = "Amazon Application Cost Profiler SDK"; - license = lib.licensesSpdx."MPL-2.0"; + license = lib.meta.getLicenseFromSpdxId "MPL-2.0"; } ) { }; @@ -62362,7 +62362,7 @@ self: { unordered-containers ]; description = "Amazon App Mesh SDK"; - license = lib.licensesSpdx."MPL-2.0"; + license = lib.meta.getLicenseFromSpdxId "MPL-2.0"; } ) { }; @@ -62403,7 +62403,7 @@ self: { unordered-containers ]; description = "Amazon App Runner SDK"; - license = lib.licensesSpdx."MPL-2.0"; + license = lib.meta.getLicenseFromSpdxId "MPL-2.0"; } ) { }; @@ -62444,7 +62444,7 @@ self: { unordered-containers ]; description = "Amazon AppStream SDK"; - license = lib.licensesSpdx."MPL-2.0"; + license = lib.meta.getLicenseFromSpdxId "MPL-2.0"; } ) { }; @@ -62485,7 +62485,7 @@ self: { unordered-containers ]; description = "Amazon AppSync SDK"; - license = lib.licensesSpdx."MPL-2.0"; + license = lib.meta.getLicenseFromSpdxId "MPL-2.0"; } ) { }; @@ -62526,7 +62526,7 @@ self: { unordered-containers ]; description = "Amazon ARC - Zonal Shift SDK"; - license = lib.licensesSpdx."MPL-2.0"; + license = lib.meta.getLicenseFromSpdxId "MPL-2.0"; } ) { }; @@ -62567,7 +62567,7 @@ self: { unordered-containers ]; description = "Amazon Athena SDK"; - license = lib.licensesSpdx."MPL-2.0"; + license = lib.meta.getLicenseFromSpdxId "MPL-2.0"; } ) { }; @@ -62608,7 +62608,7 @@ self: { unordered-containers ]; description = "Amazon Audit Manager SDK"; - license = lib.licensesSpdx."MPL-2.0"; + license = lib.meta.getLicenseFromSpdxId "MPL-2.0"; } ) { }; @@ -62649,7 +62649,7 @@ self: { unordered-containers ]; description = "Amazon Auto Scaling SDK"; - license = lib.licensesSpdx."MPL-2.0"; + license = lib.meta.getLicenseFromSpdxId "MPL-2.0"; } ) { }; @@ -62690,7 +62690,7 @@ self: { unordered-containers ]; description = "Amazon Auto Scaling Plans SDK"; - license = lib.licensesSpdx."MPL-2.0"; + license = lib.meta.getLicenseFromSpdxId "MPL-2.0"; } ) { }; @@ -62731,7 +62731,7 @@ self: { unordered-containers ]; description = "Amazon Backup SDK"; - license = lib.licensesSpdx."MPL-2.0"; + license = lib.meta.getLicenseFromSpdxId "MPL-2.0"; } ) { }; @@ -62772,7 +62772,7 @@ self: { unordered-containers ]; description = "Amazon Backup Gateway SDK"; - license = lib.licensesSpdx."MPL-2.0"; + license = lib.meta.getLicenseFromSpdxId "MPL-2.0"; } ) { }; @@ -62813,7 +62813,7 @@ self: { unordered-containers ]; description = "Amazon Backup Storage SDK"; - license = lib.licensesSpdx."MPL-2.0"; + license = lib.meta.getLicenseFromSpdxId "MPL-2.0"; } ) { }; @@ -62854,7 +62854,7 @@ self: { unordered-containers ]; description = "Amazon Batch SDK"; - license = lib.licensesSpdx."MPL-2.0"; + license = lib.meta.getLicenseFromSpdxId "MPL-2.0"; } ) { }; @@ -62895,7 +62895,7 @@ self: { unordered-containers ]; description = "Amazon BillingConductor SDK"; - license = lib.licensesSpdx."MPL-2.0"; + license = lib.meta.getLicenseFromSpdxId "MPL-2.0"; } ) { }; @@ -62936,7 +62936,7 @@ self: { unordered-containers ]; description = "Amazon Braket SDK"; - license = lib.licensesSpdx."MPL-2.0"; + license = lib.meta.getLicenseFromSpdxId "MPL-2.0"; } ) { }; @@ -62977,7 +62977,7 @@ self: { unordered-containers ]; description = "Amazon Budgets SDK"; - license = lib.licensesSpdx."MPL-2.0"; + license = lib.meta.getLicenseFromSpdxId "MPL-2.0"; } ) { }; @@ -63018,7 +63018,7 @@ self: { unordered-containers ]; description = "Amazon Certificate Manager SDK"; - license = lib.licensesSpdx."MPL-2.0"; + license = lib.meta.getLicenseFromSpdxId "MPL-2.0"; } ) { }; @@ -63059,7 +63059,7 @@ self: { unordered-containers ]; description = "Amazon Certificate Manager Private Certificate Authority SDK"; - license = lib.licensesSpdx."MPL-2.0"; + license = lib.meta.getLicenseFromSpdxId "MPL-2.0"; } ) { }; @@ -63100,7 +63100,7 @@ self: { unordered-containers ]; description = "Amazon Chime SDK"; - license = lib.licensesSpdx."MPL-2.0"; + license = lib.meta.getLicenseFromSpdxId "MPL-2.0"; } ) { }; @@ -63141,7 +63141,7 @@ self: { unordered-containers ]; description = "Amazon Chime SDK Identity SDK"; - license = lib.licensesSpdx."MPL-2.0"; + license = lib.meta.getLicenseFromSpdxId "MPL-2.0"; } ) { }; @@ -63182,7 +63182,7 @@ self: { unordered-containers ]; description = "Amazon Chime SDK Media Pipelines SDK"; - license = lib.licensesSpdx."MPL-2.0"; + license = lib.meta.getLicenseFromSpdxId "MPL-2.0"; } ) { }; @@ -63223,7 +63223,7 @@ self: { unordered-containers ]; description = "Amazon Chime SDK Meetings SDK"; - license = lib.licensesSpdx."MPL-2.0"; + license = lib.meta.getLicenseFromSpdxId "MPL-2.0"; } ) { }; @@ -63264,7 +63264,7 @@ self: { unordered-containers ]; description = "Amazon Chime SDK Messaging SDK"; - license = lib.licensesSpdx."MPL-2.0"; + license = lib.meta.getLicenseFromSpdxId "MPL-2.0"; } ) { }; @@ -63305,7 +63305,7 @@ self: { unordered-containers ]; description = "Amazon Chime SDK Voice SDK"; - license = lib.licensesSpdx."MPL-2.0"; + license = lib.meta.getLicenseFromSpdxId "MPL-2.0"; } ) { }; @@ -63346,7 +63346,7 @@ self: { unordered-containers ]; description = "Amazon Cloud9 SDK"; - license = lib.licensesSpdx."MPL-2.0"; + license = lib.meta.getLicenseFromSpdxId "MPL-2.0"; } ) { }; @@ -63387,7 +63387,7 @@ self: { unordered-containers ]; description = "Amazon Cloud Control API SDK"; - license = lib.licensesSpdx."MPL-2.0"; + license = lib.meta.getLicenseFromSpdxId "MPL-2.0"; } ) { }; @@ -63428,7 +63428,7 @@ self: { unordered-containers ]; description = "Amazon CloudDirectory SDK"; - license = lib.licensesSpdx."MPL-2.0"; + license = lib.meta.getLicenseFromSpdxId "MPL-2.0"; } ) { }; @@ -63469,7 +63469,7 @@ self: { unordered-containers ]; description = "Amazon CloudFormation SDK"; - license = lib.licensesSpdx."MPL-2.0"; + license = lib.meta.getLicenseFromSpdxId "MPL-2.0"; } ) { }; @@ -63510,7 +63510,7 @@ self: { unordered-containers ]; description = "Amazon CloudFront SDK"; - license = lib.licensesSpdx."MPL-2.0"; + license = lib.meta.getLicenseFromSpdxId "MPL-2.0"; } ) { }; @@ -63551,7 +63551,7 @@ self: { unordered-containers ]; description = "Amazon CloudHSM SDK"; - license = lib.licensesSpdx."MPL-2.0"; + license = lib.meta.getLicenseFromSpdxId "MPL-2.0"; } ) { }; @@ -63592,7 +63592,7 @@ self: { unordered-containers ]; description = "Amazon CloudHSM V2 SDK"; - license = lib.licensesSpdx."MPL-2.0"; + license = lib.meta.getLicenseFromSpdxId "MPL-2.0"; } ) { }; @@ -63633,7 +63633,7 @@ self: { unordered-containers ]; description = "Amazon CloudSearch SDK"; - license = lib.licensesSpdx."MPL-2.0"; + license = lib.meta.getLicenseFromSpdxId "MPL-2.0"; } ) { }; @@ -63674,7 +63674,7 @@ self: { unordered-containers ]; description = "Amazon CloudSearch Domain SDK"; - license = lib.licensesSpdx."MPL-2.0"; + license = lib.meta.getLicenseFromSpdxId "MPL-2.0"; } ) { }; @@ -63715,7 +63715,7 @@ self: { unordered-containers ]; description = "Amazon CloudTrail SDK"; - license = lib.licensesSpdx."MPL-2.0"; + license = lib.meta.getLicenseFromSpdxId "MPL-2.0"; } ) { }; @@ -63756,7 +63756,7 @@ self: { unordered-containers ]; description = "Amazon CloudWatch SDK"; - license = lib.licensesSpdx."MPL-2.0"; + license = lib.meta.getLicenseFromSpdxId "MPL-2.0"; } ) { }; @@ -63797,7 +63797,7 @@ self: { unordered-containers ]; description = "Amazon EventBridge SDK"; - license = lib.licensesSpdx."MPL-2.0"; + license = lib.meta.getLicenseFromSpdxId "MPL-2.0"; } ) { }; @@ -63838,7 +63838,7 @@ self: { unordered-containers ]; description = "Amazon CloudWatch Logs SDK"; - license = lib.licensesSpdx."MPL-2.0"; + license = lib.meta.getLicenseFromSpdxId "MPL-2.0"; } ) { }; @@ -63879,7 +63879,7 @@ self: { unordered-containers ]; description = "Amazon CodeArtifact SDK"; - license = lib.licensesSpdx."MPL-2.0"; + license = lib.meta.getLicenseFromSpdxId "MPL-2.0"; } ) { }; @@ -63920,7 +63920,7 @@ self: { unordered-containers ]; description = "Amazon CodeBuild SDK"; - license = lib.licensesSpdx."MPL-2.0"; + license = lib.meta.getLicenseFromSpdxId "MPL-2.0"; } ) { }; @@ -63961,7 +63961,7 @@ self: { unordered-containers ]; description = "Amazon CodeCommit SDK"; - license = lib.licensesSpdx."MPL-2.0"; + license = lib.meta.getLicenseFromSpdxId "MPL-2.0"; } ) { }; @@ -64002,7 +64002,7 @@ self: { unordered-containers ]; description = "Amazon CodeDeploy SDK"; - license = lib.licensesSpdx."MPL-2.0"; + license = lib.meta.getLicenseFromSpdxId "MPL-2.0"; } ) { }; @@ -64043,7 +64043,7 @@ self: { unordered-containers ]; description = "Amazon CodeGuru Reviewer SDK"; - license = lib.licensesSpdx."MPL-2.0"; + license = lib.meta.getLicenseFromSpdxId "MPL-2.0"; } ) { }; @@ -64084,7 +64084,7 @@ self: { unordered-containers ]; description = "Amazon CodeGuru Profiler SDK"; - license = lib.licensesSpdx."MPL-2.0"; + license = lib.meta.getLicenseFromSpdxId "MPL-2.0"; } ) { }; @@ -64125,7 +64125,7 @@ self: { unordered-containers ]; description = "Amazon CodePipeline SDK"; - license = lib.licensesSpdx."MPL-2.0"; + license = lib.meta.getLicenseFromSpdxId "MPL-2.0"; } ) { }; @@ -64166,7 +64166,7 @@ self: { unordered-containers ]; description = "Amazon CodeStar SDK"; - license = lib.licensesSpdx."MPL-2.0"; + license = lib.meta.getLicenseFromSpdxId "MPL-2.0"; } ) { }; @@ -64207,7 +64207,7 @@ self: { unordered-containers ]; description = "Amazon CodeStar connections SDK"; - license = lib.licensesSpdx."MPL-2.0"; + license = lib.meta.getLicenseFromSpdxId "MPL-2.0"; } ) { }; @@ -64248,7 +64248,7 @@ self: { unordered-containers ]; description = "Amazon CodeStar Notifications SDK"; - license = lib.licensesSpdx."MPL-2.0"; + license = lib.meta.getLicenseFromSpdxId "MPL-2.0"; } ) { }; @@ -64289,7 +64289,7 @@ self: { unordered-containers ]; description = "Amazon Cognito Identity SDK"; - license = lib.licensesSpdx."MPL-2.0"; + license = lib.meta.getLicenseFromSpdxId "MPL-2.0"; } ) { }; @@ -64330,7 +64330,7 @@ self: { unordered-containers ]; description = "Amazon Cognito Identity Provider SDK"; - license = lib.licensesSpdx."MPL-2.0"; + license = lib.meta.getLicenseFromSpdxId "MPL-2.0"; } ) { }; @@ -64371,7 +64371,7 @@ self: { unordered-containers ]; description = "Amazon Cognito Sync SDK"; - license = lib.licensesSpdx."MPL-2.0"; + license = lib.meta.getLicenseFromSpdxId "MPL-2.0"; } ) { }; @@ -64412,7 +64412,7 @@ self: { unordered-containers ]; description = "Amazon Comprehend SDK"; - license = lib.licensesSpdx."MPL-2.0"; + license = lib.meta.getLicenseFromSpdxId "MPL-2.0"; } ) { }; @@ -64453,7 +64453,7 @@ self: { unordered-containers ]; description = "Amazon Comprehend Medical SDK"; - license = lib.licensesSpdx."MPL-2.0"; + license = lib.meta.getLicenseFromSpdxId "MPL-2.0"; } ) { }; @@ -64494,7 +64494,7 @@ self: { unordered-containers ]; description = "Amazon Compute Optimizer SDK"; - license = lib.licensesSpdx."MPL-2.0"; + license = lib.meta.getLicenseFromSpdxId "MPL-2.0"; } ) { }; @@ -64535,7 +64535,7 @@ self: { unordered-containers ]; description = "Amazon Config SDK"; - license = lib.licensesSpdx."MPL-2.0"; + license = lib.meta.getLicenseFromSpdxId "MPL-2.0"; } ) { }; @@ -64576,7 +64576,7 @@ self: { unordered-containers ]; description = "Amazon Connect Service SDK"; - license = lib.licensesSpdx."MPL-2.0"; + license = lib.meta.getLicenseFromSpdxId "MPL-2.0"; } ) { }; @@ -64617,7 +64617,7 @@ self: { unordered-containers ]; description = "Amazon Connect Contact Lens SDK"; - license = lib.licensesSpdx."MPL-2.0"; + license = lib.meta.getLicenseFromSpdxId "MPL-2.0"; } ) { }; @@ -64658,7 +64658,7 @@ self: { unordered-containers ]; description = "Amazon ConnectCampaignService SDK"; - license = lib.licensesSpdx."MPL-2.0"; + license = lib.meta.getLicenseFromSpdxId "MPL-2.0"; } ) { }; @@ -64699,7 +64699,7 @@ self: { unordered-containers ]; description = "Amazon Connect Cases SDK"; - license = lib.licensesSpdx."MPL-2.0"; + license = lib.meta.getLicenseFromSpdxId "MPL-2.0"; } ) { }; @@ -64740,7 +64740,7 @@ self: { unordered-containers ]; description = "Amazon Connect Participant Service SDK"; - license = lib.licensesSpdx."MPL-2.0"; + license = lib.meta.getLicenseFromSpdxId "MPL-2.0"; } ) { }; @@ -64782,7 +64782,7 @@ self: { text ]; description = "A Haskell equivalent of \"aws rds generate-db-auth-token\""; - license = lib.licensesSpdx."MPL-2.0"; + license = lib.meta.getLicenseFromSpdxId "MPL-2.0"; hydraPlatforms = lib.platforms.none; mainProgram = "generate-db-auth-token"; broken = true; @@ -64826,7 +64826,7 @@ self: { unordered-containers ]; description = "Amazon Control Tower SDK"; - license = lib.licensesSpdx."MPL-2.0"; + license = lib.meta.getLicenseFromSpdxId "MPL-2.0"; } ) { }; @@ -64918,7 +64918,7 @@ self: { time ]; description = "Core data types and functionality for Amazonka libraries"; - license = lib.licensesSpdx."MPL-2.0"; + license = lib.meta.getLicenseFromSpdxId "MPL-2.0"; } ) { }; @@ -64959,7 +64959,7 @@ self: { unordered-containers ]; description = "Amazon Cost Explorer Service SDK"; - license = lib.licensesSpdx."MPL-2.0"; + license = lib.meta.getLicenseFromSpdxId "MPL-2.0"; } ) { }; @@ -65000,7 +65000,7 @@ self: { unordered-containers ]; description = "Amazon Cost and Usage Report Service SDK"; - license = lib.licensesSpdx."MPL-2.0"; + license = lib.meta.getLicenseFromSpdxId "MPL-2.0"; } ) { }; @@ -65041,7 +65041,7 @@ self: { unordered-containers ]; description = "Amazon Connect Customer Profiles SDK"; - license = lib.licensesSpdx."MPL-2.0"; + license = lib.meta.getLicenseFromSpdxId "MPL-2.0"; } ) { }; @@ -65082,7 +65082,7 @@ self: { unordered-containers ]; description = "Amazon Glue DataBrew SDK"; - license = lib.licensesSpdx."MPL-2.0"; + license = lib.meta.getLicenseFromSpdxId "MPL-2.0"; } ) { }; @@ -65123,7 +65123,7 @@ self: { unordered-containers ]; description = "Amazon Data Exchange SDK"; - license = lib.licensesSpdx."MPL-2.0"; + license = lib.meta.getLicenseFromSpdxId "MPL-2.0"; } ) { }; @@ -65164,7 +65164,7 @@ self: { unordered-containers ]; description = "Amazon Data Pipeline SDK"; - license = lib.licensesSpdx."MPL-2.0"; + license = lib.meta.getLicenseFromSpdxId "MPL-2.0"; } ) { }; @@ -65205,7 +65205,7 @@ self: { unordered-containers ]; description = "Amazon DataSync SDK"; - license = lib.licensesSpdx."MPL-2.0"; + license = lib.meta.getLicenseFromSpdxId "MPL-2.0"; } ) { }; @@ -65246,7 +65246,7 @@ self: { unordered-containers ]; description = "Amazon Detective SDK"; - license = lib.licensesSpdx."MPL-2.0"; + license = lib.meta.getLicenseFromSpdxId "MPL-2.0"; } ) { }; @@ -65287,7 +65287,7 @@ self: { unordered-containers ]; description = "Amazon Device Farm SDK"; - license = lib.licensesSpdx."MPL-2.0"; + license = lib.meta.getLicenseFromSpdxId "MPL-2.0"; } ) { }; @@ -65328,7 +65328,7 @@ self: { unordered-containers ]; description = "Amazon DevOps Guru SDK"; - license = lib.licensesSpdx."MPL-2.0"; + license = lib.meta.getLicenseFromSpdxId "MPL-2.0"; } ) { }; @@ -65369,7 +65369,7 @@ self: { unordered-containers ]; description = "Amazon Direct Connect SDK"; - license = lib.licensesSpdx."MPL-2.0"; + license = lib.meta.getLicenseFromSpdxId "MPL-2.0"; } ) { }; @@ -65410,7 +65410,7 @@ self: { unordered-containers ]; description = "Amazon Application Discovery Service SDK"; - license = lib.licensesSpdx."MPL-2.0"; + license = lib.meta.getLicenseFromSpdxId "MPL-2.0"; } ) { }; @@ -65451,7 +65451,7 @@ self: { unordered-containers ]; description = "Amazon Data Lifecycle Manager SDK"; - license = lib.licensesSpdx."MPL-2.0"; + license = lib.meta.getLicenseFromSpdxId "MPL-2.0"; } ) { }; @@ -65492,7 +65492,7 @@ self: { unordered-containers ]; description = "Amazon Database Migration Service SDK"; - license = lib.licensesSpdx."MPL-2.0"; + license = lib.meta.getLicenseFromSpdxId "MPL-2.0"; } ) { }; @@ -65533,7 +65533,7 @@ self: { unordered-containers ]; description = "Amazon DocumentDB with MongoDB compatibility SDK"; - license = lib.licensesSpdx."MPL-2.0"; + license = lib.meta.getLicenseFromSpdxId "MPL-2.0"; } ) { }; @@ -65574,7 +65574,7 @@ self: { unordered-containers ]; description = "Amazon DocumentDB Elastic Clusters SDK"; - license = lib.licensesSpdx."MPL-2.0"; + license = lib.meta.getLicenseFromSpdxId "MPL-2.0"; } ) { }; @@ -65615,7 +65615,7 @@ self: { unordered-containers ]; description = "Amazon Elastic Disaster Recovery Service SDK"; - license = lib.licensesSpdx."MPL-2.0"; + license = lib.meta.getLicenseFromSpdxId "MPL-2.0"; } ) { }; @@ -65656,7 +65656,7 @@ self: { unordered-containers ]; description = "Amazon Directory Service SDK"; - license = lib.licensesSpdx."MPL-2.0"; + license = lib.meta.getLicenseFromSpdxId "MPL-2.0"; } ) { }; @@ -65706,7 +65706,7 @@ self: { unordered-containers ]; description = "Amazon DynamoDB SDK"; - license = lib.licensesSpdx."MPL-2.0"; + license = lib.meta.getLicenseFromSpdxId "MPL-2.0"; hydraPlatforms = lib.platforms.none; broken = true; } @@ -65749,7 +65749,7 @@ self: { unordered-containers ]; description = "Amazon DynamoDB Accelerator (DAX) SDK"; - license = lib.licensesSpdx."MPL-2.0"; + license = lib.meta.getLicenseFromSpdxId "MPL-2.0"; } ) { }; @@ -65799,7 +65799,7 @@ self: { unordered-containers ]; description = "Amazon DynamoDB Streams SDK"; - license = lib.licensesSpdx."MPL-2.0"; + license = lib.meta.getLicenseFromSpdxId "MPL-2.0"; hydraPlatforms = lib.platforms.none; broken = true; } @@ -65842,7 +65842,7 @@ self: { unordered-containers ]; description = "Amazon Elastic Block Store SDK"; - license = lib.licensesSpdx."MPL-2.0"; + license = lib.meta.getLicenseFromSpdxId "MPL-2.0"; } ) { }; @@ -65883,7 +65883,7 @@ self: { unordered-containers ]; description = "Amazon Elastic Compute Cloud SDK"; - license = lib.licensesSpdx."MPL-2.0"; + license = lib.meta.getLicenseFromSpdxId "MPL-2.0"; } ) { }; @@ -65924,7 +65924,7 @@ self: { unordered-containers ]; description = "Amazon EC2 Instance Connect SDK"; - license = lib.licensesSpdx."MPL-2.0"; + license = lib.meta.getLicenseFromSpdxId "MPL-2.0"; } ) { }; @@ -65965,7 +65965,7 @@ self: { unordered-containers ]; description = "Amazon EC2 Container Registry SDK"; - license = lib.licensesSpdx."MPL-2.0"; + license = lib.meta.getLicenseFromSpdxId "MPL-2.0"; } ) { }; @@ -66006,7 +66006,7 @@ self: { unordered-containers ]; description = "Amazon Elastic Container Registry Public SDK"; - license = lib.licensesSpdx."MPL-2.0"; + license = lib.meta.getLicenseFromSpdxId "MPL-2.0"; } ) { }; @@ -66047,7 +66047,7 @@ self: { unordered-containers ]; description = "Amazon EC2 Container Service SDK"; - license = lib.licensesSpdx."MPL-2.0"; + license = lib.meta.getLicenseFromSpdxId "MPL-2.0"; } ) { }; @@ -66088,7 +66088,7 @@ self: { unordered-containers ]; description = "Amazon Elastic File System SDK"; - license = lib.licensesSpdx."MPL-2.0"; + license = lib.meta.getLicenseFromSpdxId "MPL-2.0"; } ) { }; @@ -66129,7 +66129,7 @@ self: { unordered-containers ]; description = "Amazon Elastic Kubernetes Service SDK"; - license = lib.licensesSpdx."MPL-2.0"; + license = lib.meta.getLicenseFromSpdxId "MPL-2.0"; } ) { }; @@ -66170,7 +66170,7 @@ self: { unordered-containers ]; description = "Amazon Elastic Inference SDK"; - license = lib.licensesSpdx."MPL-2.0"; + license = lib.meta.getLicenseFromSpdxId "MPL-2.0"; } ) { }; @@ -66211,7 +66211,7 @@ self: { unordered-containers ]; description = "Amazon ElastiCache SDK"; - license = lib.licensesSpdx."MPL-2.0"; + license = lib.meta.getLicenseFromSpdxId "MPL-2.0"; } ) { }; @@ -66252,7 +66252,7 @@ self: { unordered-containers ]; description = "Amazon Elastic Beanstalk SDK"; - license = lib.licensesSpdx."MPL-2.0"; + license = lib.meta.getLicenseFromSpdxId "MPL-2.0"; } ) { }; @@ -66293,7 +66293,7 @@ self: { unordered-containers ]; description = "Amazon Elasticsearch Service SDK"; - license = lib.licensesSpdx."MPL-2.0"; + license = lib.meta.getLicenseFromSpdxId "MPL-2.0"; } ) { }; @@ -66334,7 +66334,7 @@ self: { unordered-containers ]; description = "Amazon Elastic Transcoder SDK"; - license = lib.licensesSpdx."MPL-2.0"; + license = lib.meta.getLicenseFromSpdxId "MPL-2.0"; } ) { }; @@ -66375,7 +66375,7 @@ self: { unordered-containers ]; description = "Amazon Elastic Load Balancing SDK"; - license = lib.licensesSpdx."MPL-2.0"; + license = lib.meta.getLicenseFromSpdxId "MPL-2.0"; } ) { }; @@ -66416,7 +66416,7 @@ self: { unordered-containers ]; description = "Amazon Elastic Load Balancing SDK"; - license = lib.licensesSpdx."MPL-2.0"; + license = lib.meta.getLicenseFromSpdxId "MPL-2.0"; } ) { }; @@ -66457,7 +66457,7 @@ self: { unordered-containers ]; description = "Amazon EMR SDK"; - license = lib.licensesSpdx."MPL-2.0"; + license = lib.meta.getLicenseFromSpdxId "MPL-2.0"; } ) { }; @@ -66498,7 +66498,7 @@ self: { unordered-containers ]; description = "Amazon EMR Containers SDK"; - license = lib.licensesSpdx."MPL-2.0"; + license = lib.meta.getLicenseFromSpdxId "MPL-2.0"; } ) { }; @@ -66539,7 +66539,7 @@ self: { unordered-containers ]; description = "Amazon EMR Serverless SDK"; - license = lib.licensesSpdx."MPL-2.0"; + license = lib.meta.getLicenseFromSpdxId "MPL-2.0"; } ) { }; @@ -66580,7 +66580,7 @@ self: { unordered-containers ]; description = "Amazon CloudWatch Evidently SDK"; - license = lib.licensesSpdx."MPL-2.0"; + license = lib.meta.getLicenseFromSpdxId "MPL-2.0"; } ) { }; @@ -66621,7 +66621,7 @@ self: { unordered-containers ]; description = "Amazon FinSpace User Environment Management service SDK"; - license = lib.licensesSpdx."MPL-2.0"; + license = lib.meta.getLicenseFromSpdxId "MPL-2.0"; } ) { }; @@ -66662,7 +66662,7 @@ self: { unordered-containers ]; description = "Amazon FinSpace Public API SDK"; - license = lib.licensesSpdx."MPL-2.0"; + license = lib.meta.getLicenseFromSpdxId "MPL-2.0"; } ) { }; @@ -66703,7 +66703,7 @@ self: { unordered-containers ]; description = "Amazon Fault Injection Simulator SDK"; - license = lib.licensesSpdx."MPL-2.0"; + license = lib.meta.getLicenseFromSpdxId "MPL-2.0"; } ) { }; @@ -66744,7 +66744,7 @@ self: { unordered-containers ]; description = "Amazon Firewall Management Service SDK"; - license = lib.licensesSpdx."MPL-2.0"; + license = lib.meta.getLicenseFromSpdxId "MPL-2.0"; } ) { }; @@ -66785,7 +66785,7 @@ self: { unordered-containers ]; description = "Amazon Forecast Service SDK"; - license = lib.licensesSpdx."MPL-2.0"; + license = lib.meta.getLicenseFromSpdxId "MPL-2.0"; } ) { }; @@ -66826,7 +66826,7 @@ self: { unordered-containers ]; description = "Amazon Forecast Query Service SDK"; - license = lib.licensesSpdx."MPL-2.0"; + license = lib.meta.getLicenseFromSpdxId "MPL-2.0"; } ) { }; @@ -66867,7 +66867,7 @@ self: { unordered-containers ]; description = "Amazon Fraud Detector SDK"; - license = lib.licensesSpdx."MPL-2.0"; + license = lib.meta.getLicenseFromSpdxId "MPL-2.0"; } ) { }; @@ -66908,7 +66908,7 @@ self: { unordered-containers ]; description = "Amazon FSx SDK"; - license = lib.licensesSpdx."MPL-2.0"; + license = lib.meta.getLicenseFromSpdxId "MPL-2.0"; } ) { }; @@ -66949,7 +66949,7 @@ self: { unordered-containers ]; description = "Amazon GameLift SDK"; - license = lib.licensesSpdx."MPL-2.0"; + license = lib.meta.getLicenseFromSpdxId "MPL-2.0"; } ) { }; @@ -66990,7 +66990,7 @@ self: { unordered-containers ]; description = "Amazon GameSparks SDK"; - license = lib.licensesSpdx."MPL-2.0"; + license = lib.meta.getLicenseFromSpdxId "MPL-2.0"; } ) { }; @@ -67031,7 +67031,7 @@ self: { unordered-containers ]; description = "Amazon Glacier SDK"; - license = lib.licensesSpdx."MPL-2.0"; + license = lib.meta.getLicenseFromSpdxId "MPL-2.0"; } ) { }; @@ -67072,7 +67072,7 @@ self: { unordered-containers ]; description = "Amazon Global Accelerator SDK"; - license = lib.licensesSpdx."MPL-2.0"; + license = lib.meta.getLicenseFromSpdxId "MPL-2.0"; } ) { }; @@ -67113,7 +67113,7 @@ self: { unordered-containers ]; description = "Amazon Glue SDK"; - license = lib.licensesSpdx."MPL-2.0"; + license = lib.meta.getLicenseFromSpdxId "MPL-2.0"; } ) { }; @@ -67154,7 +67154,7 @@ self: { unordered-containers ]; description = "Amazon Managed Grafana SDK"; - license = lib.licensesSpdx."MPL-2.0"; + license = lib.meta.getLicenseFromSpdxId "MPL-2.0"; } ) { }; @@ -67195,7 +67195,7 @@ self: { unordered-containers ]; description = "Amazon Greengrass SDK"; - license = lib.licensesSpdx."MPL-2.0"; + license = lib.meta.getLicenseFromSpdxId "MPL-2.0"; } ) { }; @@ -67236,7 +67236,7 @@ self: { unordered-containers ]; description = "Amazon IoT Greengrass V2 SDK"; - license = lib.licensesSpdx."MPL-2.0"; + license = lib.meta.getLicenseFromSpdxId "MPL-2.0"; } ) { }; @@ -67277,7 +67277,7 @@ self: { unordered-containers ]; description = "Amazon Ground Station SDK"; - license = lib.licensesSpdx."MPL-2.0"; + license = lib.meta.getLicenseFromSpdxId "MPL-2.0"; } ) { }; @@ -67318,7 +67318,7 @@ self: { unordered-containers ]; description = "Amazon GuardDuty SDK"; - license = lib.licensesSpdx."MPL-2.0"; + license = lib.meta.getLicenseFromSpdxId "MPL-2.0"; } ) { }; @@ -67359,7 +67359,7 @@ self: { unordered-containers ]; description = "Amazon Health APIs and Notifications SDK"; - license = lib.licensesSpdx."MPL-2.0"; + license = lib.meta.getLicenseFromSpdxId "MPL-2.0"; } ) { }; @@ -67400,7 +67400,7 @@ self: { unordered-containers ]; description = "Amazon HealthLake SDK"; - license = lib.licensesSpdx."MPL-2.0"; + license = lib.meta.getLicenseFromSpdxId "MPL-2.0"; } ) { }; @@ -67441,7 +67441,7 @@ self: { unordered-containers ]; description = "Amazon Honeycode SDK"; - license = lib.licensesSpdx."MPL-2.0"; + license = lib.meta.getLicenseFromSpdxId "MPL-2.0"; } ) { }; @@ -67482,7 +67482,7 @@ self: { unordered-containers ]; description = "Amazon Identity and Access Management SDK"; - license = lib.licensesSpdx."MPL-2.0"; + license = lib.meta.getLicenseFromSpdxId "MPL-2.0"; } ) { }; @@ -67570,7 +67570,7 @@ self: { unordered-containers ]; description = "Amazon SSO Identity Store SDK"; - license = lib.licensesSpdx."MPL-2.0"; + license = lib.meta.getLicenseFromSpdxId "MPL-2.0"; } ) { }; @@ -67611,7 +67611,7 @@ self: { unordered-containers ]; description = "Amazon EC2 Image Builder SDK"; - license = lib.licensesSpdx."MPL-2.0"; + license = lib.meta.getLicenseFromSpdxId "MPL-2.0"; } ) { }; @@ -67652,7 +67652,7 @@ self: { unordered-containers ]; description = "Amazon Import/Export SDK"; - license = lib.licensesSpdx."MPL-2.0"; + license = lib.meta.getLicenseFromSpdxId "MPL-2.0"; } ) { }; @@ -67693,7 +67693,7 @@ self: { unordered-containers ]; description = "Amazon Inspector SDK"; - license = lib.licensesSpdx."MPL-2.0"; + license = lib.meta.getLicenseFromSpdxId "MPL-2.0"; } ) { }; @@ -67734,7 +67734,7 @@ self: { unordered-containers ]; description = "Amazon Inspector2 SDK"; - license = lib.licensesSpdx."MPL-2.0"; + license = lib.meta.getLicenseFromSpdxId "MPL-2.0"; } ) { }; @@ -67775,7 +67775,7 @@ self: { unordered-containers ]; description = "Amazon IoT SDK"; - license = lib.licensesSpdx."MPL-2.0"; + license = lib.meta.getLicenseFromSpdxId "MPL-2.0"; } ) { }; @@ -67816,7 +67816,7 @@ self: { unordered-containers ]; description = "Amazon IoT Analytics SDK"; - license = lib.licensesSpdx."MPL-2.0"; + license = lib.meta.getLicenseFromSpdxId "MPL-2.0"; } ) { }; @@ -67857,7 +67857,7 @@ self: { unordered-containers ]; description = "Amazon IoT Data Plane SDK"; - license = lib.licensesSpdx."MPL-2.0"; + license = lib.meta.getLicenseFromSpdxId "MPL-2.0"; } ) { }; @@ -67898,7 +67898,7 @@ self: { unordered-containers ]; description = "Amazon IoT Jobs Data Plane SDK"; - license = lib.licensesSpdx."MPL-2.0"; + license = lib.meta.getLicenseFromSpdxId "MPL-2.0"; } ) { }; @@ -67939,7 +67939,7 @@ self: { unordered-containers ]; description = "Amazon IoT RoboRunner SDK"; - license = lib.licensesSpdx."MPL-2.0"; + license = lib.meta.getLicenseFromSpdxId "MPL-2.0"; } ) { }; @@ -67980,7 +67980,7 @@ self: { unordered-containers ]; description = "Amazon IoT 1-Click Devices Service SDK"; - license = lib.licensesSpdx."MPL-2.0"; + license = lib.meta.getLicenseFromSpdxId "MPL-2.0"; } ) { }; @@ -68021,7 +68021,7 @@ self: { unordered-containers ]; description = "Amazon IoT 1-Click Projects Service SDK"; - license = lib.licensesSpdx."MPL-2.0"; + license = lib.meta.getLicenseFromSpdxId "MPL-2.0"; } ) { }; @@ -68062,7 +68062,7 @@ self: { unordered-containers ]; description = "Amazon IoT Core Device Advisor SDK"; - license = lib.licensesSpdx."MPL-2.0"; + license = lib.meta.getLicenseFromSpdxId "MPL-2.0"; } ) { }; @@ -68103,7 +68103,7 @@ self: { unordered-containers ]; description = "Amazon IoT Events SDK"; - license = lib.licensesSpdx."MPL-2.0"; + license = lib.meta.getLicenseFromSpdxId "MPL-2.0"; } ) { }; @@ -68144,7 +68144,7 @@ self: { unordered-containers ]; description = "Amazon IoT Events Data SDK"; - license = lib.licensesSpdx."MPL-2.0"; + license = lib.meta.getLicenseFromSpdxId "MPL-2.0"; } ) { }; @@ -68185,7 +68185,7 @@ self: { unordered-containers ]; description = "Amazon IoT Fleet Hub SDK"; - license = lib.licensesSpdx."MPL-2.0"; + license = lib.meta.getLicenseFromSpdxId "MPL-2.0"; } ) { }; @@ -68226,7 +68226,7 @@ self: { unordered-containers ]; description = "Amazon IoT FleetWise SDK"; - license = lib.licensesSpdx."MPL-2.0"; + license = lib.meta.getLicenseFromSpdxId "MPL-2.0"; } ) { }; @@ -68267,7 +68267,7 @@ self: { unordered-containers ]; description = "Amazon IoT Secure Tunneling SDK"; - license = lib.licensesSpdx."MPL-2.0"; + license = lib.meta.getLicenseFromSpdxId "MPL-2.0"; } ) { }; @@ -68308,7 +68308,7 @@ self: { unordered-containers ]; description = "Amazon IoT SiteWise SDK"; - license = lib.licensesSpdx."MPL-2.0"; + license = lib.meta.getLicenseFromSpdxId "MPL-2.0"; } ) { }; @@ -68349,7 +68349,7 @@ self: { unordered-containers ]; description = "Amazon IoT Things Graph SDK"; - license = lib.licensesSpdx."MPL-2.0"; + license = lib.meta.getLicenseFromSpdxId "MPL-2.0"; } ) { }; @@ -68390,7 +68390,7 @@ self: { unordered-containers ]; description = "Amazon IoT TwinMaker SDK"; - license = lib.licensesSpdx."MPL-2.0"; + license = lib.meta.getLicenseFromSpdxId "MPL-2.0"; } ) { }; @@ -68431,7 +68431,7 @@ self: { unordered-containers ]; description = "Amazon IoT Wireless SDK"; - license = lib.licensesSpdx."MPL-2.0"; + license = lib.meta.getLicenseFromSpdxId "MPL-2.0"; } ) { }; @@ -68472,7 +68472,7 @@ self: { unordered-containers ]; description = "Amazon Interactive Video Service SDK"; - license = lib.licensesSpdx."MPL-2.0"; + license = lib.meta.getLicenseFromSpdxId "MPL-2.0"; } ) { }; @@ -68513,7 +68513,7 @@ self: { unordered-containers ]; description = "Amazon Interactive Video Service Chat SDK"; - license = lib.licensesSpdx."MPL-2.0"; + license = lib.meta.getLicenseFromSpdxId "MPL-2.0"; } ) { }; @@ -68554,7 +68554,7 @@ self: { unordered-containers ]; description = "Amazon Managed Streaming for Kafka SDK"; - license = lib.licensesSpdx."MPL-2.0"; + license = lib.meta.getLicenseFromSpdxId "MPL-2.0"; } ) { }; @@ -68595,7 +68595,7 @@ self: { unordered-containers ]; description = "Amazon Managed Streaming for Kafka Connect SDK"; - license = lib.licensesSpdx."MPL-2.0"; + license = lib.meta.getLicenseFromSpdxId "MPL-2.0"; } ) { }; @@ -68636,7 +68636,7 @@ self: { unordered-containers ]; description = "Amazon KendraFrontendService SDK"; - license = lib.licensesSpdx."MPL-2.0"; + license = lib.meta.getLicenseFromSpdxId "MPL-2.0"; } ) { }; @@ -68677,7 +68677,7 @@ self: { unordered-containers ]; description = "Amazon Keyspaces SDK"; - license = lib.licensesSpdx."MPL-2.0"; + license = lib.meta.getLicenseFromSpdxId "MPL-2.0"; } ) { }; @@ -68718,7 +68718,7 @@ self: { unordered-containers ]; description = "Amazon Kinesis SDK"; - license = lib.licensesSpdx."MPL-2.0"; + license = lib.meta.getLicenseFromSpdxId "MPL-2.0"; } ) { }; @@ -68759,7 +68759,7 @@ self: { unordered-containers ]; description = "Amazon Kinesis Analytics SDK"; - license = lib.licensesSpdx."MPL-2.0"; + license = lib.meta.getLicenseFromSpdxId "MPL-2.0"; } ) { }; @@ -68800,7 +68800,7 @@ self: { unordered-containers ]; description = "Amazon Kinesis Firehose SDK"; - license = lib.licensesSpdx."MPL-2.0"; + license = lib.meta.getLicenseFromSpdxId "MPL-2.0"; } ) { }; @@ -68841,7 +68841,7 @@ self: { unordered-containers ]; description = "Amazon Kinesis Video Streams SDK"; - license = lib.licensesSpdx."MPL-2.0"; + license = lib.meta.getLicenseFromSpdxId "MPL-2.0"; } ) { }; @@ -68882,7 +68882,7 @@ self: { unordered-containers ]; description = "Amazon Kinesis Video Streams Archived Media SDK"; - license = lib.licensesSpdx."MPL-2.0"; + license = lib.meta.getLicenseFromSpdxId "MPL-2.0"; } ) { }; @@ -68923,7 +68923,7 @@ self: { unordered-containers ]; description = "Amazon Kinesis Video Streams Media SDK"; - license = lib.licensesSpdx."MPL-2.0"; + license = lib.meta.getLicenseFromSpdxId "MPL-2.0"; } ) { }; @@ -68964,7 +68964,7 @@ self: { unordered-containers ]; description = "Amazon Kinesis Video Signaling Channels SDK"; - license = lib.licensesSpdx."MPL-2.0"; + license = lib.meta.getLicenseFromSpdxId "MPL-2.0"; } ) { }; @@ -69005,7 +69005,7 @@ self: { unordered-containers ]; description = "Amazon Kinesis Video WebRTC Storage SDK"; - license = lib.licensesSpdx."MPL-2.0"; + license = lib.meta.getLicenseFromSpdxId "MPL-2.0"; } ) { }; @@ -69046,7 +69046,7 @@ self: { unordered-containers ]; description = "Amazon Kinesis Analytics SDK"; - license = lib.licensesSpdx."MPL-2.0"; + license = lib.meta.getLicenseFromSpdxId "MPL-2.0"; } ) { }; @@ -69087,7 +69087,7 @@ self: { unordered-containers ]; description = "Amazon Key Management Service SDK"; - license = lib.licensesSpdx."MPL-2.0"; + license = lib.meta.getLicenseFromSpdxId "MPL-2.0"; } ) { }; @@ -69128,7 +69128,7 @@ self: { unordered-containers ]; description = "Amazon Lake Formation SDK"; - license = lib.licensesSpdx."MPL-2.0"; + license = lib.meta.getLicenseFromSpdxId "MPL-2.0"; } ) { }; @@ -69169,7 +69169,7 @@ self: { unordered-containers ]; description = "Amazon Lambda SDK"; - license = lib.licensesSpdx."MPL-2.0"; + license = lib.meta.getLicenseFromSpdxId "MPL-2.0"; } ) { }; @@ -69210,7 +69210,7 @@ self: { unordered-containers ]; description = "Amazon Lex Model Building Service SDK"; - license = lib.licensesSpdx."MPL-2.0"; + license = lib.meta.getLicenseFromSpdxId "MPL-2.0"; } ) { }; @@ -69251,7 +69251,7 @@ self: { unordered-containers ]; description = "Amazon Lex Runtime Service SDK"; - license = lib.licensesSpdx."MPL-2.0"; + license = lib.meta.getLicenseFromSpdxId "MPL-2.0"; } ) { }; @@ -69292,7 +69292,7 @@ self: { unordered-containers ]; description = "Amazon Lex Model Building V2 SDK"; - license = lib.licensesSpdx."MPL-2.0"; + license = lib.meta.getLicenseFromSpdxId "MPL-2.0"; } ) { }; @@ -69333,7 +69333,7 @@ self: { unordered-containers ]; description = "Amazon License Manager SDK"; - license = lib.licensesSpdx."MPL-2.0"; + license = lib.meta.getLicenseFromSpdxId "MPL-2.0"; } ) { }; @@ -69374,7 +69374,7 @@ self: { unordered-containers ]; description = "Amazon License Manager Linux Subscriptions SDK"; - license = lib.licensesSpdx."MPL-2.0"; + license = lib.meta.getLicenseFromSpdxId "MPL-2.0"; } ) { }; @@ -69415,7 +69415,7 @@ self: { unordered-containers ]; description = "Amazon License Manager User Subscriptions SDK"; - license = lib.licensesSpdx."MPL-2.0"; + license = lib.meta.getLicenseFromSpdxId "MPL-2.0"; } ) { }; @@ -69456,7 +69456,7 @@ self: { unordered-containers ]; description = "Amazon Lightsail SDK"; - license = lib.licensesSpdx."MPL-2.0"; + license = lib.meta.getLicenseFromSpdxId "MPL-2.0"; } ) { }; @@ -69497,7 +69497,7 @@ self: { unordered-containers ]; description = "Amazon Location Service SDK"; - license = lib.licensesSpdx."MPL-2.0"; + license = lib.meta.getLicenseFromSpdxId "MPL-2.0"; } ) { }; @@ -69538,7 +69538,7 @@ self: { unordered-containers ]; description = "Amazon Lookout for Equipment SDK"; - license = lib.licensesSpdx."MPL-2.0"; + license = lib.meta.getLicenseFromSpdxId "MPL-2.0"; } ) { }; @@ -69579,7 +69579,7 @@ self: { unordered-containers ]; description = "Amazon Lookout for Metrics SDK"; - license = lib.licensesSpdx."MPL-2.0"; + license = lib.meta.getLicenseFromSpdxId "MPL-2.0"; } ) { }; @@ -69620,7 +69620,7 @@ self: { unordered-containers ]; description = "Amazon Lookout for Vision SDK"; - license = lib.licensesSpdx."MPL-2.0"; + license = lib.meta.getLicenseFromSpdxId "MPL-2.0"; } ) { }; @@ -69661,7 +69661,7 @@ self: { unordered-containers ]; description = "Amazon MainframeModernization SDK"; - license = lib.licensesSpdx."MPL-2.0"; + license = lib.meta.getLicenseFromSpdxId "MPL-2.0"; } ) { }; @@ -69702,7 +69702,7 @@ self: { unordered-containers ]; description = "Amazon Macie SDK"; - license = lib.licensesSpdx."MPL-2.0"; + license = lib.meta.getLicenseFromSpdxId "MPL-2.0"; } ) { }; @@ -69743,7 +69743,7 @@ self: { unordered-containers ]; description = "Amazon Macie 2 SDK"; - license = lib.licensesSpdx."MPL-2.0"; + license = lib.meta.getLicenseFromSpdxId "MPL-2.0"; } ) { }; @@ -69784,7 +69784,7 @@ self: { unordered-containers ]; description = "Amazon Managed Blockchain SDK"; - license = lib.licensesSpdx."MPL-2.0"; + license = lib.meta.getLicenseFromSpdxId "MPL-2.0"; } ) { }; @@ -69825,7 +69825,7 @@ self: { unordered-containers ]; description = "Amazon Marketplace Commerce Analytics SDK"; - license = lib.licensesSpdx."MPL-2.0"; + license = lib.meta.getLicenseFromSpdxId "MPL-2.0"; } ) { }; @@ -69866,7 +69866,7 @@ self: { unordered-containers ]; description = "Amazon Marketplace Catalog Service SDK"; - license = lib.licensesSpdx."MPL-2.0"; + license = lib.meta.getLicenseFromSpdxId "MPL-2.0"; } ) { }; @@ -69907,7 +69907,7 @@ self: { unordered-containers ]; description = "Amazon Marketplace Entitlement Service SDK"; - license = lib.licensesSpdx."MPL-2.0"; + license = lib.meta.getLicenseFromSpdxId "MPL-2.0"; } ) { }; @@ -69948,7 +69948,7 @@ self: { unordered-containers ]; description = "Amazon Marketplace Metering SDK"; - license = lib.licensesSpdx."MPL-2.0"; + license = lib.meta.getLicenseFromSpdxId "MPL-2.0"; } ) { }; @@ -69989,7 +69989,7 @@ self: { unordered-containers ]; description = "Amazon Mechanical Turk SDK"; - license = lib.licensesSpdx."MPL-2.0"; + license = lib.meta.getLicenseFromSpdxId "MPL-2.0"; } ) { }; @@ -70030,7 +70030,7 @@ self: { unordered-containers ]; description = "Amazon MediaConnect SDK"; - license = lib.licensesSpdx."MPL-2.0"; + license = lib.meta.getLicenseFromSpdxId "MPL-2.0"; } ) { }; @@ -70071,7 +70071,7 @@ self: { unordered-containers ]; description = "Amazon Elemental MediaConvert SDK"; - license = lib.licensesSpdx."MPL-2.0"; + license = lib.meta.getLicenseFromSpdxId "MPL-2.0"; } ) { }; @@ -70112,7 +70112,7 @@ self: { unordered-containers ]; description = "Amazon Elemental MediaLive SDK"; - license = lib.licensesSpdx."MPL-2.0"; + license = lib.meta.getLicenseFromSpdxId "MPL-2.0"; } ) { }; @@ -70153,7 +70153,7 @@ self: { unordered-containers ]; description = "Amazon Elemental MediaPackage SDK"; - license = lib.licensesSpdx."MPL-2.0"; + license = lib.meta.getLicenseFromSpdxId "MPL-2.0"; } ) { }; @@ -70194,7 +70194,7 @@ self: { unordered-containers ]; description = "Amazon Elemental MediaPackage VOD SDK"; - license = lib.licensesSpdx."MPL-2.0"; + license = lib.meta.getLicenseFromSpdxId "MPL-2.0"; } ) { }; @@ -70235,7 +70235,7 @@ self: { unordered-containers ]; description = "Amazon Elemental MediaStore SDK"; - license = lib.licensesSpdx."MPL-2.0"; + license = lib.meta.getLicenseFromSpdxId "MPL-2.0"; } ) { }; @@ -70276,7 +70276,7 @@ self: { unordered-containers ]; description = "Amazon Elemental MediaStore Data Plane SDK"; - license = lib.licensesSpdx."MPL-2.0"; + license = lib.meta.getLicenseFromSpdxId "MPL-2.0"; } ) { }; @@ -70317,7 +70317,7 @@ self: { unordered-containers ]; description = "Amazon MediaTailor SDK"; - license = lib.licensesSpdx."MPL-2.0"; + license = lib.meta.getLicenseFromSpdxId "MPL-2.0"; } ) { }; @@ -70358,7 +70358,7 @@ self: { unordered-containers ]; description = "Amazon MemoryDB SDK"; - license = lib.licensesSpdx."MPL-2.0"; + license = lib.meta.getLicenseFromSpdxId "MPL-2.0"; } ) { }; @@ -70399,7 +70399,7 @@ self: { unordered-containers ]; description = "Amazon Application Migration Service SDK"; - license = lib.licensesSpdx."MPL-2.0"; + license = lib.meta.getLicenseFromSpdxId "MPL-2.0"; } ) { }; @@ -70440,7 +70440,7 @@ self: { unordered-containers ]; description = "Amazon Migration Hub Refactor Spaces SDK"; - license = lib.licensesSpdx."MPL-2.0"; + license = lib.meta.getLicenseFromSpdxId "MPL-2.0"; } ) { }; @@ -70481,7 +70481,7 @@ self: { unordered-containers ]; description = "Amazon Migration Hub SDK"; - license = lib.licensesSpdx."MPL-2.0"; + license = lib.meta.getLicenseFromSpdxId "MPL-2.0"; } ) { }; @@ -70522,7 +70522,7 @@ self: { unordered-containers ]; description = "Amazon Migration Hub Config SDK"; - license = lib.licensesSpdx."MPL-2.0"; + license = lib.meta.getLicenseFromSpdxId "MPL-2.0"; } ) { }; @@ -70563,7 +70563,7 @@ self: { unordered-containers ]; description = "Amazon Migration Hub Orchestrator SDK"; - license = lib.licensesSpdx."MPL-2.0"; + license = lib.meta.getLicenseFromSpdxId "MPL-2.0"; } ) { }; @@ -70604,7 +70604,7 @@ self: { unordered-containers ]; description = "Amazon Migration Hub Strategy Recommendations SDK"; - license = lib.licensesSpdx."MPL-2.0"; + license = lib.meta.getLicenseFromSpdxId "MPL-2.0"; } ) { }; @@ -70645,7 +70645,7 @@ self: { unordered-containers ]; description = "Amazon Machine Learning SDK"; - license = lib.licensesSpdx."MPL-2.0"; + license = lib.meta.getLicenseFromSpdxId "MPL-2.0"; } ) { }; @@ -70686,7 +70686,7 @@ self: { unordered-containers ]; description = "Amazon Mobile SDK"; - license = lib.licensesSpdx."MPL-2.0"; + license = lib.meta.getLicenseFromSpdxId "MPL-2.0"; } ) { }; @@ -70727,7 +70727,7 @@ self: { unordered-containers ]; description = "Amazon MQ SDK"; - license = lib.licensesSpdx."MPL-2.0"; + license = lib.meta.getLicenseFromSpdxId "MPL-2.0"; } ) { }; @@ -70823,7 +70823,7 @@ self: { unordered-containers ]; description = "Amazon MWAA SDK"; - license = lib.licensesSpdx."MPL-2.0"; + license = lib.meta.getLicenseFromSpdxId "MPL-2.0"; } ) { }; @@ -70864,7 +70864,7 @@ self: { unordered-containers ]; description = "Amazon Neptune SDK"; - license = lib.licensesSpdx."MPL-2.0"; + license = lib.meta.getLicenseFromSpdxId "MPL-2.0"; } ) { }; @@ -70905,7 +70905,7 @@ self: { unordered-containers ]; description = "Amazon Network Firewall SDK"; - license = lib.licensesSpdx."MPL-2.0"; + license = lib.meta.getLicenseFromSpdxId "MPL-2.0"; } ) { }; @@ -70946,7 +70946,7 @@ self: { unordered-containers ]; description = "Amazon Network Manager SDK"; - license = lib.licensesSpdx."MPL-2.0"; + license = lib.meta.getLicenseFromSpdxId "MPL-2.0"; } ) { }; @@ -70987,7 +70987,7 @@ self: { unordered-containers ]; description = "Amazon NimbleStudio SDK"; - license = lib.licensesSpdx."MPL-2.0"; + license = lib.meta.getLicenseFromSpdxId "MPL-2.0"; } ) { }; @@ -71028,7 +71028,7 @@ self: { unordered-containers ]; description = "Amazon CloudWatch Observability Access Manager SDK"; - license = lib.licensesSpdx."MPL-2.0"; + license = lib.meta.getLicenseFromSpdxId "MPL-2.0"; } ) { }; @@ -71069,7 +71069,7 @@ self: { unordered-containers ]; description = "Amazon Omics SDK"; - license = lib.licensesSpdx."MPL-2.0"; + license = lib.meta.getLicenseFromSpdxId "MPL-2.0"; } ) { }; @@ -71110,7 +71110,7 @@ self: { unordered-containers ]; description = "Amazon OpenSearch Service SDK"; - license = lib.licensesSpdx."MPL-2.0"; + license = lib.meta.getLicenseFromSpdxId "MPL-2.0"; } ) { }; @@ -71151,7 +71151,7 @@ self: { unordered-containers ]; description = "Amazon OpenSearch Service Serverless SDK"; - license = lib.licensesSpdx."MPL-2.0"; + license = lib.meta.getLicenseFromSpdxId "MPL-2.0"; } ) { }; @@ -71192,7 +71192,7 @@ self: { unordered-containers ]; description = "Amazon OpsWorks SDK"; - license = lib.licensesSpdx."MPL-2.0"; + license = lib.meta.getLicenseFromSpdxId "MPL-2.0"; } ) { }; @@ -71233,7 +71233,7 @@ self: { unordered-containers ]; description = "Amazon OpsWorks CM SDK"; - license = lib.licensesSpdx."MPL-2.0"; + license = lib.meta.getLicenseFromSpdxId "MPL-2.0"; } ) { }; @@ -71274,7 +71274,7 @@ self: { unordered-containers ]; description = "Amazon Organizations SDK"; - license = lib.licensesSpdx."MPL-2.0"; + license = lib.meta.getLicenseFromSpdxId "MPL-2.0"; } ) { }; @@ -71315,7 +71315,7 @@ self: { unordered-containers ]; description = "Amazon Outposts SDK"; - license = lib.licensesSpdx."MPL-2.0"; + license = lib.meta.getLicenseFromSpdxId "MPL-2.0"; } ) { }; @@ -71356,7 +71356,7 @@ self: { unordered-containers ]; description = "Amazon Panorama SDK"; - license = lib.licensesSpdx."MPL-2.0"; + license = lib.meta.getLicenseFromSpdxId "MPL-2.0"; } ) { }; @@ -71397,7 +71397,7 @@ self: { unordered-containers ]; description = "Amazon Personalize SDK"; - license = lib.licensesSpdx."MPL-2.0"; + license = lib.meta.getLicenseFromSpdxId "MPL-2.0"; } ) { }; @@ -71438,7 +71438,7 @@ self: { unordered-containers ]; description = "Amazon Personalize Events SDK"; - license = lib.licensesSpdx."MPL-2.0"; + license = lib.meta.getLicenseFromSpdxId "MPL-2.0"; } ) { }; @@ -71479,7 +71479,7 @@ self: { unordered-containers ]; description = "Amazon Personalize Runtime SDK"; - license = lib.licensesSpdx."MPL-2.0"; + license = lib.meta.getLicenseFromSpdxId "MPL-2.0"; } ) { }; @@ -71520,7 +71520,7 @@ self: { unordered-containers ]; description = "Amazon Performance Insights SDK"; - license = lib.licensesSpdx."MPL-2.0"; + license = lib.meta.getLicenseFromSpdxId "MPL-2.0"; } ) { }; @@ -71561,7 +71561,7 @@ self: { unordered-containers ]; description = "Amazon Pinpoint SDK"; - license = lib.licensesSpdx."MPL-2.0"; + license = lib.meta.getLicenseFromSpdxId "MPL-2.0"; } ) { }; @@ -71602,7 +71602,7 @@ self: { unordered-containers ]; description = "Amazon Pinpoint Email Service SDK"; - license = lib.licensesSpdx."MPL-2.0"; + license = lib.meta.getLicenseFromSpdxId "MPL-2.0"; } ) { }; @@ -71643,7 +71643,7 @@ self: { unordered-containers ]; description = "Amazon Pinpoint SMS and Voice Service SDK"; - license = lib.licensesSpdx."MPL-2.0"; + license = lib.meta.getLicenseFromSpdxId "MPL-2.0"; } ) { }; @@ -71684,7 +71684,7 @@ self: { unordered-containers ]; description = "Amazon Pinpoint SMS Voice V2 SDK"; - license = lib.licensesSpdx."MPL-2.0"; + license = lib.meta.getLicenseFromSpdxId "MPL-2.0"; } ) { }; @@ -71725,7 +71725,7 @@ self: { unordered-containers ]; description = "Amazon EventBridge Pipes SDK"; - license = lib.licensesSpdx."MPL-2.0"; + license = lib.meta.getLicenseFromSpdxId "MPL-2.0"; } ) { }; @@ -71766,7 +71766,7 @@ self: { unordered-containers ]; description = "Amazon Polly SDK"; - license = lib.licensesSpdx."MPL-2.0"; + license = lib.meta.getLicenseFromSpdxId "MPL-2.0"; } ) { }; @@ -71807,7 +71807,7 @@ self: { unordered-containers ]; description = "Amazon Price List Service SDK"; - license = lib.licensesSpdx."MPL-2.0"; + license = lib.meta.getLicenseFromSpdxId "MPL-2.0"; } ) { }; @@ -71848,7 +71848,7 @@ self: { unordered-containers ]; description = "Amazon Private 5G SDK"; - license = lib.licensesSpdx."MPL-2.0"; + license = lib.meta.getLicenseFromSpdxId "MPL-2.0"; } ) { }; @@ -71889,7 +71889,7 @@ self: { unordered-containers ]; description = "Amazon Proton SDK"; - license = lib.licensesSpdx."MPL-2.0"; + license = lib.meta.getLicenseFromSpdxId "MPL-2.0"; } ) { }; @@ -71930,7 +71930,7 @@ self: { unordered-containers ]; description = "Amazon QLDB SDK"; - license = lib.licensesSpdx."MPL-2.0"; + license = lib.meta.getLicenseFromSpdxId "MPL-2.0"; } ) { }; @@ -71971,7 +71971,7 @@ self: { unordered-containers ]; description = "Amazon QLDB Session SDK"; - license = lib.licensesSpdx."MPL-2.0"; + license = lib.meta.getLicenseFromSpdxId "MPL-2.0"; } ) { }; @@ -72012,7 +72012,7 @@ self: { unordered-containers ]; description = "Amazon QuickSight SDK"; - license = lib.licensesSpdx."MPL-2.0"; + license = lib.meta.getLicenseFromSpdxId "MPL-2.0"; } ) { }; @@ -72053,7 +72053,7 @@ self: { unordered-containers ]; description = "Amazon Resource Access Manager SDK"; - license = lib.licensesSpdx."MPL-2.0"; + license = lib.meta.getLicenseFromSpdxId "MPL-2.0"; } ) { }; @@ -72094,7 +72094,7 @@ self: { unordered-containers ]; description = "Amazon Recycle Bin SDK"; - license = lib.licensesSpdx."MPL-2.0"; + license = lib.meta.getLicenseFromSpdxId "MPL-2.0"; } ) { }; @@ -72135,7 +72135,7 @@ self: { unordered-containers ]; description = "Amazon Relational Database Service SDK"; - license = lib.licensesSpdx."MPL-2.0"; + license = lib.meta.getLicenseFromSpdxId "MPL-2.0"; } ) { }; @@ -72176,7 +72176,7 @@ self: { unordered-containers ]; description = "Amazon RDS DataService SDK"; - license = lib.licensesSpdx."MPL-2.0"; + license = lib.meta.getLicenseFromSpdxId "MPL-2.0"; } ) { }; @@ -72217,7 +72217,7 @@ self: { unordered-containers ]; description = "Amazon Redshift SDK"; - license = lib.licensesSpdx."MPL-2.0"; + license = lib.meta.getLicenseFromSpdxId "MPL-2.0"; } ) { }; @@ -72258,7 +72258,7 @@ self: { unordered-containers ]; description = "Amazon Redshift Data API Service SDK"; - license = lib.licensesSpdx."MPL-2.0"; + license = lib.meta.getLicenseFromSpdxId "MPL-2.0"; } ) { }; @@ -72299,7 +72299,7 @@ self: { unordered-containers ]; description = "Amazon Redshift Serverless SDK"; - license = lib.licensesSpdx."MPL-2.0"; + license = lib.meta.getLicenseFromSpdxId "MPL-2.0"; } ) { }; @@ -72340,7 +72340,7 @@ self: { unordered-containers ]; description = "Amazon Rekognition SDK"; - license = lib.licensesSpdx."MPL-2.0"; + license = lib.meta.getLicenseFromSpdxId "MPL-2.0"; } ) { }; @@ -72381,7 +72381,7 @@ self: { unordered-containers ]; description = "Amazon Resilience Hub SDK"; - license = lib.licensesSpdx."MPL-2.0"; + license = lib.meta.getLicenseFromSpdxId "MPL-2.0"; } ) { }; @@ -72422,7 +72422,7 @@ self: { unordered-containers ]; description = "Amazon Resource Explorer SDK"; - license = lib.licensesSpdx."MPL-2.0"; + license = lib.meta.getLicenseFromSpdxId "MPL-2.0"; } ) { }; @@ -72463,7 +72463,7 @@ self: { unordered-containers ]; description = "Amazon Resource Groups SDK"; - license = lib.licensesSpdx."MPL-2.0"; + license = lib.meta.getLicenseFromSpdxId "MPL-2.0"; } ) { }; @@ -72504,7 +72504,7 @@ self: { unordered-containers ]; description = "Amazon Resource Groups Tagging API SDK"; - license = lib.licensesSpdx."MPL-2.0"; + license = lib.meta.getLicenseFromSpdxId "MPL-2.0"; } ) { }; @@ -72545,7 +72545,7 @@ self: { unordered-containers ]; description = "Amazon RoboMaker SDK"; - license = lib.licensesSpdx."MPL-2.0"; + license = lib.meta.getLicenseFromSpdxId "MPL-2.0"; } ) { }; @@ -72586,7 +72586,7 @@ self: { unordered-containers ]; description = "Amazon IAM Roles Anywhere SDK"; - license = lib.licensesSpdx."MPL-2.0"; + license = lib.meta.getLicenseFromSpdxId "MPL-2.0"; } ) { }; @@ -72628,7 +72628,7 @@ self: { unordered-containers ]; description = "Amazon Route 53 SDK"; - license = lib.licensesSpdx."MPL-2.0"; + license = lib.meta.getLicenseFromSpdxId "MPL-2.0"; } ) { }; @@ -72669,7 +72669,7 @@ self: { unordered-containers ]; description = "Amazon Cloud Map SDK"; - license = lib.licensesSpdx."MPL-2.0"; + license = lib.meta.getLicenseFromSpdxId "MPL-2.0"; } ) { }; @@ -72710,7 +72710,7 @@ self: { unordered-containers ]; description = "Amazon Route 53 Domains SDK"; - license = lib.licensesSpdx."MPL-2.0"; + license = lib.meta.getLicenseFromSpdxId "MPL-2.0"; } ) { }; @@ -72751,7 +72751,7 @@ self: { unordered-containers ]; description = "Amazon Route53 Recovery Cluster SDK"; - license = lib.licensesSpdx."MPL-2.0"; + license = lib.meta.getLicenseFromSpdxId "MPL-2.0"; } ) { }; @@ -72792,7 +72792,7 @@ self: { unordered-containers ]; description = "Amazon Route53 Recovery Control Config SDK"; - license = lib.licensesSpdx."MPL-2.0"; + license = lib.meta.getLicenseFromSpdxId "MPL-2.0"; } ) { }; @@ -72833,7 +72833,7 @@ self: { unordered-containers ]; description = "Amazon Route53 Recovery Readiness SDK"; - license = lib.licensesSpdx."MPL-2.0"; + license = lib.meta.getLicenseFromSpdxId "MPL-2.0"; } ) { }; @@ -72874,7 +72874,7 @@ self: { unordered-containers ]; description = "Amazon Route 53 Resolver SDK"; - license = lib.licensesSpdx."MPL-2.0"; + license = lib.meta.getLicenseFromSpdxId "MPL-2.0"; } ) { }; @@ -72915,7 +72915,7 @@ self: { unordered-containers ]; description = "Amazon CloudWatch RUM SDK"; - license = lib.licensesSpdx."MPL-2.0"; + license = lib.meta.getLicenseFromSpdxId "MPL-2.0"; } ) { }; @@ -72959,7 +72959,7 @@ self: { unordered-containers ]; description = "Amazon Simple Storage Service SDK"; - license = lib.licensesSpdx."MPL-2.0"; + license = lib.meta.getLicenseFromSpdxId "MPL-2.0"; } ) { }; @@ -73034,7 +73034,7 @@ self: { unordered-containers ]; description = "Amazon Simple Storage Service SDK - Client-Side Encryption"; - license = lib.licensesSpdx."MPL-2.0"; + license = lib.meta.getLicenseFromSpdxId "MPL-2.0"; hydraPlatforms = lib.platforms.none; broken = true; } @@ -73120,7 +73120,7 @@ self: { unordered-containers ]; description = "Amazon S3 on Outposts SDK"; - license = lib.licensesSpdx."MPL-2.0"; + license = lib.meta.getLicenseFromSpdxId "MPL-2.0"; } ) { }; @@ -73161,7 +73161,7 @@ self: { unordered-containers ]; description = "Amazon SageMaker Service SDK"; - license = lib.licensesSpdx."MPL-2.0"; + license = lib.meta.getLicenseFromSpdxId "MPL-2.0"; } ) { }; @@ -73202,7 +73202,7 @@ self: { unordered-containers ]; description = "Amazon Augmented AI Runtime SDK"; - license = lib.licensesSpdx."MPL-2.0"; + license = lib.meta.getLicenseFromSpdxId "MPL-2.0"; } ) { }; @@ -73243,7 +73243,7 @@ self: { unordered-containers ]; description = "Amazon Sagemaker Edge Manager SDK"; - license = lib.licensesSpdx."MPL-2.0"; + license = lib.meta.getLicenseFromSpdxId "MPL-2.0"; } ) { }; @@ -73284,7 +73284,7 @@ self: { unordered-containers ]; description = "Amazon SageMaker Feature Store Runtime SDK"; - license = lib.licensesSpdx."MPL-2.0"; + license = lib.meta.getLicenseFromSpdxId "MPL-2.0"; } ) { }; @@ -73325,7 +73325,7 @@ self: { unordered-containers ]; description = "Amazon SageMaker geospatial capabilities SDK"; - license = lib.licensesSpdx."MPL-2.0"; + license = lib.meta.getLicenseFromSpdxId "MPL-2.0"; } ) { }; @@ -73366,7 +73366,7 @@ self: { unordered-containers ]; description = "Amazon SageMaker Metrics Service SDK"; - license = lib.licensesSpdx."MPL-2.0"; + license = lib.meta.getLicenseFromSpdxId "MPL-2.0"; } ) { }; @@ -73407,7 +73407,7 @@ self: { unordered-containers ]; description = "Amazon SageMaker Runtime SDK"; - license = lib.licensesSpdx."MPL-2.0"; + license = lib.meta.getLicenseFromSpdxId "MPL-2.0"; } ) { }; @@ -73448,7 +73448,7 @@ self: { unordered-containers ]; description = "Amazon Savings Plans SDK"; - license = lib.licensesSpdx."MPL-2.0"; + license = lib.meta.getLicenseFromSpdxId "MPL-2.0"; } ) { }; @@ -73489,7 +73489,7 @@ self: { unordered-containers ]; description = "Amazon EventBridge Scheduler SDK"; - license = lib.licensesSpdx."MPL-2.0"; + license = lib.meta.getLicenseFromSpdxId "MPL-2.0"; } ) { }; @@ -73530,7 +73530,7 @@ self: { unordered-containers ]; description = "Amazon Schemas SDK"; - license = lib.licensesSpdx."MPL-2.0"; + license = lib.meta.getLicenseFromSpdxId "MPL-2.0"; } ) { }; @@ -73571,7 +73571,7 @@ self: { unordered-containers ]; description = "Amazon SimpleDB SDK"; - license = lib.licensesSpdx."MPL-2.0"; + license = lib.meta.getLicenseFromSpdxId "MPL-2.0"; } ) { }; @@ -73612,7 +73612,7 @@ self: { unordered-containers ]; description = "Amazon Secrets Manager SDK"; - license = lib.licensesSpdx."MPL-2.0"; + license = lib.meta.getLicenseFromSpdxId "MPL-2.0"; } ) { }; @@ -73653,7 +73653,7 @@ self: { unordered-containers ]; description = "Amazon SecurityHub SDK"; - license = lib.licensesSpdx."MPL-2.0"; + license = lib.meta.getLicenseFromSpdxId "MPL-2.0"; } ) { }; @@ -73694,7 +73694,7 @@ self: { unordered-containers ]; description = "Amazon Security Lake SDK"; - license = lib.licensesSpdx."MPL-2.0"; + license = lib.meta.getLicenseFromSpdxId "MPL-2.0"; } ) { }; @@ -73735,7 +73735,7 @@ self: { unordered-containers ]; description = "Amazon ServerlessApplicationRepository SDK"; - license = lib.licensesSpdx."MPL-2.0"; + license = lib.meta.getLicenseFromSpdxId "MPL-2.0"; } ) { }; @@ -73776,7 +73776,7 @@ self: { unordered-containers ]; description = "Amazon Quotas SDK"; - license = lib.licensesSpdx."MPL-2.0"; + license = lib.meta.getLicenseFromSpdxId "MPL-2.0"; } ) { }; @@ -73817,7 +73817,7 @@ self: { unordered-containers ]; description = "Amazon Service Catalog SDK"; - license = lib.licensesSpdx."MPL-2.0"; + license = lib.meta.getLicenseFromSpdxId "MPL-2.0"; } ) { }; @@ -73858,7 +73858,7 @@ self: { unordered-containers ]; description = "Amazon Service Catalog App Registry SDK"; - license = lib.licensesSpdx."MPL-2.0"; + license = lib.meta.getLicenseFromSpdxId "MPL-2.0"; } ) { }; @@ -73899,7 +73899,7 @@ self: { unordered-containers ]; description = "Amazon Simple Email Service SDK"; - license = lib.licensesSpdx."MPL-2.0"; + license = lib.meta.getLicenseFromSpdxId "MPL-2.0"; } ) { }; @@ -73940,7 +73940,7 @@ self: { unordered-containers ]; description = "Amazon Simple Email Service SDK"; - license = lib.licensesSpdx."MPL-2.0"; + license = lib.meta.getLicenseFromSpdxId "MPL-2.0"; } ) { }; @@ -73981,7 +73981,7 @@ self: { unordered-containers ]; description = "Amazon Shield SDK"; - license = lib.licensesSpdx."MPL-2.0"; + license = lib.meta.getLicenseFromSpdxId "MPL-2.0"; } ) { }; @@ -74022,7 +74022,7 @@ self: { unordered-containers ]; description = "Amazon Signer SDK"; - license = lib.licensesSpdx."MPL-2.0"; + license = lib.meta.getLicenseFromSpdxId "MPL-2.0"; } ) { }; @@ -74063,7 +74063,7 @@ self: { unordered-containers ]; description = "Amazon SimSpace Weaver SDK"; - license = lib.licensesSpdx."MPL-2.0"; + license = lib.meta.getLicenseFromSpdxId "MPL-2.0"; } ) { }; @@ -74104,7 +74104,7 @@ self: { unordered-containers ]; description = "Amazon Server Migration Service SDK"; - license = lib.licensesSpdx."MPL-2.0"; + license = lib.meta.getLicenseFromSpdxId "MPL-2.0"; } ) { }; @@ -74145,7 +74145,7 @@ self: { unordered-containers ]; description = "Amazon Pinpoint SMS and Voice Service SDK"; - license = lib.licensesSpdx."MPL-2.0"; + license = lib.meta.getLicenseFromSpdxId "MPL-2.0"; } ) { }; @@ -74186,7 +74186,7 @@ self: { unordered-containers ]; description = "Amazon Snow Device Management SDK"; - license = lib.licensesSpdx."MPL-2.0"; + license = lib.meta.getLicenseFromSpdxId "MPL-2.0"; } ) { }; @@ -74227,7 +74227,7 @@ self: { unordered-containers ]; description = "Amazon Import/Export Snowball SDK"; - license = lib.licensesSpdx."MPL-2.0"; + license = lib.meta.getLicenseFromSpdxId "MPL-2.0"; } ) { }; @@ -74268,7 +74268,7 @@ self: { unordered-containers ]; description = "Amazon Simple Notification Service SDK"; - license = lib.licensesSpdx."MPL-2.0"; + license = lib.meta.getLicenseFromSpdxId "MPL-2.0"; } ) { }; @@ -74309,7 +74309,7 @@ self: { unordered-containers ]; description = "Amazon Simple Queue Service SDK"; - license = lib.licensesSpdx."MPL-2.0"; + license = lib.meta.getLicenseFromSpdxId "MPL-2.0"; } ) { }; @@ -74350,7 +74350,7 @@ self: { unordered-containers ]; description = "Amazon Simple Systems Manager (SSM) SDK"; - license = lib.licensesSpdx."MPL-2.0"; + license = lib.meta.getLicenseFromSpdxId "MPL-2.0"; } ) { }; @@ -74391,7 +74391,7 @@ self: { unordered-containers ]; description = "Amazon Systems Manager Incident Manager Contacts SDK"; - license = lib.licensesSpdx."MPL-2.0"; + license = lib.meta.getLicenseFromSpdxId "MPL-2.0"; } ) { }; @@ -74432,7 +74432,7 @@ self: { unordered-containers ]; description = "Amazon Systems Manager Incident Manager SDK"; - license = lib.licensesSpdx."MPL-2.0"; + license = lib.meta.getLicenseFromSpdxId "MPL-2.0"; } ) { }; @@ -74473,7 +74473,7 @@ self: { unordered-containers ]; description = "Amazon Systems Manager for SAP SDK"; - license = lib.licensesSpdx."MPL-2.0"; + license = lib.meta.getLicenseFromSpdxId "MPL-2.0"; } ) { }; @@ -74514,7 +74514,7 @@ self: { unordered-containers ]; description = "Amazon Single Sign-On SDK"; - license = lib.licensesSpdx."MPL-2.0"; + license = lib.meta.getLicenseFromSpdxId "MPL-2.0"; } ) { }; @@ -74555,7 +74555,7 @@ self: { unordered-containers ]; description = "Amazon Single Sign-On Admin SDK"; - license = lib.licensesSpdx."MPL-2.0"; + license = lib.meta.getLicenseFromSpdxId "MPL-2.0"; } ) { }; @@ -74596,7 +74596,7 @@ self: { unordered-containers ]; description = "Amazon SSO OIDC SDK"; - license = lib.licensesSpdx."MPL-2.0"; + license = lib.meta.getLicenseFromSpdxId "MPL-2.0"; } ) { }; @@ -74637,7 +74637,7 @@ self: { unordered-containers ]; description = "Amazon Step Functions SDK"; - license = lib.licensesSpdx."MPL-2.0"; + license = lib.meta.getLicenseFromSpdxId "MPL-2.0"; } ) { }; @@ -74678,7 +74678,7 @@ self: { unordered-containers ]; description = "Amazon Storage Gateway SDK"; - license = lib.licensesSpdx."MPL-2.0"; + license = lib.meta.getLicenseFromSpdxId "MPL-2.0"; } ) { }; @@ -74719,7 +74719,7 @@ self: { unordered-containers ]; description = "Amazon Security Token Service SDK"; - license = lib.licensesSpdx."MPL-2.0"; + license = lib.meta.getLicenseFromSpdxId "MPL-2.0"; } ) { }; @@ -74760,7 +74760,7 @@ self: { unordered-containers ]; description = "Amazon Support SDK"; - license = lib.licensesSpdx."MPL-2.0"; + license = lib.meta.getLicenseFromSpdxId "MPL-2.0"; } ) { }; @@ -74801,7 +74801,7 @@ self: { unordered-containers ]; description = "Amazon Support App SDK"; - license = lib.licensesSpdx."MPL-2.0"; + license = lib.meta.getLicenseFromSpdxId "MPL-2.0"; } ) { }; @@ -74842,7 +74842,7 @@ self: { unordered-containers ]; description = "Amazon Simple Workflow Service SDK"; - license = lib.licensesSpdx."MPL-2.0"; + license = lib.meta.getLicenseFromSpdxId "MPL-2.0"; } ) { }; @@ -74883,7 +74883,7 @@ self: { unordered-containers ]; description = "Amazon Synthetics SDK"; - license = lib.licensesSpdx."MPL-2.0"; + license = lib.meta.getLicenseFromSpdxId "MPL-2.0"; } ) { }; @@ -74940,7 +74940,7 @@ self: { yaml ]; description = "Common functionality for Amazonka library test-suites"; - license = lib.licensesSpdx."MPL-2.0"; + license = lib.meta.getLicenseFromSpdxId "MPL-2.0"; } ) { }; @@ -74981,7 +74981,7 @@ self: { unordered-containers ]; description = "Amazon Textract SDK"; - license = lib.licensesSpdx."MPL-2.0"; + license = lib.meta.getLicenseFromSpdxId "MPL-2.0"; } ) { }; @@ -75022,7 +75022,7 @@ self: { unordered-containers ]; description = "Amazon Timestream Query SDK"; - license = lib.licensesSpdx."MPL-2.0"; + license = lib.meta.getLicenseFromSpdxId "MPL-2.0"; } ) { }; @@ -75063,7 +75063,7 @@ self: { unordered-containers ]; description = "Amazon Timestream Write SDK"; - license = lib.licensesSpdx."MPL-2.0"; + license = lib.meta.getLicenseFromSpdxId "MPL-2.0"; } ) { }; @@ -75104,7 +75104,7 @@ self: { unordered-containers ]; description = "Amazon Transcribe Service SDK"; - license = lib.licensesSpdx."MPL-2.0"; + license = lib.meta.getLicenseFromSpdxId "MPL-2.0"; } ) { }; @@ -75145,7 +75145,7 @@ self: { unordered-containers ]; description = "Amazon Transfer Family SDK"; - license = lib.licensesSpdx."MPL-2.0"; + license = lib.meta.getLicenseFromSpdxId "MPL-2.0"; } ) { }; @@ -75186,7 +75186,7 @@ self: { unordered-containers ]; description = "Amazon Translate SDK"; - license = lib.licensesSpdx."MPL-2.0"; + license = lib.meta.getLicenseFromSpdxId "MPL-2.0"; } ) { }; @@ -75227,7 +75227,7 @@ self: { unordered-containers ]; description = "Amazon Voice ID SDK"; - license = lib.licensesSpdx."MPL-2.0"; + license = lib.meta.getLicenseFromSpdxId "MPL-2.0"; } ) { }; @@ -75268,7 +75268,7 @@ self: { unordered-containers ]; description = "Amazon WAF SDK"; - license = lib.licensesSpdx."MPL-2.0"; + license = lib.meta.getLicenseFromSpdxId "MPL-2.0"; } ) { }; @@ -75309,7 +75309,7 @@ self: { unordered-containers ]; description = "Amazon WAF Regional SDK"; - license = lib.licensesSpdx."MPL-2.0"; + license = lib.meta.getLicenseFromSpdxId "MPL-2.0"; } ) { }; @@ -75350,7 +75350,7 @@ self: { unordered-containers ]; description = "Amazon WAFV2 SDK"; - license = lib.licensesSpdx."MPL-2.0"; + license = lib.meta.getLicenseFromSpdxId "MPL-2.0"; } ) { }; @@ -75391,7 +75391,7 @@ self: { unordered-containers ]; description = "Amazon Well-Architected Tool SDK"; - license = lib.licensesSpdx."MPL-2.0"; + license = lib.meta.getLicenseFromSpdxId "MPL-2.0"; } ) { }; @@ -75432,7 +75432,7 @@ self: { unordered-containers ]; description = "Amazon Connect Wisdom Service SDK"; - license = lib.licensesSpdx."MPL-2.0"; + license = lib.meta.getLicenseFromSpdxId "MPL-2.0"; } ) { }; @@ -75473,7 +75473,7 @@ self: { unordered-containers ]; description = "Amazon WorkDocs SDK"; - license = lib.licensesSpdx."MPL-2.0"; + license = lib.meta.getLicenseFromSpdxId "MPL-2.0"; } ) { }; @@ -75514,7 +75514,7 @@ self: { unordered-containers ]; description = "Amazon WorkLink SDK"; - license = lib.licensesSpdx."MPL-2.0"; + license = lib.meta.getLicenseFromSpdxId "MPL-2.0"; } ) { }; @@ -75555,7 +75555,7 @@ self: { unordered-containers ]; description = "Amazon WorkMail SDK"; - license = lib.licensesSpdx."MPL-2.0"; + license = lib.meta.getLicenseFromSpdxId "MPL-2.0"; } ) { }; @@ -75596,7 +75596,7 @@ self: { unordered-containers ]; description = "Amazon WorkMail Message Flow SDK"; - license = lib.licensesSpdx."MPL-2.0"; + license = lib.meta.getLicenseFromSpdxId "MPL-2.0"; } ) { }; @@ -75637,7 +75637,7 @@ self: { unordered-containers ]; description = "Amazon WorkSpaces SDK"; - license = lib.licensesSpdx."MPL-2.0"; + license = lib.meta.getLicenseFromSpdxId "MPL-2.0"; } ) { }; @@ -75678,7 +75678,7 @@ self: { unordered-containers ]; description = "Amazon WorkSpaces Web SDK"; - license = lib.licensesSpdx."MPL-2.0"; + license = lib.meta.getLicenseFromSpdxId "MPL-2.0"; } ) { }; @@ -75719,7 +75719,7 @@ self: { unordered-containers ]; description = "Amazon X-Ray SDK"; - license = lib.licensesSpdx."MPL-2.0"; + license = lib.meta.getLicenseFromSpdxId "MPL-2.0"; } ) { }; @@ -77777,7 +77777,7 @@ self: { HUnit ]; description = "Yet another alternative Prelude for Haskell"; - license = lib.licensesSpdx."MIT"; + license = lib.meta.getLicenseFromSpdxId "MIT"; } ) { }; @@ -77984,7 +77984,7 @@ self: { text ]; description = "Fault injection for QuickCheck"; - license = lib.licensesSpdx."MIT"; + license = lib.meta.getLicenseFromSpdxId "MIT"; } ) { }; @@ -78013,7 +78013,7 @@ self: { time ]; description = "Simple job/task/event scheduler/cronjob"; - license = lib.licensesSpdx."ISC"; + license = lib.meta.getLicenseFromSpdxId "ISC"; } ) { }; @@ -78087,7 +78087,7 @@ self: { ]; testToolDepends = [ hspec-discover ]; description = "Please see the README on Github at "; - license = lib.licensesSpdx."MIT"; + license = lib.meta.getLicenseFromSpdxId "MIT"; hydraPlatforms = lib.platforms.none; broken = true; } @@ -78116,7 +78116,7 @@ self: { text ]; description = "Please see the README on Github at "; - license = lib.licensesSpdx."MIT"; + license = lib.meta.getLicenseFromSpdxId "MIT"; hydraPlatforms = lib.platforms.none; } ) { }; @@ -78191,7 +78191,7 @@ self: { ]; testToolDepends = [ hspec-discover ]; description = "Please see the README on Github at "; - license = lib.licensesSpdx."MIT"; + license = lib.meta.getLicenseFromSpdxId "MIT"; hydraPlatforms = lib.platforms.none; } ) { }; @@ -78243,7 +78243,7 @@ self: { ]; testToolDepends = [ hspec-discover ]; description = "Please see the README on Github at "; - license = lib.licensesSpdx."MIT"; + license = lib.meta.getLicenseFromSpdxId "MIT"; hydraPlatforms = lib.platforms.none; } ) { }; @@ -78288,7 +78288,7 @@ self: { ]; testToolDepends = [ hspec-discover ]; description = "Please see the README on Github at "; - license = lib.licensesSpdx."MIT"; + license = lib.meta.getLicenseFromSpdxId "MIT"; hydraPlatforms = lib.platforms.none; broken = true; } @@ -78353,7 +78353,7 @@ self: { ]; testToolDepends = [ hspec-discover ]; description = "Please see the README on Github at "; - license = lib.licensesSpdx."MIT"; + license = lib.meta.getLicenseFromSpdxId "MIT"; hydraPlatforms = lib.platforms.none; broken = true; } @@ -78398,7 +78398,7 @@ self: { ]; testToolDepends = [ hspec-discover ]; description = "Please see the README on Github at "; - license = lib.licensesSpdx."MIT"; + license = lib.meta.getLicenseFromSpdxId "MIT"; hydraPlatforms = lib.platforms.none; broken = true; } @@ -78491,7 +78491,7 @@ self: { ]; testToolDepends = [ hspec-discover ]; description = "Please see the README on Github at "; - license = lib.licensesSpdx."MIT"; + license = lib.meta.getLicenseFromSpdxId "MIT"; hydraPlatforms = lib.platforms.none; } ) { }; @@ -78581,7 +78581,7 @@ self: { ]; testToolDepends = [ hspec-discover ]; description = "Please see the README on Github at "; - license = lib.licensesSpdx."MIT"; + license = lib.meta.getLicenseFromSpdxId "MIT"; hydraPlatforms = lib.platforms.none; } ) { }; @@ -78640,7 +78640,7 @@ self: { ]; testToolDepends = [ hspec-discover ]; description = "Please see the README on Github at "; - license = lib.licensesSpdx."MIT"; + license = lib.meta.getLicenseFromSpdxId "MIT"; hydraPlatforms = lib.platforms.none; broken = true; } @@ -78718,7 +78718,7 @@ self: { ]; testToolDepends = [ hspec-discover ]; description = "Please see the README on Github at "; - license = lib.licensesSpdx."MIT"; + license = lib.meta.getLicenseFromSpdxId "MIT"; hydraPlatforms = lib.platforms.none; broken = true; } @@ -78754,7 +78754,7 @@ self: { ]; testToolDepends = [ hspec-discover ]; description = "Please see the README on Github at "; - license = lib.licensesSpdx."MIT"; + license = lib.meta.getLicenseFromSpdxId "MIT"; hydraPlatforms = lib.platforms.none; broken = true; } @@ -79033,7 +79033,7 @@ self: { unordered-containers ]; description = "Utility functions commonly used while solving Advent of Code puzzles"; - license = lib.licensesSpdx."BSD-3-Clause"; + license = lib.meta.getLicenseFromSpdxId "BSD-3-Clause"; } ) { }; @@ -79058,7 +79058,7 @@ self: { ghc-prim ]; description = "prelude for Algebra of Programming"; - license = lib.licensesSpdx."BSD-3-Clause"; + license = lib.meta.getLicenseFromSpdxId "BSD-3-Clause"; hydraPlatforms = lib.platforms.none; broken = true; } @@ -79390,7 +79390,7 @@ self: { vector ]; description = "Adaptation of the apecs library for the effectful ecosystem"; - license = lib.licensesSpdx."BSD-3-Clause"; + license = lib.meta.getLicenseFromSpdxId "BSD-3-Clause"; } ) { }; @@ -81458,7 +81458,7 @@ self: { sha256 = "0bkcwrxz313825vvm0yspj7vw2zmky8g2vq1yb9s8wgxzm4b7m8n"; libraryHaskellDepends = [ base ]; description = "A class for things that can be applied"; - license = lib.licensesSpdx."MIT"; + license = lib.meta.getLicenseFromSpdxId "MIT"; } ) { }; @@ -81523,7 +81523,7 @@ self: { sha256 = "0jr81m0mksfxbvzjs3c73kilr09w4gh7zv1amdx9xcvq5zb96imd"; libraryHaskellDepends = [ base ]; description = "Generalized logic operations for Applicative and Alternative functors"; - license = lib.licensesSpdx."BSD-3-Clause"; + license = lib.meta.getLicenseFromSpdxId "BSD-3-Clause"; } ) { }; @@ -81682,7 +81682,7 @@ self: { vector ]; description = "Lift a binary, non-decreasing function onto ordered lists and order the output"; - license = lib.licensesSpdx."BSD-3-Clause"; + license = lib.meta.getLicenseFromSpdxId "BSD-3-Clause"; } ) { }; @@ -81779,7 +81779,7 @@ self: { unix-compat ]; description = "Perform refactorings specified by the refact library"; - license = lib.licensesSpdx."BSD-3-Clause"; + license = lib.meta.getLicenseFromSpdxId "BSD-3-Clause"; mainProgram = "refactor"; } ) { }; @@ -82336,7 +82336,7 @@ self: { ]; testToolDepends = [ hspec-discover ]; description = "Datadog client for Haskell"; - license = lib.licensesSpdx."MIT"; + license = lib.meta.getLicenseFromSpdxId "MIT"; } ) { }; @@ -82370,7 +82370,7 @@ self: { ]; testToolDepends = [ hspec-discover ]; description = "LRU cache based on STM"; - license = lib.licensesSpdx."MIT"; + license = lib.meta.getLicenseFromSpdxId "MIT"; hydraPlatforms = lib.platforms.none; broken = true; } @@ -82421,7 +82421,7 @@ self: { ]; testToolDepends = [ hspec-discover ]; description = "Counter library for submitting metrics to a backend such as datadog"; - license = lib.licensesSpdx."MIT"; + license = lib.meta.getLicenseFromSpdxId "MIT"; hydraPlatforms = lib.platforms.none; broken = true; } @@ -82470,7 +82470,7 @@ self: { ]; testToolDepends = [ hspec-discover ]; description = "Simple logging library"; - license = lib.licensesSpdx."MIT"; + license = lib.meta.getLicenseFromSpdxId "MIT"; hydraPlatforms = lib.platforms.none; mainProgram = "arbor-monad-logger-example"; broken = true; @@ -82531,7 +82531,7 @@ self: { ]; testToolDepends = [ hspec-discover ]; description = "Core metric library for publishing metrics"; - license = lib.licensesSpdx."MIT"; + license = lib.meta.getLicenseFromSpdxId "MIT"; hydraPlatforms = lib.platforms.none; broken = true; } @@ -82603,7 +82603,7 @@ self: { ]; testToolDepends = [ hspec-discover ]; description = "Metric library backend for datadog"; - license = lib.licensesSpdx."MIT"; + license = lib.meta.getLicenseFromSpdxId "MIT"; hydraPlatforms = lib.platforms.none; } ) { }; @@ -82637,7 +82637,7 @@ self: { text ]; description = "Convenience types and functions for postgresql-simple"; - license = lib.licensesSpdx."MIT"; + license = lib.meta.getLicenseFromSpdxId "MIT"; hydraPlatforms = lib.platforms.none; broken = true; } @@ -82900,7 +82900,7 @@ self: { text ]; description = "Distribute hackage packages to archlinux"; - license = lib.licensesSpdx."MIT"; + license = lib.meta.getLicenseFromSpdxId "MIT"; hydraPlatforms = lib.platforms.none; broken = true; } @@ -82978,7 +82978,7 @@ self: { time ]; description = "Arch Linux official and AUR web interface binding"; - license = lib.licensesSpdx."MIT"; + license = lib.meta.getLicenseFromSpdxId "MIT"; maintainers = [ lib.maintainers.berberman ]; } ) { }; @@ -83545,7 +83545,7 @@ self: { transformers ]; description = "Parse and render JSON"; - license = lib.licensesSpdx."MIT"; + license = lib.meta.getLicenseFromSpdxId "MIT"; hydraPlatforms = lib.platforms.none; mainProgram = "argo"; broken = true; @@ -83946,7 +83946,7 @@ self: { unix ]; description = "Run docker-compose with help from Nix/NixOS"; - license = lib.licensesSpdx."Apache-2.0"; + license = lib.meta.getLicenseFromSpdxId "Apache-2.0"; mainProgram = "arion"; maintainers = [ lib.maintainers.roberth ]; } @@ -84482,7 +84482,7 @@ self: { tasty-hunit ]; description = "Builders for arrays"; - license = lib.licensesSpdx."BSD-3-Clause"; + license = lib.meta.getLicenseFromSpdxId "BSD-3-Clause"; } ) { }; @@ -84517,7 +84517,7 @@ self: { tasty-quickcheck ]; description = "Lists of chunks"; - license = lib.licensesSpdx."BSD-3-Clause"; + license = lib.meta.getLicenseFromSpdxId "BSD-3-Clause"; } ) { }; @@ -84747,7 +84747,7 @@ self: { ]; testToolDepends = [ hspec-discover ]; description = "Haskell bindings to the ArrayFire general-purpose GPU library"; - license = lib.licensesSpdx."BSD-3-Clause"; + license = lib.meta.getLicenseFromSpdxId "BSD-3-Clause"; hydraPlatforms = lib.platforms.none; broken = true; } @@ -84784,7 +84784,7 @@ self: { tasty-smallcheck ]; description = "Memory-efficient ArrayList implementation"; - license = lib.licensesSpdx."BSD-3-Clause"; + license = lib.meta.getLicenseFromSpdxId "BSD-3-Clause"; hydraPlatforms = lib.platforms.none; } ) { }; @@ -85035,7 +85035,7 @@ self: { text ]; description = "Basic types and instances for Valve's Artifact Card-set API"; - license = lib.licensesSpdx."AGPL-3.0-or-later"; + license = lib.meta.getLicenseFromSpdxId "AGPL-3.0-or-later"; hydraPlatforms = lib.platforms.none; broken = true; } @@ -85089,7 +85089,7 @@ self: { template-haskell ]; description = "Archive execution tool"; - license = lib.licensesSpdx."BSD-3-Clause"; + license = lib.meta.getLicenseFromSpdxId "BSD-3-Clause"; mainProgram = "arx"; } ) { }; @@ -85152,7 +85152,7 @@ self: { text ]; description = "Tiny client for the arXiv Atom API with a simple query DSL"; - license = lib.licensesSpdx."BSD-3-Clause"; + license = lib.meta.getLicenseFromSpdxId "BSD-3-Clause"; hydraPlatforms = lib.platforms.none; broken = true; } @@ -85193,7 +85193,7 @@ self: { time ]; description = "Command line tool to search and download papers from arXiv.org"; - license = lib.licensesSpdx."BSD-3-Clause"; + license = lib.meta.getLicenseFromSpdxId "BSD-3-Clause"; hydraPlatforms = lib.platforms.none; mainProgram = "arxiv-client-cli"; } @@ -85359,7 +85359,7 @@ self: { text ]; description = "The ASCII character set and encoding"; - license = lib.licensesSpdx."Apache-2.0"; + license = lib.meta.getLicenseFromSpdxId "Apache-2.0"; hydraPlatforms = lib.platforms.none; } ) { }; @@ -85419,7 +85419,7 @@ self: { hspec ]; description = "ASCII letter case"; - license = lib.licensesSpdx."Apache-2.0"; + license = lib.meta.getLicenseFromSpdxId "Apache-2.0"; } ) { }; @@ -85449,7 +85449,7 @@ self: { hspec ]; description = "ASCII character without an upper/lower case distinction"; - license = lib.licensesSpdx."Apache-2.0"; + license = lib.meta.getLicenseFromSpdxId "Apache-2.0"; hydraPlatforms = lib.platforms.none; broken = true; } @@ -85477,7 +85477,7 @@ self: { hspec ]; description = "A Char type representing an ASCII character"; - license = lib.licensesSpdx."Apache-2.0"; + license = lib.meta.getLicenseFromSpdxId "Apache-2.0"; } ) { }; @@ -85553,7 +85553,7 @@ self: { hspec ]; description = "ASCII character groups"; - license = lib.licensesSpdx."Apache-2.0"; + license = lib.meta.getLicenseFromSpdxId "Apache-2.0"; hydraPlatforms = lib.platforms.none; broken = true; } @@ -85625,7 +85625,7 @@ self: { text ]; description = "ASCII representations of numbers"; - license = lib.licensesSpdx."Apache-2.0"; + license = lib.meta.getLicenseFromSpdxId "Apache-2.0"; hydraPlatforms = lib.platforms.none; } ) { }; @@ -85651,7 +85651,7 @@ self: { hedgehog ]; description = "Various categorizations of ASCII characters"; - license = lib.licensesSpdx."Apache-2.0"; + license = lib.meta.getLicenseFromSpdxId "Apache-2.0"; } ) { }; @@ -85777,7 +85777,7 @@ self: { text ]; description = "Representing ASCII with refined supersets"; - license = lib.licensesSpdx."Apache-2.0"; + license = lib.meta.getLicenseFromSpdxId "Apache-2.0"; hydraPlatforms = lib.platforms.none; } ) { }; @@ -85852,7 +85852,7 @@ self: { text ]; description = "Template Haskell support for ASCII"; - license = lib.licensesSpdx."Apache-2.0"; + license = lib.meta.getLicenseFromSpdxId "Apache-2.0"; hydraPlatforms = lib.platforms.none; } ) { }; @@ -86144,7 +86144,7 @@ self: { text ]; description = "AsciiDoc parser"; - license = lib.licensesSpdx."BSD-3-Clause"; + license = lib.meta.getLicenseFromSpdxId "BSD-3-Clause"; mainProgram = "hasciidoc"; } ) { }; @@ -86314,7 +86314,7 @@ self: { hspec-discover ]; description = "Library for creating and querying segmented feeds"; - license = lib.licensesSpdx."MIT"; + license = lib.meta.getLicenseFromSpdxId "MIT"; hydraPlatforms = lib.platforms.none; mainProgram = "asif"; broken = true; @@ -86453,7 +86453,7 @@ self: { text-short ]; description = "ASN.1 BER Encode and Decode"; - license = lib.licensesSpdx."BSD-3-Clause"; + license = lib.meta.getLicenseFromSpdxId "BSD-3-Clause"; hydraPlatforms = lib.platforms.none; broken = true; } @@ -87018,7 +87018,7 @@ self: { weigh ]; description = "A solution to the assignment problem"; - license = lib.licensesSpdx."BSD-3-Clause"; + license = lib.meta.getLicenseFromSpdxId "BSD-3-Clause"; } ) { }; @@ -87058,7 +87058,7 @@ self: { editedCabalFile = "1r0as5s5a0xv2pcpxj1a1snxc3kdq1crh6hfy7y5n9d5xm010svn"; libraryHaskellDepends = [ base ]; description = "swap and assoc: Symmetric and Semigroupy Bifunctors"; - license = lib.licensesSpdx."BSD-3-Clause"; + license = lib.meta.getLicenseFromSpdxId "BSD-3-Clause"; } ) { }; @@ -87085,7 +87085,7 @@ self: { hedgehog ]; description = "Association lists (lists of tuples)"; - license = lib.licensesSpdx."MIT"; + license = lib.meta.getLicenseFromSpdxId "MIT"; hydraPlatforms = lib.platforms.none; broken = true; } @@ -87117,7 +87117,7 @@ self: { ListLike ]; description = "Association lists (list-like collections of tuples)"; - license = lib.licensesSpdx."MIT"; + license = lib.meta.getLicenseFromSpdxId "MIT"; hydraPlatforms = lib.platforms.none; broken = true; } @@ -87161,7 +87161,7 @@ self: { ]; testToolDepends = [ doctest ]; description = "Partial Semigroup and Semigroup operations"; - license = lib.licensesSpdx."BSD-3-Clause"; + license = lib.meta.getLicenseFromSpdxId "BSD-3-Clause"; } ) { }; @@ -88504,7 +88504,7 @@ self: { xml-types ]; description = "Streaming parser/renderer for the Atom 1.0 standard (RFC 4287)."; - license = lib.licensesSpdx."CC0-1.0"; + license = lib.meta.getLicenseFromSpdxId "CC0-1.0"; } ) { }; @@ -88565,7 +88565,7 @@ self: { tasty-quickcheck ]; description = "Mutable counters that can be modified with atomic operatinos"; - license = lib.licensesSpdx."Apache-2.0"; + license = lib.meta.getLicenseFromSpdxId "Apache-2.0"; } ) { }; @@ -88611,7 +88611,7 @@ self: { text ]; description = "Type-safe, composable CSS utility functions. Inspired by Tailwindcss and Elm-UI"; - license = lib.licensesSpdx."BSD-3-Clause"; + license = lib.meta.getLicenseFromSpdxId "BSD-3-Clause"; hydraPlatforms = lib.platforms.none; broken = true; } @@ -88679,7 +88679,7 @@ self: { ]; testHaskellDepends = [ base ]; description = "Generalizations of atomicModifyIORef"; - license = lib.licensesSpdx."BSD-2-Clause"; + license = lib.meta.getLicenseFromSpdxId "BSD-2-Clause"; hydraPlatforms = lib.platforms.none; broken = true; } @@ -88702,7 +88702,7 @@ self: { primitive ]; description = "A safe approach to CAS and other atomic ops in Haskell"; - license = lib.licensesSpdx."BSD-3-Clause"; + license = lib.meta.getLicenseFromSpdxId "BSD-3-Clause"; } ) { }; @@ -88918,7 +88918,7 @@ self: { text ]; description = "Interface to automated theorem provers"; - license = lib.licensesSpdx."GPL-3.0-only"; + license = lib.meta.getLicenseFromSpdxId "GPL-3.0-only"; hydraPlatforms = lib.platforms.none; } ) { }; @@ -89027,7 +89027,7 @@ self: { tasty-bench ]; description = "Faster integer division and modulus operations"; - license = lib.licensesSpdx."MIT"; + license = lib.meta.getLicenseFromSpdxId "MIT"; } ) { }; @@ -89710,7 +89710,7 @@ self: { vector ]; description = "Parsing of aeson's Value with attoparsec"; - license = lib.licensesSpdx."BSD-3-Clause"; + license = lib.meta.getLicenseFromSpdxId "BSD-3-Clause"; } ) { }; @@ -89851,7 +89851,7 @@ self: { uuid ]; description = "Parsers for the standard Haskell data types"; - license = lib.licensesSpdx."MIT"; + license = lib.meta.getLicenseFromSpdxId "MIT"; } ) { }; @@ -89951,7 +89951,7 @@ self: { text ]; description = "Use Attoparsec to parse framed protocol byte streams"; - license = lib.licensesSpdx."BSD-3-Clause"; + license = lib.meta.getLicenseFromSpdxId "BSD-3-Clause"; } ) { }; @@ -90119,7 +90119,7 @@ self: { ]; doHaddock = false; description = "right-to-left parser backward compatible with attoparsec"; - license = lib.licensesSpdx."BSD-3-Clause"; + license = lib.meta.getLicenseFromSpdxId "BSD-3-Clause"; hydraPlatforms = lib.platforms.none; } ) { }; @@ -90249,7 +90249,7 @@ self: { text ]; description = "Conveniently run Attoparsec parsers"; - license = lib.licensesSpdx."Apache-2.0"; + license = lib.meta.getLicenseFromSpdxId "Apache-2.0"; hydraPlatforms = lib.platforms.none; broken = true; } @@ -90327,7 +90327,7 @@ self: { time ]; description = "Attoparsec parsers of time"; - license = lib.licensesSpdx."MIT"; + license = lib.meta.getLicenseFromSpdxId "MIT"; } ) { }; @@ -90705,7 +90705,7 @@ self: { tasty-hunit ]; description = "Access metadata from the Arch Linux User Repository"; - license = lib.licensesSpdx."GPL-3.0-only"; + license = lib.meta.getLicenseFromSpdxId "GPL-3.0-only"; hydraPlatforms = lib.platforms.none; broken = true; } @@ -90842,7 +90842,7 @@ self: { versions ]; description = "A secure package manager for Arch Linux and the AUR"; - license = lib.licensesSpdx."GPL-3.0-only"; + license = lib.meta.getLicenseFromSpdxId "GPL-3.0-only"; hydraPlatforms = lib.platforms.none; mainProgram = "aura"; } @@ -91137,7 +91137,7 @@ self: { tasty-hunit ]; description = "Automatically add things to module export list"; - license = lib.licensesSpdx."BSD-3-Clause"; + license = lib.meta.getLicenseFromSpdxId "BSD-3-Clause"; hydraPlatforms = lib.platforms.none; broken = true; } @@ -91182,7 +91182,7 @@ self: { tasty-hunit ]; description = "Extract code segment to top level function"; - license = lib.licensesSpdx."BSD-3-Clause"; + license = lib.meta.getLicenseFromSpdxId "BSD-3-Clause"; hydraPlatforms = lib.platforms.none; broken = true; } @@ -91231,7 +91231,7 @@ self: { tasty-hunit ]; description = "Automatically add import statements"; - license = lib.licensesSpdx."BSD-3-Clause"; + license = lib.meta.getLicenseFromSpdxId "BSD-3-Clause"; hydraPlatforms = lib.platforms.none; broken = true; } @@ -91291,7 +91291,7 @@ self: { tasty-hunit ]; description = "Case splitting plugin"; - license = lib.licensesSpdx."BSD-3-Clause"; + license = lib.meta.getLicenseFromSpdxId "BSD-3-Clause"; hydraPlatforms = lib.platforms.none; broken = true; } @@ -91689,7 +91689,7 @@ self: { ]; executableHaskellDepends = [ base ]; description = "Automatically re-export modules"; - license = lib.licensesSpdx."MIT"; + license = lib.meta.getLicenseFromSpdxId "MIT"; mainProgram = "autoexporter"; } ) { }; @@ -91781,7 +91781,7 @@ self: { tasty-quickcheck ]; description = "automata"; - license = lib.licensesSpdx."BSD-3-Clause"; + license = lib.meta.getLicenseFromSpdxId "BSD-3-Clause"; hydraPlatforms = lib.platforms.none; broken = true; } @@ -91852,7 +91852,7 @@ self: { transformers ]; description = "Effectful streams and automata in coalgebraic encoding"; - license = lib.licensesSpdx."MIT"; + license = lib.meta.getLicenseFromSpdxId "MIT"; } ) { }; @@ -91929,7 +91929,7 @@ self: { witherable ]; description = "Effectful streams and automata in coalgebraic encoding"; - license = lib.licensesSpdx."MIT"; + license = lib.meta.getLicenseFromSpdxId "MIT"; hydraPlatforms = lib.platforms.none; } ) { }; @@ -92127,7 +92127,7 @@ self: { filepath ]; description = "Custom Setup to automate package modules discovery"; - license = lib.licensesSpdx."MPL-2.0"; + license = lib.meta.getLicenseFromSpdxId "MPL-2.0"; hydraPlatforms = lib.platforms.none; broken = true; } @@ -92858,7 +92858,7 @@ self: { vector ]; description = "Avro serialization support for Haskell"; - license = lib.licensesSpdx."BSD-3-Clause"; + license = lib.meta.getLicenseFromSpdxId "BSD-3-Clause"; hydraPlatforms = lib.platforms.none; broken = true; } @@ -92945,7 +92945,7 @@ self: { unordered-containers ]; description = "Tool for decoding avro"; - license = lib.licensesSpdx."BSD-3-Clause"; + license = lib.meta.getLicenseFromSpdxId "BSD-3-Clause"; hydraPlatforms = lib.platforms.none; mainProgram = "avro-decode"; broken = true; @@ -93378,7 +93378,7 @@ self: { vector ]; description = "Export grades from AWS Academy to different formats"; - license = lib.licensesSpdx."MIT"; + license = lib.meta.getLicenseFromSpdxId "MIT"; hydraPlatforms = lib.platforms.none; mainProgram = "aws-academy-grade-exporter"; broken = true; @@ -93423,7 +93423,7 @@ self: { ]; testToolDepends = [ tasty-discover ]; description = "Types and optics for manipulating Amazon Resource Names (ARNs)"; - license = lib.licensesSpdx."BSD-3-Clause"; + license = lib.meta.getLicenseFromSpdxId "BSD-3-Clause"; } ) { }; @@ -93480,7 +93480,7 @@ self: { neat-interpolation ]; description = "Generate signed cookies for AWS CloudFront"; - license = lib.licensesSpdx."MIT"; + license = lib.meta.getLicenseFromSpdxId "MIT"; hydraPlatforms = lib.platforms.none; mainProgram = "aws-cloudfront-signed-cookies"; broken = true; @@ -93957,7 +93957,7 @@ self: { tz ]; description = "AWS EventBridge cron, rate, and one-time parser with scheduler"; - license = lib.licensesSpdx."BSD-3-Clause"; + license = lib.meta.getLicenseFromSpdxId "BSD-3-Clause"; hydraPlatforms = lib.platforms.none; broken = true; } @@ -94517,7 +94517,7 @@ self: { text ]; description = "Haskell on AWS Lambda Runtime API"; - license = lib.licensesSpdx."Apache-2.0"; + license = lib.meta.getLicenseFromSpdxId "Apache-2.0"; hydraPlatforms = lib.platforms.none; mainProgram = "example-lambda"; broken = true; @@ -94959,7 +94959,7 @@ self: { validation ]; description = "Fetch data from AWS Secrets Manager"; - license = lib.licensesSpdx."MIT"; + license = lib.meta.getLicenseFromSpdxId "MIT"; hydraPlatforms = lib.platforms.none; broken = true; } @@ -95301,7 +95301,7 @@ self: { text ]; description = "Extract recent daily AWS costs"; - license = lib.licensesSpdx."GPL-2.0-only"; + license = lib.meta.getLicenseFromSpdxId "GPL-2.0-only"; mainProgram = "aws-spend-summary"; maintainers = [ lib.maintainers.danielrolls ]; } @@ -95559,7 +95559,7 @@ self: { text ]; description = "Extract recent daily AWS costs"; - license = lib.licensesSpdx."GPL-2.0-only"; + license = lib.meta.getLicenseFromSpdxId "GPL-2.0-only"; hydraPlatforms = lib.platforms.none; mainProgram = "awsspendsummary"; broken = true; @@ -95886,7 +95886,7 @@ self: { urbit-hob ]; description = "Interact with Azimuth from Haskell"; - license = lib.licensesSpdx."MPL-2.0"; + license = lib.meta.getLicenseFromSpdxId "MPL-2.0"; hydraPlatforms = lib.platforms.none; } ) { }; @@ -95928,7 +95928,7 @@ self: { vector ]; description = "A modular game engine and Entity-Component-System (ECS) for Haskell"; - license = lib.licensesSpdx."BSD-3-Clause"; + license = lib.meta.getLicenseFromSpdxId "BSD-3-Clause"; } ) { }; @@ -95953,7 +95953,7 @@ self: { mtl ]; description = "A type-safe and friendly Entity-Component-System (ECS) for Haskell"; - license = lib.licensesSpdx."BSD-3-Clause"; + license = lib.meta.getLicenseFromSpdxId "BSD-3-Clause"; hydraPlatforms = lib.platforms.none; broken = true; } @@ -95991,7 +95991,7 @@ self: { ]; testHaskellDepends = [ base ]; description = "OpenGL rendering for Aztecs"; - license = lib.licensesSpdx."BSD-3-Clause"; + license = lib.meta.getLicenseFromSpdxId "BSD-3-Clause"; } ) { }; @@ -96023,7 +96023,7 @@ self: { ]; testHaskellDepends = [ base ]; description = "OpenGL text rendering for Aztecs"; - license = lib.licensesSpdx."BSD-3-Clause"; + license = lib.meta.getLicenseFromSpdxId "BSD-3-Clause"; } ) { }; @@ -96053,7 +96053,7 @@ self: { ]; testHaskellDepends = [ base ]; description = "GLFW backed for Aztecs"; - license = lib.licensesSpdx."BSD-3-Clause"; + license = lib.meta.getLicenseFromSpdxId "BSD-3-Clause"; mainProgram = "aztecs-glfw"; } ) { }; @@ -96088,7 +96088,7 @@ self: { QuickCheck ]; description = "A type-safe and friendly Entity-Component-System (ECS) for Haskell"; - license = lib.licensesSpdx."BSD-3-Clause"; + license = lib.meta.getLicenseFromSpdxId "BSD-3-Clause"; hydraPlatforms = lib.platforms.none; broken = true; } @@ -96121,7 +96121,7 @@ self: { text ]; description = "A type-safe and friendly Entity-Component-System (ECS) for Haskell"; - license = lib.licensesSpdx."BSD-3-Clause"; + license = lib.meta.getLicenseFromSpdxId "BSD-3-Clause"; hydraPlatforms = lib.platforms.none; broken = true; } @@ -96158,7 +96158,7 @@ self: { text ]; description = "A type-safe and friendly Entity-Component-System (ECS) for Haskell"; - license = lib.licensesSpdx."BSD-3-Clause"; + license = lib.meta.getLicenseFromSpdxId "BSD-3-Clause"; hydraPlatforms = lib.platforms.none; } ) { }; @@ -96194,7 +96194,7 @@ self: { text ]; description = "A type-safe and friendly Entity-Component-System (ECS) for Haskell"; - license = lib.licensesSpdx."BSD-3-Clause"; + license = lib.meta.getLicenseFromSpdxId "BSD-3-Clause"; hydraPlatforms = lib.platforms.none; } ) { }; @@ -96218,7 +96218,7 @@ self: { linear ]; description = "Transform components for Aztecs"; - license = lib.licensesSpdx."BSD-3-Clause"; + license = lib.meta.getLicenseFromSpdxId "BSD-3-Clause"; } ) { }; @@ -96342,7 +96342,7 @@ self: { wreq ]; description = "send email with microsoft azure"; - license = lib.licensesSpdx."BSD-3-Clause"; + license = lib.meta.getLicenseFromSpdxId "BSD-3-Clause"; hydraPlatforms = lib.platforms.none; broken = true; } @@ -96417,7 +96417,7 @@ self: { libraryToolDepends = [ proto-lens-protoc ]; testHaskellDepends = [ base ]; description = "Azure Functions Worker"; - license = lib.licensesSpdx."MIT"; + license = lib.meta.getLicenseFromSpdxId "MIT"; hydraPlatforms = lib.platforms.none; } ) { }; @@ -96811,7 +96811,7 @@ self: { yaml ]; description = "A tool and library for building virtual machine images"; - license = lib.licensesSpdx."MIT"; + license = lib.meta.getLicenseFromSpdxId "MIT"; hydraPlatforms = lib.platforms.none; mainProgram = "b9c"; } @@ -96895,7 +96895,7 @@ self: { tasty-hunit ]; description = "Library for generating parsers from ABNF"; - license = lib.licensesSpdx."MIT"; + license = lib.meta.getLicenseFromSpdxId "MIT"; hydraPlatforms = lib.platforms.none; broken = true; } @@ -97129,7 +97129,7 @@ self: { unix ]; description = "Backstop a target directory by source directories"; - license = lib.licensesSpdx."GPL-3.0-only"; + license = lib.meta.getLicenseFromSpdxId "GPL-3.0-only"; hydraPlatforms = lib.platforms.none; mainProgram = "backstop"; broken = true; @@ -97411,7 +97411,7 @@ self: { testToolDepends = [ hspec-discover ]; doHaddock = false; description = "Text layout engine built on top of HarfBuzz"; - license = lib.licensesSpdx."GPL-3.0-only"; + license = lib.meta.getLicenseFromSpdxId "GPL-3.0-only"; hydraPlatforms = lib.platforms.none; } ) { }; @@ -97888,7 +97888,7 @@ self: { time ]; description = "German bank holidays and public holidays"; - license = lib.licensesSpdx."MIT"; + license = lib.meta.getLicenseFromSpdxId "MIT"; } ) { }; @@ -98058,7 +98058,7 @@ self: { hspec-discover ]; description = "Barbies with layered clothes"; - license = lib.licensesSpdx."Apache-2.0"; + license = lib.meta.getLicenseFromSpdxId "Apache-2.0"; } ) { }; @@ -98087,7 +98087,7 @@ self: { base ]; description = "Create strippable HKD via TH"; - license = lib.licensesSpdx."BSD-3-Clause"; + license = lib.meta.getLicenseFromSpdxId "BSD-3-Clause"; hydraPlatforms = lib.platforms.none; broken = true; } @@ -98415,7 +98415,7 @@ self: { ghc-prim ]; description = "Core data structures and operations"; - license = lib.licensesSpdx."BSD-3-Clause"; + license = lib.meta.getLicenseFromSpdxId "BSD-3-Clause"; hydraPlatforms = lib.platforms.none; } ) { }; @@ -98534,7 +98534,7 @@ self: { editedCabalFile = "03x7hrd4xv9xa0v72srn19v402nwws93n7jgakliabfshacd4pp3"; libraryHaskellDepends = [ base ]; description = "Backport of 'Foreign.C.ConstPtr'"; - license = lib.licensesSpdx."AGPL-3.0-only"; + license = lib.meta.getLicenseFromSpdxId "AGPL-3.0-only"; } ) { }; @@ -98587,7 +98587,7 @@ self: { text ]; description = "RFC4648 Binary-to-text encodings (e.g. base64)"; - license = lib.licensesSpdx."BSD-3-Clause"; + license = lib.meta.getLicenseFromSpdxId "BSD-3-Clause"; hydraPlatforms = lib.platforms.none; broken = true; } @@ -98645,7 +98645,7 @@ self: { libraryHaskellDepends = [ base ]; doHaddock = false; description = "\"base\" package sans \"Prelude\" module"; - license = lib.licensesSpdx."BSD-3-Clause"; + license = lib.meta.getLicenseFromSpdxId "BSD-3-Clause"; } ) { }; @@ -98681,7 +98681,7 @@ self: { sha256 = "1lqxa8lhnhiyxkqcwq82a8g2sizhagy3l0z7x57xrmn9y81sy241"; libraryHaskellDepends = [ base ]; description = "Featureful preludes formed solely from the \"base\" package"; - license = lib.licensesSpdx."MIT"; + license = lib.meta.getLicenseFromSpdxId "MIT"; } ) { }; @@ -98750,7 +98750,7 @@ self: { text ]; description = "Fast RFC 4648-compliant Base16 encoding"; - license = lib.licensesSpdx."BSD-3-Clause"; + license = lib.meta.getLicenseFromSpdxId "BSD-3-Clause"; } ) { }; @@ -98877,7 +98877,7 @@ self: { text ]; description = "Fast RFC 4648-compliant Base32 encoding"; - license = lib.licensesSpdx."BSD-3-Clause"; + license = lib.meta.getLicenseFromSpdxId "BSD-3-Clause"; } ) { }; @@ -99182,7 +99182,7 @@ self: { wide-word ]; description = "Base62 encoding and decoding"; - license = lib.licensesSpdx."BSD-3-Clause"; + license = lib.meta.getLicenseFromSpdxId "BSD-3-Clause"; hydraPlatforms = lib.platforms.none; broken = true; } @@ -99294,7 +99294,7 @@ self: { random ]; description = "Base64 encoding of byte sequences"; - license = lib.licensesSpdx."BSD-3-Clause"; + license = lib.meta.getLicenseFromSpdxId "BSD-3-Clause"; } ) { }; @@ -99523,7 +99523,7 @@ self: { sha256 = "1s4nacp3ripdn895c863hmnpaqmbkiisjp3y45v1q28qdjy052qv"; libraryHaskellDepends = [ base ]; description = "alternative prelude"; - license = lib.licensesSpdx."MIT"; + license = lib.meta.getLicenseFromSpdxId "MIT"; hydraPlatforms = lib.platforms.none; broken = true; } @@ -99540,7 +99540,7 @@ self: { libraryHaskellDepends = [ ghc-internal ]; executableHaskellDepends = [ ghc-internal ]; description = "baseless claims"; - license = lib.licensesSpdx."MIT"; + license = lib.meta.getLicenseFromSpdxId "MIT"; mainProgram = "exe"; } ) { }; @@ -99726,7 +99726,7 @@ self: { text ]; description = "Implements encoders/decoders for basesystems"; - license = lib.licensesSpdx."BSD-3-Clause"; + license = lib.meta.getLicenseFromSpdxId "BSD-3-Clause"; hydraPlatforms = lib.platforms.none; broken = true; } @@ -99839,7 +99839,7 @@ self: { sha256 = "0dgckarxy6lyaq2m02yisv41k7q0k40xph7v039rxx71bgih196d"; libraryHaskellDepends = [ base ]; description = "Basic implementation of General Problem Solver algorithm"; - license = lib.licensesSpdx."MIT"; + license = lib.meta.getLicenseFromSpdxId "MIT"; hydraPlatforms = lib.platforms.none; broken = true; } @@ -99962,7 +99962,7 @@ self: { transformers ]; description = "Modules for primitive types"; - license = lib.licensesSpdx."BSD-3-Clause"; + license = lib.meta.getLicenseFromSpdxId "BSD-3-Clause"; hydraPlatforms = lib.platforms.none; broken = true; } @@ -100815,7 +100815,7 @@ self: { transformers ]; description = "Library for parsing, constructing, and printing BBCode"; - license = lib.licensesSpdx."GPL-3.0-or-later"; + license = lib.meta.getLicenseFromSpdxId "GPL-3.0-or-later"; hydraPlatforms = lib.platforms.none; broken = true; } @@ -101692,7 +101692,7 @@ self: { time ]; description = "DuckDB backend for Beam"; - license = lib.licensesSpdx."MIT"; + license = lib.meta.getLicenseFromSpdxId "MIT"; hydraPlatforms = lib.platforms.none; } ) { }; @@ -101741,7 +101741,7 @@ self: { time ]; description = "Integration of large-records with beam-core"; - license = lib.licensesSpdx."BSD-3-Clause"; + license = lib.meta.getLicenseFromSpdxId "BSD-3-Clause"; } ) { }; @@ -102169,7 +102169,7 @@ self: { word8 ]; description = "Low-level Haskell bindings to the BearLibTerminal graphics library"; - license = lib.licensesSpdx."MIT"; + license = lib.meta.getLicenseFromSpdxId "MIT"; hydraPlatforms = lib.platforms.none; mainProgram = "omni"; broken = true; @@ -102294,7 +102294,7 @@ self: { ]; testToolDepends = [ hspec-discover ]; description = "Implementation of the Bech32 cryptocurrency address format (BIP 0173)"; - license = lib.licensesSpdx."Apache-2.0"; + license = lib.meta.getLicenseFromSpdxId "Apache-2.0"; hydraPlatforms = lib.platforms.none; mainProgram = "bech32"; broken = true; @@ -102329,7 +102329,7 @@ self: { ]; testToolDepends = [ hspec-discover ]; description = "Template Haskell extensions to the Bech32 library"; - license = lib.licensesSpdx."Apache-2.0"; + license = lib.meta.getLicenseFromSpdxId "Apache-2.0"; hydraPlatforms = lib.platforms.none; } ) { }; @@ -102677,7 +102677,7 @@ self: { vector ]; description = "Bencode encoding and decoding library"; - license = lib.licensesSpdx."MIT"; + license = lib.meta.getLicenseFromSpdxId "MIT"; } ) { }; @@ -102950,7 +102950,7 @@ self: { ]; testToolDepends = [ hspec-discover ]; description = "Bencodex reader/writer for Haskell"; - license = lib.licensesSpdx."GPL-3.0-or-later"; + license = lib.meta.getLicenseFromSpdxId "GPL-3.0-or-later"; hydraPlatforms = lib.platforms.none; broken = true; } @@ -103008,7 +103008,7 @@ self: { ghc-prim ]; description = "A library for encoding and decoding of BEncode data"; - license = lib.licensesSpdx."BSD-3-Clause"; + license = lib.meta.getLicenseFromSpdxId "BSD-3-Clause"; } ) { }; @@ -103149,7 +103149,7 @@ self: { hspec ]; description = "Simplify tests where Either or Maybe types are returned from monadic code"; - license = lib.licensesSpdx."BSD-3-Clause"; + license = lib.meta.getLicenseFromSpdxId "BSD-3-Clause"; } ) { }; @@ -103905,7 +103905,7 @@ self: { transformers ]; description = "Make instance constraints bidirectional"; - license = lib.licensesSpdx."MIT"; + license = lib.meta.getLicenseFromSpdxId "MIT"; hydraPlatforms = lib.platforms.none; broken = true; } @@ -104521,7 +104521,7 @@ self: { some ]; description = "Bin: binary natural numbers"; - license = lib.licensesSpdx."GPL-2.0-or-later"; + license = lib.meta.getLicenseFromSpdxId "GPL-2.0-or-later"; } ) { }; @@ -104660,7 +104660,7 @@ self: { zlib ]; description = "Binary serialisation for Haskell values using lazy ByteStrings"; - license = lib.licensesSpdx."BSD-3-Clause"; + license = lib.meta.getLicenseFromSpdxId "BSD-3-Clause"; hydraPlatforms = lib.platforms.none; } ) { }; @@ -105075,7 +105075,7 @@ self: { vector ]; description = "Orphan instances for binary"; - license = lib.licensesSpdx."BSD-3-Clause"; + license = lib.meta.getLicenseFromSpdxId "BSD-3-Clause"; } ) { }; @@ -105244,7 +105244,7 @@ self: { tasty-quickcheck ]; description = "An efficient but limited parser API specialised to bytestrings"; - license = lib.licensesSpdx."MIT"; + license = lib.meta.getLicenseFromSpdxId "MIT"; } ) { }; @@ -105664,7 +105664,7 @@ self: { unordered-containers ]; description = "Tagged binary serialisation"; - license = lib.licensesSpdx."BSD-3-Clause"; + license = lib.meta.getLicenseFromSpdxId "BSD-3-Clause"; hydraPlatforms = lib.platforms.none; } ) { }; @@ -105777,7 +105777,7 @@ self: { binary ]; description = "VarInt encoding/decoding via Data.Binary"; - license = lib.licensesSpdx."BSD-3-Clause"; + license = lib.meta.getLicenseFromSpdxId "BSD-3-Clause"; } ) { }; @@ -105803,7 +105803,7 @@ self: { testHaskellDepends = [ base ]; doHaddock = false; description = "Haskell bindings to binaryen"; - license = lib.licensesSpdx."BSD-3-Clause"; + license = lib.meta.getLicenseFromSpdxId "BSD-3-Clause"; } ) { }; @@ -105884,7 +105884,7 @@ self: { ]; testToolDepends = [ hspec-discover ]; description = "Variable binding for abstract syntax tree"; - license = lib.licensesSpdx."MIT"; + license = lib.meta.getLicenseFromSpdxId "MIT"; hydraPlatforms = lib.platforms.none; broken = true; } @@ -106754,7 +106754,7 @@ self: { bindings-DSL ]; description = "Low level bindings to libpci"; - license = lib.licensesSpdx."BSD-3-Clause"; + license = lib.meta.getLicenseFromSpdxId "BSD-3-Clause"; hydraPlatforms = lib.platforms.none; broken = true; } @@ -107046,7 +107046,7 @@ self: { ]; libraryPkgconfigDepends = [ portaudio ]; description = "Low-level bindings to portaudio library"; - license = lib.licensesSpdx."BSD-3-Clause"; + license = lib.meta.getLicenseFromSpdxId "BSD-3-Clause"; } ) { inherit (pkgs) portaudio; }; @@ -108224,7 +108224,7 @@ self: { tasty-hunit ]; description = "BIP-0032: Hierarchical Deterministic Wallets for Bitcoin and other cryptocurrencies"; - license = lib.licensesSpdx."Apache-2.0"; + license = lib.meta.getLicenseFromSpdxId "Apache-2.0"; hydraPlatforms = lib.platforms.none; } ) { }; @@ -108396,7 +108396,7 @@ self: { libraryHaskellDepends = [ base ]; testHaskellDepends = [ base ]; description = "Birds of Paradise"; - license = lib.licensesSpdx."BSD-3-Clause"; + license = lib.meta.getLicenseFromSpdxId "BSD-3-Clause"; hydraPlatforms = lib.platforms.none; broken = true; } @@ -108725,7 +108725,7 @@ self: { toolshed ]; description = "Plays chess"; - license = lib.licensesSpdx."GPL-3.0-or-later"; + license = lib.meta.getLicenseFromSpdxId "GPL-3.0-or-later"; hydraPlatforms = lib.platforms.none; } ) { }; @@ -108915,7 +108915,7 @@ self: { bytestring ]; description = "Bit array based on ByteString"; - license = lib.licensesSpdx."BSD-3-Clause"; + license = lib.meta.getLicenseFromSpdxId "BSD-3-Clause"; } ) { }; @@ -108964,7 +108964,7 @@ self: { tasty-hunit ]; description = "Bitcoin address generation and rendering. Parsing coming soon."; - license = lib.licensesSpdx."Apache-2.0"; + license = lib.meta.getLicenseFromSpdxId "Apache-2.0"; hydraPlatforms = lib.platforms.none; } ) { }; @@ -109173,7 +109173,7 @@ self: { text ]; description = "BIP 158 compact block filters"; - license = lib.licensesSpdx."BSD-3-Clause"; + license = lib.meta.getLicenseFromSpdxId "BSD-3-Clause"; hydraPlatforms = lib.platforms.none; broken = true; } @@ -109208,7 +109208,7 @@ self: { time ]; description = "Bitcoin hash primitives"; - license = lib.licensesSpdx."Apache-2.0"; + license = lib.meta.getLicenseFromSpdxId "Apache-2.0"; } ) { }; @@ -109316,7 +109316,7 @@ self: { tasty-hunit ]; description = "Bitcoin keys"; - license = lib.licensesSpdx."Apache-2.0"; + license = lib.meta.getLicenseFromSpdxId "Apache-2.0"; hydraPlatforms = lib.platforms.none; broken = true; } @@ -109606,7 +109606,7 @@ self: { unordered-containers ]; description = "Resources for working with miniscript, and script descriptors"; - license = lib.licensesSpdx."BSD-3-Clause"; + license = lib.meta.getLicenseFromSpdxId "BSD-3-Clause"; hydraPlatforms = lib.platforms.none; broken = true; } @@ -109758,7 +109758,7 @@ self: { text ]; description = "A library for working with bitcoin-core regtest networks"; - license = lib.licensesSpdx."BSD-3-Clause"; + license = lib.meta.getLicenseFromSpdxId "BSD-3-Clause"; hydraPlatforms = lib.platforms.none; mainProgram = "bitcoind-rpc-explorer"; } @@ -109807,7 +109807,7 @@ self: { transformers ]; description = "A streamlined interface to bitcoin core using Haskoin types and Servant"; - license = lib.licensesSpdx."BSD-3-Clause"; + license = lib.meta.getLicenseFromSpdxId "BSD-3-Clause"; hydraPlatforms = lib.platforms.none; broken = true; } @@ -109839,7 +109839,7 @@ self: { ]; testToolDepends = [ sydtest-discover ]; description = "Generic and easy to use haskell bitfields"; - license = lib.licensesSpdx."MIT"; + license = lib.meta.getLicenseFromSpdxId "MIT"; hydraPlatforms = lib.platforms.none; broken = true; } @@ -109974,7 +109974,7 @@ self: { QuickCheck ]; description = "Bitmasks for efficient storing of boolean flags"; - license = lib.licensesSpdx."BSD-3-Clause"; + license = lib.meta.getLicenseFromSpdxId "BSD-3-Clause"; } ) { }; @@ -110184,7 +110184,7 @@ self: { vector ]; description = "Useful bitwise operations"; - license = lib.licensesSpdx."BSD-3-Clause"; + license = lib.meta.getLicenseFromSpdxId "BSD-3-Clause"; hydraPlatforms = lib.platforms.none; } ) { }; @@ -110226,7 +110226,7 @@ self: { hspec ]; description = "Showing data as strings of 0 and 1"; - license = lib.licensesSpdx."Apache-2.0"; + license = lib.meta.getLicenseFromSpdxId "Apache-2.0"; hydraPlatforms = lib.platforms.none; broken = true; } @@ -110400,7 +110400,7 @@ self: { vector ]; description = "Fast, packed, strict and lazy bit streams with stream fusion"; - license = lib.licensesSpdx."CC0-1.0"; + license = lib.meta.getLicenseFromSpdxId "CC0-1.0"; } ) { }; @@ -110419,7 +110419,7 @@ self: { bytestring ]; description = "Lazy bit strings"; - license = lib.licensesSpdx."BSD-3-Clause"; + license = lib.meta.getLicenseFromSpdxId "BSD-3-Clause"; } ) { }; @@ -110834,7 +110834,7 @@ self: { validation ]; description = "A lousy Prelude replacement by a lousy dude"; - license = lib.licensesSpdx."BSD-3-Clause"; + license = lib.meta.getLicenseFromSpdxId "BSD-3-Clause"; } ) { }; @@ -110857,7 +110857,7 @@ self: { text ]; description = "A lousy Prelude replacement by a lousy dude"; - license = lib.licensesSpdx."BSD-3-Clause"; + license = lib.meta.getLicenseFromSpdxId "BSD-3-Clause"; hydraPlatforms = lib.platforms.none; broken = true; } @@ -111217,7 +111217,7 @@ self: { criterion ]; description = "A library providing BLAKE2"; - license = lib.licensesSpdx."Unlicense"; + license = lib.meta.getLicenseFromSpdxId "Unlicense"; } ) { }; @@ -111244,7 +111244,7 @@ self: { tasty-hunit ]; description = "BLAKE3 hashing algorithm"; - license = lib.licensesSpdx."Apache-2.0"; + license = lib.meta.getLicenseFromSpdxId "Apache-2.0"; platforms = lib.platforms.x86; } ) { }; @@ -111748,7 +111748,7 @@ self: { text ]; description = "blaze-html backend for colonnade"; - license = lib.licensesSpdx."BSD-3-Clause"; + license = lib.meta.getLicenseFromSpdxId "BSD-3-Clause"; hydraPlatforms = lib.platforms.none; } ) { }; @@ -112463,7 +112463,7 @@ self: { text ]; description = "An HTML generator for Haskell"; - license = lib.licensesSpdx."MIT"; + license = lib.meta.getLicenseFromSpdxId "MIT"; } ) { }; @@ -112602,7 +112602,7 @@ self: { ]; testToolDepends = [ tasty-discover ]; description = "API definitions for blockfrost.io"; - license = lib.licensesSpdx."Apache-2.0"; + license = lib.meta.getLicenseFromSpdxId "Apache-2.0"; } ) { }; @@ -112656,7 +112656,7 @@ self: { ]; testToolDepends = [ tasty-discover ]; description = "blockfrost.io basic client"; - license = lib.licensesSpdx."Apache-2.0"; + license = lib.meta.getLicenseFromSpdxId "Apache-2.0"; maintainers = [ lib.maintainers.sorki ]; } ) { }; @@ -112706,7 +112706,7 @@ self: { text ]; description = "blockfrost.io common client definitions / instances"; - license = lib.licensesSpdx."Apache-2.0"; + license = lib.meta.getLicenseFromSpdxId "Apache-2.0"; } ) { }; @@ -112739,7 +112739,7 @@ self: { time ]; description = "blockfrost.io pretty-printing utilities"; - license = lib.licensesSpdx."Apache-2.0"; + license = lib.meta.getLicenseFromSpdxId "Apache-2.0"; } ) { }; @@ -112858,7 +112858,7 @@ self: { ]; doHaddock = false; description = "Perform batches of disk I/O operations"; - license = lib.licensesSpdx."Apache-2.0"; + license = lib.meta.getLicenseFromSpdxId "Apache-2.0"; hydraPlatforms = lib.platforms.none; } ) { }; @@ -112912,7 +112912,7 @@ self: { ]; benchmarkPkgconfigDepends = [ liburing ]; description = "Perform batches of asynchronous disk IO operations"; - license = lib.licensesSpdx."BSD-3-Clause"; + license = lib.meta.getLicenseFromSpdxId "BSD-3-Clause"; hydraPlatforms = lib.platforms.none; broken = true; } @@ -113065,7 +113065,7 @@ self: { ]; testToolDepends = [ hspec-discover ]; description = "Elasticsearch client library for Haskell"; - license = lib.licensesSpdx."BSD-3-Clause"; + license = lib.meta.getLicenseFromSpdxId "BSD-3-Clause"; } ) { }; @@ -113160,7 +113160,7 @@ self: { ]; testToolDepends = [ hspec-discover ]; description = "Elasticsearch client library for Haskell"; - license = lib.licensesSpdx."BSD-3-Clause"; + license = lib.meta.getLicenseFromSpdxId "BSD-3-Clause"; hydraPlatforms = lib.platforms.none; } ) { }; @@ -113259,7 +113259,7 @@ self: { hedgehog ]; description = "visual bloom filter for neotrellis m4 output"; - license = lib.licensesSpdx."BSD-3-Clause"; + license = lib.meta.getLicenseFromSpdxId "BSD-3-Clause"; hydraPlatforms = lib.platforms.none; mainProgram = "bloohm"; broken = true; @@ -113297,7 +113297,7 @@ self: { test-framework-quickcheck2 ]; description = "Pure and impure Bloom Filter implementations"; - license = lib.licensesSpdx."BSD-3-Clause"; + license = lib.meta.getLicenseFromSpdxId "BSD-3-Clause"; } ) { }; @@ -113350,7 +113350,7 @@ self: { ]; doHaddock = false; description = "Fast, compact Bloom filters"; - license = lib.licensesSpdx."Apache-2.0"; + license = lib.meta.getLicenseFromSpdxId "Apache-2.0"; } ) { }; @@ -113728,7 +113728,7 @@ self: { sha256 = "17vlgidjmz7dyqllfwc9q6r2xvmjhj7w6wwyxrc2xpgpg7jbklm2"; libraryHaskellDepends = [ bluefin-internal ]; description = "The Bluefin effect system"; - license = lib.licensesSpdx."MIT"; + license = lib.meta.getLicenseFromSpdxId "MIT"; maintainers = [ lib.maintainers.maralorn ]; } ) { }; @@ -113741,7 +113741,7 @@ self: { sha256 = "0yvqp9mvwpqqqwfa8nzvcscai3ajm04l7frsh0pba43rnbvq1fng"; libraryHaskellDepends = [ bluefin-internal ]; description = "The Bluefin effect system"; - license = lib.licensesSpdx."MIT"; + license = lib.meta.getLicenseFromSpdxId "MIT"; hydraPlatforms = lib.platforms.none; maintainers = [ lib.maintainers.maralorn ]; } @@ -113780,7 +113780,7 @@ self: { tasty-bench ]; description = "Algebraic effects and named handlers in Bluefin"; - license = lib.licensesSpdx."MIT"; + license = lib.meta.getLicenseFromSpdxId "MIT"; } ) { }; @@ -113801,7 +113801,7 @@ self: { bluefin ]; description = "The Bluefin effect system, user contributions"; - license = lib.licensesSpdx."MIT"; + license = lib.meta.getLicenseFromSpdxId "MIT"; hydraPlatforms = lib.platforms.none; broken = true; } @@ -113831,7 +113831,7 @@ self: { ]; testHaskellDepends = [ base ]; description = "The Bluefin effect system, internals"; - license = lib.licensesSpdx."MIT"; + license = lib.meta.getLicenseFromSpdxId "MIT"; } ) { }; @@ -113861,7 +113861,7 @@ self: { ]; testHaskellDepends = [ base ]; description = "The Bluefin effect system, internals"; - license = lib.licensesSpdx."MIT"; + license = lib.meta.getLicenseFromSpdxId "MIT"; hydraPlatforms = lib.platforms.none; } ) { }; @@ -113895,7 +113895,7 @@ self: { text ]; description = "bluefin support for high-level PostgreSQL operations via Opaleye"; - license = lib.licensesSpdx."BSD-3-Clause"; + license = lib.meta.getLicenseFromSpdxId "BSD-3-Clause"; } ) { }; @@ -113918,7 +113918,7 @@ self: { unliftio-pool ]; description = "bluefin support for mid-level PostgreSQL operations"; - license = lib.licensesSpdx."BSD-3-Clause"; + license = lib.meta.getLicenseFromSpdxId "BSD-3-Clause"; } ) { }; @@ -113941,7 +113941,7 @@ self: { random ]; description = "The Bluefin effect system, random generators"; - license = lib.licensesSpdx."MIT"; + license = lib.meta.getLicenseFromSpdxId "MIT"; hydraPlatforms = lib.platforms.none; broken = true; } @@ -114015,7 +114015,7 @@ self: { text ]; description = "Tools for interacting with Bluesky / AT Protocol"; - license = lib.licensesSpdx."BSD-3-Clause"; + license = lib.meta.getLicenseFromSpdxId "BSD-3-Clause"; } ) { }; @@ -114630,7 +114630,7 @@ self: { ]; testToolDepends = [ tasty-discover ]; description = "Generate Haskell boilerplate"; - license = lib.licensesSpdx."GPL-3.0-or-later"; + license = lib.meta.getLicenseFromSpdxId "GPL-3.0-or-later"; hydraPlatforms = lib.platforms.none; mainProgram = "boilerplate"; broken = true; @@ -114686,7 +114686,7 @@ self: { vector ]; description = "Bolt driver for Neo4j"; - license = lib.licensesSpdx."BSD-3-Clause"; + license = lib.meta.getLicenseFromSpdxId "BSD-3-Clause"; hydraPlatforms = lib.platforms.none; broken = true; } @@ -116161,7 +116161,7 @@ self: { transformers ]; description = "Boring and Absurd types"; - license = lib.licensesSpdx."BSD-3-Clause"; + license = lib.meta.getLicenseFromSpdxId "BSD-3-Clause"; } ) { }; @@ -116271,7 +116271,7 @@ self: { wide-word ]; description = "Implementation of BORSH serialisation"; - license = lib.licensesSpdx."BSD-3-Clause"; + license = lib.meta.getLicenseFromSpdxId "BSD-3-Clause"; hydraPlatforms = lib.platforms.none; broken = true; } @@ -116313,7 +116313,7 @@ self: { libraryHaskellDepends = [ base ]; libraryPkgconfigDepends = [ botan ]; description = "Raw Botan bindings"; - license = lib.licensesSpdx."BSD-3-Clause"; + license = lib.meta.getLicenseFromSpdxId "BSD-3-Clause"; maintainers = [ lib.maintainers.mikatammi ]; } ) { botan = null; }; @@ -116361,7 +116361,7 @@ self: { text ]; description = "Low-level Botan bindings"; - license = lib.licensesSpdx."BSD-3-Clause"; + license = lib.meta.getLicenseFromSpdxId "BSD-3-Clause"; maintainers = [ lib.maintainers.mikatammi ]; } ) { }; @@ -116459,7 +116459,7 @@ self: { text ]; description = "Encoding and decoding for the Bottom spec"; - license = lib.licensesSpdx."Apache-2.0"; + license = lib.meta.getLicenseFromSpdxId "Apache-2.0"; hydraPlatforms = lib.platforms.none; mainProgram = "bottom"; broken = true; @@ -116564,7 +116564,7 @@ self: { utf8-string ]; description = "ScopeH and ScopeT extras for bound"; - license = lib.licensesSpdx."BSD-3-Clause"; + license = lib.meta.getLicenseFromSpdxId "BSD-3-Clause"; } ) { }; @@ -116677,7 +116677,7 @@ self: { tasty-hunit ]; description = "A strict, immutable, thread-safe, single-ended, bounded queue"; - license = lib.licensesSpdx."BSD-3-Clause"; + license = lib.meta.getLicenseFromSpdxId "BSD-3-Clause"; } ) { }; @@ -116879,7 +116879,7 @@ self: { time ]; description = "A profunctor effect system?"; - license = lib.licensesSpdx."BSD-3-Clause"; + license = lib.meta.getLicenseFromSpdxId "BSD-3-Clause"; } ) { }; @@ -116904,7 +116904,7 @@ self: { time ]; description = "CSV parsing in a box"; - license = lib.licensesSpdx."BSD-3-Clause"; + license = lib.meta.getLicenseFromSpdxId "BSD-3-Clause"; hydraPlatforms = lib.platforms.none; broken = true; } @@ -116944,7 +116944,7 @@ self: { optparse-applicative ]; description = "Box websockets"; - license = lib.licensesSpdx."BSD-3-Clause"; + license = lib.meta.getLicenseFromSpdxId "BSD-3-Clause"; mainProgram = "box-socket"; } ) { }; @@ -117040,7 +117040,7 @@ self: { ]; testHaskellDepends = [ base ]; description = "A minimal typed unix path library"; - license = lib.licensesSpdx."BSD-3-Clause"; + license = lib.meta.getLicenseFromSpdxId "BSD-3-Clause"; hydraPlatforms = lib.platforms.none; broken = true; } @@ -117420,7 +117420,7 @@ self: { tasty-hunit ]; description = "Set breakpoints using a GHC plugin"; - license = lib.licensesSpdx."MIT"; + license = lib.meta.getLicenseFromSpdxId "MIT"; } ) { }; @@ -117723,7 +117723,7 @@ self: { vty ]; description = "Calendar widget for the Brick TUI library"; - license = lib.licensesSpdx."MIT"; + license = lib.meta.getLicenseFromSpdxId "MIT"; hydraPlatforms = lib.platforms.none; broken = true; } @@ -117837,7 +117837,7 @@ self: { vector ]; description = "Search forward or backward for certain kinds of items in brick list"; - license = lib.licensesSpdx."0BSD"; + license = lib.meta.getLicenseFromSpdxId "0BSD"; hydraPlatforms = lib.platforms.none; broken = true; } @@ -117866,7 +117866,7 @@ self: { vector ]; description = "Skip a certain kind of items when moving in brick list"; - license = lib.licensesSpdx."0BSD"; + license = lib.meta.getLicenseFromSpdxId "0BSD"; } ) { }; @@ -117915,7 +117915,7 @@ self: { ]; testHaskellDepends = [ base ]; description = "Panes library for Brick providing composition and isolation for TUI apps"; - license = lib.licensesSpdx."ISC"; + license = lib.meta.getLicenseFromSpdxId "ISC"; mainProgram = "mywork-example"; } ) { }; @@ -117976,7 +117976,7 @@ self: { vty ]; description = "Tabular list widgets for brick"; - license = lib.licensesSpdx."0BSD"; + license = lib.meta.getLicenseFromSpdxId "0BSD"; } ) { }; @@ -118291,7 +118291,7 @@ self: { ]; libraryToolDepends = [ c2hs ]; description = "Painless 2D vector graphics, animations, and simulations powered by GLFW"; - license = lib.licensesSpdx."MIT"; + license = lib.meta.getLicenseFromSpdxId "MIT"; } ) { }; @@ -118310,7 +118310,7 @@ self: { brillo ]; description = "Data structures and algorithms for working with 2D graphics"; - license = lib.licensesSpdx."MIT"; + license = lib.meta.getLicenseFromSpdxId "MIT"; hydraPlatforms = lib.platforms.none; broken = true; } @@ -118361,7 +118361,7 @@ self: { vector ]; description = "Examples using the Brillo library"; - license = lib.licensesSpdx."MIT"; + license = lib.meta.getLicenseFromSpdxId "MIT"; hydraPlatforms = lib.platforms.none; } ) { }; @@ -118453,7 +118453,7 @@ self: { webp ]; description = "Load any image supported by Juicy.Pixels in your brillo application"; - license = lib.licensesSpdx."BSD-3-Clause"; + license = lib.meta.getLicenseFromSpdxId "BSD-3-Clause"; mainProgram = "brillo-juicy-viewer"; } ) { }; @@ -118485,7 +118485,7 @@ self: { text ]; description = "Brillo picture data types and rendering functions"; - license = lib.licensesSpdx."MIT"; + license = lib.meta.getLicenseFromSpdxId "MIT"; } ) { }; @@ -118624,7 +118624,7 @@ self: { yaml ]; description = "Haskell source code formatter"; - license = lib.licensesSpdx."AGPL-3.0-only"; + license = lib.meta.getLicenseFromSpdxId "AGPL-3.0-only"; hydraPlatforms = lib.platforms.none; mainProgram = "brittany"; broken = true; @@ -118697,7 +118697,7 @@ self: { ]; doHaddock = false; description = "Closable, fair, single-wakeup channel type that avoids 0 reader space leaks"; - license = lib.licensesSpdx."BSD-3-Clause"; + license = lib.meta.getLicenseFromSpdxId "BSD-3-Clause"; } ) { }; @@ -118710,7 +118710,7 @@ self: { libraryHaskellDepends = [ broadcast-chan ]; doHaddock = false; description = "Conduit-based parallel streaming code for broadcast-chan"; - license = lib.licensesSpdx."BSD-3-Clause"; + license = lib.meta.getLicenseFromSpdxId "BSD-3-Clause"; hydraPlatforms = lib.platforms.none; broken = true; } @@ -118725,7 +118725,7 @@ self: { libraryHaskellDepends = [ broadcast-chan ]; doHaddock = false; description = "Pipes-based parallel streaming code for broadcast-chan"; - license = lib.licensesSpdx."BSD-3-Clause"; + license = lib.meta.getLicenseFromSpdxId "BSD-3-Clause"; } ) { }; @@ -118783,7 +118783,7 @@ self: { random ]; description = "Helpers for generating tests for broadcast-chan"; - license = lib.licensesSpdx."BSD-3-Clause"; + license = lib.meta.getLicenseFromSpdxId "BSD-3-Clause"; hydraPlatforms = lib.platforms.none; broken = true; } @@ -119226,7 +119226,7 @@ self: { ]; doHaddock = false; description = "Toolkit for Bézier curves and brush stroking"; - license = lib.licensesSpdx."BSD-3-Clause"; + license = lib.meta.getLicenseFromSpdxId "BSD-3-Clause"; hydraPlatforms = lib.platforms.none; } ) { }; @@ -119290,7 +119290,7 @@ self: { unordered-containers ]; description = "Brush strokes document model and renderer"; - license = lib.licensesSpdx."BSD-3-Clause"; + license = lib.meta.getLicenseFromSpdxId "BSD-3-Clause"; hydraPlatforms = lib.platforms.none; } ) { }; @@ -120787,7 +120787,7 @@ self: { transformers ]; description = "Build Systems à la Carte"; - license = lib.licensesSpdx."MIT"; + license = lib.meta.getLicenseFromSpdxId "MIT"; hydraPlatforms = lib.platforms.none; broken = true; } @@ -120843,7 +120843,7 @@ self: { text ]; description = "Compute, fetch and install Cabal build plans into a local environment"; - license = lib.licensesSpdx."BSD-3-Clause"; + license = lib.meta.getLicenseFromSpdxId "BSD-3-Clause"; hydraPlatforms = lib.platforms.none; mainProgram = "build-env"; broken = true; @@ -120962,7 +120962,7 @@ self: { primitive-unaligned ]; description = "bounded ByteArray builder type"; - license = lib.licensesSpdx."BSD-3-Clause"; + license = lib.meta.getLicenseFromSpdxId "BSD-3-Clause"; hydraPlatforms = lib.platforms.none; broken = true; } @@ -121324,7 +121324,7 @@ self: { split ]; description = "Automatically bump package versions, also transitively"; - license = lib.licensesSpdx."BSD-3-Clause"; + license = lib.meta.getLicenseFromSpdxId "BSD-3-Clause"; mainProgram = "bumper"; } ) { }; @@ -121426,7 +121426,7 @@ self: { ]; testHaskellDepends = [ base ]; description = "Parse webforms & render to interactive hypertext"; - license = lib.licensesSpdx."GPL-3.0-only"; + license = lib.meta.getLicenseFromSpdxId "GPL-3.0-only"; hydraPlatforms = lib.platforms.none; mainProgram = "bureaucromancy"; broken = true; @@ -121500,7 +121500,7 @@ self: { text ]; description = "Parse and render URI templates"; - license = lib.licensesSpdx."MIT"; + license = lib.meta.getLicenseFromSpdxId "MIT"; } ) { }; @@ -122042,7 +122042,7 @@ self: { sha256 = "0afywcb7n2h2vycxg47myaqz49xrlnjpyq753smildjlkl79jx79"; libraryHaskellDepends = [ base ]; description = "Define embeddings of small bit vectors into larger ones"; - license = lib.licensesSpdx."BSD-3-Clause"; + license = lib.meta.getLicenseFromSpdxId "BSD-3-Clause"; } ) { }; @@ -122114,7 +122114,7 @@ self: { ]; doHaddock = false; description = "Efficient little-endian bit vector library"; - license = lib.licensesSpdx."BSD-3-Clause"; + license = lib.meta.getLicenseFromSpdxId "BSD-3-Clause"; hydraPlatforms = lib.platforms.none; } ) { }; @@ -122184,7 +122184,7 @@ self: { parameterized-utils ]; description = "Well-typed lenses for bv-sized bitvectors"; - license = lib.licensesSpdx."BSD-3-Clause"; + license = lib.meta.getLicenseFromSpdxId "BSD-3-Clause"; hydraPlatforms = lib.platforms.none; broken = true; } @@ -122221,7 +122221,7 @@ self: { tasty-hunit ]; description = "Give aliases to record fields"; - license = lib.licensesSpdx."BSD-3-Clause"; + license = lib.meta.getLicenseFromSpdxId "BSD-3-Clause"; hydraPlatforms = lib.platforms.none; broken = true; } @@ -122282,7 +122282,7 @@ self: { text ]; description = "Library for creating command-line interfaces (colors, menus, etc.)"; - license = lib.licensesSpdx."BSD-2-Clause"; + license = lib.meta.getLicenseFromSpdxId "BSD-2-Clause"; } ) { }; @@ -122339,7 +122339,7 @@ self: { tasty-quickcheck ]; description = "Sets and maps with 8-bit words for keys"; - license = lib.licensesSpdx."BSD-3-Clause"; + license = lib.meta.getLicenseFromSpdxId "BSD-3-Clause"; hydraPlatforms = lib.platforms.none; broken = true; } @@ -122375,7 +122375,7 @@ self: { text ]; description = "Read strings describing a number of bytes like 2Kb and 0.5 MiB"; - license = lib.licensesSpdx."GPL-3.0-only"; + license = lib.meta.getLicenseFromSpdxId "GPL-3.0-only"; maintainers = [ lib.maintainers.danielrolls ]; } ) { }; @@ -122404,7 +122404,7 @@ self: { wide-word ]; description = "Portable big-endian and little-endian conversions"; - license = lib.licensesSpdx."BSD-3-Clause"; + license = lib.meta.getLicenseFromSpdxId "BSD-3-Clause"; } ) { }; @@ -122521,7 +122521,7 @@ self: { text-short ]; description = "Build byte arrays"; - license = lib.licensesSpdx."BSD-3-Clause"; + license = lib.meta.getLicenseFromSpdxId "BSD-3-Clause"; } ) { }; @@ -122604,7 +122604,7 @@ self: { unordered-containers ]; description = "Universal hashing of bytes"; - license = lib.licensesSpdx."BSD-3-Clause"; + license = lib.meta.getLicenseFromSpdxId "BSD-3-Clause"; } ) { }; @@ -122631,7 +122631,7 @@ self: { primitive ]; description = "Fast logging"; - license = lib.licensesSpdx."BSD-3-Clause"; + license = lib.meta.getLicenseFromSpdxId "BSD-3-Clause"; badPlatforms = lib.platforms.darwin; } ) { }; @@ -122839,7 +122839,7 @@ self: { random ]; description = "Calculate string metrics on Bytes efficiently"; - license = lib.licensesSpdx."BSD-3-Clause"; + license = lib.meta.getLicenseFromSpdxId "BSD-3-Clause"; } ) { }; @@ -122868,7 +122868,7 @@ self: { tasty-hunit ]; description = "Template haskell macro for casing on Bytes"; - license = lib.licensesSpdx."MIT"; + license = lib.meta.getLicenseFromSpdxId "MIT"; } ) { }; @@ -122945,7 +122945,7 @@ self: { gauge ]; description = "Slicing managed and unmanaged memory"; - license = lib.licensesSpdx."BSD-3-Clause"; + license = lib.meta.getLicenseFromSpdxId "BSD-3-Clause"; } ) { }; @@ -122999,7 +122999,7 @@ self: { primitive ]; description = "Nonresumable byte parser"; - license = lib.licensesSpdx."BSD-3-Clause"; + license = lib.meta.getLicenseFromSpdxId "BSD-3-Clause"; } ) { }; @@ -123047,7 +123047,7 @@ self: { tasty-bench ]; description = "Fast, compact, strict and lazy byte strings with a list interface"; - license = lib.licensesSpdx."BSD-3-Clause"; + license = lib.meta.getLicenseFromSpdxId "BSD-3-Clause"; hydraPlatforms = lib.platforms.none; } ) { }; @@ -123073,7 +123073,7 @@ self: { text ]; description = "Aeson instances for ByteString, using base 64 encoding"; - license = lib.licensesSpdx."BSD-3-Clause"; + license = lib.meta.getLicenseFromSpdxId "BSD-3-Clause"; } ) { }; @@ -123422,7 +123422,7 @@ self: { mono-traversable ]; description = "Byte String implemented on Finger Tree"; - license = lib.licensesSpdx."BSD-3-Clause"; + license = lib.meta.getLicenseFromSpdxId "BSD-3-Clause"; } ) { }; @@ -123488,7 +123488,7 @@ self: { tasty-smallcheck ]; description = "Efficiently parse and produce common integral and fractional numbers"; - license = lib.licensesSpdx."BSD-3-Clause"; + license = lib.meta.getLicenseFromSpdxId "BSD-3-Clause"; } ) { }; @@ -123765,7 +123765,7 @@ self: { rerebase ]; description = "An efficient strict bytestring builder"; - license = lib.licensesSpdx."MIT"; + license = lib.meta.getLicenseFromSpdxId "MIT"; } ) { }; @@ -123788,7 +123788,7 @@ self: { primitive ]; description = "break bytestrings up into substrings"; - license = lib.licensesSpdx."BSD-3-Clause"; + license = lib.meta.getLicenseFromSpdxId "BSD-3-Clause"; hydraPlatforms = lib.platforms.none; broken = true; } @@ -123900,7 +123900,7 @@ self: { criterion ]; description = "A very efficient ByteString builder implementation based on the binary tree"; - license = lib.licensesSpdx."MIT"; + license = lib.meta.getLicenseFromSpdxId "MIT"; } ) { }; @@ -123950,7 +123950,7 @@ self: { QuickCheck ]; description = "An efficient finite map from bytestrings to values"; - license = lib.licensesSpdx."BSD-3-Clause"; + license = lib.meta.getLicenseFromSpdxId "BSD-3-Clause"; } ) { }; @@ -124093,7 +124093,7 @@ self: { unpacked-maybe ]; description = "Tries with Bytes as keys"; - license = lib.licensesSpdx."BSD-3-Clause"; + license = lib.meta.getLicenseFromSpdxId "BSD-3-Clause"; hydraPlatforms = lib.platforms.none; } ) { }; @@ -124238,7 +124238,7 @@ self: { tasty-hunit ]; description = "High-level bindings to bz3"; - license = lib.licensesSpdx."AGPL-3.0-or-later"; + license = lib.meta.getLicenseFromSpdxId "AGPL-3.0-or-later"; } ) { }; @@ -124273,7 +124273,7 @@ self: { sha256 = "0iax0fq5y24lcjkjsk66khry9s6v9hhd3zfrwg8mvgs07waq2m59"; doHaddock = false; description = "bzip2 C sources"; - license = lib.licensesSpdx."BSD-3-Clause"; + license = lib.meta.getLicenseFromSpdxId "BSD-3-Clause"; } ) { }; @@ -124907,7 +124907,7 @@ self: { ]; testToolDepends = [ hspec-discover ]; description = "Manipulate patterns in cellular automata, create and parse RLE files"; - license = lib.licensesSpdx."MIT"; + license = lib.meta.getLicenseFromSpdxId "MIT"; hydraPlatforms = lib.platforms.none; broken = true; } @@ -125076,7 +125076,7 @@ self: { temporary ]; description = "Extend Cabal build-depends from the command line"; - license = lib.licensesSpdx."BSD-3-Clause"; + license = lib.meta.getLicenseFromSpdxId "BSD-3-Clause"; hydraPlatforms = lib.platforms.none; mainProgram = "cabal-add"; } @@ -125139,7 +125139,7 @@ self: { temporary ]; description = "Extend Cabal build-depends from the command line"; - license = lib.licensesSpdx."BSD-3-Clause"; + license = lib.meta.getLicenseFromSpdxId "BSD-3-Clause"; mainProgram = "cabal-add"; } ) { }; @@ -125334,7 +125334,7 @@ self: { time ]; description = "Bundling C/C++ projects in Cabal package made easy"; - license = lib.licensesSpdx."BSD-3-Clause"; + license = lib.meta.getLicenseFromSpdxId "BSD-3-Clause"; hydraPlatforms = lib.platforms.none; broken = true; } @@ -125484,7 +125484,7 @@ self: { ]; testToolDepends = [ hspec-discover ]; description = "CI Assistant for Haskell projects"; - license = lib.licensesSpdx."BSD-3-Clause"; + license = lib.meta.getLicenseFromSpdxId "BSD-3-Clause"; hydraPlatforms = lib.platforms.none; mainProgram = "cabal-cache"; } @@ -125751,7 +125751,7 @@ self: { text ]; description = "Create a Debianization for a Cabal package"; - license = lib.licensesSpdx."BSD-3-Clause"; + license = lib.meta.getLicenseFromSpdxId "BSD-3-Clause"; hydraPlatforms = lib.platforms.none; mainProgram = "cabal-debian"; broken = true; @@ -125843,7 +125843,7 @@ self: { text ]; description = "Create a Debianization for a Cabal package"; - license = lib.licensesSpdx."BSD-3-Clause"; + license = lib.meta.getLicenseFromSpdxId "BSD-3-Clause"; hydraPlatforms = lib.platforms.none; mainProgram = "cabal-debian"; broken = true; @@ -125897,7 +125897,7 @@ self: { QuickCheck ]; description = "QuickCheck for Cabal tests"; - license = lib.licensesSpdx."MIT"; + license = lib.meta.getLicenseFromSpdxId "MIT"; hydraPlatforms = lib.platforms.none; broken = true; } @@ -126049,7 +126049,7 @@ self: { time ]; description = "Cabal utility"; - license = lib.licensesSpdx."MIT"; + license = lib.meta.getLicenseFromSpdxId "MIT"; hydraPlatforms = lib.platforms.none; mainProgram = "cabal-edit"; broken = true; @@ -126203,7 +126203,7 @@ self: { doctest-parallel ]; description = "Fix for cabal files"; - license = lib.licensesSpdx."BSD-3-Clause"; + license = lib.meta.getLicenseFromSpdxId "BSD-3-Clause"; hydraPlatforms = lib.platforms.none; mainProgram = "cabal-fix"; broken = true; @@ -126263,7 +126263,7 @@ self: { zlib ]; description = "Generate a FlatPak manifest from a Cabal package description"; - license = lib.licensesSpdx."BSD-3-Clause"; + license = lib.meta.getLicenseFromSpdxId "BSD-3-Clause"; mainProgram = "cabal-flatpak"; maintainers = [ lib.maintainers.thielema ]; } @@ -126450,7 +126450,7 @@ self: { transformers ]; description = "Formats package descriptions"; - license = lib.licensesSpdx."MIT"; + license = lib.meta.getLicenseFromSpdxId "MIT"; mainProgram = "cabal-gild"; maintainers = [ lib.maintainers.turion ]; } @@ -126507,7 +126507,7 @@ self: { transformers ]; description = "Formats package descriptions"; - license = lib.licensesSpdx."MIT"; + license = lib.meta.getLicenseFromSpdxId "MIT"; hydraPlatforms = lib.platforms.none; mainProgram = "cabal-gild"; maintainers = [ lib.maintainers.turion ]; @@ -126635,7 +126635,7 @@ self: { ]; doCheck = false; description = "Give Haskell development tools access to Cabal project environment"; - license = lib.licensesSpdx."Apache-2.0"; + license = lib.meta.getLicenseFromSpdxId "Apache-2.0"; hydraPlatforms = lib.platforms.none; broken = true; } @@ -126702,7 +126702,7 @@ self: { ]; testToolDepends = [ tasty-discover ]; description = "generate hoogle database for cabal project and dependencies"; - license = lib.licensesSpdx."BSD-3-Clause"; + license = lib.meta.getLicenseFromSpdxId "BSD-3-Clause"; mainProgram = "cabal-hoogle"; } ) { }; @@ -126886,7 +126886,7 @@ self: { mv bash-completion $out/share/bash-completion/completions ''; description = "The command-line interface for Cabal and Hackage"; - license = lib.licensesSpdx."BSD-3-Clause"; + license = lib.meta.getLicenseFromSpdxId "BSD-3-Clause"; hydraPlatforms = lib.platforms.none; mainProgram = "cabal"; maintainers = [ lib.maintainers.sternenseemann ]; @@ -127270,7 +127270,7 @@ self: { tasty-quickcheck ]; description = "The solver component of cabal-install"; - license = lib.licensesSpdx."BSD-3-Clause"; + license = lib.meta.getLicenseFromSpdxId "BSD-3-Clause"; } ) { }; @@ -127431,7 +127431,7 @@ self: { ]; executableHaskellDepends = [ base ]; description = "Matrix builds for cabal"; - license = lib.licensesSpdx."BSD-3-Clause"; + license = lib.meta.getLicenseFromSpdxId "BSD-3-Clause"; hydraPlatforms = lib.platforms.none; mainProgram = "cabal-matrix"; broken = true; @@ -127573,7 +127573,7 @@ self: { process ]; description = "Make Cabal aware of pkg-config package versions"; - license = lib.licensesSpdx."BSD-3-Clause"; + license = lib.meta.getLicenseFromSpdxId "BSD-3-Clause"; maintainers = [ lib.maintainers.roberth ]; } ) { }; @@ -127641,7 +127641,7 @@ self: { vector ]; description = "Library and utility for processing cabal's plan.json file"; - license = lib.licensesSpdx."GPL-2.0-or-later"; + license = lib.meta.getLicenseFromSpdxId "GPL-2.0-or-later"; mainProgram = "cabal-plan"; } ) { }; @@ -127675,7 +127675,7 @@ self: { text ]; description = "Derives cabal bounds from build plans"; - license = lib.licensesSpdx."BSD-2-Clause"; + license = lib.meta.getLicenseFromSpdxId "BSD-2-Clause"; mainProgram = "cabal-plan-bounds"; maintainers = [ lib.maintainers.nomeata ]; } @@ -127951,7 +127951,7 @@ self: { yaml ]; executableHaskellDepends = [ base ]; - license = lib.licensesSpdx."BSD-3-Clause"; + license = lib.meta.getLicenseFromSpdxId "BSD-3-Clause"; hydraPlatforms = lib.platforms.none; mainProgram = "cabal-scaffold"; broken = true; @@ -128075,7 +128075,7 @@ self: { utility-ht ]; description = "Topologically sort cabal packages"; - license = lib.licensesSpdx."BSD-3-Clause"; + license = lib.meta.getLicenseFromSpdxId "BSD-3-Clause"; } ) { }; @@ -128122,7 +128122,7 @@ self: { utility-ht ]; description = "Topologically sort cabal packages"; - license = lib.licensesSpdx."BSD-3-Clause"; + license = lib.meta.getLicenseFromSpdxId "BSD-3-Clause"; hydraPlatforms = lib.platforms.none; } ) { }; @@ -129235,7 +129235,7 @@ self: { tasty-hunit ]; description = "A simple library to cache IO actions"; - license = lib.licensesSpdx."Apache-2.0"; + license = lib.meta.getLicenseFromSpdxId "Apache-2.0"; } ) { }; @@ -129333,7 +129333,7 @@ self: { transformers ]; description = "Cache combinators"; - license = lib.licensesSpdx."BSD-3-Clause"; + license = lib.meta.getLicenseFromSpdxId "BSD-3-Clause"; hydraPlatforms = lib.platforms.none; broken = true; } @@ -129591,7 +129591,7 @@ self: { ]; testToolDepends = [ hspec-discover ]; description = "Command-line client for Nix binary cache hosting https://cachix.org"; - license = lib.licensesSpdx."Apache-2.0"; + license = lib.meta.getLicenseFromSpdxId "Apache-2.0"; maintainers = [ lib.maintainers.domenkozar ]; } ) { inherit (pkgs) nix; }; @@ -129665,7 +129665,7 @@ self: { ]; testToolDepends = [ hspec-discover ]; description = "Servant HTTP API specification for https://cachix.org"; - license = lib.licensesSpdx."Apache-2.0"; + license = lib.meta.getLicenseFromSpdxId "Apache-2.0"; maintainers = [ lib.maintainers.domenkozar ]; } ) { }; @@ -129764,7 +129764,7 @@ self: { random ]; description = "That rabbit's got a vicious streak a mile wide!"; - license = lib.licensesSpdx."BSD-3-Clause"; + license = lib.meta.getLicenseFromSpdxId "BSD-3-Clause"; hydraPlatforms = lib.platforms.none; broken = true; } @@ -129876,7 +129876,7 @@ self: { ]; libraryPkgconfigDepends = [ cairo ]; description = "Binding to the Cairo library"; - license = lib.licensesSpdx."BSD-3-Clause"; + license = lib.meta.getLicenseFromSpdxId "BSD-3-Clause"; } ) { inherit (pkgs) cairo; }; @@ -130922,7 +130922,7 @@ self: { QuickCheck ]; description = "HIE-based Haskell call graph and source code visualizer"; - license = lib.licensesSpdx."BSD-3-Clause"; + license = lib.meta.getLicenseFromSpdxId "BSD-3-Clause"; mainProgram = "calligraphy"; } ) { }; @@ -131280,7 +131280,7 @@ self: { time ]; description = "Canadian income tax calculation"; - license = lib.licensesSpdx."GPL-3.0-or-later"; + license = lib.meta.getLicenseFromSpdxId "GPL-3.0-or-later"; hydraPlatforms = lib.platforms.none; } ) { }; @@ -131775,7 +131775,7 @@ self: { ]; testToolDepends = [ hspec-discover ]; description = "Convert data to and from a natural number representation"; - license = lib.licensesSpdx."MIT"; + license = lib.meta.getLicenseFromSpdxId "MIT"; } ) { }; @@ -132130,7 +132130,7 @@ self: { vector ]; description = "Cap'n Proto for Haskell"; - license = lib.licensesSpdx."MIT"; + license = lib.meta.getLicenseFromSpdxId "MIT"; hydraPlatforms = lib.platforms.none; mainProgram = "capnpc-haskell"; } @@ -133781,7 +133781,7 @@ self: { rerebase ]; description = "A converter for spinal, snake and camel cases"; - license = lib.licensesSpdx."MIT"; + license = lib.meta.getLicenseFromSpdxId "MIT"; } ) { }; @@ -134588,7 +134588,7 @@ self: { vector ]; description = "io-streams interface for the cassava CSV library"; - license = lib.licensesSpdx."BSD-3-Clause"; + license = lib.meta.getLicenseFromSpdxId "BSD-3-Clause"; } ) { }; @@ -134627,7 +134627,7 @@ self: { vector ]; description = "`TemplateHaskell` helpers for `cassava`"; - license = lib.licensesSpdx."BSD-3-Clause"; + license = lib.meta.getLicenseFromSpdxId "BSD-3-Clause"; } ) { }; @@ -134773,7 +134773,7 @@ self: { text ]; description = "Portable CRC-32C"; - license = lib.licensesSpdx."BSD-3-Clause"; + license = lib.meta.getLicenseFromSpdxId "BSD-3-Clause"; } ) { }; @@ -135311,7 +135311,7 @@ self: { ]; doHaddock = false; description = "Dependency injection library"; - license = lib.licensesSpdx."BSD-3-Clause"; + license = lib.meta.getLicenseFromSpdxId "BSD-3-Clause"; mainProgram = "cauldron-example-wiring"; } ) { }; @@ -135591,7 +135591,7 @@ self: { vector ]; description = "Bindings to read Crystallographic Binary Files (mostly from detectors)"; - license = lib.licensesSpdx."GPL-3.0-or-later"; + license = lib.meta.getLicenseFromSpdxId "GPL-3.0-or-later"; hydraPlatforms = lib.platforms.none; mainProgram = "cbf-bench-binary"; broken = true; @@ -136147,7 +136147,7 @@ self: { websockets ]; description = "A library for the Chrome Devtools Protocol"; - license = lib.licensesSpdx."BSD-3-Clause"; + license = lib.meta.getLicenseFromSpdxId "BSD-3-Clause"; hydraPlatforms = lib.platforms.none; broken = true; } @@ -136922,7 +136922,7 @@ self: { unordered-containers ]; description = "Integration of \"cereal\" and \"unordered-containers\""; - license = lib.licensesSpdx."MIT"; + license = lib.meta.getLicenseFromSpdxId "MIT"; } ) { }; @@ -137141,7 +137141,7 @@ self: { ]; testToolDepends = [ hspec-discover ]; description = "Type directed application configuration parsing and accessors"; - license = lib.licensesSpdx."MIT"; + license = lib.meta.getLicenseFromSpdxId "MIT"; hydraPlatforms = lib.platforms.none; broken = true; } @@ -137319,7 +137319,7 @@ self: { base-prelude ]; description = "A Future type that is interruptible anytime and exportable to C/C++"; - license = lib.licensesSpdx."BSD-3-Clause"; + license = lib.meta.getLicenseFromSpdxId "BSD-3-Clause"; hydraPlatforms = lib.platforms.none; broken = true; } @@ -137603,7 +137603,7 @@ self: { yaml ]; description = "Command line tool"; - license = lib.licensesSpdx."GPL-2.0-or-later"; + license = lib.meta.getLicenseFromSpdxId "GPL-2.0-or-later"; hydraPlatforms = lib.platforms.none; mainProgram = "cgrep"; broken = true; @@ -137641,7 +137641,7 @@ self: { path-io ]; description = "A container-/cgroup-aware substitute for the GHC RTS `-N` flag"; - license = lib.licensesSpdx."MPL-2.0"; + license = lib.meta.getLicenseFromSpdxId "MPL-2.0"; hydraPlatforms = lib.platforms.none; broken = true; } @@ -137780,7 +137780,7 @@ self: { time ]; description = "Mining Client for Kadena Chainweb"; - license = lib.licensesSpdx."BSD-3-Clause"; + license = lib.meta.getLicenseFromSpdxId "BSD-3-Clause"; hydraPlatforms = lib.platforms.none; mainProgram = "chainweb-mining-client"; } @@ -138219,7 +138219,7 @@ self: { witherable ]; description = "Stateful monad transformer based on monoidal actions"; - license = lib.licensesSpdx."MIT"; + license = lib.meta.getLicenseFromSpdxId "MIT"; } ) { }; @@ -138252,7 +138252,7 @@ self: { tasty-hunit ]; description = "Stateful monad transformer based on monoidal actions"; - license = lib.licensesSpdx."MIT"; + license = lib.meta.getLicenseFromSpdxId "MIT"; } ) { }; @@ -138298,7 +138298,7 @@ self: { tasty-hunit ]; description = "Stateful monad transformer based on monoidal actions"; - license = lib.licensesSpdx."MIT"; + license = lib.meta.getLicenseFromSpdxId "MIT"; } ) { }; @@ -138327,7 +138327,7 @@ self: { some ]; description = "Stateful monad transformer based on monoidal actions"; - license = lib.licensesSpdx."MIT"; + license = lib.meta.getLicenseFromSpdxId "MIT"; } ) { }; @@ -138375,7 +138375,7 @@ self: { vector ]; description = "A diagnostics library for Haskell"; - license = lib.licensesSpdx."MIT"; + license = lib.meta.getLicenseFromSpdxId "MIT"; hydraPlatforms = lib.platforms.none; } ) { }; @@ -138490,7 +138490,7 @@ self: { libraryHaskellDepends = [ base ]; testHaskellDepends = [ base ]; description = "Pattern synonyms for ASCII characters for Word8, Word16 etc"; - license = lib.licensesSpdx."BSD-3-Clause"; + license = lib.meta.getLicenseFromSpdxId "BSD-3-Clause"; } ) { }; @@ -138730,7 +138730,7 @@ self: { time ]; description = "Charting library targetting SVGs"; - license = lib.licensesSpdx."BSD-3-Clause"; + license = lib.meta.getLicenseFromSpdxId "BSD-3-Clause"; } ) { }; @@ -138793,7 +138793,7 @@ self: { numhask ]; description = "See readme.md"; - license = lib.licensesSpdx."BSD-3-Clause"; + license = lib.meta.getLicenseFromSpdxId "BSD-3-Clause"; hydraPlatforms = lib.platforms.none; mainProgram = "chart-svg-various"; } @@ -139487,7 +139487,7 @@ self: { QuickCheck ]; description = "Checks context free grammar for ambiguity using brute force up to given limit"; - license = lib.licensesSpdx."BSD-3-Clause"; + license = lib.meta.getLicenseFromSpdxId "BSD-3-Clause"; hydraPlatforms = lib.platforms.none; broken = true; } @@ -139778,7 +139778,7 @@ self: { transformers ]; description = "A simple and intuitive library for automated testing"; - license = lib.licensesSpdx."MIT"; + license = lib.meta.getLicenseFromSpdxId "MIT"; } ) { }; @@ -139801,7 +139801,7 @@ self: { HUnit ]; description = "HUnit support for Chell"; - license = lib.licensesSpdx."MIT"; + license = lib.meta.getLicenseFromSpdxId "MIT"; } ) { }; @@ -139826,7 +139826,7 @@ self: { random ]; description = "QuickCheck support for Chell"; - license = lib.licensesSpdx."MIT"; + license = lib.meta.getLicenseFromSpdxId "MIT"; hydraPlatforms = lib.platforms.none; broken = true; } @@ -140101,7 +140101,7 @@ self: { containers ]; description = "A Library for Chess Game Logic"; - license = lib.licensesSpdx."BSD-3-Clause"; + license = lib.meta.getLicenseFromSpdxId "BSD-3-Clause"; hydraPlatforms = lib.platforms.none; broken = true; } @@ -140219,7 +140219,7 @@ self: { text ]; description = "Parse and scrape recipe blogs"; - license = lib.licensesSpdx."MIT"; + license = lib.meta.getLicenseFromSpdxId "MIT"; hydraPlatforms = lib.platforms.none; mainProgram = "chez-grater"; broken = true; @@ -140289,7 +140289,7 @@ self: { uuid ]; description = "A tmux client for Polysemy"; - license = lib.licensesSpdx."BSD-2-Clause-Patent"; + license = lib.meta.getLicenseFromSpdxId "BSD-2-Clause-Patent"; hydraPlatforms = lib.platforms.none; broken = true; } @@ -140361,7 +140361,7 @@ self: { tasty-hedgehog ]; description = "Testing tools for chiasma"; - license = lib.licensesSpdx."BSD-2-Clause-Patent"; + license = lib.meta.getLicenseFromSpdxId "BSD-2-Clause-Patent"; hydraPlatforms = lib.platforms.none; } ) { }; @@ -140420,7 +140420,7 @@ self: { vector ]; description = "Lazy infinite streams with O(1) indexing and applications for memoization"; - license = lib.licensesSpdx."BSD-3-Clause"; + license = lib.meta.getLicenseFromSpdxId "BSD-3-Clause"; } ) { }; @@ -140496,7 +140496,7 @@ self: { sha256 = "0v9yykg2ip6y1cf25d101nvpsn8p1p4mw213pmi3005qqhv17hcc"; libraryHaskellDepends = [ base ]; description = "A solution to boolean blindness"; - license = lib.licensesSpdx."BSD-3-Clause"; + license = lib.meta.getLicenseFromSpdxId "BSD-3-Clause"; } ) { }; @@ -141204,7 +141204,7 @@ self: { time ]; description = "A high-performance time library"; - license = lib.licensesSpdx."BSD-3-Clause"; + license = lib.meta.getLicenseFromSpdxId "BSD-3-Clause"; } ) { }; @@ -141244,7 +141244,7 @@ self: { ]; benchmarkHaskellDepends = [ base ]; description = "Benchmarking tool with focus on comparing results"; - license = lib.licensesSpdx."BSD-3-Clause"; + license = lib.meta.getLicenseFromSpdxId "BSD-3-Clause"; hydraPlatforms = lib.platforms.none; mainProgram = "chronos"; broken = true; @@ -141509,7 +141509,7 @@ self: { sha256 = "018k9a014q4zprsla5k5hrdq1zwpp7hmckc0ldaj7nf6vg1hxas2"; libraryHaskellDepends = [ base ]; description = "Automatically convert Generic instances to and from church representations"; - license = lib.licensesSpdx."MIT"; + license = lib.meta.getLicenseFromSpdxId "MIT"; hydraPlatforms = lib.platforms.none; broken = true; } @@ -141612,7 +141612,7 @@ self: { unagi-chan ]; description = "Channel/Arrow based streaming computation library"; - license = lib.licensesSpdx."MIT"; + license = lib.meta.getLicenseFromSpdxId "MIT"; hydraPlatforms = lib.platforms.none; broken = true; } @@ -141672,7 +141672,7 @@ self: { uuid ]; description = "API bindings to IOHK's Cicero job scheduler"; - license = lib.licensesSpdx."Apache-2.0"; + license = lib.meta.getLicenseFromSpdxId "Apache-2.0"; hydraPlatforms = lib.platforms.none; mainProgram = "cicero-cli"; broken = true; @@ -142548,7 +142548,7 @@ self: { vector ]; description = "Circular fixed-sized mutable vectors"; - license = lib.licensesSpdx."BSD-3-Clause"; + license = lib.meta.getLicenseFromSpdxId "BSD-3-Clause"; maintainers = [ lib.maintainers.dschrempf ]; } ) { }; @@ -142569,7 +142569,7 @@ self: { hspec ]; description = "Make bounded enum types circular"; - license = lib.licensesSpdx."MIT"; + license = lib.meta.getLicenseFromSpdxId "MIT"; } ) { }; @@ -142830,7 +142830,7 @@ self: { transformers ]; description = "Generates citations and bibliography from CSL styles"; - license = lib.licensesSpdx."BSD-2-Clause"; + license = lib.meta.getLicenseFromSpdxId "BSD-2-Clause"; maintainers = [ lib.maintainers.sternenseemann ]; } ) { }; @@ -142903,7 +142903,7 @@ self: { transformers ]; description = "Generates citations and bibliography from CSL styles"; - license = lib.licensesSpdx."BSD-2-Clause"; + license = lib.meta.getLicenseFromSpdxId "BSD-2-Clause"; hydraPlatforms = lib.platforms.none; maintainers = [ lib.maintainers.sternenseemann ]; } @@ -143573,7 +143573,7 @@ self: { time ]; description = "Type-safe DSL for healthcare claims validation and X12 processing"; - license = lib.licensesSpdx."BSD-3-Clause"; + license = lib.meta.getLicenseFromSpdxId "BSD-3-Clause"; mainProgram = "claims-x12-dsl-exe"; } ) { }; @@ -143830,7 +143830,7 @@ self: { tasty-hunit ]; description = "A class for types with only finitely many inhabitants"; - license = lib.licensesSpdx."MIT"; + license = lib.meta.getLicenseFromSpdxId "MIT"; hydraPlatforms = lib.platforms.none; broken = true; } @@ -143928,7 +143928,7 @@ self: { ]; executableHaskellDepends = [ base ]; description = "Clash: a functional hardware description language - GHC frontend"; - license = lib.licensesSpdx."BSD-2-Clause"; + license = lib.meta.getLicenseFromSpdxId "BSD-2-Clause"; } ) { }; @@ -144093,7 +144093,7 @@ self: { unordered-containers ]; description = "Clash: a functional hardware description language - As a library"; - license = lib.licensesSpdx."BSD-2-Clause"; + license = lib.meta.getLicenseFromSpdxId "BSD-2-Clause"; mainProgram = "v16-upgrade-primitives"; } ) { }; @@ -144141,7 +144141,7 @@ self: { transformers ]; description = "Hedgehog Generators for clash-lib"; - license = lib.licensesSpdx."BSD-2-Clause"; + license = lib.meta.getLicenseFromSpdxId "BSD-2-Clause"; } ) { }; @@ -144299,7 +144299,7 @@ self: { template-haskell ]; description = "Clash: a functional hardware description language - Prelude library"; - license = lib.licensesSpdx."BSD-2-Clause"; + license = lib.meta.getLicenseFromSpdxId "BSD-2-Clause"; } ) { }; @@ -144326,7 +144326,7 @@ self: { text ]; description = "Hedgehog Generators for clash-prelude"; - license = lib.licensesSpdx."BSD-2-Clause"; + license = lib.meta.getLicenseFromSpdxId "BSD-2-Clause"; } ) { }; @@ -144714,7 +144714,7 @@ self: { ]; testToolDepends = [ tasty-discover ]; description = "An interface for a handler-independent, typeclass-based effect system"; - license = lib.licensesSpdx."MPL-2.0"; + license = lib.meta.getLicenseFromSpdxId "MPL-2.0"; hydraPlatforms = lib.platforms.none; } ) { }; @@ -144743,7 +144743,7 @@ self: { ]; testToolDepends = [ tasty-discover ]; description = "An interface for a handler-independent, typeclass-based effect system"; - license = lib.licensesSpdx."MPL-2.0"; + license = lib.meta.getLicenseFromSpdxId "MPL-2.0"; hydraPlatforms = lib.platforms.none; broken = true; } @@ -144784,7 +144784,7 @@ self: { ]; testToolDepends = [ tasty-discover ]; description = "Automatic compliance with the classy-effects protocols"; - license = lib.licensesSpdx."MPL-2.0"; + license = lib.meta.getLicenseFromSpdxId "MPL-2.0"; hydraPlatforms = lib.platforms.none; } ) { }; @@ -145154,7 +145154,7 @@ self: { vector ]; description = "Servant bindings to Anthropic's Claude API"; - license = lib.licensesSpdx."BSD-3-Clause"; + license = lib.meta.getLicenseFromSpdxId "BSD-3-Clause"; } ) { }; @@ -147471,7 +147471,7 @@ self: { unix ]; description = "Project file manager for Claude AI integrations"; - license = lib.licensesSpdx."MIT"; + license = lib.meta.getLicenseFromSpdxId "MIT"; hydraPlatforms = lib.platforms.none; broken = true; } @@ -147614,7 +147614,7 @@ self: { template-haskell ]; description = "Closed type class declarations"; - license = lib.licensesSpdx."BSD-3-Clause"; + license = lib.meta.getLicenseFromSpdxId "BSD-3-Clause"; hydraPlatforms = lib.platforms.none; broken = true; } @@ -147837,7 +147837,7 @@ self: { warp ]; description = "Lightweight and efficient choreographic programming for cloud services"; - license = lib.licensesSpdx."MPL-2.0"; + license = lib.meta.getLicenseFromSpdxId "MPL-2.0"; hydraPlatforms = lib.platforms.none; broken = true; } @@ -147878,7 +147878,7 @@ self: { time ]; description = "Unofficial Haskell SDK for the CloudEvents specification"; - license = lib.licensesSpdx."BSD-3-Clause"; + license = lib.meta.getLicenseFromSpdxId "BSD-3-Clause"; } ) { }; @@ -148040,7 +148040,7 @@ self: { template-haskell ]; description = "CLI tool to easily spin up and control compute instances in various cloud environments"; - license = lib.licensesSpdx."BSD-3-Clause"; + license = lib.meta.getLicenseFromSpdxId "BSD-3-Clause"; mainProgram = "cloudy"; maintainers = [ lib.maintainers.cdepillabout ]; } @@ -148828,7 +148828,7 @@ self: { text ]; description = "Collection of Lens for cmark-gfm with minimal dependencies"; - license = lib.licensesSpdx."BSD-3-Clause"; + license = lib.meta.getLicenseFromSpdxId "BSD-3-Clause"; hydraPlatforms = lib.platforms.none; broken = true; } @@ -148891,7 +148891,7 @@ self: { text ]; description = "Collection of lens for CMark with minimal dependencies"; - license = lib.licensesSpdx."BSD-3-Clause"; + license = lib.meta.getLicenseFromSpdxId "BSD-3-Clause"; hydraPlatforms = lib.platforms.none; broken = true; } @@ -149253,7 +149253,7 @@ self: { hedgehog ]; description = "(C)oncurrent (M)onoidal (F)olds"; - license = lib.licensesSpdx."MIT"; + license = lib.meta.getLicenseFromSpdxId "MIT"; hydraPlatforms = lib.platforms.none; broken = true; } @@ -149740,7 +149740,7 @@ self: { hedgehog ]; description = "Composable Contravariant Comonadic Logging Library"; - license = lib.licensesSpdx."MPL-2.0"; + license = lib.meta.getLicenseFromSpdxId "MPL-2.0"; } ) { }; @@ -149763,7 +149763,7 @@ self: { stm ]; description = "Asynchronous backend for co-log library"; - license = lib.licensesSpdx."MPL-2.0"; + license = lib.meta.getLicenseFromSpdxId "MPL-2.0"; } ) { }; @@ -149785,7 +149785,7 @@ self: { Glob ]; description = "Composable Contravariant Comonadic Logging Library"; - license = lib.licensesSpdx."MPL-2.0"; + license = lib.meta.getLicenseFromSpdxId "MPL-2.0"; } ) { }; @@ -149837,7 +149837,7 @@ self: { ]; testToolDepends = [ tasty-discover ]; description = "effectful log effect using co-log-core"; - license = lib.licensesSpdx."BSD-3-Clause"; + license = lib.meta.getLicenseFromSpdxId "BSD-3-Clause"; hydraPlatforms = lib.platforms.none; broken = true; } @@ -149868,7 +149868,7 @@ self: { text ]; description = "Structured messages support in co-log ecosystem"; - license = lib.licensesSpdx."MPL-2.0"; + license = lib.meta.getLicenseFromSpdxId "MPL-2.0"; hydraPlatforms = lib.platforms.none; broken = true; } @@ -149898,7 +149898,7 @@ self: { polysemy ]; description = "Composable Contravariant Comonadic Logging Library"; - license = lib.licensesSpdx."MPL-2.0"; + license = lib.meta.getLicenseFromSpdxId "MPL-2.0"; mainProgram = "play-colog-poly"; } ) { }; @@ -149944,7 +149944,7 @@ self: { polysemy-plugin ]; description = "A Polysemy logging effect for high quality (unstructured) logs"; - license = lib.licensesSpdx."BSD-3-Clause"; + license = lib.meta.getLicenseFromSpdxId "BSD-3-Clause"; hydraPlatforms = lib.platforms.none; mainProgram = "example"; broken = true; @@ -149982,7 +149982,7 @@ self: { co-log ]; description = "Simple enhancements for logging with co-log"; - license = lib.licensesSpdx."ISC"; + license = lib.meta.getLicenseFromSpdxId "ISC"; mainProgram = "co-log-simple"; } ) { }; @@ -150147,7 +150147,7 @@ self: { vector ]; description = "Computational biology toolkit to collaborate with researchers in constructive protein engineering"; - license = lib.licensesSpdx."BSD-3-Clause"; + license = lib.meta.getLicenseFromSpdxId "BSD-3-Clause"; } ) { }; @@ -150829,7 +150829,7 @@ self: { transformers ]; description = "CodeT"; - license = lib.licensesSpdx."BSD-3-Clause"; + license = lib.meta.getLicenseFromSpdxId "BSD-3-Clause"; } ) { }; @@ -150870,7 +150870,7 @@ self: { transformers ]; description = "GHC type-checker plugin for solving LiftT instances from codet"; - license = lib.licensesSpdx."BSD-3-Clause"; + license = lib.meta.getLicenseFromSpdxId "BSD-3-Clause"; hydraPlatforms = lib.platforms.none; broken = true; } @@ -151104,7 +151104,7 @@ self: { sha256 = "1g2a723xlbj2blpyfgcr6jg6a2yyca7pa5dgw9jnpip98hssmhsa"; libraryHaskellDepends = [ base ]; description = "Coercions with improved type inference"; - license = lib.licensesSpdx."BSD-3-Clause"; + license = lib.meta.getLicenseFromSpdxId "BSD-3-Clause"; } ) { }; @@ -151118,7 +151118,7 @@ self: { editedCabalFile = "01zvrzly922rxf1cl9g8fh6hz8963xl1mmr30pbsbxfl1246ilbw"; libraryHaskellDepends = [ base ]; description = "Coercible but only in one direction"; - license = lib.licensesSpdx."BSD-3-Clause"; + license = lib.meta.getLicenseFromSpdxId "BSD-3-Clause"; } ) { }; @@ -151141,7 +151141,7 @@ self: { profunctors ]; description = "Combine profunctors with coercible-subtypes"; - license = lib.licensesSpdx."BSD-3-Clause"; + license = lib.meta.getLicenseFromSpdxId "BSD-3-Clause"; } ) { }; @@ -151772,7 +151772,7 @@ self: { tasty-hunit ]; description = "Equivariant CSM classes of coincident root loci"; - license = lib.licensesSpdx."BSD-3-Clause"; + license = lib.meta.getLicenseFromSpdxId "BSD-3-Clause"; hydraPlatforms = lib.platforms.none; } ) { }; @@ -151829,7 +151829,7 @@ self: { utility-ht ]; description = "Linear Programming using COIN-OR/CLP and comfort-array"; - license = lib.licensesSpdx."BSD-3-Clause"; + license = lib.meta.getLicenseFromSpdxId "BSD-3-Clause"; badPlatforms = [ "aarch64-linux" ]; maintainers = [ lib.maintainers.thielema ]; } @@ -152501,7 +152501,7 @@ self: { hashable ]; description = "Generate a color for a hashable object"; - license = lib.licensesSpdx."BSD-3-Clause"; + license = lib.meta.getLicenseFromSpdxId "BSD-3-Clause"; } ) { }; @@ -152817,7 +152817,7 @@ self: { text ]; description = "Print and parse colors"; - license = lib.licensesSpdx."Apache-2.0"; + license = lib.meta.getLicenseFromSpdxId "Apache-2.0"; hydraPlatforms = lib.platforms.none; broken = true; } @@ -152851,7 +152851,7 @@ self: { text ]; description = "Convenient interface for printing colourful messages"; - license = lib.licensesSpdx."MPL-2.0"; + license = lib.meta.getLicenseFromSpdxId "MPL-2.0"; } ) { }; @@ -153435,7 +153435,7 @@ self: { mtl ]; description = "Collection of combinators over standard typeclasses"; - license = lib.licensesSpdx."MIT"; + license = lib.meta.getLicenseFromSpdxId "MIT"; } ) { }; @@ -153574,7 +153574,7 @@ self: { ]; doHaddock = false; description = "Additional shape types for the comfort-array package"; - license = lib.licensesSpdx."BSD-3-Clause"; + license = lib.meta.getLicenseFromSpdxId "BSD-3-Clause"; maintainers = [ lib.maintainers.thielema ]; } ) { }; @@ -153629,7 +153629,7 @@ self: { utility-ht ]; description = "Numerical Basic Linear Algebra using BLAS"; - license = lib.licensesSpdx."BSD-3-Clause"; + license = lib.meta.getLicenseFromSpdxId "BSD-3-Clause"; maintainers = [ lib.maintainers.thielema ]; } ) { }; @@ -153674,7 +153674,7 @@ self: { storable-record ]; description = "High-level interface to FFTW (Fast Fourier Transform) based on comfort-array"; - license = lib.licensesSpdx."BSD-3-Clause"; + license = lib.meta.getLicenseFromSpdxId "BSD-3-Clause"; maintainers = [ lib.maintainers.thielema ]; } ) { }; @@ -153726,7 +153726,7 @@ self: { utility-ht ]; description = "Linear Programming using GLPK and comfort-array"; - license = lib.licensesSpdx."BSD-3-Clause"; + license = lib.meta.getLicenseFromSpdxId "BSD-3-Clause"; maintainers = [ lib.maintainers.thielema ]; } ) { inherit (pkgs) glpk; }; @@ -153997,7 +153997,7 @@ self: { unordered-containers ]; description = "A command line argument/option parser library"; - license = lib.licensesSpdx."MIT"; + license = lib.meta.getLicenseFromSpdxId "MIT"; mainProgram = "task-manager"; } ) { }; @@ -154023,7 +154023,7 @@ self: { mtl ]; description = "A monad for commanders"; - license = lib.licensesSpdx."MIT"; + license = lib.meta.getLicenseFromSpdxId "MIT"; } ) { }; @@ -154147,7 +154147,7 @@ self: { text ]; description = "Pure Haskell commonmark parser"; - license = lib.licensesSpdx."BSD-3-Clause"; + license = lib.meta.getLicenseFromSpdxId "BSD-3-Clause"; } ) { }; @@ -154273,7 +154273,7 @@ self: { text ]; description = "An initial encoding of the CommonMark language"; - license = lib.licensesSpdx."ISC"; + license = lib.meta.getLicenseFromSpdxId "ISC"; } ) { }; @@ -154337,7 +154337,7 @@ self: { yaml ]; description = "Simple interface to commonmark-hs for parsing real-world Markdown"; - license = lib.licensesSpdx."MIT"; + license = lib.meta.getLicenseFromSpdxId "MIT"; } ) { }; @@ -154391,7 +154391,7 @@ self: { url-slug ]; description = "Obsidian-friendly commonmark wikilink parser"; - license = lib.licensesSpdx."MIT"; + license = lib.meta.getLicenseFromSpdxId "MIT"; } ) { }; @@ -154515,7 +154515,7 @@ self: { containers ]; description = "Commutative semigroups"; - license = lib.licensesSpdx."BSD-3-Clause"; + license = lib.meta.getLicenseFromSpdxId "BSD-3-Clause"; maintainers = [ lib.maintainers.alexfmpe ]; } ) { }; @@ -154586,7 +154586,7 @@ self: { tasty-quickcheck ]; description = "Coactions of comonads on functors"; - license = lib.licensesSpdx."AGPL-3.0-or-later"; + license = lib.meta.getLicenseFromSpdxId "AGPL-3.0-or-later"; } ) { }; @@ -154798,7 +154798,7 @@ self: { yaml ]; description = "Compatibility checker for OpenAPI"; - license = lib.licensesSpdx."MIT"; + license = lib.meta.getLicenseFromSpdxId "MIT"; hydraPlatforms = lib.platforms.none; broken = true; } @@ -154981,7 +154981,7 @@ self: { tasty-quickcheck ]; description = "Stacks, queues, and deques with compact representations"; - license = lib.licensesSpdx."BSD-3-Clause"; + license = lib.meta.getLicenseFromSpdxId "BSD-3-Clause"; hydraPlatforms = lib.platforms.none; broken = true; } @@ -157219,7 +157219,7 @@ self: { sha256 = "0aprzrslrbsl3d7j49nmx0kxx71m39zi7xlfyw8wnazqpi8mfwwb"; libraryHaskellDepends = [ base ]; description = "Concurrent actions that may fail with a value"; - license = lib.licensesSpdx."BSD-3-Clause"; + license = lib.meta.getLicenseFromSpdxId "BSD-3-Clause"; } ) { }; @@ -157279,7 +157279,7 @@ self: { executableHaskellDepends = [ base ]; testHaskellDepends = [ base ]; description = "A declarative UI framework"; - license = lib.licensesSpdx."BSD-3-Clause"; + license = lib.meta.getLicenseFromSpdxId "BSD-3-Clause"; mainProgram = "ui"; } ) { }; @@ -160842,7 +160842,7 @@ self: { text ]; description = "Schema definitions for the config-value package"; - license = lib.licensesSpdx."ISC"; + license = lib.meta.getLicenseFromSpdxId "ISC"; } ) { }; @@ -160908,7 +160908,7 @@ self: { text ]; description = "Simple, layout-based value language similar to YAML or JSON"; - license = lib.licensesSpdx."MIT"; + license = lib.meta.getLicenseFromSpdxId "MIT"; } ) { }; @@ -161113,7 +161113,7 @@ self: { yaml ]; description = "Tools for specifying and parsing configurations"; - license = lib.licensesSpdx."MIT"; + license = lib.meta.getLicenseFromSpdxId "MIT"; mainProgram = "example"; } ) { }; @@ -161427,7 +161427,7 @@ self: { text ]; description = "Tracable multi-source config management"; - license = lib.licensesSpdx."BSD-3-Clause"; + license = lib.meta.getLicenseFromSpdxId "BSD-3-Clause"; hydraPlatforms = lib.platforms.none; broken = true; } @@ -161947,7 +161947,7 @@ self: { doctest ]; description = "A safe interface for Const summarization"; - license = lib.licensesSpdx."BSD-3-Clause"; + license = lib.meta.getLicenseFromSpdxId "BSD-3-Clause"; hydraPlatforms = lib.platforms.none; broken = true; } @@ -162199,7 +162199,7 @@ self: { libraryHaskellDepends = [ base ]; testHaskellDepends = [ base ]; description = "Existential type that can be constrained"; - license = lib.licensesSpdx."MIT"; + license = lib.meta.getLicenseFromSpdxId "MIT"; } ) { }; @@ -162343,7 +162343,7 @@ self: { ]; testToolDepends = [ hspec-discover ]; description = "Constraint manipulation"; - license = lib.licensesSpdx."BSD-2-Clause"; + license = lib.meta.getLicenseFromSpdxId "BSD-2-Clause"; } ) { }; @@ -162724,7 +162724,7 @@ self: { transformers-base ]; description = "Concurrent PostgreSQL data consumers"; - license = lib.licensesSpdx."BSD-3-Clause"; + license = lib.meta.getLicenseFromSpdxId "BSD-3-Clause"; } ) { }; @@ -162788,7 +162788,7 @@ self: { transformers-base ]; description = "Concurrent PostgreSQL data consumers"; - license = lib.licensesSpdx."BSD-3-Clause"; + license = lib.meta.getLicenseFromSpdxId "BSD-3-Clause"; hydraPlatforms = lib.platforms.none; } ) { }; @@ -162826,7 +162826,7 @@ self: { transformers-base ]; description = "Prometheus metrics for the consumers library"; - license = lib.licensesSpdx."BSD-3-Clause"; + license = lib.meta.getLicenseFromSpdxId "BSD-3-Clause"; } ) { }; @@ -162908,7 +162908,7 @@ self: { template-haskell ]; description = "Assorted concrete container types"; - license = lib.licensesSpdx."BSD-3-Clause"; + license = lib.meta.getLicenseFromSpdxId "BSD-3-Clause"; hydraPlatforms = lib.platforms.none; } ) { }; @@ -163222,7 +163222,7 @@ self: { text-show ]; description = "Generate art from context-free grammars"; - license = lib.licensesSpdx."BSD-3-Clause"; + license = lib.meta.getLicenseFromSpdxId "BSD-3-Clause"; mainProgram = "examples"; } ) { }; @@ -163476,7 +163476,7 @@ self: { weigh ]; description = "Unified interface for primitive arrays"; - license = lib.licensesSpdx."BSD-3-Clause"; + license = lib.meta.getLicenseFromSpdxId "BSD-3-Clause"; } ) { }; @@ -163831,7 +163831,7 @@ self: { witherable ]; description = "Higher-order functions with their function arguments at the end, for channeling the full power of BlockArguments and LambdaCase"; - license = lib.licensesSpdx."BSD-2-Clause"; + license = lib.meta.getLicenseFromSpdxId "BSD-2-Clause"; } ) { }; @@ -164598,7 +164598,7 @@ self: { template-haskell ]; description = "Statically typed unit conversions"; - license = lib.licensesSpdx."BSD-3-Clause"; + license = lib.meta.getLicenseFromSpdxId "BSD-3-Clause"; } ) { }; @@ -164764,7 +164764,7 @@ self: { ]; doHaddock = false; description = "A type-safe client generator for Convex for both Rust and Python"; - license = lib.licensesSpdx."MIT"; + license = lib.meta.getLicenseFromSpdxId "MIT"; hydraPlatforms = lib.platforms.none; mainProgram = "convex-schema-parser"; broken = true; @@ -164798,7 +164798,7 @@ self: { Unique ]; description = "Convex hull"; - license = lib.licensesSpdx."GPL-3.0-only"; + license = lib.meta.getLicenseFromSpdxId "GPL-3.0-only"; hydraPlatforms = lib.platforms.none; broken = true; } @@ -164901,7 +164901,7 @@ self: { time ]; description = "For serving cookies"; - license = lib.licensesSpdx."Apache-2.0"; + license = lib.meta.getLicenseFromSpdxId "Apache-2.0"; hydraPlatforms = lib.platforms.none; broken = true; } @@ -164961,7 +164961,7 @@ self: { megaparsec ]; description = "Parser for the Cook markup language"; - license = lib.licensesSpdx."MIT"; + license = lib.meta.getLicenseFromSpdxId "MIT"; hydraPlatforms = lib.platforms.none; mainProgram = "cooklang-hs"; broken = true; @@ -165917,7 +165917,7 @@ self: { ]; doHaddock = false; description = "System for verifying the correctness of generated Copilot programs"; - license = lib.licensesSpdx."BSD-3-Clause"; + license = lib.meta.getLicenseFromSpdxId "BSD-3-Clause"; hydraPlatforms = lib.platforms.none; mainProgram = "verify-examples"; broken = true; @@ -166288,7 +166288,7 @@ self: { ]; executableHaskellDepends = [ base ]; description = "Print the Core representation of a binding with a GHC plugin"; - license = lib.licensesSpdx."BSD-3-Clause"; + license = lib.meta.getLicenseFromSpdxId "BSD-3-Clause"; mainProgram = "core-of-name"; } ) { }; @@ -166745,7 +166745,7 @@ self: { text ]; description = "Types for interaction with CoreNLP"; - license = lib.licensesSpdx."AGPL-3.0-or-later"; + license = lib.meta.getLicenseFromSpdxId "AGPL-3.0-or-later"; hydraPlatforms = lib.platforms.none; broken = true; } @@ -166800,7 +166800,7 @@ self: { transformers ]; description = "classy optical monadic state"; - license = lib.licensesSpdx."BSD-2-Clause-Patent"; + license = lib.meta.getLicenseFromSpdxId "BSD-2-Clause-Patent"; } ) { }; @@ -167319,7 +167319,7 @@ self: { tasty-hunit ]; description = "Countable, Searchable, Finite, Empty classes"; - license = lib.licensesSpdx."BSD-3-Clause"; + license = lib.meta.getLicenseFromSpdxId "BSD-3-Clause"; } ) { }; @@ -167485,7 +167485,7 @@ self: { text ]; description = "Country data type and functions"; - license = lib.licensesSpdx."BSD-3-Clause"; + license = lib.meta.getLicenseFromSpdxId "BSD-3-Clause"; } ) { }; @@ -167659,7 +167659,7 @@ self: { tasty-hunit ]; description = "Well-conditioned estimation of large-dimensional covariance matrices"; - license = lib.licensesSpdx."GPL-3.0-or-later"; + license = lib.meta.getLicenseFromSpdxId "GPL-3.0-or-later"; maintainers = [ lib.maintainers.dschrempf ]; } ) { }; @@ -167737,7 +167737,7 @@ self: { vector ]; description = "Standalone IR for Cardano scripts"; - license = lib.licensesSpdx."Apache-2.0"; + license = lib.meta.getLicenseFromSpdxId "Apache-2.0"; hydraPlatforms = lib.platforms.none; broken = true; } @@ -167790,7 +167790,7 @@ self: { semirings ]; description = "Coya monoids"; - license = lib.licensesSpdx."BSD-3-Clause"; + license = lib.meta.getLicenseFromSpdxId "BSD-3-Clause"; } ) { }; @@ -167825,7 +167825,7 @@ self: { text ]; description = "Haskell bindings to the CozoDB C API"; - license = lib.licensesSpdx."MPL-2.0"; + license = lib.meta.getLicenseFromSpdxId "MPL-2.0"; hydraPlatforms = lib.platforms.none; broken = true; } @@ -168141,7 +168141,7 @@ self: { vector-algorithms ]; description = "Competitive programming problemsetting toolchain"; - license = lib.licensesSpdx."MIT"; + license = lib.meta.getLicenseFromSpdxId "MIT"; hydraPlatforms = lib.platforms.none; broken = true; } @@ -168356,7 +168356,7 @@ self: { executableHaskellDepends = [ base ]; testHaskellDepends = [ base ]; description = "A library to detect CPU features"; - license = lib.licensesSpdx."BSD-3-Clause"; + license = lib.meta.getLicenseFromSpdxId "BSD-3-Clause"; mainProgram = "cpu-features-demo"; } ) { }; @@ -168380,7 +168380,7 @@ self: { enumset ]; description = "Binding for the cpuid machine instruction on x86 compatible processors"; - license = lib.licensesSpdx."GPL-2.0-only"; + license = lib.meta.getLicenseFromSpdxId "GPL-2.0-only"; platforms = lib.platforms.x86; } ) { }; @@ -168580,7 +168580,7 @@ self: { uuid ]; description = "Cassandra CQL binary protocol"; - license = lib.licensesSpdx."0BSD"; + license = lib.meta.getLicenseFromSpdxId "0BSD"; hydraPlatforms = lib.platforms.none; } ) { }; @@ -169230,7 +169230,7 @@ self: { tasty-golden ]; description = "Crack various integer and floating-point data formats"; - license = lib.licensesSpdx."BSD-3-Clause"; + license = lib.meta.getLicenseFromSpdxId "BSD-3-Clause"; mainProgram = "crackNum"; } ) { }; @@ -169738,7 +169738,7 @@ self: { criterion ]; description = "crc32c"; - license = lib.licensesSpdx."BSD-3-Clause"; + license = lib.meta.getLicenseFromSpdxId "BSD-3-Clause"; platforms = lib.platforms.x86; } ) { }; @@ -169843,7 +169843,7 @@ self: { transformers ]; description = "Garbage collected event folding CRDT"; - license = lib.licensesSpdx."MIT"; + license = lib.meta.getLicenseFromSpdxId "MIT"; } ) { }; @@ -169916,7 +169916,7 @@ self: { test-framework-quickcheck2 ]; description = "Framework for artificial life experiments"; - license = lib.licensesSpdx."BSD-3-Clause"; + license = lib.meta.getLicenseFromSpdxId "BSD-3-Clause"; hydraPlatforms = lib.platforms.none; broken = true; } @@ -170122,7 +170122,7 @@ self: { unliftio ]; description = "Reasoning about amortized time complexity"; - license = lib.licensesSpdx."BSD-3-Clause"; + license = lib.meta.getLicenseFromSpdxId "BSD-3-Clause"; mainProgram = "creditmonad"; } ) { }; @@ -170199,7 +170199,7 @@ self: { vector ]; description = "A clean aeson wrapper"; - license = lib.licensesSpdx."BSD-3-Clause"; + license = lib.meta.getLicenseFromSpdxId "BSD-3-Clause"; } ) { }; @@ -170693,7 +170693,7 @@ self: { vector ]; description = "A simple tool for comparing in Criterion benchmark results"; - license = lib.licensesSpdx."BSD-3-Clause"; + license = lib.meta.getLicenseFromSpdxId "BSD-3-Clause"; hydraPlatforms = lib.platforms.none; mainProgram = "criterion-cmp"; broken = true; @@ -171240,7 +171240,7 @@ self: { unliftio ]; description = "Encryption and decryption"; - license = lib.licensesSpdx."MIT"; + license = lib.meta.getLicenseFromSpdxId "MIT"; } ) { }; @@ -171279,7 +171279,7 @@ self: { text ]; description = "Dead simple broken links checker on local HTML folders"; - license = lib.licensesSpdx."ISC"; + license = lib.meta.getLicenseFromSpdxId "ISC"; hydraPlatforms = lib.platforms.none; mainProgram = "croque-mort"; broken = true; @@ -171366,7 +171366,7 @@ self: { what4 ]; description = "Crucible is a library for language-agnostic symbolic simulation"; - license = lib.licensesSpdx."BSD-3-Clause"; + license = lib.meta.getLicenseFromSpdxId "BSD-3-Clause"; } ) { }; @@ -171433,7 +171433,7 @@ self: { text ]; description = "An interactive debugger for Crucible programs"; - license = lib.licensesSpdx."BSD-3-Clause"; + license = lib.meta.getLicenseFromSpdxId "BSD-3-Clause"; hydraPlatforms = lib.platforms.none; mainProgram = "crucible-debug"; broken = true; @@ -171520,7 +171520,7 @@ self: { what4 ]; description = "Support for translating and executing LLVM code in Crucible"; - license = lib.licensesSpdx."BSD-3-Clause"; + license = lib.meta.getLicenseFromSpdxId "BSD-3-Clause"; hydraPlatforms = lib.platforms.none; broken = true; } @@ -171588,7 +171588,7 @@ self: { what4 ]; description = "An implementation of symbolic I/O primitives for Crucible"; - license = lib.licensesSpdx."BSD-3-Clause"; + license = lib.meta.getLicenseFromSpdxId "BSD-3-Clause"; } ) { }; @@ -171648,7 +171648,7 @@ self: { what4 ]; description = "A syntax for reading and writing Crucible control-flow graphs"; - license = lib.licensesSpdx."BSD-3-Clause"; + license = lib.meta.getLicenseFromSpdxId "BSD-3-Clause"; } ) { }; @@ -171811,7 +171811,7 @@ self: { yaml ]; description = "Simple top-level library for Crucible Simulation"; - license = lib.licensesSpdx."BSD-3-Clause"; + license = lib.meta.getLicenseFromSpdxId "BSD-3-Clause"; hydraPlatforms = lib.platforms.none; } ) { }; @@ -171938,7 +171938,7 @@ self: { what4 ]; description = "A verification tool for C programs"; - license = lib.licensesSpdx."BSD-3-Clause"; + license = lib.meta.getLicenseFromSpdxId "BSD-3-Clause"; hydraPlatforms = lib.platforms.none; } ) { }; @@ -172190,7 +172190,7 @@ self: { QuickCheck ]; description = "An educational tool for studying classical cryptography schemes"; - license = lib.licensesSpdx."BSD-3-Clause"; + license = lib.meta.getLicenseFromSpdxId "BSD-3-Clause"; hydraPlatforms = lib.platforms.none; } ) { }; @@ -172705,7 +172705,7 @@ self: { tasty-hunit ]; description = "Adaptation of the crypto-rng library for the effectful ecosystem"; - license = lib.licensesSpdx."MIT"; + license = lib.meta.getLicenseFromSpdxId "MIT"; } ) { }; @@ -173306,7 +173306,7 @@ self: { criterion ]; description = "Fast, pure and practical SHA-512 implementation"; - license = lib.licensesSpdx."BSD-3-Clause"; + license = lib.meta.getLicenseFromSpdxId "BSD-3-Clause"; } ) { }; @@ -173565,7 +173565,7 @@ self: { ]; doHaddock = false; description = "Cryptol: The Language of Cryptography"; - license = lib.licensesSpdx."BSD-3-Clause"; + license = lib.meta.getLicenseFromSpdxId "BSD-3-Clause"; hydraPlatforms = lib.platforms.none; } ) { }; @@ -175308,7 +175308,7 @@ self: { ]; testToolDepends = [ tasty-discover ]; description = "generates Haskell bindings for CSS classes"; - license = lib.licensesSpdx."BSD-3-Clause"; + license = lib.meta.getLicenseFromSpdxId "BSD-3-Clause"; } ) { }; @@ -175715,7 +175715,7 @@ self: { transformers ]; description = "extracts data from a CSV file"; - license = lib.licensesSpdx."GPL-3.0-or-later"; + license = lib.meta.getLicenseFromSpdxId "GPL-3.0-or-later"; hydraPlatforms = lib.platforms.none; broken = true; } @@ -176177,7 +176177,7 @@ self: { ]; doHaddock = false; description = "Haskell Implementation of Cuckoo Filters"; - license = lib.licensesSpdx."BSD-3-Clause"; + license = lib.meta.getLicenseFromSpdxId "BSD-3-Clause"; hydraPlatforms = lib.platforms.none; broken = true; } @@ -176446,7 +176446,7 @@ self: { tree-diff ]; description = "CDDL Generator and test utilities"; - license = lib.licensesSpdx."Apache-2.0"; + license = lib.meta.getLicenseFromSpdxId "Apache-2.0"; hydraPlatforms = lib.platforms.none; mainProgram = "cuddle"; broken = true; @@ -176497,7 +176497,7 @@ self: { ]; testToolDepends = [ hspec-discover ]; description = "Support for construction, rendering, and parsing of CUE sheets"; - license = lib.licensesSpdx."BSD-3-Clause"; + license = lib.meta.getLicenseFromSpdxId "BSD-3-Clause"; } ) { }; @@ -176759,7 +176759,7 @@ self: { text ]; description = "Curly braces (brackets) expanding"; - license = lib.licensesSpdx."LGPL-3.0-only"; + license = lib.meta.getLicenseFromSpdxId "LGPL-3.0-only"; hydraPlatforms = lib.platforms.none; broken = true; } @@ -177732,7 +177732,7 @@ self: { template-haskell ]; description = "Customizable string interpolation quasiquoters"; - license = lib.licensesSpdx."BSD-3-Clause"; + license = lib.meta.getLicenseFromSpdxId "BSD-3-Clause"; hydraPlatforms = lib.platforms.none; broken = true; } @@ -177982,7 +177982,7 @@ self: { text ]; description = "Common Vulnerability Scoring System"; - license = lib.licensesSpdx."BSD-3-Clause"; + license = lib.meta.getLicenseFromSpdxId "BSD-3-Clause"; } ) { }; @@ -178295,7 +178295,7 @@ self: { ]; doHaddock = false; description = "Digits 0-9"; - license = lib.licensesSpdx."MIT"; + license = lib.meta.getLicenseFromSpdxId "MIT"; hydraPlatforms = lib.platforms.none; broken = true; } @@ -178951,7 +178951,7 @@ self: { optics-core ]; description = "Use OverloadedRecordDot for nested optics access"; - license = lib.licensesSpdx."BSD-3-Clause"; + license = lib.meta.getLicenseFromSpdxId "BSD-3-Clause"; } ) { }; @@ -178985,7 +178985,7 @@ self: { ]; doHaddock = false; description = "Servant support for lucid2"; - license = lib.licensesSpdx."BSD-3-Clause"; + license = lib.meta.getLicenseFromSpdxId "BSD-3-Clause"; } ) { }; @@ -179024,7 +179024,7 @@ self: { ]; doHaddock = false; description = "SQLite client library"; - license = lib.licensesSpdx."BSD-3-Clause"; + license = lib.meta.getLicenseFromSpdxId "BSD-3-Clause"; hydraPlatforms = lib.platforms.none; broken = true; } @@ -179474,7 +179474,7 @@ self: { mv contrib/darcs_completion $out/share/bash-completion/completions/darcs ''; description = "a distributed, interactive, smart revision control system"; - license = lib.licensesSpdx."GPL-2.0-or-later"; + license = lib.meta.getLicenseFromSpdxId "GPL-2.0-or-later"; mainProgram = "darcs"; } ) { }; @@ -180841,7 +180841,7 @@ self: { QuickCheck ]; description = "Simple functional ring type"; - license = lib.licensesSpdx."BSD-3-Clause"; + license = lib.meta.getLicenseFromSpdxId "BSD-3-Clause"; } ) { }; @@ -180881,7 +180881,7 @@ self: { constraints ]; description = "Define Backwards Compatibility Schemes for Arbitrary Data"; - license = lib.licensesSpdx."MIT"; + license = lib.meta.getLicenseFromSpdxId "MIT"; } ) { }; @@ -181002,7 +181002,7 @@ self: { ]; doHaddock = false; description = "Fast and safe implementation of common compiler machinery"; - license = lib.licensesSpdx."AGPL-3.0-only"; + license = lib.meta.getLicenseFromSpdxId "AGPL-3.0-only"; } ) { }; @@ -181027,7 +181027,7 @@ self: { mtl ]; description = "A class for types with a default value"; - license = lib.licensesSpdx."BSD-3-Clause"; + license = lib.meta.getLicenseFromSpdxId "BSD-3-Clause"; } ) { }; @@ -181039,7 +181039,7 @@ self: { sha256 = "1d6m12yv5vjciwbig484jrv9qpy7v762k51rpalcimhbzg231r8a"; libraryHaskellDepends = [ data-default ]; description = "A class for types with a default value (compatibility shim)"; - license = lib.licensesSpdx."BSD-3-Clause"; + license = lib.meta.getLicenseFromSpdxId "BSD-3-Clause"; } ) { }; @@ -181145,7 +181145,7 @@ self: { data-default-class ]; description = "Default instances for types in base"; - license = lib.licensesSpdx."BSD-3-Clause"; + license = lib.meta.getLicenseFromSpdxId "BSD-3-Clause"; hydraPlatforms = lib.platforms.none; broken = true; } @@ -181216,7 +181216,7 @@ self: { data-default-class ]; description = "Default instances for types in containers"; - license = lib.licensesSpdx."BSD-3-Clause"; + license = lib.meta.getLicenseFromSpdxId "BSD-3-Clause"; hydraPlatforms = lib.platforms.none; broken = true; } @@ -181239,7 +181239,7 @@ self: { dlist ]; description = "Default instances for types in dlist"; - license = lib.licensesSpdx."BSD-3-Clause"; + license = lib.meta.getLicenseFromSpdxId "BSD-3-Clause"; hydraPlatforms = lib.platforms.none; broken = true; } @@ -181283,7 +181283,7 @@ self: { old-locale ]; description = "Default instances for types in old-locale"; - license = lib.licensesSpdx."BSD-3-Clause"; + license = lib.meta.getLicenseFromSpdxId "BSD-3-Clause"; hydraPlatforms = lib.platforms.none; broken = true; } @@ -181616,7 +181616,7 @@ self: { ]; testToolDepends = [ tasty-discover ]; description = "A basic framework for effect systems based on effects represented by GADTs"; - license = lib.licensesSpdx."MPL-2.0"; + license = lib.meta.getLicenseFromSpdxId "MPL-2.0"; } ) { }; @@ -181654,7 +181654,7 @@ self: { ]; testToolDepends = [ tasty-discover ]; description = "A basic framework for effect systems based on effects represented by GADTs"; - license = lib.licensesSpdx."MPL-2.0"; + license = lib.meta.getLicenseFromSpdxId "MPL-2.0"; } ) { }; @@ -181705,7 +181705,7 @@ self: { ]; testToolDepends = [ tasty-discover ]; description = "Template Haskell utilities for the data-effects library"; - license = lib.licensesSpdx."MPL-2.0"; + license = lib.meta.getLicenseFromSpdxId "MPL-2.0"; } ) { }; @@ -181731,7 +181731,7 @@ self: { primitive ]; description = "Coerce between unlifted boxed and lifted types"; - license = lib.licensesSpdx."MIT"; + license = lib.meta.getLicenseFromSpdxId "MIT"; } ) { }; @@ -182071,7 +182071,7 @@ self: { hashable ]; description = "Fixpoint data types"; - license = lib.licensesSpdx."BSD-3-Clause"; + license = lib.meta.getLicenseFromSpdxId "BSD-3-Clause"; } ) { }; @@ -182178,7 +182178,7 @@ self: { HUnit ]; description = "Specify that lifted values were forced to WHNF or NF"; - license = lib.licensesSpdx."MIT"; + license = lib.meta.getLicenseFromSpdxId "MIT"; hydraPlatforms = lib.platforms.none; broken = true; } @@ -182200,7 +182200,7 @@ self: { hspec ]; description = "A simple multi-way tree data structure"; - license = lib.licensesSpdx."Apache-2.0"; + license = lib.meta.getLicenseFromSpdxId "Apache-2.0"; hydraPlatforms = lib.platforms.none; broken = true; } @@ -182268,7 +182268,7 @@ self: { distributive ]; description = "Updatable analogue of Distributive functors"; - license = lib.licensesSpdx."BSD-3-Clause"; + license = lib.meta.getLicenseFromSpdxId "BSD-3-Clause"; } ) { }; @@ -182976,7 +182976,7 @@ self: { sha256 = "00i8saxn6wdp9k3q4h8sp46pnhx37s3infipv3db8r6llhma2ns1"; libraryHaskellDepends = [ base ]; description = "A data type for non-exclusive disjunction"; - license = lib.licensesSpdx."BSD-3-Clause"; + license = lib.meta.getLicenseFromSpdxId "BSD-3-Clause"; } ) { }; @@ -183042,7 +183042,7 @@ self: { text ]; description = "Read PDF form fields"; - license = lib.licensesSpdx."MIT"; + license = lib.meta.getLicenseFromSpdxId "MIT"; hydraPlatforms = lib.platforms.none; mainProgram = "pdfreader"; broken = true; @@ -183112,7 +183112,7 @@ self: { raw-strings-qq ]; description = "Prometheus metrics text format"; - license = lib.licensesSpdx."BSD-3-Clause"; + license = lib.meta.getLicenseFromSpdxId "BSD-3-Clause"; } ) { }; @@ -183166,7 +183166,7 @@ self: { test-framework-quickcheck2 ]; description = "R-Tree is a spatial data structure similar to Quadtrees or B-Trees"; - license = lib.licensesSpdx."MIT"; + license = lib.meta.getLicenseFromSpdxId "MIT"; hydraPlatforms = lib.platforms.none; broken = true; } @@ -183191,7 +183191,7 @@ self: { transformers ]; description = "Unify STRef and IORef in plain Haskell 98"; - license = lib.licensesSpdx."BSD-3-Clause"; + license = lib.meta.getLicenseFromSpdxId "BSD-3-Clause"; maintainers = [ lib.maintainers.thielema ]; } ) { }; @@ -183286,7 +183286,7 @@ self: { unordered-containers ]; description = "Data.Reify for GADTs"; - license = lib.licensesSpdx."BSD-3-Clause"; + license = lib.meta.getLicenseFromSpdxId "BSD-3-Clause"; mainProgram = "example-ast"; } ) { }; @@ -184011,7 +184011,7 @@ self: { ]; testToolDepends = [ hspec-discover ]; description = "SVD (System view description) file handling"; - license = lib.licensesSpdx."BSD-3-Clause"; + license = lib.meta.getLicenseFromSpdxId "BSD-3-Clause"; mainProgram = "pretty-svd"; } ) { }; @@ -184300,7 +184300,7 @@ self: { vector ]; description = "Dynamic growable resizable mutable generic vector"; - license = lib.licensesSpdx."BSD-3-Clause"; + license = lib.meta.getLicenseFromSpdxId "BSD-3-Clause"; hydraPlatforms = lib.platforms.none; broken = true; } @@ -184421,7 +184421,7 @@ self: { sha256 = "1zq9xsiky6mf0b0n83za0y8w28fl4gf53h49d1zd220dqmxx057q"; libraryHaskellDepends = [ base ]; description = "Encryption library"; - license = lib.licensesSpdx."MIT"; + license = lib.meta.getLicenseFromSpdxId "MIT"; } ) { }; @@ -184608,7 +184608,7 @@ self: { ]; testToolDepends = [ tasty-discover ]; description = "Datadog tracing client and mock agent"; - license = lib.licensesSpdx."BSD-3-Clause"; + license = lib.meta.getLicenseFromSpdxId "BSD-3-Clause"; hydraPlatforms = lib.platforms.none; mainProgram = "datadog-agent"; } @@ -184924,7 +184924,7 @@ self: { process ]; description = "A fast, safe, and intuitive DataFrame library"; - license = lib.licensesSpdx."GPL-3.0-or-later"; + license = lib.meta.getLicenseFromSpdxId "GPL-3.0-or-later"; } ) { }; @@ -185042,7 +185042,7 @@ self: { random ]; description = "A fast, safe, and intuitive DataFrame library"; - license = lib.licensesSpdx."MIT"; + license = lib.meta.getLicenseFromSpdxId "MIT"; hydraPlatforms = lib.platforms.none; } ) { }; @@ -185067,7 +185067,7 @@ self: { ]; testHaskellDepends = [ base ]; description = "Converts between dataframes and hasktorch tensors"; - license = lib.licensesSpdx."MIT"; + license = lib.meta.getLicenseFromSpdxId "MIT"; } ) { }; @@ -185121,7 +185121,7 @@ self: { vector ]; description = "Persistent database integration for the dataframe library"; - license = lib.licensesSpdx."GPL-3.0-or-later"; + license = lib.meta.getLicenseFromSpdxId "GPL-3.0-or-later"; } ) { }; @@ -185440,7 +185440,7 @@ self: { wai ]; description = "Haskell bindings for Datastar"; - license = lib.licensesSpdx."MIT"; + license = lib.meta.getLicenseFromSpdxId "MIT"; } ) { }; @@ -185813,7 +185813,7 @@ self: { criterion ]; description = "Generation and traversal of compressed directed acyclic dawg graphs"; - license = lib.licensesSpdx."BSD-3-Clause"; + license = lib.meta.getLicenseFromSpdxId "BSD-3-Clause"; hydraPlatforms = lib.platforms.none; broken = true; } @@ -185836,7 +185836,7 @@ self: { kan-extensions ]; description = "A comonoid w.r.t. Day"; - license = lib.licensesSpdx."BSD-3-Clause"; + license = lib.meta.getLicenseFromSpdxId "BSD-3-Clause"; } ) { }; @@ -187620,7 +187620,7 @@ self: { ]; doHaddock = false; description = "Haskell bindings for Dear ImGui"; - license = lib.licensesSpdx."BSD-3-Clause"; + license = lib.meta.getLicenseFromSpdxId "BSD-3-Clause"; hydraPlatforms = lib.platforms.none; broken = true; } @@ -187728,7 +187728,7 @@ self: { text ]; description = "Modules for working with the Debian package system"; - license = lib.licensesSpdx."BSD-3-Clause"; + license = lib.meta.getLicenseFromSpdxId "BSD-3-Clause"; } ) { }; @@ -187821,7 +187821,7 @@ self: { text ]; description = "Modules for working with the Debian package system"; - license = lib.licensesSpdx."BSD-3-Clause"; + license = lib.meta.getLicenseFromSpdxId "BSD-3-Clause"; hydraPlatforms = lib.platforms.none; } ) { }; @@ -187918,7 +187918,7 @@ self: { tasty-quickcheck ]; description = "de Bruijn indices and levels"; - license = lib.licensesSpdx."BSD-3-Clause"; + license = lib.meta.getLicenseFromSpdxId "BSD-3-Clause"; } ) { }; @@ -187941,7 +187941,7 @@ self: { some ]; description = "de Bruijn indices and levels"; - license = lib.licensesSpdx."BSD-3-Clause"; + license = lib.meta.getLicenseFromSpdxId "BSD-3-Clause"; } ) { }; @@ -188284,7 +188284,7 @@ self: { tasty-golden ]; description = "Like Debug.Trace but writing to files."; - license = lib.licensesSpdx."MIT"; + license = lib.meta.getLicenseFromSpdxId "MIT"; hydraPlatforms = lib.platforms.none; broken = true; } @@ -188370,7 +188370,7 @@ self: { optparse-applicative ]; description = "Utilities for making your applications more debuggable"; - license = lib.licensesSpdx."BSD-3-Clause"; + license = lib.meta.getLicenseFromSpdxId "BSD-3-Clause"; } ) { }; @@ -188787,7 +188787,7 @@ self: { witherable ]; description = "Deeply-nested, multiple key type maps"; - license = lib.licensesSpdx."BSD-3-Clause"; + license = lib.meta.getLicenseFromSpdxId "BSD-3-Clause"; } ) { }; @@ -189103,7 +189103,7 @@ self: { stm ]; description = "Candidate NFData Instances for Types in base"; - license = lib.licensesSpdx."MIT"; + license = lib.meta.getLicenseFromSpdxId "MIT"; hydraPlatforms = lib.platforms.none; broken = true; } @@ -189216,7 +189216,7 @@ self: { semigroupoids ]; description = "Applicative maps"; - license = lib.licensesSpdx."BSD-3-Clause"; + license = lib.meta.getLicenseFromSpdxId "BSD-3-Clause"; hydraPlatforms = lib.platforms.none; broken = true; } @@ -189263,7 +189263,7 @@ self: { tasty-quickcheck ]; description = "Abstractions over deferred folds"; - license = lib.licensesSpdx."MIT"; + license = lib.meta.getLicenseFromSpdxId "MIT"; } ) { }; @@ -189559,7 +189559,7 @@ self: { sop-core ]; description = "Defunctionalization helpers"; - license = lib.licensesSpdx."BSD-3-Clause"; + license = lib.meta.getLicenseFromSpdxId "BSD-3-Clause"; hydraPlatforms = lib.platforms.none; } ) { }; @@ -189581,7 +189581,7 @@ self: { singleton-bool ]; description = "Defunctionalization helpers: booleans"; - license = lib.licensesSpdx."BSD-3-Clause"; + license = lib.meta.getLicenseFromSpdxId "BSD-3-Clause"; hydraPlatforms = lib.platforms.none; broken = true; } @@ -189595,7 +189595,7 @@ self: { sha256 = "0yy02va22bhxk1gl1m1k4c84sc788g891p5m81mr3bai5y7vq402"; libraryHaskellDepends = [ base ]; description = "Defunctionalization helpers: core definitions"; - license = lib.licensesSpdx."BSD-3-Clause"; + license = lib.meta.getLicenseFromSpdxId "BSD-3-Clause"; } ) { }; @@ -189616,7 +189616,7 @@ self: { sop-core ]; description = "Defunctionalization helpers: lists"; - license = lib.licensesSpdx."BSD-3-Clause"; + license = lib.meta.getLicenseFromSpdxId "BSD-3-Clause"; } ) { }; @@ -189820,7 +189820,7 @@ self: { Unique ]; description = "Delaunay tessellation"; - license = lib.licensesSpdx."GPL-3.0-only"; + license = lib.meta.getLicenseFromSpdxId "GPL-3.0-only"; hydraPlatforms = lib.platforms.none; broken = true; } @@ -189961,7 +189961,7 @@ self: { base ]; description = "Parse bounce messages per RFC3464, RFC3463"; - license = lib.licensesSpdx."BSD-3-Clause"; + license = lib.meta.getLicenseFromSpdxId "BSD-3-Clause"; } ) { }; @@ -190089,7 +190089,7 @@ self: { ]; testToolDepends = [ hspec-discover ]; description = "Facilities for storing a Haskell value, using delta types"; - license = lib.licensesSpdx."Apache-2.0"; + license = lib.meta.getLicenseFromSpdxId "Apache-2.0"; hydraPlatforms = lib.platforms.none; broken = true; } @@ -190122,7 +190122,7 @@ self: { ]; testToolDepends = [ hspec-discover ]; description = "Delta types, also known as change actions"; - license = lib.licensesSpdx."Apache-2.0"; + license = lib.meta.getLicenseFromSpdxId "Apache-2.0"; } ) { }; @@ -190179,7 +190179,7 @@ self: { vector ]; description = "Framework for ∆Q System Development"; - license = lib.licensesSpdx."BSD-3-Clause"; + license = lib.meta.getLicenseFromSpdxId "BSD-3-Clause"; } ) { }; @@ -190245,7 +190245,7 @@ self: { transformers ]; description = "Demangler for C++ mangled names"; - license = lib.licensesSpdx."BSD-3-Clause"; + license = lib.meta.getLicenseFromSpdxId "BSD-3-Clause"; hydraPlatforms = lib.platforms.none; mainProgram = "demangle"; broken = true; @@ -190512,7 +190512,7 @@ self: { unliftio-core ]; description = "Dependency injection for records-of-functions"; - license = lib.licensesSpdx."BSD-3-Clause"; + license = lib.meta.getLicenseFromSpdxId "BSD-3-Clause"; hydraPlatforms = lib.platforms.none; broken = true; } @@ -190582,7 +190582,7 @@ self: { unliftio-core ]; description = "Giving good advice to functions in records-of-functions"; - license = lib.licensesSpdx."BSD-3-Clause"; + license = lib.meta.getLicenseFromSpdxId "BSD-3-Clause"; hydraPlatforms = lib.platforms.none; } ) { }; @@ -190645,7 +190645,7 @@ self: { unordered-containers ]; description = "A dynamic environment for dependency injection"; - license = lib.licensesSpdx."BSD-3-Clause"; + license = lib.meta.getLicenseFromSpdxId "BSD-3-Clause"; hydraPlatforms = lib.platforms.none; } ) { }; @@ -190703,7 +190703,7 @@ self: { unliftio-core ]; description = "Pair resources files with types within your program"; - license = lib.licensesSpdx."BSD-3-Clause"; + license = lib.meta.getLicenseFromSpdxId "BSD-3-Clause"; hydraPlatforms = lib.platforms.none; } ) { }; @@ -190775,7 +190775,7 @@ self: { some ]; description = "A generalisation of EnumMap to dependent types"; - license = lib.licensesSpdx."BSD-3-Clause"; + license = lib.meta.getLicenseFromSpdxId "BSD-3-Clause"; } ) { }; @@ -190913,7 +190913,7 @@ self: { dependent-sum ]; description = "Dependent finite maps (partial dependent products)"; - license = lib.licensesSpdx."BSD-3-Clause"; + license = lib.meta.getLicenseFromSpdxId "BSD-3-Clause"; } ) { }; @@ -191302,7 +191302,7 @@ self: { tasty-quickcheck ]; description = "Double-ended queues"; - license = lib.licensesSpdx."MIT"; + license = lib.meta.getLicenseFromSpdxId "MIT"; } ) { }; @@ -191556,7 +191556,7 @@ self: { HUnit ]; description = "This package generates data constructor predicate functions"; - license = lib.licensesSpdx."BSD-3-Clause"; + license = lib.meta.getLicenseFromSpdxId "BSD-3-Clause"; } ) { }; @@ -191635,7 +191635,7 @@ self: { primitive-unaligned ]; description = "Derive Prim and PrimUnaligned"; - license = lib.licensesSpdx."GPL-3.0-or-later"; + license = lib.meta.getLicenseFromSpdxId "GPL-3.0-or-later"; hydraPlatforms = lib.platforms.none; broken = true; } @@ -191851,7 +191851,7 @@ self: { bytestring ]; description = "Type driven generic aeson instance customisation"; - license = lib.licensesSpdx."BSD-3-Clause"; + license = lib.meta.getLicenseFromSpdxId "BSD-3-Clause"; } ) { }; @@ -191937,7 +191937,7 @@ self: { HUnit ]; description = "Derive a Show instance without field selector names"; - license = lib.licensesSpdx."BSD-3-Clause"; + license = lib.meta.getLicenseFromSpdxId "BSD-3-Clause"; } ) { }; @@ -191978,7 +191978,7 @@ self: { unliftio-core ]; description = "Derive instances for monad transformer stacks"; - license = lib.licensesSpdx."BSD-3-Clause"; + license = lib.meta.getLicenseFromSpdxId "BSD-3-Clause"; } ) { }; @@ -191991,7 +191991,7 @@ self: { libraryHaskellDepends = [ base ]; testHaskellDepends = [ base ]; description = "Deriving via first-class functions"; - license = lib.licensesSpdx."BSD-3-Clause"; + license = lib.meta.getLicenseFromSpdxId "BSD-3-Clause"; } ) { }; @@ -192073,7 +192073,7 @@ self: { HUnit ]; description = "Parse and render JSON simply"; - license = lib.licensesSpdx."MIT"; + license = lib.meta.getLicenseFromSpdxId "MIT"; hydraPlatforms = lib.platforms.none; mainProgram = "derulo"; broken = true; @@ -192131,7 +192131,7 @@ self: { transformers ]; description = "Combinators for describing binary data structures"; - license = lib.licensesSpdx."BSD-3-Clause"; + license = lib.meta.getLicenseFromSpdxId "BSD-3-Clause"; hydraPlatforms = lib.platforms.none; broken = true; } @@ -192659,7 +192659,7 @@ self: { text ]; description = "Conversion between Devanagari Unicode, Harvard-Kyoto, IAST and ISO15919"; - license = lib.licensesSpdx."BSD-3-Clause"; + license = lib.meta.getLicenseFromSpdxId "BSD-3-Clause"; hydraPlatforms = lib.platforms.none; broken = true; } @@ -192876,7 +192876,7 @@ self: { xmlbf ]; description = "Render and parse df1 logs as HTML"; - license = lib.licensesSpdx."BSD-3-Clause"; + license = lib.meta.getLicenseFromSpdxId "BSD-3-Clause"; } ) { }; @@ -193008,7 +193008,7 @@ self: { unordered-containers ]; description = "A generic data integrity layer"; - license = lib.licensesSpdx."BSD-3-Clause"; + license = lib.meta.getLicenseFromSpdxId "BSD-3-Clause"; hydraPlatforms = lib.platforms.none; mainProgram = "dfinity-radix-tree-example"; } @@ -193443,7 +193443,7 @@ self: { ]; doCheck = false; description = "A configuration language guaranteed to terminate"; - license = lib.licensesSpdx."BSD-3-Clause"; + license = lib.meta.getLicenseFromSpdxId "BSD-3-Clause"; mainProgram = "dhall"; maintainers = [ lib.maintainers.Gabriella439 ]; } @@ -194193,7 +194193,7 @@ self: { yasi ]; description = "Convert recursive ADTs from and to Dhall"; - license = lib.licensesSpdx."CC0-1.0"; + license = lib.meta.getLicenseFromSpdxId "CC0-1.0"; hydraPlatforms = lib.platforms.none; broken = true; } @@ -194272,7 +194272,7 @@ self: { unordered-containers ]; description = "Encrypt Decrypt Dhall expressions"; - license = lib.licensesSpdx."BSD-3-Clause"; + license = lib.meta.getLicenseFromSpdxId "BSD-3-Clause"; hydraPlatforms = lib.platforms.none; mainProgram = "dhall-secret"; } @@ -194345,7 +194345,7 @@ self: { text ]; description = "Render dhall text with shell commands as function arguments"; - license = lib.licensesSpdx."MIT"; + license = lib.meta.getLicenseFromSpdxId "MIT"; hydraPlatforms = lib.platforms.none; mainProgram = "dhall-text-shell"; broken = true; @@ -194422,7 +194422,7 @@ self: { text ]; description = "Compile Dhall expressions to Cabal files"; - license = lib.licensesSpdx."MIT"; + license = lib.meta.getLicenseFromSpdxId "MIT"; hydraPlatforms = lib.platforms.none; broken = true; } @@ -194713,7 +194713,7 @@ self: { random ]; description = "abstract syntax tree for multiple programming languages"; - license = lib.licensesSpdx."GPL-3.0-only"; + license = lib.meta.getLicenseFromSpdxId "GPL-3.0-only"; hydraPlatforms = lib.platforms.none; broken = true; } @@ -194747,7 +194747,7 @@ self: { random ]; description = "Intermediate language for static code analysis"; - license = lib.licensesSpdx."GPL-3.0-only"; + license = lib.meta.getLicenseFromSpdxId "GPL-3.0-only"; hydraPlatforms = lib.platforms.none; broken = true; } @@ -194774,7 +194774,7 @@ self: { dhscanner-bitcode ]; description = "knowledge base predicates for static code analysis"; - license = lib.licensesSpdx."GPL-3.0-only"; + license = lib.meta.getLicenseFromSpdxId "GPL-3.0-only"; hydraPlatforms = lib.platforms.none; } ) { }; @@ -196060,7 +196060,7 @@ self: { text ]; description = "A Pandoc filter to express diagrams inline using the Haskell EDSL _Diagrams_"; - license = lib.licensesSpdx."BSD-3-Clause"; + license = lib.meta.getLicenseFromSpdxId "BSD-3-Clause"; mainProgram = "diagrams-pandoc"; } ) { }; @@ -196554,7 +196554,7 @@ self: { ]; testToolDepends = [ hspec-discover ]; description = "A Dialogflow Fulfillment library for Haskell"; - license = lib.licensesSpdx."BSD-3-Clause"; + license = lib.meta.getLicenseFromSpdxId "BSD-3-Clause"; hydraPlatforms = lib.platforms.none; broken = true; } @@ -196582,7 +196582,7 @@ self: { ]; executableHaskellDepends = [ base ]; description = "I/O in Haskell Report 1.2"; - license = lib.licensesSpdx."BSD-3-Clause"; + license = lib.meta.getLicenseFromSpdxId "BSD-3-Clause"; mainProgram = "examples"; } ) { }; @@ -196674,7 +196674,7 @@ self: { random-fu ]; description = "Simplistic D&D style dice-rolling system"; - license = lib.licensesSpdx."Unlicense"; + license = lib.meta.getLicenseFromSpdxId "Unlicense"; mainProgram = "dice"; } ) { }; @@ -197013,7 +197013,7 @@ self: { show-combinators ]; description = "Map file locations across diffs"; - license = lib.licensesSpdx."MIT"; + license = lib.meta.getLicenseFromSpdxId "MIT"; } ) { }; @@ -197392,7 +197392,7 @@ self: { ]; libraryPkgconfigDepends = [ zlib ]; description = "CRC32 and Adler32 hashes for bytestrings"; - license = lib.licensesSpdx."BSD-2-Clause"; + license = lib.meta.getLicenseFromSpdxId "BSD-2-Clause"; } ) { inherit (pkgs) zlib; }; @@ -197941,7 +197941,7 @@ self: { QuickCheck ]; description = "Converts integers to lists of digits and back"; - license = lib.licensesSpdx."BSD-3-Clause"; + license = lib.meta.getLicenseFromSpdxId "BSD-3-Clause"; } ) { }; @@ -197983,7 +197983,7 @@ self: { QuickCheck ]; description = "Directed Graphs"; - license = lib.licensesSpdx."BSD-3-Clause"; + license = lib.meta.getLicenseFromSpdxId "BSD-3-Clause"; } ) { }; @@ -198912,7 +198912,7 @@ self: { unix ]; description = "Platform-agnostic library for filesystem operations"; - license = lib.licensesSpdx."BSD-3-Clause"; + license = lib.meta.getLicenseFromSpdxId "BSD-3-Clause"; hydraPlatforms = lib.platforms.none; } ) { }; @@ -199098,7 +199098,7 @@ self: { unix ]; description = "Stream directory entries in constant memory in vanilla IO"; - license = lib.licensesSpdx."Apache-2.0"; + license = lib.meta.getLicenseFromSpdxId "Apache-2.0"; } ) { }; @@ -199141,7 +199141,7 @@ self: { unix ]; description = "Stream directory entries in constant memory in vanilla IO"; - license = lib.licensesSpdx."Apache-2.0"; + license = lib.meta.getLicenseFromSpdxId "Apache-2.0"; hydraPlatforms = lib.platforms.none; } ) { }; @@ -199297,7 +199297,7 @@ self: { vector ]; description = "Multivariate Dirichlet distribution"; - license = lib.licensesSpdx."BSD-3-Clause"; + license = lib.meta.getLicenseFromSpdxId "BSD-3-Clause"; maintainers = [ lib.maintainers.dschrempf ]; } ) { }; @@ -199521,7 +199521,7 @@ self: { tasty-golden ]; description = "Functional programming language for teaching discrete math"; - license = lib.licensesSpdx."BSD-3-Clause"; + license = lib.meta.getLicenseFromSpdxId "BSD-3-Clause"; hydraPlatforms = lib.platforms.none; mainProgram = "disco"; broken = true; @@ -200230,7 +200230,7 @@ self: { tasty-quickcheck ]; description = "Disjoint containers"; - license = lib.licensesSpdx."BSD-3-Clause"; + license = lib.meta.getLicenseFromSpdxId "BSD-3-Clause"; } ) { }; @@ -200351,7 +200351,7 @@ self: { text ]; description = "On-disk storage, but referentially transparent"; - license = lib.licensesSpdx."BSD-3-Clause"; + license = lib.meta.getLicenseFromSpdxId "BSD-3-Clause"; hydraPlatforms = lib.platforms.none; broken = true; } @@ -200774,7 +200774,7 @@ self: { network-transport-tcp ]; description = "Cloud Haskell: Erlang-style concurrency in Haskell"; - license = lib.licensesSpdx."BSD-3-Clause"; + license = lib.meta.getLicenseFromSpdxId "BSD-3-Clause"; } ) { }; @@ -200814,7 +200814,7 @@ self: { tasty-hunit ]; description = "Cloud Haskell Async API"; - license = lib.licensesSpdx."BSD-3-Clause"; + license = lib.meta.getLicenseFromSpdxId "BSD-3-Clause"; } ) { }; @@ -200925,7 +200925,7 @@ self: { tasty-hunit ]; description = "The Cloud Haskell Application Platform"; - license = lib.licensesSpdx."BSD-3-Clause"; + license = lib.meta.getLicenseFromSpdxId "BSD-3-Clause"; } ) { }; @@ -201006,7 +201006,7 @@ self: { tasty-hunit ]; description = "Execution Framework for The Cloud Haskell Application Platform"; - license = lib.licensesSpdx."BSD-3-Clause"; + license = lib.meta.getLicenseFromSpdxId "BSD-3-Clause"; } ) { }; @@ -201063,7 +201063,7 @@ self: { tasty-quickcheck ]; description = "Cloud Haskell Extras"; - license = lib.licensesSpdx."BSD-3-Clause"; + license = lib.meta.getLicenseFromSpdxId "BSD-3-Clause"; } ) { }; @@ -201500,7 +201500,7 @@ self: { tasty-hunit ]; description = "Simple zero-configuration backend for Cloud Haskell"; - license = lib.licensesSpdx."BSD-3-Clause"; + license = lib.meta.getLicenseFromSpdxId "BSD-3-Clause"; hydraPlatforms = lib.platforms.none; broken = true; } @@ -201567,7 +201567,7 @@ self: { tasty-hunit ]; description = "Supervisors for The Cloud Haskell Application Platform"; - license = lib.licensesSpdx."BSD-3-Clause"; + license = lib.meta.getLicenseFromSpdxId "BSD-3-Clause"; } ) { }; @@ -201594,7 +201594,7 @@ self: { stm ]; description = "Cloud Haskell Test Support"; - license = lib.licensesSpdx."BSD-3-Clause"; + license = lib.meta.getLicenseFromSpdxId "BSD-3-Clause"; } ) { }; @@ -201736,7 +201736,7 @@ self: { tasty ]; description = "Tests and test support tools for distributed-process"; - license = lib.licensesSpdx."BSD-3-Clause"; + license = lib.meta.getLicenseFromSpdxId "BSD-3-Clause"; } ) { }; @@ -201830,7 +201830,7 @@ self: { rank1dynamic ]; description = "Compositional, type-safe, polymorphic static values and closures"; - license = lib.licensesSpdx."BSD-3-Clause"; + license = lib.meta.getLicenseFromSpdxId "BSD-3-Clause"; } ) { }; @@ -202099,7 +202099,7 @@ self: { witherable ]; description = "Unifying Parsers, Printers & Grammars"; - license = lib.licensesSpdx."BSD-3-Clause"; + license = lib.meta.getLicenseFromSpdxId "BSD-3-Clause"; } ) { }; @@ -202122,7 +202122,7 @@ self: { text ]; description = "ditto is a type-safe HTML form generation and validation library"; - license = lib.licensesSpdx."BSD-3-Clause"; + license = lib.meta.getLicenseFromSpdxId "BSD-3-Clause"; } ) { }; @@ -202377,7 +202377,7 @@ self: { pretty ]; description = "Generate Haskell code from a type"; - license = lib.licensesSpdx."BSD-3-Clause"; + license = lib.meta.getLicenseFromSpdxId "BSD-3-Clause"; mainProgram = "djinn"; } ) { }; @@ -202519,7 +202519,7 @@ self: { tasty-bench ]; description = "Parser and renderer for djot light markup syntax"; - license = lib.licensesSpdx."MIT"; + license = lib.meta.getLicenseFromSpdxId "MIT"; mainProgram = "djoths"; } ) { }; @@ -203135,7 +203135,7 @@ self: { text ]; description = "DNS name parsing and pattern matching utilities"; - license = lib.licensesSpdx."BSD-3-Clause"; + license = lib.meta.getLicenseFromSpdxId "BSD-3-Clause"; hydraPlatforms = lib.platforms.none; broken = true; } @@ -203390,7 +203390,7 @@ self: { time ]; description = "DigitalOcean Spaces API bindings"; - license = lib.licensesSpdx."BSD-3-Clause"; + license = lib.meta.getLicenseFromSpdxId "BSD-3-Clause"; hydraPlatforms = lib.platforms.none; broken = true; } @@ -204645,7 +204645,7 @@ self: { transformers ]; description = "Run doctest's in a Cabal.Test.exitcode-stdio environment"; - license = lib.licensesSpdx."BSD-3-Clause"; + license = lib.meta.getLicenseFromSpdxId "BSD-3-Clause"; maintainers = [ lib.maintainers.thielema ]; } ) { }; @@ -204681,7 +204681,7 @@ self: { utility-ht ]; description = "Alternative doctest implementation that extracts comments to modules"; - license = lib.licensesSpdx."BSD-3-Clause"; + license = lib.meta.getLicenseFromSpdxId "BSD-3-Clause"; mainProgram = "doctest-extract-0.1"; maintainers = [ lib.maintainers.thielema ]; } @@ -204695,7 +204695,7 @@ self: { sha256 = "1hb3zx1xzib3v41blnwcbhc2v0rzwdzq7gm4sajqndimwjkkxc67"; libraryHaskellDepends = [ base ]; description = "Parts of doctest exposed as library"; - license = lib.licensesSpdx."MIT"; + license = lib.meta.getLicenseFromSpdxId "MIT"; maintainers = [ lib.maintainers.thielema ]; } ) { }; @@ -205244,7 +205244,7 @@ self: { ]; testToolDepends = [ hspec-discover ]; description = "A cross-platform dotfiles manager"; - license = lib.licensesSpdx."GPL-3.0-or-later"; + license = lib.meta.getLicenseFromSpdxId "GPL-3.0-or-later"; hydraPlatforms = lib.platforms.none; mainProgram = "dojang"; } @@ -205516,7 +205516,7 @@ self: { th-orphans ]; description = "Codegen helping you define domain models"; - license = lib.licensesSpdx."MIT"; + license = lib.meta.getLicenseFromSpdxId "MIT"; } ) { }; @@ -205561,7 +205561,7 @@ self: { rerebase ]; description = "Integration of domain with aeson"; - license = lib.licensesSpdx."MIT"; + license = lib.meta.getLicenseFromSpdxId "MIT"; } ) { }; @@ -205644,7 +205644,7 @@ self: { rerebase ]; description = "Integration of domain with cereal"; - license = lib.licensesSpdx."MIT"; + license = lib.meta.getLicenseFromSpdxId "MIT"; } ) { }; @@ -205669,7 +205669,7 @@ self: { th-lift-instances ]; description = "Low-level API of \"domain\""; - license = lib.licensesSpdx."MIT"; + license = lib.meta.getLicenseFromSpdxId "MIT"; } ) { }; @@ -205704,7 +205704,7 @@ self: { rerebase ]; description = "Integration of domain with optics"; - license = lib.licensesSpdx."MIT"; + license = lib.meta.getLicenseFromSpdxId "MIT"; } ) { }; @@ -206115,7 +206115,7 @@ self: { text ]; description = "Datatypes and encoding for graphviz dot files"; - license = lib.licensesSpdx."BSD-3-Clause"; + license = lib.meta.getLicenseFromSpdxId "BSD-3-Clause"; } ) { }; @@ -206437,7 +206437,7 @@ self: { these ]; description = "dot language parsing and printing"; - license = lib.licensesSpdx."BSD-3-Clause"; + license = lib.meta.getLicenseFromSpdxId "BSD-3-Clause"; } ) { }; @@ -206475,7 +206475,7 @@ self: { text ]; description = "Fast conversion between single and double precision floating point and text"; - license = lib.licensesSpdx."BSD-2-Clause"; + license = lib.meta.getLicenseFromSpdxId "BSD-2-Clause"; } ) { }; @@ -206850,7 +206850,7 @@ self: { vector-space ]; description = "Reverse mode automatic differentiation"; - license = lib.licensesSpdx."MIT"; + license = lib.meta.getLicenseFromSpdxId "MIT"; hydraPlatforms = lib.platforms.none; broken = true; } @@ -207054,7 +207054,7 @@ self: { Win32 ]; description = "Windows DPAPI bindings"; - license = lib.licensesSpdx."MPL-2.0"; + license = lib.meta.getLicenseFromSpdxId "MPL-2.0"; hydraPlatforms = lib.platforms.none; broken = true; } @@ -207514,7 +207514,7 @@ self: { relude ]; description = "See README for more info"; - license = lib.licensesSpdx."MPL-2.0"; + license = lib.meta.getLicenseFromSpdxId "MPL-2.0"; hydraPlatforms = lib.platforms.none; mainProgram = "dr-cabal"; broken = true; @@ -207616,7 +207616,7 @@ self: { ]; executableHaskellDepends = [ base ]; description = "Actor library for Haskell"; - license = lib.licensesSpdx."BSD-3-Clause"; + license = lib.meta.getLicenseFromSpdxId "BSD-3-Clause"; } ) { }; @@ -207895,7 +207895,7 @@ self: { ]; testHaskellDepends = [ base ]; description = "Deriving without spelling out \"deriving\""; - license = lib.licensesSpdx."MIT"; + license = lib.meta.getLicenseFromSpdxId "MIT"; hydraPlatforms = lib.platforms.none; broken = true; } @@ -208480,7 +208480,7 @@ self: { QuickCheck ]; description = "Haskell Digital Signal Processing"; - license = lib.licensesSpdx."GPL-2.0-only"; + license = lib.meta.getLicenseFromSpdxId "GPL-2.0-only"; maintainers = [ lib.maintainers.thielema ]; } ) { }; @@ -208565,7 +208565,7 @@ self: { vector ]; description = "DSV (delimiter-separated values)"; - license = lib.licensesSpdx."MIT"; + license = lib.meta.getLicenseFromSpdxId "MIT"; hydraPlatforms = lib.platforms.none; broken = true; } @@ -208877,7 +208877,7 @@ self: { doctest ]; description = "Automatically generate dual constructions"; - license = lib.licensesSpdx."AGPL-3.0-or-later"; + license = lib.meta.getLicenseFromSpdxId "AGPL-3.0-or-later"; hydraPlatforms = lib.platforms.none; maintainers = [ lib.maintainers.sellout ]; broken = true; @@ -208986,7 +208986,7 @@ self: { time ]; description = "Haskell FFI bindings for DuckDB"; - license = lib.licensesSpdx."MPL-2.0"; + license = lib.meta.getLicenseFromSpdxId "MPL-2.0"; hydraPlatforms = lib.platforms.none; broken = true; } @@ -209018,7 +209018,7 @@ self: { vector ]; description = "Haskell bindings for duckdb"; - license = lib.licensesSpdx."MIT"; + license = lib.meta.getLicenseFromSpdxId "MIT"; hydraPlatforms = lib.platforms.none; broken = true; } @@ -209075,7 +209075,7 @@ self: { uuid ]; description = "Haskell FFI bindings for DuckDB"; - license = lib.licensesSpdx."MPL-2.0"; + license = lib.meta.getLicenseFromSpdxId "MPL-2.0"; hydraPlatforms = lib.platforms.none; } ) { }; @@ -209166,7 +209166,7 @@ self: { unordered-containers ]; description = "A Haskell library for parsing text into structured data"; - license = lib.licensesSpdx."BSD-3-Clause"; + license = lib.meta.getLicenseFromSpdxId "BSD-3-Clause"; hydraPlatforms = lib.platforms.none; broken = true; } @@ -209463,7 +209463,7 @@ self: { ]; executableHaskellDepends = [ base ]; description = "Dunning t-digest for online quantile estimation"; - license = lib.licensesSpdx."BSD-3-Clause"; + license = lib.meta.getLicenseFromSpdxId "BSD-3-Clause"; } ) { }; @@ -209606,7 +209606,7 @@ self: { tasty-hunit ]; description = "Duplicate any closure"; - license = lib.licensesSpdx."BSD-3-Clause"; + license = lib.meta.getLicenseFromSpdxId "BSD-3-Clause"; hydraPlatforms = lib.platforms.none; broken = true; } @@ -209750,7 +209750,7 @@ self: { filepath ]; description = "durable/atomic file system writes (from rio package)"; - license = lib.licensesSpdx."BSD-3-Clause"; + license = lib.meta.getLicenseFromSpdxId "BSD-3-Clause"; hydraPlatforms = lib.platforms.none; broken = true; } @@ -210046,7 +210046,7 @@ self: { unordered-containers ]; description = "Dotted Version Vectors (DVV)"; - license = lib.licensesSpdx."MIT"; + license = lib.meta.getLicenseFromSpdxId "MIT"; } ) { }; @@ -210171,7 +210171,7 @@ self: { ]; testHaskellDepends = [ base ]; description = "A minimal testing library"; - license = lib.licensesSpdx."ISC"; + license = lib.meta.getLicenseFromSpdxId "ISC"; } ) { }; @@ -210297,7 +210297,7 @@ self: { generics-sop ]; description = "Programatically identify space leaks in your program"; - license = lib.licensesSpdx."BSD-3-Clause"; + license = lib.meta.getLicenseFromSpdxId "BSD-3-Clause"; } ) { }; @@ -211407,7 +211407,7 @@ self: { vector ]; description = "Configure dzen2 bars in Dhall language"; - license = lib.licensesSpdx."BSD-3-Clause"; + license = lib.meta.getLicenseFromSpdxId "BSD-3-Clause"; hydraPlatforms = lib.platforms.none; mainProgram = "dzen-dhall"; broken = true; @@ -211472,7 +211472,7 @@ self: { transformers ]; description = "An event-oriented observability library"; - license = lib.licensesSpdx."Apache-2.0"; + license = lib.meta.getLicenseFromSpdxId "Apache-2.0"; hydraPlatforms = lib.platforms.none; broken = true; } @@ -211516,7 +211516,7 @@ self: { unordered-containers ]; description = "OpenTelemetry-based rendering for e11y"; - license = lib.licensesSpdx."Apache-2.0"; + license = lib.meta.getLicenseFromSpdxId "Apache-2.0"; hydraPlatforms = lib.platforms.none; } ) { }; @@ -211547,7 +211547,7 @@ self: { base ]; description = "Automatically read config.json from the current directory"; - license = lib.licensesSpdx."MIT"; + license = lib.meta.getLicenseFromSpdxId "MIT"; mainProgram = "simple-example"; } ) { }; @@ -211681,7 +211681,7 @@ self: { vector ]; description = "Binding to C++ earcut library"; - license = lib.licensesSpdx."ISC"; + license = lib.meta.getLicenseFromSpdxId "ISC"; hydraPlatforms = lib.platforms.none; broken = true; } @@ -212170,7 +212170,7 @@ self: { time ]; description = "A Haskell description of the eBird API"; - license = lib.licensesSpdx."MIT"; + license = lib.meta.getLicenseFromSpdxId "MIT"; hydraPlatforms = lib.platforms.none; broken = true; } @@ -212212,7 +212212,7 @@ self: { ]; executableHaskellDepends = [ base ]; description = "A command-line utility for interacting with the eBird API"; - license = lib.licensesSpdx."MIT"; + license = lib.meta.getLicenseFromSpdxId "MIT"; hydraPlatforms = lib.platforms.none; mainProgram = "ebird-cli"; } @@ -212245,7 +212245,7 @@ self: { text ]; description = "Client functions for querying the eBird API"; - license = lib.licensesSpdx."MIT"; + license = lib.meta.getLicenseFromSpdxId "MIT"; hydraPlatforms = lib.platforms.none; broken = true; } @@ -212648,7 +212648,7 @@ self: { ]; executableHaskellDepends = [ base ]; description = "Build \"as static as possible\" executable on Linux"; - license = lib.licensesSpdx."MIT"; + license = lib.meta.getLicenseFromSpdxId "MIT"; mainProgram = "ecstatic"; } ) { }; @@ -212788,7 +212788,7 @@ self: { text ]; description = "Hole-Fit Synthesis using ECTAs"; - license = lib.licensesSpdx."MIT"; + license = lib.meta.getLicenseFromSpdxId "MIT"; hydraPlatforms = lib.platforms.none; broken = true; } @@ -213004,7 +213004,7 @@ self: { text ]; description = "Templating language with similar syntax and features to Liquid or Jinja2"; - license = lib.licensesSpdx."MPL-2.0"; + license = lib.meta.getLicenseFromSpdxId "MPL-2.0"; hydraPlatforms = lib.platforms.none; mainProgram = "ede"; broken = true; @@ -213647,7 +213647,7 @@ self: { sha256 = "0bhin9ngl078asi7d8cgd8df21ngbb2f1sk3i3x708qn9m48kasz"; libraryHaskellDepends = [ base ]; description = "A data structure for emission plans"; - license = lib.licensesSpdx."MIT"; + license = lib.meta.getLicenseFromSpdxId "MIT"; } ) { }; @@ -213800,7 +213800,7 @@ self: { unliftio ]; description = "An easy to use, performant extensible effects library"; - license = lib.licensesSpdx."BSD-3-Clause"; + license = lib.meta.getLicenseFromSpdxId "BSD-3-Clause"; } ) { }; @@ -213835,7 +213835,7 @@ self: { unliftio-core ]; description = "An easy to use, performant extensible effects library"; - license = lib.licensesSpdx."BSD-3-Clause"; + license = lib.meta.getLicenseFromSpdxId "BSD-3-Clause"; } ) { }; @@ -213870,7 +213870,7 @@ self: { text ]; description = "effectful support for high-level PostgreSQL operations via Opaleye"; - license = lib.licensesSpdx."BSD-3-Clause"; + license = lib.meta.getLicenseFromSpdxId "BSD-3-Clause"; } ) { }; @@ -213896,7 +213896,7 @@ self: { effectful-core ]; description = "A GHC plugin for improving disambiguation of effects"; - license = lib.licensesSpdx."BSD-3-Clause"; + license = lib.meta.getLicenseFromSpdxId "BSD-3-Clause"; } ) { }; @@ -213933,7 +213933,7 @@ self: { timeit ]; description = "Simple work queue for bounded concurrency (effectful wrapper)"; - license = lib.licensesSpdx."ISC"; + license = lib.meta.getLicenseFromSpdxId "ISC"; } ) { }; @@ -213958,7 +213958,7 @@ self: { unliftio-pool ]; description = "effectful support for mid-level PostgreSQL operations"; - license = lib.licensesSpdx."BSD-3-Clause"; + license = lib.meta.getLicenseFromSpdxId "BSD-3-Clause"; } ) { }; @@ -213979,7 +213979,7 @@ self: { primitive ]; description = "`ST`-style mutation for `effectful`"; - license = lib.licensesSpdx."CC0-1.0"; + license = lib.meta.getLicenseFromSpdxId "CC0-1.0"; hydraPlatforms = lib.platforms.none; broken = true; } @@ -214014,7 +214014,7 @@ self: { effectful-core ]; description = "Template Haskell utilities for the effectful library"; - license = lib.licensesSpdx."BSD-3-Clause"; + license = lib.meta.getLicenseFromSpdxId "BSD-3-Clause"; } ) { }; @@ -214117,7 +214117,7 @@ self: { testToolDepends = [ tasty-discover ]; doHaddock = false; description = "Effectful effects for testing"; - license = lib.licensesSpdx."BSD-3-Clause"; + license = lib.meta.getLicenseFromSpdxId "BSD-3-Clause"; hydraPlatforms = lib.platforms.none; broken = true; } @@ -214842,7 +214842,7 @@ self: { transformers ]; description = "Minimalistic SMTP client for Haskell"; - license = lib.licensesSpdx."MIT"; + license = lib.meta.getLicenseFromSpdxId "MIT"; } ) { }; @@ -214972,7 +214972,7 @@ self: { executableHaskellDepends = [ base ]; executableToolDepends = [ markdown-unlit ]; description = "IO with Exceptions tracked on the type-level"; - license = lib.licensesSpdx."MPL-2.0"; + license = lib.meta.getLicenseFromSpdxId "MPL-2.0"; hydraPlatforms = lib.platforms.none; mainProgram = "readme"; broken = true; @@ -215061,7 +215061,7 @@ self: { doctest ]; description = "Functions involving lists of Either"; - license = lib.licensesSpdx."Apache-2.0"; + license = lib.meta.getLicenseFromSpdxId "Apache-2.0"; hydraPlatforms = lib.platforms.none; broken = true; } @@ -215098,7 +215098,7 @@ self: { hspec-discover ]; description = "The simplest ‘MonadFail’ instance"; - license = lib.licensesSpdx."Apache-2.0"; + license = lib.meta.getLicenseFromSpdxId "Apache-2.0"; } ) { }; @@ -215110,7 +215110,7 @@ self: { sha256 = "0llfkcq1j7l09vhn38s1asin90ki2xzkpr9xxqpvx0jvpdppza7i"; libraryHaskellDepends = [ base ]; description = "Either with a stricter Semigroup instance"; - license = lib.licensesSpdx."BSD-2-Clause"; + license = lib.meta.getLicenseFromSpdxId "BSD-2-Clause"; } ) { }; @@ -215180,7 +215180,7 @@ self: { vector ]; description = "Binding to EJDB2 C library, an embedded JSON noSQL database"; - license = lib.licensesSpdx."MIT"; + license = lib.meta.getLicenseFromSpdxId "MIT"; hydraPlatforms = lib.platforms.none; broken = true; } @@ -215787,7 +215787,7 @@ self: { unpacked-maybe-text ]; description = "Serialization of Elasticsearch requests and responses"; - license = lib.licensesSpdx."BSD-3-Clause"; + license = lib.meta.getLicenseFromSpdxId "BSD-3-Clause"; hydraPlatforms = lib.platforms.none; } ) { }; @@ -217032,7 +217032,7 @@ self: { ]; doHaddock = false; description = "Crossing the road between Haskell and Elm"; - license = lib.licensesSpdx."MPL-2.0"; + license = lib.meta.getLicenseFromSpdxId "MPL-2.0"; } ) { }; @@ -217329,7 +217329,7 @@ self: { text ]; description = "Generate Elm datatype definitions, encoders and decoders from Haskell datatypes"; - license = lib.licensesSpdx."BSD-3-Clause"; + license = lib.meta.getLicenseFromSpdxId "BSD-3-Clause"; mainProgram = "generate-test-app-code"; } ) { }; @@ -217524,7 +217524,7 @@ self: { tlynx ]; description = "Validate and (optionally) redo ELynx analyses"; - license = lib.licensesSpdx."GPL-3.0-or-later"; + license = lib.meta.getLicenseFromSpdxId "GPL-3.0-or-later"; mainProgram = "elynx"; maintainers = [ lib.maintainers.dschrempf ]; } @@ -217557,7 +217557,7 @@ self: { tlynx ]; description = "Validate and (optionally) redo ELynx analyses"; - license = lib.licensesSpdx."GPL-3.0-or-later"; + license = lib.meta.getLicenseFromSpdxId "GPL-3.0-or-later"; hydraPlatforms = lib.platforms.none; mainProgram = "elynx"; maintainers = [ lib.maintainers.dschrempf ]; @@ -217613,7 +217613,7 @@ self: { ]; benchmarkHaskellDepends = [ base ]; description = "Simulate molecular sequences along trees"; - license = lib.licensesSpdx."GPL-3.0-or-later"; + license = lib.meta.getLicenseFromSpdxId "GPL-3.0-or-later"; maintainers = [ lib.maintainers.dschrempf ]; } ) { }; @@ -217667,7 +217667,7 @@ self: { ]; benchmarkHaskellDepends = [ base ]; description = "Simulate molecular sequences along trees"; - license = lib.licensesSpdx."GPL-3.0-or-later"; + license = lib.meta.getLicenseFromSpdxId "GPL-3.0-or-later"; hydraPlatforms = lib.platforms.none; maintainers = [ lib.maintainers.dschrempf ]; } @@ -217695,7 +217695,7 @@ self: { hspec ]; description = "Import and export Nexus files"; - license = lib.licensesSpdx."GPL-3.0-or-later"; + license = lib.meta.getLicenseFromSpdxId "GPL-3.0-or-later"; maintainers = [ lib.maintainers.dschrempf ]; } ) { }; @@ -217722,7 +217722,7 @@ self: { hspec ]; description = "Import and export Nexus files"; - license = lib.licensesSpdx."GPL-3.0-or-later"; + license = lib.meta.getLicenseFromSpdxId "GPL-3.0-or-later"; hydraPlatforms = lib.platforms.none; maintainers = [ lib.maintainers.dschrempf ]; } @@ -217773,7 +217773,7 @@ self: { vector ]; description = "Handle molecular sequences"; - license = lib.licensesSpdx."GPL-3.0-or-later"; + license = lib.meta.getLicenseFromSpdxId "GPL-3.0-or-later"; maintainers = [ lib.maintainers.dschrempf ]; } ) { }; @@ -217823,7 +217823,7 @@ self: { vector ]; description = "Handle molecular sequences"; - license = lib.licensesSpdx."GPL-3.0-or-later"; + license = lib.meta.getLicenseFromSpdxId "GPL-3.0-or-later"; hydraPlatforms = lib.platforms.none; maintainers = [ lib.maintainers.dschrempf ]; } @@ -217868,7 +217868,7 @@ self: { zlib ]; description = "Tools for ELynx"; - license = lib.licensesSpdx."GPL-3.0-or-later"; + license = lib.meta.getLicenseFromSpdxId "GPL-3.0-or-later"; maintainers = [ lib.maintainers.dschrempf ]; } ) { }; @@ -217912,7 +217912,7 @@ self: { zlib ]; description = "Tools for ELynx"; - license = lib.licensesSpdx."GPL-3.0-or-later"; + license = lib.meta.getLicenseFromSpdxId "GPL-3.0-or-later"; hydraPlatforms = lib.platforms.none; maintainers = [ lib.maintainers.dschrempf ]; } @@ -217981,7 +217981,7 @@ self: { random ]; description = "Handle phylogenetic trees"; - license = lib.licensesSpdx."GPL-3.0-or-later"; + license = lib.meta.getLicenseFromSpdxId "GPL-3.0-or-later"; maintainers = [ lib.maintainers.dschrempf ]; } ) { }; @@ -218048,7 +218048,7 @@ self: { random ]; description = "Handle phylogenetic trees"; - license = lib.licensesSpdx."GPL-3.0-or-later"; + license = lib.meta.getLicenseFromSpdxId "GPL-3.0-or-later"; hydraPlatforms = lib.platforms.none; maintainers = [ lib.maintainers.dschrempf ]; } @@ -218118,7 +218118,7 @@ self: { websockets ]; description = "Static site generator library with hot reload"; - license = lib.licensesSpdx."AGPL-3.0-only"; + license = lib.meta.getLicenseFromSpdxId "AGPL-3.0-only"; } ) { }; @@ -218169,7 +218169,7 @@ self: { url-slug ]; description = "Useful route types for Ema"; - license = lib.licensesSpdx."AGPL-3.0-only"; + license = lib.meta.getLicenseFromSpdxId "AGPL-3.0-only"; hydraPlatforms = lib.platforms.none; } ) { }; @@ -218213,7 +218213,7 @@ self: { url-slug ]; description = "Generic deriving for Ema routes"; - license = lib.licensesSpdx."AGPL-3.0-only"; + license = lib.meta.getLicenseFromSpdxId "AGPL-3.0-only"; hydraPlatforms = lib.platforms.none; broken = true; } @@ -218304,7 +218304,7 @@ self: { void ]; description = "Utilities to write Emacs dynamic modules"; - license = lib.licensesSpdx."Apache-2.0"; + license = lib.meta.getLicenseFromSpdxId "Apache-2.0"; } ) { }; @@ -218355,7 +218355,7 @@ self: { void ]; description = "Utilities to write Emacs dynamic modules"; - license = lib.licensesSpdx."Apache-2.0"; + license = lib.meta.getLicenseFromSpdxId "Apache-2.0"; hydraPlatforms = lib.platforms.none; } ) { }; @@ -218545,7 +218545,7 @@ self: { isExecutable = true; executableHaskellDepends = [ base ]; description = "Perform basic syntax and deliverability checks on email addresses"; - license = lib.licensesSpdx."AGPL-3.0-or-later"; + license = lib.meta.getLicenseFromSpdxId "AGPL-3.0-or-later"; mainProgram = "email-validator"; } ) { }; @@ -218936,7 +218936,7 @@ self: { yaml ]; description = "Emanate a structured view of your plain-text notes"; - license = lib.licensesSpdx."AGPL-3.0-only"; + license = lib.meta.getLicenseFromSpdxId "AGPL-3.0-only"; hydraPlatforms = lib.platforms.none; mainProgram = "emanote"; broken = true; @@ -219043,7 +219043,7 @@ self: { chronos ]; description = "execute actions periodically while avoiding drift"; - license = lib.licensesSpdx."BSD-3-Clause"; + license = lib.meta.getLicenseFromSpdxId "BSD-3-Clause"; hydraPlatforms = lib.platforms.none; broken = true; } @@ -219242,7 +219242,7 @@ self: { transformers ]; description = "Embedded shell"; - license = lib.licensesSpdx."BSD-3-Clause"; + license = lib.meta.getLicenseFromSpdxId "BSD-3-Clause"; } ) { }; @@ -220502,7 +220502,7 @@ self: { deepseq ]; description = "Enum wrappers for IntMap and IntSet"; - license = lib.licensesSpdx."BSD-3-Clause"; + license = lib.meta.getLicenseFromSpdxId "BSD-3-Clause"; hydraPlatforms = lib.platforms.none; broken = true; } @@ -220574,7 +220574,7 @@ self: { template-haskell ]; description = "TH-generated EnumSet/EnumMap wrappers around IntSet/IntMap"; - license = lib.licensesSpdx."BSD-3-Clause"; + license = lib.meta.getLicenseFromSpdxId "BSD-3-Clause"; hydraPlatforms = lib.platforms.none; broken = true; } @@ -220647,7 +220647,7 @@ self: { sha256 = "0xm9638nkikfy62abims10jmmr9y3rm2vb22aqh4qmjcj4r37ibq"; libraryHaskellDepends = [ base ]; description = "Conditionally running IO actions based on environment variables"; - license = lib.licensesSpdx."MIT"; + license = lib.meta.getLicenseFromSpdxId "MIT"; } ) { }; @@ -220898,7 +220898,7 @@ self: { ]; testToolDepends = [ hspec-discover ]; description = "Provides FromEnv in envy instance for Record of extensible"; - license = lib.licensesSpdx."BSD-3-Clause"; + license = lib.meta.getLicenseFromSpdxId "BSD-3-Clause"; hydraPlatforms = lib.platforms.none; broken = true; } @@ -221149,7 +221149,7 @@ self: { profunctors ]; description = "See readme.md"; - license = lib.licensesSpdx."BSD-3-Clause"; + license = lib.meta.getLicenseFromSpdxId "BSD-3-Clause"; hydraPlatforms = lib.platforms.none; broken = true; } @@ -221201,7 +221201,7 @@ self: { text ]; description = "Temporary PostgreSQL databases for testing"; - license = lib.licensesSpdx."BSD-3-Clause"; + license = lib.meta.getLicenseFromSpdxId "BSD-3-Clause"; hydraPlatforms = lib.platforms.none; broken = true; } @@ -221417,7 +221417,7 @@ self: { zip-archive ]; description = "Library for parsing epub document metadata"; - license = lib.licensesSpdx."ISC"; + license = lib.meta.getLicenseFromSpdxId "ISC"; mainProgram = "epub-metadata-example"; } ) { }; @@ -221469,7 +221469,7 @@ self: { regex-compat ]; description = "Command line utilities for working with epub files"; - license = lib.licensesSpdx."ISC"; + license = lib.meta.getLicenseFromSpdxId "ISC"; hydraPlatforms = lib.platforms.none; broken = true; } @@ -221582,7 +221582,7 @@ self: { void ]; description = "Proof assistant for Haskell using DataKinds & PolyKinds"; - license = lib.licensesSpdx."BSD-3-Clause"; + license = lib.meta.getLicenseFromSpdxId "BSD-3-Clause"; } ) { }; @@ -221651,7 +221651,7 @@ self: { time ]; description = "Application level triggered, and edge triggered event multiqueues"; - license = lib.licensesSpdx."BSD-3-Clause"; + license = lib.meta.getLicenseFromSpdxId "BSD-3-Clause"; hydraPlatforms = lib.platforms.none; broken = true; } @@ -221835,7 +221835,7 @@ self: { websockets ]; description = "Decentralized messaging and synchronization"; - license = lib.licensesSpdx."BSD-3-Clause"; + license = lib.meta.getLicenseFromSpdxId "BSD-3-Clause"; hydraPlatforms = lib.platforms.none; mainProgram = "erebos"; broken = true; @@ -221895,7 +221895,7 @@ self: { unix ]; description = "Test framework with virtual network using Linux namespaces"; - license = lib.licensesSpdx."GPL-3.0-only"; + license = lib.meta.getLicenseFromSpdxId "GPL-3.0-only"; platforms = lib.platforms.linux; mainProgram = "erebos-tester"; } @@ -222158,7 +222158,7 @@ self: { time ]; description = "Generic API client library for ERPNext"; - license = lib.licensesSpdx."MIT"; + license = lib.meta.getLicenseFromSpdxId "MIT"; hydraPlatforms = lib.platforms.none; broken = true; } @@ -222199,7 +222199,7 @@ self: { ]; testToolDepends = [ hspec-discover ]; description = "Source code error pretty printing"; - license = lib.licensesSpdx."MIT"; + license = lib.meta.getLicenseFromSpdxId "MIT"; mainProgram = "errata-example"; } ) { }; @@ -222245,7 +222245,7 @@ self: { doctest ]; description = "The canonical error type"; - license = lib.licensesSpdx."MIT"; + license = lib.meta.getLicenseFromSpdxId "MIT"; } ) { }; @@ -222304,7 +222304,7 @@ self: { ]; testHaskellDepends = [ base ]; description = "Error code functions"; - license = lib.licensesSpdx."BSD-3-Clause"; + license = lib.meta.getLicenseFromSpdxId "BSD-3-Clause"; } ) { }; @@ -222843,7 +222843,7 @@ self: { text ]; description = "draw circuit (DAG) for Ersatz.Bit"; - license = lib.licensesSpdx."GPL-3.0-only"; + license = lib.meta.getLicenseFromSpdxId "GPL-3.0-only"; hydraPlatforms = lib.platforms.none; } ) { }; @@ -222922,7 +222922,7 @@ self: { tasty-hunit ]; description = "Easily build and run haskell code to solve AoC problems"; - license = lib.licensesSpdx."AGPL-3.0-or-later"; + license = lib.meta.getLicenseFromSpdxId "AGPL-3.0-or-later"; hydraPlatforms = lib.platforms.none; broken = true; } @@ -223621,7 +223621,7 @@ self: { text ]; description = "postgis bindings for esqueleto"; - license = lib.licensesSpdx."MIT"; + license = lib.meta.getLicenseFromSpdxId "MIT"; } ) { }; @@ -223701,7 +223701,7 @@ self: { transformers ]; description = "PostgreSQL full text search for Esqueleto"; - license = lib.licensesSpdx."MIT"; + license = lib.meta.getLicenseFromSpdxId "MIT"; hydraPlatforms = lib.platforms.none; broken = true; } @@ -223778,7 +223778,7 @@ self: { vector-sized ]; description = "General purpose live coding framework"; - license = lib.licensesSpdx."BSD-3-Clause"; + license = lib.meta.getLicenseFromSpdxId "BSD-3-Clause"; maintainers = [ lib.maintainers.turion ]; } ) { }; @@ -224895,7 +224895,7 @@ self: { ]; testToolDepends = [ hspec-discover ]; description = "Mathematics utilities for Haskell"; - license = lib.licensesSpdx."MIT"; + license = lib.meta.getLicenseFromSpdxId "MIT"; } ) { }; @@ -225091,7 +225091,7 @@ self: { unix ]; description = "Bindings to libevdev"; - license = lib.licensesSpdx."BSD-3-Clause"; + license = lib.meta.getLicenseFromSpdxId "BSD-3-Clause"; platforms = lib.platforms.linux; } ) { inherit (pkgs) libevdev; }; @@ -225129,7 +225129,7 @@ self: { unix ]; description = "Bridge for working with evdev and streamly"; - license = lib.licensesSpdx."BSD-3-Clause"; + license = lib.meta.getLicenseFromSpdxId "BSD-3-Clause"; platforms = lib.platforms.linux; hydraPlatforms = lib.platforms.none; broken = true; @@ -226124,7 +226124,7 @@ self: { unordered-containers ]; description = "Live processing of eventlog data"; - license = lib.licensesSpdx."BSD-3-Clause"; + license = lib.meta.getLicenseFromSpdxId "BSD-3-Clause"; } ) { }; @@ -226163,7 +226163,7 @@ self: { text ]; description = "Stream eventlog data into InfluxDB"; - license = lib.licensesSpdx."BSD-3-Clause"; + license = lib.meta.getLicenseFromSpdxId "BSD-3-Clause"; mainProgram = "eventlog-live-influxdb"; } ) { }; @@ -226231,7 +226231,7 @@ self: { yaml ]; description = "Stream eventlog data to the OpenTelemetry Collector"; - license = lib.licensesSpdx."BSD-3-Clause"; + license = lib.meta.getLicenseFromSpdxId "BSD-3-Clause"; hydraPlatforms = lib.platforms.none; mainProgram = "eventlog-live-otelcol"; } @@ -226245,7 +226245,7 @@ self: { sha256 = "10dkiazyszkm33x2bqz6vvi4ldkbnfjcjh4zn314p2w56pw3b330"; libraryHaskellDepends = [ base ]; description = "Stream GHC eventlog events to external processes"; - license = lib.licensesSpdx."BSD-3-Clause"; + license = lib.meta.getLicenseFromSpdxId "BSD-3-Clause"; } ) { }; @@ -226268,7 +226268,7 @@ self: { text ]; description = "Control command protocol for eventlog-socket"; - license = lib.licensesSpdx."BSD-3-Clause"; + license = lib.meta.getLicenseFromSpdxId "BSD-3-Clause"; } ) { }; @@ -226341,7 +226341,7 @@ self: { text ]; description = "Visualise an eventlog"; - license = lib.licensesSpdx."BSD-3-Clause"; + license = lib.meta.getLicenseFromSpdxId "BSD-3-Clause"; mainProgram = "eventlog2html"; maintainers = [ lib.maintainers.maralorn ]; } @@ -226870,7 +226870,7 @@ self: { unliftio-core ]; description = "An event-oriented observability library"; - license = lib.licensesSpdx."Apache-2.0"; + license = lib.meta.getLicenseFromSpdxId "Apache-2.0"; hydraPlatforms = lib.platforms.none; broken = true; } @@ -226933,7 +226933,7 @@ self: { warp ]; description = "Grab bag of eventuo11y-enriched functionality"; - license = lib.licensesSpdx."Apache-2.0"; + license = lib.meta.getLicenseFromSpdxId "Apache-2.0"; hydraPlatforms = lib.platforms.none; } ) { }; @@ -226953,7 +226953,7 @@ self: { template-haskell ]; description = "DSL for defining eventuo11y fields and selectors"; - license = lib.licensesSpdx."Apache-2.0"; + license = lib.meta.getLicenseFromSpdxId "Apache-2.0"; hydraPlatforms = lib.platforms.none; broken = true; } @@ -226988,7 +226988,7 @@ self: { uuid ]; description = "aeson-based rendering for eventuo11y"; - license = lib.licensesSpdx."Apache-2.0"; + license = lib.meta.getLicenseFromSpdxId "Apache-2.0"; hydraPlatforms = lib.platforms.none; } ) { }; @@ -227012,7 +227012,7 @@ self: { text ]; description = "OpenTelemetry-based rendering for eventuo11y"; - license = lib.licensesSpdx."Apache-2.0"; + license = lib.meta.getLicenseFromSpdxId "Apache-2.0"; hydraPlatforms = lib.platforms.none; } ) { }; @@ -227036,7 +227036,7 @@ self: { prometheus ]; description = "Prometheus backend for eventuo11y"; - license = lib.licensesSpdx."Apache-2.0"; + license = lib.meta.getLicenseFromSpdxId "Apache-2.0"; hydraPlatforms = lib.platforms.none; } ) { }; @@ -227392,7 +227392,7 @@ self: { tasty-hunit ]; description = "Exact Kantorovich distance between finite probability measures"; - license = lib.licensesSpdx."BSD-3-Clause"; + license = lib.meta.getLicenseFromSpdxId "BSD-3-Clause"; hydraPlatforms = lib.platforms.none; } ) { }; @@ -227506,7 +227506,7 @@ self: { libraryHaskellDepends = [ base ]; executableHaskellDepends = [ base ]; description = "Example Haskell Project"; - license = lib.licensesSpdx."BSD-3-Clause"; + license = lib.meta.getLicenseFromSpdxId "BSD-3-Clause"; mainProgram = "example-haskell-project"; } ) { }; @@ -228208,7 +228208,7 @@ self: { xml-optics ]; description = "A library for crawling exhentai"; - license = lib.licensesSpdx."BSD-3-Clause"; + license = lib.meta.getLicenseFromSpdxId "BSD-3-Clause"; hydraPlatforms = lib.platforms.none; broken = true; } @@ -228351,7 +228351,7 @@ self: { vector ]; description = "Haskell bindings to ExifTool"; - license = lib.licensesSpdx."MIT"; + license = lib.meta.getLicenseFromSpdxId "MIT"; hydraPlatforms = lib.platforms.none; broken = true; } @@ -228964,7 +228964,7 @@ self: { incipit-base ]; description = "Customizable quasiquote interpolation"; - license = lib.licensesSpdx."BSD-2-Clause-Patent"; + license = lib.meta.getLicenseFromSpdxId "BSD-2-Clause-Patent"; } ) { }; @@ -229458,7 +229458,7 @@ self: { hspec ]; description = "Predicates that can explain themselves"; - license = lib.licensesSpdx."BSD-3-Clause"; + license = lib.meta.getLicenseFromSpdxId "BSD-3-Clause"; hydraPlatforms = lib.platforms.none; broken = true; } @@ -229527,7 +229527,7 @@ self: { transformers ]; description = "Exceptions which are explicit in the type signature"; - license = lib.licensesSpdx."BSD-3-Clause"; + license = lib.meta.getLicenseFromSpdxId "BSD-3-Clause"; maintainers = [ lib.maintainers.thielema ]; } ) { }; @@ -230075,7 +230075,7 @@ self: { HUnit ]; description = "Support for an 80-bit extended float"; - license = lib.licensesSpdx."BSD-3-Clause"; + license = lib.meta.getLicenseFromSpdxId "BSD-3-Clause"; hydraPlatforms = lib.platforms.none; broken = true; } @@ -230263,7 +230263,7 @@ self: { template-haskell ]; description = "Extensible, efficient, optics-friendly data types and effects"; - license = lib.licensesSpdx."BSD-3-Clause"; + license = lib.meta.getLicenseFromSpdxId "BSD-3-Clause"; hydraPlatforms = lib.platforms.none; broken = true; } @@ -230451,7 +230451,7 @@ self: { unliftio ]; description = "Message passing concurrency as extensible-effect"; - license = lib.licensesSpdx."BSD-3-Clause"; + license = lib.meta.getLicenseFromSpdxId "BSD-3-Clause"; hydraPlatforms = lib.platforms.none; broken = true; } @@ -230504,7 +230504,7 @@ self: { extensible ]; description = "Operational-based extensible effect library"; - license = lib.licensesSpdx."BSD-3-Clause"; + license = lib.meta.getLicenseFromSpdxId "BSD-3-Clause"; hydraPlatforms = lib.platforms.none; } ) { }; @@ -230621,7 +230621,7 @@ self: { text ]; description = "Parse Haskell Language Extensions"; - license = lib.licensesSpdx."MPL-2.0"; + license = lib.meta.getLicenseFromSpdxId "MPL-2.0"; hydraPlatforms = lib.platforms.none; mainProgram = "extensions"; } @@ -230684,7 +230684,7 @@ self: { text ]; description = "Parse Haskell Language Extensions"; - license = lib.licensesSpdx."MPL-2.0"; + license = lib.meta.getLicenseFromSpdxId "MPL-2.0"; mainProgram = "extensions"; } ) { }; @@ -230746,7 +230746,7 @@ self: { text ]; description = "Parse Haskell Language Extensions"; - license = lib.licensesSpdx."MPL-2.0"; + license = lib.meta.getLicenseFromSpdxId "MPL-2.0"; hydraPlatforms = lib.platforms.none; mainProgram = "extensions"; } @@ -230810,7 +230810,7 @@ self: { HUnit ]; description = "Extism bindings"; - license = lib.licensesSpdx."BSD-3-Clause"; + license = lib.meta.getLicenseFromSpdxId "BSD-3-Clause"; hydraPlatforms = lib.platforms.none; broken = true; } @@ -230835,7 +230835,7 @@ self: { json ]; description = "Extism manifest bindings"; - license = lib.licensesSpdx."BSD-3-Clause"; + license = lib.meta.getLicenseFromSpdxId "BSD-3-Clause"; hydraPlatforms = lib.platforms.none; broken = true; } @@ -230871,7 +230871,7 @@ self: { ]; executableHaskellDepends = [ base ]; description = "Extism Plugin Development Kit"; - license = lib.licensesSpdx."BSD-3-Clause"; + license = lib.meta.getLicenseFromSpdxId "BSD-3-Clause"; hydraPlatforms = lib.platforms.none; broken = true; } @@ -231333,7 +231333,7 @@ self: { toolshed ]; description = "Rational arithmetic in an irrational world"; - license = lib.licensesSpdx."GPL-3.0-or-later"; + license = lib.meta.getLicenseFromSpdxId "GPL-3.0-or-later"; hydraPlatforms = lib.platforms.none; mainProgram = "factory"; broken = true; @@ -231971,7 +231971,7 @@ self: { QuickCheck ]; description = "Extensible fake file system for testing"; - license = lib.licensesSpdx."Apache-2.0"; + license = lib.meta.getLicenseFromSpdxId "Apache-2.0"; } ) { }; @@ -232001,7 +232001,7 @@ self: { QuickCheck ]; description = "Monad to pull from fake stream-like objects"; - license = lib.licensesSpdx."Apache-2.0"; + license = lib.meta.getLicenseFromSpdxId "Apache-2.0"; } ) { }; @@ -232263,7 +232263,7 @@ self: { tasty-hunit ]; description = "Property-based testing with internal integrated shrinking"; - license = lib.licensesSpdx."BSD-3-Clause"; + license = lib.meta.getLicenseFromSpdxId "BSD-3-Clause"; maintainers = [ lib.maintainers.maralorn ]; } ) { }; @@ -232320,7 +232320,7 @@ self: { tasty-hunit ]; description = "Property-based testing with internal integrated shrinking"; - license = lib.licensesSpdx."BSD-3-Clause"; + license = lib.meta.getLicenseFromSpdxId "BSD-3-Clause"; hydraPlatforms = lib.platforms.none; maintainers = [ lib.maintainers.maralorn ]; } @@ -233356,7 +233356,7 @@ self: { template-haskell ]; description = "A fast open-union type suitable for 100+ contained alternatives"; - license = lib.licensesSpdx."BSD-3-Clause"; + license = lib.meta.getLicenseFromSpdxId "BSD-3-Clause"; hydraPlatforms = lib.platforms.none; broken = true; } @@ -233845,7 +233845,7 @@ self: { HUnit ]; description = "Stubs for dependencies of test code"; - license = lib.licensesSpdx."BSD-3-Clause"; + license = lib.meta.getLicenseFromSpdxId "BSD-3-Clause"; hydraPlatforms = lib.platforms.none; broken = true; } @@ -234016,7 +234016,7 @@ self: { vector ]; description = "Various utility libraries"; - license = lib.licensesSpdx."BSD-3-Clause"; + license = lib.meta.getLicenseFromSpdxId "BSD-3-Clause"; hydraPlatforms = lib.platforms.none; broken = true; } @@ -234293,7 +234293,7 @@ self: { xdg-basedir ]; description = "Fedora packager tool to build package branches"; - license = lib.licensesSpdx."GPL-2.0-or-later"; + license = lib.meta.getLicenseFromSpdxId "GPL-2.0-or-later"; hydraPlatforms = lib.platforms.none; mainProgram = "fbrnch"; } @@ -234427,7 +234427,7 @@ self: { fcf-family ]; description = "Family-of-families instances for base"; - license = lib.licensesSpdx."MIT"; + license = lib.meta.getLicenseFromSpdxId "MIT"; } ) { }; @@ -234509,7 +234509,7 @@ self: { text ]; description = "Data structures and algorithms for first-class-families"; - license = lib.licensesSpdx."BSD-3-Clause"; + license = lib.meta.getLicenseFromSpdxId "BSD-3-Clause"; hydraPlatforms = lib.platforms.none; broken = true; } @@ -234538,7 +234538,7 @@ self: { first-class-families ]; description = "Family of families: featherweight defunctionalization"; - license = lib.licensesSpdx."MIT"; + license = lib.meta.getLicenseFromSpdxId "MIT"; } ) { }; @@ -234784,7 +234784,7 @@ self: { text ]; description = "Admin API for Firebase Cloud Messaging"; - license = lib.licensesSpdx."BSD-3-Clause"; + license = lib.meta.getLicenseFromSpdxId "BSD-3-Clause"; hydraPlatforms = lib.platforms.none; mainProgram = "fcm-client"; broken = true; @@ -234911,7 +234911,7 @@ self: { ]; executablePkgconfigDepends = [ ncurses ]; description = "A terminal broughlike game about manipulating vision"; - license = lib.licensesSpdx."AGPL-3.0-or-later"; + license = lib.meta.getLicenseFromSpdxId "AGPL-3.0-or-later"; hydraPlatforms = lib.platforms.none; mainProgram = "fearOfView"; broken = true; @@ -235098,7 +235098,7 @@ self: { random ]; description = "Forward error correction of ByteStrings"; - license = lib.licensesSpdx."GPL-2.0-or-later"; + license = lib.meta.getLicenseFromSpdxId "GPL-2.0-or-later"; hydraPlatforms = lib.platforms.none; mainProgram = "benchmark-zfec"; broken = true; @@ -235996,7 +235996,7 @@ self: { ]; executableHaskellDepends = [ base ]; description = "Declarative feedback loop manager"; - license = lib.licensesSpdx."GPL-3.0-only"; + license = lib.meta.getLicenseFromSpdxId "GPL-3.0-only"; hydraPlatforms = lib.platforms.none; broken = true; } @@ -236054,7 +236054,7 @@ self: { executableSystemDepends = [ mxnet ]; executableToolDepends = [ c2hs ]; description = "FFI to MXNet"; - license = lib.licensesSpdx."BSD-3-Clause"; + license = lib.meta.getLicenseFromSpdxId "BSD-3-Clause"; hydraPlatforms = lib.platforms.none; mainProgram = "mxnet-op-gen"; } @@ -236132,7 +236132,7 @@ self: { store ]; description = "Cocodataset with cocoapi"; - license = lib.licensesSpdx."BSD-3-Clause"; + license = lib.meta.getLicenseFromSpdxId "BSD-3-Clause"; hydraPlatforms = lib.platforms.none; mainProgram = "imageutils"; broken = true; @@ -236282,7 +236282,7 @@ self: { vector ]; description = "Some datasets"; - license = lib.licensesSpdx."BSD-3-Clause"; + license = lib.meta.getLicenseFromSpdxId "BSD-3-Clause"; hydraPlatforms = lib.platforms.none; } ) { }; @@ -236334,7 +236334,7 @@ self: { store ]; description = "fei examples"; - license = lib.licensesSpdx."BSD-3-Clause"; + license = lib.meta.getLicenseFromSpdxId "BSD-3-Clause"; hydraPlatforms = lib.platforms.none; } ) { }; @@ -236374,7 +236374,7 @@ self: { vector ]; description = "A collection of standard models"; - license = lib.licensesSpdx."BSD-3-Clause"; + license = lib.meta.getLicenseFromSpdxId "BSD-3-Clause"; hydraPlatforms = lib.platforms.none; } ) { }; @@ -236436,7 +236436,7 @@ self: { wl-pprint-text ]; description = "Train a neural network with MXNet in Haskell"; - license = lib.licensesSpdx."BSD-3-Clause"; + license = lib.meta.getLicenseFromSpdxId "BSD-3-Clause"; hydraPlatforms = lib.platforms.none; } ) { }; @@ -236805,7 +236805,7 @@ self: { ]; libraryToolDepends = [ c2hs ]; description = "C bindings plus conveniences for the festival tts system"; - license = lib.licensesSpdx."BSD-3-Clause"; + license = lib.meta.getLicenseFromSpdxId "BSD-3-Clause"; hydraPlatforms = lib.platforms.none; broken = true; } @@ -237033,7 +237033,7 @@ self: { unordered-containers ]; description = "Automatic C++ binding generation"; - license = lib.licensesSpdx."BSD-2-Clause"; + license = lib.meta.getLicenseFromSpdxId "BSD-2-Clause"; } ) { }; @@ -237054,7 +237054,7 @@ self: { template-haskell ]; description = "Runtime for fficxx-generated library"; - license = lib.licensesSpdx."BSD-2-Clause"; + license = lib.meta.getLicenseFromSpdxId "BSD-2-Clause"; } ) { }; @@ -237227,7 +237227,7 @@ self: { fftwFloat ]; description = "Low-level interface to FFTW (Fast Fourier Transform)"; - license = lib.licensesSpdx."BSD-3-Clause"; + license = lib.meta.getLicenseFromSpdxId "BSD-3-Clause"; maintainers = [ lib.maintainers.thielema ]; } ) @@ -237297,7 +237297,7 @@ self: { ]; testToolDepends = [ tasty-discover ]; description = "FFunctor typeclass"; - license = lib.licensesSpdx."BSD-3-Clause"; + license = lib.meta.getLicenseFromSpdxId "BSD-3-Clause"; hydraPlatforms = lib.platforms.none; broken = true; } @@ -237435,7 +237435,7 @@ self: { semirings ]; description = "fibonacci algebra"; - license = lib.licensesSpdx."BSD-3-Clause"; + license = lib.meta.getLicenseFromSpdxId "BSD-3-Clause"; hydraPlatforms = lib.platforms.none; broken = true; } @@ -237622,7 +237622,7 @@ self: { tasty-hunit ]; description = "Codegen Haskell types to other languages"; - license = lib.licensesSpdx."BSD-3-Clause"; + license = lib.meta.getLicenseFromSpdxId "BSD-3-Clause"; hydraPlatforms = lib.platforms.none; broken = true; } @@ -237899,7 +237899,7 @@ self: { temporary ]; description = "Basic file IO operations via 'OsPath'"; - license = lib.licensesSpdx."BSD-3-Clause"; + license = lib.meta.getLicenseFromSpdxId "BSD-3-Clause"; } ) { }; @@ -237937,7 +237937,7 @@ self: { temporary ]; description = "Basic file IO operations via 'OsPath'"; - license = lib.licensesSpdx."BSD-3-Clause"; + license = lib.meta.getLicenseFromSpdxId "BSD-3-Clause"; hydraPlatforms = lib.platforms.none; } ) { }; @@ -238118,7 +238118,7 @@ self: { tasty-bench ]; description = "File URI parsing"; - license = lib.licensesSpdx."BSD-3-Clause"; + license = lib.meta.getLicenseFromSpdxId "BSD-3-Clause"; } ) { }; @@ -238248,7 +238248,7 @@ self: { process ]; description = "Portable interface to file locking (flock / LockFileEx)"; - license = lib.licensesSpdx."CC0-1.0"; + license = lib.meta.getLicenseFromSpdxId "CC0-1.0"; } ) { }; @@ -238353,7 +238353,7 @@ self: { tasty-bench ]; description = "Library for manipulating FilePaths in a cross platform way"; - license = lib.licensesSpdx."BSD-3-Clause"; + license = lib.meta.getLicenseFromSpdxId "BSD-3-Clause"; hydraPlatforms = lib.platforms.none; } ) { }; @@ -238638,7 +238638,7 @@ self: { semigroups ]; description = "A shared set of abstractions and types for representing filessytem data"; - license = lib.licensesSpdx."BSD-3-Clause"; + license = lib.meta.getLicenseFromSpdxId "BSD-3-Clause"; hydraPlatforms = lib.platforms.none; broken = true; } @@ -238928,7 +238928,7 @@ self: { tagged ]; description = "Nat and Fin: peano naturals and finite numbers"; - license = lib.licensesSpdx."BSD-3-Clause"; + license = lib.meta.getLicenseFromSpdxId "BSD-3-Clause"; } ) { }; @@ -239363,7 +239363,7 @@ self: { vector-sized ]; description = "A better, more type-safe Enum"; - license = lib.licensesSpdx."GPL-3.0-or-later"; + license = lib.meta.getLicenseFromSpdxId "GPL-3.0-or-later"; } ) { }; @@ -239421,7 +239421,7 @@ self: { vector ]; description = "Flexible and easy deriving of type classes for finitary types"; - license = lib.licensesSpdx."GPL-3.0-or-later"; + license = lib.meta.getLicenseFromSpdxId "GPL-3.0-or-later"; hydraPlatforms = lib.platforms.none; } ) { }; @@ -239457,7 +239457,7 @@ self: { optics-core ]; description = "Prisms and Isos between finitary types"; - license = lib.licensesSpdx."GPL-3.0-or-later"; + license = lib.meta.getLicenseFromSpdxId "GPL-3.0-or-later"; hydraPlatforms = lib.platforms.none; broken = true; } @@ -239614,7 +239614,7 @@ self: { HUnit ]; description = "Operations and classification for finite semigroups"; - license = lib.licensesSpdx."MIT"; + license = lib.meta.getLicenseFromSpdxId "MIT"; } ) { }; @@ -239883,7 +239883,7 @@ self: { time ]; description = "Firebase Auth, Firestore, and Servant integration for Haskell"; - license = lib.licensesSpdx."BSD-3-Clause"; + license = lib.meta.getLicenseFromSpdxId "BSD-3-Clause"; } ) { }; @@ -240092,7 +240092,7 @@ self: { template-haskell ]; description = "First-class typeclass instances"; - license = lib.licensesSpdx."BSD-3-Clause"; + license = lib.meta.getLicenseFromSpdxId "BSD-3-Clause"; } ) { }; @@ -240111,7 +240111,7 @@ self: { transformers ]; description = "First class patterns and pattern matching, using type families"; - license = lib.licensesSpdx."BSD-3-Clause"; + license = lib.meta.getLicenseFromSpdxId "BSD-3-Clause"; hydraPlatforms = lib.platforms.none; broken = true; } @@ -240539,7 +240539,7 @@ self: { text ]; description = "Fixes whitespace issues"; - license = lib.licensesSpdx."MIT"; + license = lib.meta.getLicenseFromSpdxId "MIT"; mainProgram = "fix-whitespace"; } ) { }; @@ -240575,7 +240575,7 @@ self: { ghc-internal ]; description = "Fixed-point number build on generic integral number"; - license = lib.licensesSpdx."BSD-3-Clause"; + license = lib.meta.getLicenseFromSpdxId "BSD-3-Clause"; } ) { }; @@ -240602,7 +240602,7 @@ self: { utility-ht ]; description = "Lists with statically known length based on non-empty package"; - license = lib.licensesSpdx."BSD-3-Clause"; + license = lib.meta.getLicenseFromSpdxId "BSD-3-Clause"; maintainers = [ lib.maintainers.thielema ]; } ) { }; @@ -240748,7 +240748,7 @@ self: { time ]; description = "Pure Haskell library to repeat an action at a specific frequency"; - license = lib.licensesSpdx."MIT"; + license = lib.meta.getLicenseFromSpdxId "MIT"; hydraPlatforms = lib.platforms.none; broken = true; } @@ -240785,7 +240785,7 @@ self: { template-haskell ]; description = "Generic vectors with statically known size"; - license = lib.licensesSpdx."BSD-3-Clause"; + license = lib.meta.getLicenseFromSpdxId "BSD-3-Clause"; } ) { }; @@ -240820,7 +240820,7 @@ self: { template-haskell ]; description = "Generic vectors with statically known size"; - license = lib.licensesSpdx."BSD-3-Clause"; + license = lib.meta.getLicenseFromSpdxId "BSD-3-Clause"; hydraPlatforms = lib.platforms.none; } ) { }; @@ -241465,7 +241465,7 @@ self: { ]; testToolDepends = [ hspec-discover ]; description = "Complete high-level binding to libFLAC"; - license = lib.licensesSpdx."BSD-3-Clause"; + license = lib.meta.getLicenseFromSpdxId "BSD-3-Clause"; } ) { inherit (pkgs) flac; }; @@ -241503,7 +241503,7 @@ self: { ]; testToolDepends = [ hspec-discover ]; description = "Support for writing pictures into FLAC metadata blocks with JuicyPixels"; - license = lib.licensesSpdx."BSD-3-Clause"; + license = lib.meta.getLicenseFromSpdxId "BSD-3-Clause"; } ) { }; @@ -241969,7 +241969,7 @@ self: { parsec ]; description = "flatten a latex multi-file latex document and remove all comments"; - license = lib.licensesSpdx."GPL-2.0-only"; + license = lib.meta.getLicenseFromSpdxId "GPL-2.0-only"; mainProgram = "flat-tex"; } ) { }; @@ -242138,7 +242138,7 @@ self: { text ]; description = "Flatbuffers encoding based on a syntax tree"; - license = lib.licensesSpdx."BSD-3-Clause"; + license = lib.meta.getLicenseFromSpdxId "BSD-3-Clause"; } ) { }; @@ -242183,7 +242183,7 @@ self: { text ]; description = "Parse flatbuffers"; - license = lib.licensesSpdx."BSD-3-Clause"; + license = lib.meta.getLicenseFromSpdxId "BSD-3-Clause"; hydraPlatforms = lib.platforms.none; broken = true; } @@ -242212,7 +242212,7 @@ self: { vector ]; description = "Haskell bindings for FlatCV image processing library"; - license = lib.licensesSpdx."ISC"; + license = lib.meta.getLicenseFromSpdxId "ISC"; } ) { }; @@ -242361,7 +242361,7 @@ self: { text ]; description = "Flexible numeric parsers for real-world programming languages"; - license = lib.licensesSpdx."MIT"; + license = lib.meta.getLicenseFromSpdxId "MIT"; hydraPlatforms = lib.platforms.none; broken = true; } @@ -242679,7 +242679,7 @@ self: { ]; libraryToolDepends = [ proto-lens-protoc ]; description = "Flink stateful functions SDK"; - license = lib.licensesSpdx."MPL-2.0"; + license = lib.meta.getLicenseFromSpdxId "MPL-2.0"; hydraPlatforms = lib.platforms.none; broken = true; } @@ -243030,7 +243030,7 @@ self: { HUnit ]; description = "Write more understandable Haskell"; - license = lib.licensesSpdx."MIT"; + license = lib.meta.getLicenseFromSpdxId "MIT"; } ) { }; @@ -244418,7 +244418,7 @@ self: { criterion ]; description = "fnmatch C wrapper"; - license = lib.licensesSpdx."Apache-2.0"; + license = lib.meta.getLicenseFromSpdxId "Apache-2.0"; } ) { }; @@ -244445,7 +244445,7 @@ self: { tasty-hunit ]; description = "A general abstraction for manipulating elements of container data structures"; - license = lib.licensesSpdx."MIT"; + license = lib.meta.getLicenseFromSpdxId "MIT"; } ) { }; @@ -244665,7 +244665,7 @@ self: { ]; doHaddock = false; description = "Compatibility package for the Foldable1 and Bifoldable1 type classes"; - license = lib.licensesSpdx."BSD-3-Clause"; + license = lib.meta.getLicenseFromSpdxId "BSD-3-Clause"; } ) { }; @@ -244750,7 +244750,7 @@ self: { safe-exceptions ]; description = "Exception handling with FoldM"; - license = lib.licensesSpdx."MIT"; + license = lib.meta.getLicenseFromSpdxId "MIT"; hydraPlatforms = lib.platforms.none; broken = true; } @@ -244936,7 +244936,7 @@ self: { lens-family-core ]; description = "Transducers for foldl folds"; - license = lib.licensesSpdx."BSD-3-Clause"; + license = lib.meta.getLicenseFromSpdxId "BSD-3-Clause"; hydraPlatforms = lib.platforms.none; broken = true; } @@ -245322,7 +245322,7 @@ self: { ]; doHaddock = false; description = "The folly C++ library from Meta"; - license = lib.licensesSpdx."Apache-2.0"; + license = lib.meta.getLicenseFromSpdxId "Apache-2.0"; hydraPlatforms = lib.platforms.none; broken = true; } @@ -245450,7 +245450,7 @@ self: { text ]; description = "Queries your system (Linux/BSD/etc) font database"; - license = lib.licensesSpdx."MIT"; + license = lib.meta.getLicenseFromSpdxId "MIT"; hydraPlatforms = lib.platforms.none; mainProgram = "fontconfig-pure"; broken = true; @@ -245490,7 +245490,7 @@ self: { unicode-data-scripts ]; description = "Determine fonts used to render text"; - license = lib.licensesSpdx."GPL-3.0-or-later"; + license = lib.meta.getLicenseFromSpdxId "GPL-3.0-or-later"; hydraPlatforms = lib.platforms.none; mainProgram = "fontwhich"; } @@ -245723,7 +245723,7 @@ self: { ]; testToolDepends = [ hspec-discover ]; description = "A collection of helpers for ffi"; - license = lib.licensesSpdx."BSD-3-Clause"; + license = lib.meta.getLicenseFromSpdxId "BSD-3-Clause"; hydraPlatforms = lib.platforms.none; broken = true; } @@ -246158,7 +246158,7 @@ self: { text ]; description = "Formatting of doubles"; - license = lib.licensesSpdx."BSD-3-Clause"; + license = lib.meta.getLicenseFromSpdxId "BSD-3-Clause"; } ) { }; @@ -246254,7 +246254,7 @@ self: { text ]; description = "Combinator-based type-safe formatting (like printf() or FORMAT)"; - license = lib.licensesSpdx."BSD-3-Clause"; + license = lib.meta.getLicenseFromSpdxId "BSD-3-Clause"; } ) { }; @@ -246427,7 +246427,7 @@ self: { text ]; description = "Parse and serialize FDF, the Forms Data Format"; - license = lib.licensesSpdx."BSD-3-Clause"; + license = lib.meta.getLicenseFromSpdxId "BSD-3-Clause"; hydraPlatforms = lib.platforms.none; } ) { }; @@ -247259,7 +247259,7 @@ self: { ]; testToolDepends = [ hspec-discover ]; description = "A formatter for Haskell source code"; - license = lib.licensesSpdx."BSD-3-Clause"; + license = lib.meta.getLicenseFromSpdxId "BSD-3-Clause"; hydraPlatforms = lib.platforms.none; mainProgram = "fourmolu"; } @@ -247367,7 +247367,7 @@ self: { ]; testToolDepends = [ hspec-discover ]; description = "A formatter for Haskell source code"; - license = lib.licensesSpdx."BSD-3-Clause"; + license = lib.meta.getLicenseFromSpdxId "BSD-3-Clause"; hydraPlatforms = lib.platforms.none; mainProgram = "fourmolu"; } @@ -247479,7 +247479,7 @@ self: { ]; testToolDepends = [ hspec-discover ]; description = "A formatter for Haskell source code"; - license = lib.licensesSpdx."BSD-3-Clause"; + license = lib.meta.getLicenseFromSpdxId "BSD-3-Clause"; mainProgram = "fourmolu"; } ) { }; @@ -247520,7 +247520,7 @@ self: { tasty-bench ]; description = "IEEE 754-2019 compliant operations"; - license = lib.licensesSpdx."BSD-3-Clause"; + license = lib.meta.getLicenseFromSpdxId "BSD-3-Clause"; } ) { }; @@ -247716,7 +247716,7 @@ self: { libraryPkgconfigDepends = [ fplll ]; testHaskellDepends = [ base ]; description = "Haskell bindings to "; - license = lib.licensesSpdx."LGPL-2.1-or-later"; + license = lib.meta.getLicenseFromSpdxId "LGPL-2.1-or-later"; hydraPlatforms = lib.platforms.none; } ) { inherit (pkgs) fplll; }; @@ -247966,7 +247966,7 @@ self: { ]; testToolDepends = [ hspec-discover ]; description = "Composable resource management and dependency injection"; - license = lib.licensesSpdx."BSD-3-Clause"; + license = lib.meta.getLicenseFromSpdxId "BSD-3-Clause"; } ) { }; @@ -248050,7 +248050,7 @@ self: { ]; testToolDepends = [ tasty-discover ]; description = "Reference implementation of FractalText"; - license = lib.licensesSpdx."Apache-2.0"; + license = lib.meta.getLicenseFromSpdxId "Apache-2.0"; } ) { }; @@ -248083,7 +248083,7 @@ self: { sha256 = "0y2rkbmpzhn0zz273i1lfxv7f270yv89nmacs9m17rhjcj9n7243"; libraryHaskellDepends = [ base ]; description = "Numbers in the range [0.005, 1] as a sum of 2, 3, 4 or 5 unit fractions of special types."; - license = lib.licensesSpdx."MIT"; + license = lib.meta.getLicenseFromSpdxId "MIT"; } ) { }; @@ -248372,7 +248372,7 @@ self: { process ]; description = "CLI frecency history"; - license = lib.licensesSpdx."BSD-3-Clause"; + license = lib.meta.getLicenseFromSpdxId "BSD-3-Clause"; mainProgram = "frecently"; } ) { }; @@ -249209,7 +249209,7 @@ self: { transformers ]; description = "Free algebras"; - license = lib.licensesSpdx."MPL-2.0"; + license = lib.meta.getLicenseFromSpdxId "MPL-2.0"; } ) { }; @@ -249237,7 +249237,7 @@ self: { transformers ]; description = "Free Applicative Transformer"; - license = lib.licensesSpdx."BSD-3-Clause"; + license = lib.meta.getLicenseFromSpdxId "BSD-3-Clause"; hydraPlatforms = lib.platforms.none; broken = true; } @@ -249287,7 +249287,7 @@ self: { criterion ]; description = "efficient data types for free categories and arrows"; - license = lib.licensesSpdx."MPL-2.0"; + license = lib.meta.getLicenseFromSpdxId "MPL-2.0"; } ) { }; @@ -249469,7 +249469,7 @@ self: { void ]; description = "Create games for free"; - license = lib.licensesSpdx."BSD-3-Clause"; + license = lib.meta.getLicenseFromSpdxId "BSD-3-Clause"; hydraPlatforms = lib.platforms.none; } ) { }; @@ -249533,7 +249533,7 @@ self: { ]; testHaskellDepends = [ base ]; description = "Lawful list and set monad transformers based on free monads"; - license = lib.licensesSpdx."MIT"; + license = lib.meta.getLicenseFromSpdxId "MIT"; hydraPlatforms = lib.platforms.none; broken = true; } @@ -250051,7 +250051,7 @@ self: { libraryHaskellDepends = [ base ]; testHaskellDepends = [ base ]; description = "class NonDetable.N and Failable.F"; - license = lib.licensesSpdx."BSD-3-Clause"; + license = lib.meta.getLicenseFromSpdxId "BSD-3-Clause"; } ) { }; @@ -250150,7 +250150,7 @@ self: { libraryHaskellDepends = [ base ]; testHaskellDepends = [ base ]; description = "Freer par monad"; - license = lib.licensesSpdx."BSD-3-Clause"; + license = lib.meta.getLicenseFromSpdxId "BSD-3-Clause"; } ) { }; @@ -250200,7 +250200,7 @@ self: { mtl ]; description = "A friendly effect system for Haskell"; - license = lib.licensesSpdx."BSD-3-Clause"; + license = lib.meta.getLicenseFromSpdxId "BSD-3-Clause"; hydraPlatforms = lib.platforms.none; mainProgram = "freer-simple-examples"; broken = true; @@ -250549,7 +250549,7 @@ self: { happy ]; description = "A functional DSL for vertex-centric large-scale graph processing"; - license = lib.licensesSpdx."MIT"; + license = lib.meta.getLicenseFromSpdxId "MIT"; hydraPlatforms = lib.platforms.none; mainProgram = "fregel"; broken = true; @@ -250615,7 +250615,7 @@ self: { gauge ]; description = "Are you ready to get freaky?"; - license = lib.licensesSpdx."MIT"; + license = lib.meta.getLicenseFromSpdxId "MIT"; hydraPlatforms = lib.platforms.none; broken = true; } @@ -250666,7 +250666,7 @@ self: { text-replace ]; description = "Identifies and replaces frequent subsequences in long strings"; - license = lib.licensesSpdx."BSD-3-Clause"; + license = lib.meta.getLicenseFromSpdxId "BSD-3-Clause"; hydraPlatforms = lib.platforms.none; mainProgram = "frequent-substring-exe"; } @@ -250763,7 +250763,7 @@ self: { template-haskell ]; description = "high-powered optics in a small package"; - license = lib.licensesSpdx."BSD-3-Clause"; + license = lib.meta.getLicenseFromSpdxId "BSD-3-Clause"; hydraPlatforms = lib.platforms.none; broken = true; } @@ -250786,7 +250786,7 @@ self: { fused-effects ]; description = "fresnel/fused-effects integration"; - license = lib.licensesSpdx."BSD-3-Clause"; + license = lib.meta.getLicenseFromSpdxId "BSD-3-Clause"; hydraPlatforms = lib.platforms.none; } ) { }; @@ -250948,7 +250948,7 @@ self: { optparse-applicative ]; description = "Attempt to pretty-print any input"; - license = lib.licensesSpdx."BSD-3-Clause"; + license = lib.meta.getLicenseFromSpdxId "BSD-3-Clause"; mainProgram = "friendly"; } ) { }; @@ -251006,7 +251006,7 @@ self: { semigroups ]; description = "Linear time composable parser for PEG grammars"; - license = lib.licensesSpdx."BSD-3-Clause"; + license = lib.meta.getLicenseFromSpdxId "BSD-3-Clause"; } ) { }; @@ -251047,7 +251047,7 @@ self: { ]; testToolDepends = [ hspec-discover ]; description = "Provides a generic way to construct values from environment variables"; - license = lib.licensesSpdx."MIT"; + license = lib.meta.getLicenseFromSpdxId "MIT"; hydraPlatforms = lib.platforms.none; broken = true; } @@ -251515,7 +251515,7 @@ self: { text ]; description = "Abstract interface for the file system"; - license = lib.licensesSpdx."Apache-2.0"; + license = lib.meta.getLicenseFromSpdxId "Apache-2.0"; hydraPlatforms = lib.platforms.none; broken = true; } @@ -251600,7 +251600,7 @@ self: { text ]; description = "Simulated file systems"; - license = lib.licensesSpdx."Apache-2.0"; + license = lib.meta.getLicenseFromSpdxId "Apache-2.0"; hydraPlatforms = lib.platforms.none; } ) { }; @@ -251973,7 +251973,7 @@ self: { unix ]; description = "Watch a file/directory and run a command when it's modified"; - license = lib.licensesSpdx."BSD-3-Clause"; + license = lib.meta.getLicenseFromSpdxId "BSD-3-Clause"; hydraPlatforms = lib.platforms.none; mainProgram = "fswatcher"; broken = true; @@ -252015,7 +252015,7 @@ self: { libraryHaskellDepends = [ base ]; testHaskellDepends = [ base ]; description = "FTC Queue"; - license = lib.licensesSpdx."BSD-3-Clause"; + license = lib.meta.getLicenseFromSpdxId "BSD-3-Clause"; } ) { }; @@ -252393,7 +252393,7 @@ self: { vector ]; description = "In-memory full text search engine"; - license = lib.licensesSpdx."BSD-3-Clause"; + license = lib.meta.getLicenseFromSpdxId "BSD-3-Clause"; } ) { }; @@ -253194,7 +253194,7 @@ self: { transformers ]; description = "FFunctor: functors on (the usual) Functors"; - license = lib.licensesSpdx."BSD-3-Clause"; + license = lib.meta.getLicenseFromSpdxId "BSD-3-Clause"; hydraPlatforms = lib.platforms.none; } ) { }; @@ -253293,7 +253293,7 @@ self: { transformers ]; description = "Convert values from one type into another"; - license = lib.licensesSpdx."MIT"; + license = lib.meta.getLicenseFromSpdxId "MIT"; hydraPlatforms = lib.platforms.none; broken = true; } @@ -253562,7 +253562,7 @@ self: { time ]; description = "GLL parser with simple combinator interface"; - license = lib.licensesSpdx."BSD-3-Clause"; + license = lib.meta.getLicenseFromSpdxId "BSD-3-Clause"; hydraPlatforms = lib.platforms.none; } ) { }; @@ -253722,7 +253722,7 @@ self: { sha256 = "0jf8yhk45n06avl9avgmawvazsz585i7jppvcds6pjd8pqdb2qk4"; libraryHaskellDepends = [ base ]; description = "Type-level function utilities"; - license = lib.licensesSpdx."BSD-3-Clause"; + license = lib.meta.getLicenseFromSpdxId "BSD-3-Clause"; hydraPlatforms = lib.platforms.none; broken = true; } @@ -253765,7 +253765,7 @@ self: { transformers ]; description = "A fast, flexible, fused effect system"; - license = lib.licensesSpdx."BSD-3-Clause"; + license = lib.meta.getLicenseFromSpdxId "BSD-3-Clause"; maintainers = [ lib.maintainers.mangoiv ]; } ) { }; @@ -253798,7 +253798,7 @@ self: { ]; testToolDepends = [ markdown-unlit ]; description = "Handle exceptions thrown in IO with fused-effects"; - license = lib.licensesSpdx."BSD-3-Clause"; + license = lib.meta.getLicenseFromSpdxId "BSD-3-Clause"; hydraPlatforms = lib.platforms.none; broken = true; } @@ -253828,7 +253828,7 @@ self: { microlens ]; description = "Monadic lens combinators for fused-effects"; - license = lib.licensesSpdx."BSD-3-Clause"; + license = lib.meta.getLicenseFromSpdxId "BSD-3-Clause"; } ) { }; @@ -253911,7 +253911,7 @@ self: { gauge ]; description = "High-quality random number generation as an effect"; - license = lib.licensesSpdx."BSD-3-Clause"; + license = lib.meta.getLicenseFromSpdxId "BSD-3-Clause"; hydraPlatforms = lib.platforms.none; broken = true; } @@ -253934,7 +253934,7 @@ self: { optics-core ]; description = "Bridge between the optics and fused-effects ecosystems"; - license = lib.licensesSpdx."BSD-3-Clause"; + license = lib.meta.getLicenseFromSpdxId "BSD-3-Clause"; } ) { }; @@ -253957,7 +253957,7 @@ self: { transformers ]; description = "Random number generation for fused-effects"; - license = lib.licensesSpdx."BSD-3-Clause"; + license = lib.meta.getLicenseFromSpdxId "BSD-3-Clause"; } ) { }; @@ -253987,7 +253987,7 @@ self: { ]; testHaskellDepends = [ base ]; description = "A readline-like effect and carrier for fused-effects"; - license = lib.licensesSpdx."BSD-3-Clause"; + license = lib.meta.getLicenseFromSpdxId "BSD-3-Clause"; } ) { }; @@ -254073,7 +254073,7 @@ self: { template-haskell ]; description = "Template Haskell helpers for fused-effects"; - license = lib.licensesSpdx."BSD-3-Clause"; + license = lib.meta.getLicenseFromSpdxId "BSD-3-Clause"; hydraPlatforms = lib.platforms.none; broken = true; } @@ -254144,7 +254144,7 @@ self: { transformers ]; description = "GHC plugin to make stream fusion more predictable"; - license = lib.licensesSpdx."Apache-2.0"; + license = lib.meta.getLicenseFromSpdxId "Apache-2.0"; } ) { }; @@ -254156,7 +254156,7 @@ self: { sha256 = "14lzymjna6faiwj7bdm1jrz42jfj3w1wi2hv66mldjhadf45613d"; libraryHaskellDepends = [ base ]; description = "Types for the fusion-plugin package"; - license = lib.licensesSpdx."BSD-3-Clause"; + license = lib.meta.getLicenseFromSpdxId "BSD-3-Clause"; } ) { }; @@ -254315,7 +254315,7 @@ self: { ]; doHaddock = false; description = "An optimising compiler for a functional, array-oriented language"; - license = lib.licensesSpdx."ISC"; + license = lib.meta.getLicenseFromSpdxId "ISC"; mainProgram = "futhark"; maintainers = [ lib.maintainers.athas ]; } @@ -254372,7 +254372,7 @@ self: { vector ]; description = "An implementation of the Futhark data format"; - license = lib.licensesSpdx."ISC"; + license = lib.meta.getLicenseFromSpdxId "ISC"; } ) { }; @@ -254411,7 +254411,7 @@ self: { text ]; description = "Definition and serialisation instances for Futhark manifests"; - license = lib.licensesSpdx."ISC"; + license = lib.meta.getLicenseFromSpdxId "ISC"; } ) { }; @@ -254444,7 +254444,7 @@ self: { text ]; description = "Client implementation of the Futhark server protocol"; - license = lib.licensesSpdx."ISC"; + license = lib.meta.getLicenseFromSpdxId "ISC"; } ) { }; @@ -254479,7 +254479,7 @@ self: { text ]; description = "Client implementation of the Futhark server protocol"; - license = lib.licensesSpdx."ISC"; + license = lib.meta.getLicenseFromSpdxId "ISC"; hydraPlatforms = lib.platforms.none; } ) { }; @@ -254749,7 +254749,7 @@ self: { ]; testToolDepends = [ hspec-discover ]; description = "Tools for processing unstructured text data"; - license = lib.licensesSpdx."MIT"; + license = lib.meta.getLicenseFromSpdxId "MIT"; hydraPlatforms = lib.platforms.none; broken = true; } @@ -254900,7 +254900,7 @@ self: { tasty-hunit ]; description = "Library for constructing and manipulating fuzzy sets and fuzzy relations"; - license = lib.licensesSpdx."BSD-3-Clause"; + license = lib.meta.getLicenseFromSpdxId "BSD-3-Clause"; } ) { }; @@ -254942,7 +254942,7 @@ self: { ]; testToolDepends = [ hspec-discover ]; description = "Fuzzy text matching"; - license = lib.licensesSpdx."MIT"; + license = lib.meta.getLicenseFromSpdxId "MIT"; hydraPlatforms = lib.platforms.none; mainProgram = "bench"; broken = true; @@ -255027,7 +255027,7 @@ self: { vector ]; description = "Fuzzy set data structure for approximate string matching"; - license = lib.licensesSpdx."BSD-3-Clause"; + license = lib.meta.getLicenseFromSpdxId "BSD-3-Clause"; } ) { }; @@ -255222,7 +255222,7 @@ self: { ]; testToolDepends = [ hspec-discover ]; description = "Modular effectful computations with explicit environments and errors"; - license = lib.licensesSpdx."MIT"; + license = lib.meta.getLicenseFromSpdxId "MIT"; hydraPlatforms = lib.platforms.none; broken = true; } @@ -255708,7 +255708,7 @@ self: { hspec ]; description = "Composable, streaming, and efficient left folds"; - license = lib.licensesSpdx."BSD-3-Clause"; + license = lib.meta.getLicenseFromSpdxId "BSD-3-Clause"; hydraPlatforms = lib.platforms.none; broken = true; } @@ -256004,7 +256004,7 @@ self: { sha256 = "0r8wybcqn7g24q8abrw757h76r75l4jh4hjx91yh44h4c1r6k4yf"; doHaddock = false; description = "TBA"; - license = lib.licensesSpdx."BSD-3-Clause"; + license = lib.meta.getLicenseFromSpdxId "BSD-3-Clause"; } ) { }; @@ -256342,7 +256342,7 @@ self: { text ]; description = "Pure Nix binary cache protocol library"; - license = lib.licensesSpdx."MIT"; + license = lib.meta.getLicenseFromSpdxId "MIT"; } ) { }; @@ -256369,7 +256369,7 @@ self: { directory ]; description = "Pure Haskell 2D raster graphics engine"; - license = lib.licensesSpdx."BSD-3-Clause"; + license = lib.meta.getLicenseFromSpdxId "BSD-3-Clause"; } ) { }; @@ -256397,7 +256397,7 @@ self: { directory ]; description = "Procedural music and sound effect synthesis"; - license = lib.licensesSpdx."BSD-3-Clause"; + license = lib.meta.getLicenseFromSpdxId "BSD-3-Clause"; } ) { }; @@ -256422,7 +256422,7 @@ self: { text ]; description = "Pure Haskell SVG generation"; - license = lib.licensesSpdx."BSD-3-Clause"; + license = lib.meta.getLicenseFromSpdxId "BSD-3-Clause"; } ) { }; @@ -256482,7 +256482,7 @@ self: { deepseq ]; description = "Transport-level networking library with zero-copy Storable serialization"; - license = lib.licensesSpdx."MIT"; + license = lib.meta.getLicenseFromSpdxId "MIT"; } ) { }; @@ -256594,7 +256594,7 @@ self: { yaml ]; description = "A library for downloading data from a Great Black Swamp server"; - license = lib.licensesSpdx."BSD-3-Clause"; + license = lib.meta.getLicenseFromSpdxId "BSD-3-Clause"; hydraPlatforms = lib.platforms.none; } ) { }; @@ -257646,7 +257646,7 @@ self: { x509 ]; description = "a simple Gemini capsule (server)"; - license = lib.licensesSpdx."AGPL-3.0-or-later"; + license = lib.meta.getLicenseFromSpdxId "AGPL-3.0-or-later"; hydraPlatforms = lib.platforms.none; broken = true; } @@ -257745,7 +257745,7 @@ self: { transformers ]; description = "A simple Happstack-style Gemini router"; - license = lib.licensesSpdx."BSD-3-Clause"; + license = lib.meta.getLicenseFromSpdxId "BSD-3-Clause"; } ) { }; @@ -257780,7 +257780,7 @@ self: { utf8-string ]; description = "A lightweight server for the Gemini protocol"; - license = lib.licensesSpdx."BSD-3-Clause"; + license = lib.meta.getLicenseFromSpdxId "BSD-3-Clause"; } ) { }; @@ -257827,7 +257827,7 @@ self: { transformers ]; description = "A barebones textboard for the Gemini protocol"; - license = lib.licensesSpdx."BSD-3-Clause"; + license = lib.meta.getLicenseFromSpdxId "BSD-3-Clause"; mainProgram = "gemini-textboard"; } ) { }; @@ -257853,7 +257853,7 @@ self: { text ]; description = "a tiny gemtext parser"; - license = lib.licensesSpdx."LGPL-3.0-or-later"; + license = lib.meta.getLicenseFromSpdxId "LGPL-3.0-or-later"; } ) { }; @@ -257943,7 +257943,7 @@ self: { unordered-containers ]; description = "yet another static gemlog generator + converter"; - license = lib.licensesSpdx."GPL-3.0-or-later"; + license = lib.meta.getLicenseFromSpdxId "GPL-3.0-or-later"; } ) { }; @@ -258096,7 +258096,7 @@ self: { text ]; description = "A library for interacting with various generative AI LLMs"; - license = lib.licensesSpdx."ISC"; + license = lib.meta.getLicenseFromSpdxId "ISC"; hydraPlatforms = lib.platforms.none; broken = true; } @@ -258259,7 +258259,7 @@ self: { transformers ]; description = "Exception-safe resource management in more monads"; - license = lib.licensesSpdx."Apache-2.0"; + license = lib.meta.getLicenseFromSpdxId "Apache-2.0"; hydraPlatforms = lib.platforms.none; broken = true; } @@ -258534,7 +258534,7 @@ self: { ]; testToolDepends = [ hspec-discover ]; description = "Generic case analysis"; - license = lib.licensesSpdx."BSD-3-Clause"; + license = lib.meta.getLicenseFromSpdxId "BSD-3-Clause"; } ) { }; @@ -258791,7 +258791,7 @@ self: { ]; testToolDepends = [ hspec-discover ]; description = "Generic structural diffs"; - license = lib.licensesSpdx."BSD-3-Clause"; + license = lib.meta.getLicenseFromSpdxId "BSD-3-Clause"; } ) { }; @@ -258832,7 +258832,7 @@ self: { ]; testToolDepends = [ hspec-discover ]; description = "Diff instances for common types"; - license = lib.licensesSpdx."BSD-3-Clause"; + license = lib.meta.getLicenseFromSpdxId "BSD-3-Clause"; } ) { }; @@ -258874,7 +258874,7 @@ self: { sha256 = "0x624z5zq9d0w2yrcb9b5qpnjnvm4qkni6csdm1nh7f14yx1v3wq"; libraryHaskellDepends = [ base ]; description = "Generically derived enumerations"; - license = lib.licensesSpdx."MIT"; + license = lib.meta.getLicenseFromSpdxId "MIT"; } ) { }; @@ -258947,7 +258947,7 @@ self: { inspection-testing ]; description = "Generically extract and replace collections of record fields"; - license = lib.licensesSpdx."BSD-3-Clause"; + license = lib.meta.getLicenseFromSpdxId "BSD-3-Clause"; hydraPlatforms = lib.platforms.none; broken = true; } @@ -259102,7 +259102,7 @@ self: { libraryHaskellDepends = [ base ]; testHaskellDepends = [ base ]; description = "Monomorphic field lens like with generic-lens"; - license = lib.licensesSpdx."BSD-3-Clause"; + license = lib.meta.getLicenseFromSpdxId "BSD-3-Clause"; } ) { }; @@ -259115,7 +259115,7 @@ self: { libraryHaskellDepends = [ base ]; testHaskellDepends = [ base ]; description = "Derive Bounded and Enum for sum types and Enum for product types"; - license = lib.licensesSpdx."BSD-3-Clause"; + license = lib.meta.getLicenseFromSpdxId "BSD-3-Clause"; } ) { }; @@ -259157,7 +259157,7 @@ self: { generics-sop ]; description = "First class pattern matching"; - license = lib.licensesSpdx."MIT"; + license = lib.meta.getLicenseFromSpdxId "MIT"; hydraPlatforms = lib.platforms.none; broken = true; } @@ -259335,7 +259335,7 @@ self: { optics-core ]; description = "Monomorphic field opics like with generic-lens"; - license = lib.licensesSpdx."BSD-3-Clause"; + license = lib.meta.getLicenseFromSpdxId "BSD-3-Clause"; } ) { }; @@ -262182,7 +262182,7 @@ self: { QuickCheck ]; description = "Terrestrial coordinate systems and geodetic calculations"; - license = lib.licensesSpdx."BSD-3-Clause"; + license = lib.meta.getLicenseFromSpdxId "BSD-3-Clause"; } ) { }; @@ -262216,7 +262216,7 @@ self: { QuickCheck ]; description = "Terrestrial coordinate systems and geodetic calculations"; - license = lib.licensesSpdx."BSD-3-Clause"; + license = lib.meta.getLicenseFromSpdxId "BSD-3-Clause"; hydraPlatforms = lib.platforms.none; } ) { }; @@ -262555,7 +262555,7 @@ self: { ]; testSystemDepends = [ geos ]; description = "Bindings for GEOS"; - license = lib.licensesSpdx."MIT"; + license = lib.meta.getLicenseFromSpdxId "MIT"; hydraPlatforms = lib.platforms.none; broken = true; } @@ -262602,7 +262602,7 @@ self: { time ]; description = "A gerrit client library"; - license = lib.licensesSpdx."Apache-2.0"; + license = lib.meta.getLicenseFromSpdxId "Apache-2.0"; } ) { }; @@ -262749,7 +262749,7 @@ self: { th-lift-instances ]; description = "gettext-th can internationalise a haskell program without runtime dependencies"; - license = lib.licensesSpdx."BSD-3-Clause"; + license = lib.meta.getLicenseFromSpdxId "BSD-3-Clause"; } ) { }; @@ -262773,7 +262773,7 @@ self: { HUnit ]; description = "The family of Extreme Value Distributions"; - license = lib.licensesSpdx."ISC"; + license = lib.meta.getLicenseFromSpdxId "ISC"; hydraPlatforms = lib.platforms.none; broken = true; } @@ -263086,7 +263086,7 @@ self: { happy ]; description = "The GHC API"; - license = lib.licensesSpdx."BSD-3-Clause"; + license = lib.meta.getLicenseFromSpdxId "BSD-3-Clause"; hydraPlatforms = lib.platforms.none; } ) @@ -263147,7 +263147,7 @@ self: { ghc-bignum ]; description = "Backwards-compatible orphan instances for ghc-bignum"; - license = lib.licensesSpdx."BSD-3-Clause"; + license = lib.meta.getLicenseFromSpdxId "BSD-3-Clause"; } ) { }; @@ -263189,7 +263189,7 @@ self: { unix ]; description = "Shared functionality between GHC and its boot libraries"; - license = lib.licensesSpdx."BSD-3-Clause"; + license = lib.meta.getLicenseFromSpdxId "BSD-3-Clause"; hydraPlatforms = lib.platforms.none; } ) { }; @@ -263228,7 +263228,7 @@ self: { testHaskellDepends = [ base ]; doHaddock = false; description = "\"GHC.ByteOrder\" API Compatibility Layer"; - license = lib.licensesSpdx."BSD-3-Clause"; + license = lib.meta.getLicenseFromSpdxId "BSD-3-Clause"; } ) { }; @@ -263346,7 +263346,7 @@ self: { sha256 = "0y8n31ri08rl1nzm4phjz5azia7zmwswv2fhzkx828xll6cpqbc3"; libraryHaskellDepends = [ base ]; description = "GHC compatibility for MicroHs"; - license = lib.licensesSpdx."Apache-2.0"; + license = lib.meta.getLicenseFromSpdxId "Apache-2.0"; hydraPlatforms = lib.platforms.none; broken = true; } @@ -263572,7 +263572,7 @@ self: { ]; executableHaskellDepends = [ base ]; description = "A simple TUI using ghc-debug"; - license = lib.licensesSpdx."BSD-3-Clause"; + license = lib.meta.getLicenseFromSpdxId "BSD-3-Clause"; mainProgram = "ghc-debug-brick"; maintainers = [ lib.maintainers.maralorn ]; } @@ -263639,7 +263639,7 @@ self: { vector ]; description = "Useful functions for writing heap analysis tools which use ghc-debug"; - license = lib.licensesSpdx."BSD-3-Clause"; + license = lib.meta.getLicenseFromSpdxId "BSD-3-Clause"; } ) { }; @@ -263682,7 +263682,7 @@ self: { unordered-containers ]; description = "Connect to a socket created by ghc-debug-stub and analyse the heap of the debuggee program"; - license = lib.licensesSpdx."BSD-3-Clause"; + license = lib.meta.getLicenseFromSpdxId "BSD-3-Clause"; } ) { }; @@ -263703,7 +263703,7 @@ self: { filepath ]; description = "Definitions needed by ghc-debug-stub and ghc-debug-common"; - license = lib.licensesSpdx."BSD-3-Clause"; + license = lib.meta.getLicenseFromSpdxId "BSD-3-Clause"; } ) { }; @@ -263728,7 +263728,7 @@ self: { ghc-prim ]; description = "Functions for instrumenting your application so the heap can be analysed with ghc-debug-common"; - license = lib.licensesSpdx."BSD-3-Clause"; + license = lib.meta.getLicenseFromSpdxId "BSD-3-Clause"; maintainers = [ lib.maintainers.maralorn ]; } ) { }; @@ -263797,7 +263797,7 @@ self: { ]; testHaskellDepends = [ base ]; description = "A step-through machine-interface debugger for GHC Haskell"; - license = lib.licensesSpdx."BSD-3-Clause"; + license = lib.meta.getLicenseFromSpdxId "BSD-3-Clause"; hydraPlatforms = lib.platforms.none; mainProgram = "ghc-debug-adapter"; broken = true; @@ -263823,7 +263823,7 @@ self: { template-haskell ]; description = "Automatically generate GHC API counterparts to Haskell declarations"; - license = lib.licensesSpdx."BSD-3-Clause"; + license = lib.meta.getLicenseFromSpdxId "BSD-3-Clause"; hydraPlatforms = lib.platforms.none; broken = true; } @@ -263854,7 +263854,7 @@ self: { text ]; description = "An AST and compiler plugin for dumping GHC's Core representation"; - license = lib.licensesSpdx."BSD-3-Clause"; + license = lib.meta.getLicenseFromSpdxId "BSD-3-Clause"; hydraPlatforms = lib.platforms.none; broken = true; } @@ -263957,7 +263957,7 @@ self: { regex-tdfa ]; description = "Handy tools for working with ghc-dump dumps"; - license = lib.licensesSpdx."BSD-3-Clause"; + license = lib.meta.getLicenseFromSpdxId "BSD-3-Clause"; hydraPlatforms = lib.platforms.none; mainProgram = "ghc-dump"; } @@ -264004,7 +264004,7 @@ self: { ghc-events ]; description = "Let an application read its own eventlog"; - license = lib.licensesSpdx."BSD-3-Clause"; + license = lib.meta.getLicenseFromSpdxId "BSD-3-Clause"; } ) { }; @@ -264043,7 +264043,7 @@ self: { ]; testHaskellDepends = [ base ]; description = "Library and tool for parsing .eventlog files from GHC"; - license = lib.licensesSpdx."BSD-3-Clause"; + license = lib.meta.getLicenseFromSpdxId "BSD-3-Clause"; mainProgram = "ghc-events"; } ) { }; @@ -264079,7 +264079,7 @@ self: { ]; testHaskellDepends = [ base ]; description = "Library and tool for parsing .eventlog files from GHC"; - license = lib.licensesSpdx."BSD-3-Clause"; + license = lib.meta.getLicenseFromSpdxId "BSD-3-Clause"; hydraPlatforms = lib.platforms.none; mainProgram = "ghc-events"; } @@ -264141,7 +264141,7 @@ self: { base ]; description = "Analyze and visualize event logs"; - license = lib.licensesSpdx."BSD-3-Clause"; + license = lib.meta.getLicenseFromSpdxId "BSD-3-Clause"; hydraPlatforms = lib.platforms.none; mainProgram = "ghc-events-analyze"; broken = true; @@ -264449,7 +264449,7 @@ self: { syb ]; description = "ExactPrint for GHC"; - license = lib.licensesSpdx."BSD-3-Clause"; + license = lib.meta.getLicenseFromSpdxId "BSD-3-Clause"; hydraPlatforms = lib.platforms.none; } ) { }; @@ -264500,7 +264500,7 @@ self: { syb ]; description = "ExactPrint for GHC"; - license = lib.licensesSpdx."BSD-3-Clause"; + license = lib.meta.getLicenseFromSpdxId "BSD-3-Clause"; } ) { }; @@ -264513,7 +264513,7 @@ self: { isLibrary = true; isExecutable = true; description = "ExactPrint for GHC"; - license = lib.licensesSpdx."BSD-3-Clause"; + license = lib.meta.getLicenseFromSpdxId "BSD-3-Clause"; hydraPlatforms = lib.platforms.none; } ) { }; @@ -264527,7 +264527,7 @@ self: { isLibrary = true; isExecutable = true; description = "ExactPrint for GHC"; - license = lib.licensesSpdx."BSD-3-Clause"; + license = lib.meta.getLicenseFromSpdxId "BSD-3-Clause"; hydraPlatforms = lib.platforms.none; } ) { }; @@ -264547,7 +264547,7 @@ self: { ghc-internal ]; description = "Experimental features of GHC's standard library"; - license = lib.licensesSpdx."BSD-3-Clause"; + license = lib.meta.getLicenseFromSpdxId "BSD-3-Clause"; hydraPlatforms = lib.platforms.none; } ) { }; @@ -264646,7 +264646,7 @@ self: { rts ]; description = "Functions for walking GHC's heap"; - license = lib.licensesSpdx."BSD-3-Clause"; + license = lib.meta.getLicenseFromSpdxId "BSD-3-Clause"; hydraPlatforms = lib.platforms.none; } ) { }; @@ -264805,7 +264805,7 @@ self: { template-haskell ]; description = "Translate Haskell source to Template Haskell expression"; - license = lib.licensesSpdx."BSD-3-Clause"; + license = lib.meta.getLicenseFromSpdxId "BSD-3-Clause"; } ) { }; @@ -264991,7 +264991,7 @@ self: { version = "9.1401.0"; sha256 = "0cm61xppbqdc6g3z746dbsvbk96g687lrk3ncz0ysmm03h6rbr42"; description = "Basic libraries"; - license = lib.licensesSpdx."BSD-3-Clause"; + license = lib.meta.getLicenseFromSpdxId "BSD-3-Clause"; hydraPlatforms = lib.platforms.none; broken = true; } @@ -265083,7 +265083,7 @@ self: { happy ]; description = "The GHC API, decoupled from GHC versions"; - license = lib.licensesSpdx."BSD-3-Clause"; + license = lib.meta.getLicenseFromSpdxId "BSD-3-Clause"; hydraPlatforms = lib.platforms.none; } ) { }; @@ -265148,7 +265148,7 @@ self: { happy ]; description = "The GHC API, decoupled from GHC versions"; - license = lib.licensesSpdx."BSD-3-Clause"; + license = lib.meta.getLicenseFromSpdxId "BSD-3-Clause"; hydraPlatforms = lib.platforms.none; } ) { }; @@ -265213,7 +265213,7 @@ self: { happy ]; description = "The GHC API, decoupled from GHC versions"; - license = lib.licensesSpdx."BSD-3-Clause"; + license = lib.meta.getLicenseFromSpdxId "BSD-3-Clause"; hydraPlatforms = lib.platforms.none; } ) { }; @@ -265280,7 +265280,7 @@ self: { happy ]; description = "The GHC API, decoupled from GHC versions"; - license = lib.licensesSpdx."BSD-3-Clause"; + license = lib.meta.getLicenseFromSpdxId "BSD-3-Clause"; } ) { }; @@ -265346,7 +265346,7 @@ self: { happy ]; description = "The GHC API, decoupled from GHC versions"; - license = lib.licensesSpdx."BSD-3-Clause"; + license = lib.meta.getLicenseFromSpdxId "BSD-3-Clause"; hydraPlatforms = lib.platforms.none; } ) { }; @@ -265403,7 +265403,7 @@ self: { happy ]; description = "The GHC API, decoupled from GHC versions"; - license = lib.licensesSpdx."BSD-3-Clause"; + license = lib.meta.getLicenseFromSpdxId "BSD-3-Clause"; hydraPlatforms = lib.platforms.none; } ) { }; @@ -265460,7 +265460,7 @@ self: { happy ]; description = "The GHC API, decoupled from GHC versions"; - license = lib.licensesSpdx."BSD-3-Clause"; + license = lib.meta.getLicenseFromSpdxId "BSD-3-Clause"; hydraPlatforms = lib.platforms.none; } ) { }; @@ -265521,7 +265521,7 @@ self: { happy ]; description = "The GHC API, decoupled from GHC versions"; - license = lib.licensesSpdx."BSD-3-Clause"; + license = lib.meta.getLicenseFromSpdxId "BSD-3-Clause"; } ) { }; @@ -265581,7 +265581,7 @@ self: { happy ]; description = "The GHC API, decoupled from GHC versions"; - license = lib.licensesSpdx."BSD-3-Clause"; + license = lib.meta.getLicenseFromSpdxId "BSD-3-Clause"; hydraPlatforms = lib.platforms.none; } ) { }; @@ -265718,7 +265718,7 @@ self: { uniplate ]; description = "Programming with GHC parse trees"; - license = lib.licensesSpdx."BSD-3-Clause"; + license = lib.meta.getLicenseFromSpdxId "BSD-3-Clause"; mainProgram = "ghc-lib-parser-ex-build-tool"; } ) { }; @@ -265773,7 +265773,7 @@ self: { uniplate ]; description = "Programming with GHC parse trees"; - license = lib.licensesSpdx."BSD-3-Clause"; + license = lib.meta.getLicenseFromSpdxId "BSD-3-Clause"; hydraPlatforms = lib.platforms.none; mainProgram = "ghc-lib-parser-ex-build-tool"; } @@ -266279,7 +266279,7 @@ self: { hspec ]; description = "GHC Plugin for non-empty lists"; - license = lib.licensesSpdx."MPL-2.0"; + license = lib.meta.getLicenseFromSpdxId "MPL-2.0"; hydraPlatforms = lib.platforms.none; broken = true; } @@ -266308,7 +266308,7 @@ self: { testHaskellDepends = [ base ]; doHaddock = false; description = "Type checker plugins without the type checking"; - license = lib.licensesSpdx."MPL-2.0"; + license = lib.meta.getLicenseFromSpdxId "MPL-2.0"; hydraPlatforms = lib.platforms.none; } ) { }; @@ -266338,7 +266338,7 @@ self: { libraryHaskellDepends = [ rts ]; librarySystemDepends = [ c ]; description = "GHC primitives"; - license = lib.licensesSpdx."BSD-3-Clause"; + license = lib.meta.getLicenseFromSpdxId "BSD-3-Clause"; hydraPlatforms = lib.platforms.none; } ) { c = null; }; @@ -266386,7 +266386,7 @@ self: { text ]; description = "Library for parsing GHC time and allocation profiling reports"; - license = lib.licensesSpdx."BSD-3-Clause"; + license = lib.meta.getLicenseFromSpdxId "BSD-3-Clause"; } ) { }; @@ -266658,7 +266658,7 @@ self: { sha256 = "1b5xm1zlvw3kv45y2dksisc4lhfbvk7df7sb7n1ypxmdvzwi010a"; libraryHaskellDepends = [ base ]; description = "RTS Callstack annotation library"; - license = lib.licensesSpdx."BSD-3-Clause"; + license = lib.meta.getLicenseFromSpdxId "BSD-3-Clause"; } ) { }; @@ -266689,7 +266689,7 @@ self: { text ]; description = "RTS Callstack profiler for GHC"; - license = lib.licensesSpdx."BSD-3-Clause"; + license = lib.meta.getLicenseFromSpdxId "BSD-3-Clause"; } ) { }; @@ -266718,7 +266718,7 @@ self: { transformers ]; description = "Thread sample types and serialisation logic for `ghc-stack-profiler`"; - license = lib.licensesSpdx."BSD-3-Clause"; + license = lib.meta.getLicenseFromSpdxId "BSD-3-Clause"; } ) { }; @@ -266758,7 +266758,7 @@ self: { ]; executableHaskellDepends = [ base ]; description = "Convert eventlog messages from `ghc-stack-profiler` into a speedscope json"; - license = lib.licensesSpdx."BSD-3-Clause"; + license = lib.meta.getLicenseFromSpdxId "BSD-3-Clause"; hydraPlatforms = lib.platforms.none; mainProgram = "ghc-stack-profiler-speedscope"; broken = true; @@ -266866,7 +266866,7 @@ self: { text ]; description = "Symbol on term level"; - license = lib.licensesSpdx."BSD-3-Clause"; + license = lib.meta.getLicenseFromSpdxId "BSD-3-Clause"; hydraPlatforms = lib.platforms.none; broken = true; } @@ -266898,7 +266898,7 @@ self: { ]; testToolDepends = [ hspec-discover ]; description = "Syntax highlighter for Haskell using the lexer of GHC"; - license = lib.licensesSpdx."BSD-3-Clause"; + license = lib.meta.getLicenseFromSpdxId "BSD-3-Clause"; } ) { }; @@ -266928,7 +266928,7 @@ self: { ]; testToolDepends = [ hspec-discover ]; description = "Syntax highlighter for Haskell using the lexer of GHC"; - license = lib.licensesSpdx."BSD-3-Clause"; + license = lib.meta.getLicenseFromSpdxId "BSD-3-Clause"; hydraPlatforms = lib.platforms.none; } ) { }; @@ -266986,7 +266986,7 @@ self: { yaml ]; description = "Utility for generating ctags and etags with GHC API"; - license = lib.licensesSpdx."MPL-2.0"; + license = lib.meta.getLicenseFromSpdxId "MPL-2.0"; hydraPlatforms = lib.platforms.none; mainProgram = "ghc-tags"; } @@ -267045,7 +267045,7 @@ self: { yaml ]; description = "Utility for generating ctags and etags with GHC API"; - license = lib.licensesSpdx."MPL-2.0"; + license = lib.meta.getLicenseFromSpdxId "MPL-2.0"; hydraPlatforms = lib.platforms.none; mainProgram = "ghc-tags"; } @@ -267102,7 +267102,7 @@ self: { yaml ]; description = "Utility for generating ctags and etags with GHC API"; - license = lib.licensesSpdx."MPL-2.0"; + license = lib.meta.getLicenseFromSpdxId "MPL-2.0"; mainProgram = "ghc-tags"; } ) { }; @@ -267134,7 +267134,7 @@ self: { text ]; description = "CTags and ETags from Haskell syntax tree"; - license = lib.licensesSpdx."MPL-2.0"; + license = lib.meta.getLicenseFromSpdxId "MPL-2.0"; } ) { }; @@ -267169,7 +267169,7 @@ self: { text ]; description = "Streaming interface for ghc-tags-core"; - license = lib.licensesSpdx."MPL-2.0"; + license = lib.meta.getLicenseFromSpdxId "MPL-2.0"; } ) { }; @@ -267214,7 +267214,7 @@ self: { text ]; description = "A compiler plugin which generates tags file from GHC parsed syntax tree"; - license = lib.licensesSpdx."MPL-2.0"; + license = lib.meta.getLicenseFromSpdxId "MPL-2.0"; } ) { }; @@ -267241,7 +267241,7 @@ self: { transformers ]; description = "An API for type-checker plugins"; - license = lib.licensesSpdx."BSD-3-Clause"; + license = lib.meta.getLicenseFromSpdxId "BSD-3-Clause"; } ) { }; @@ -267365,7 +267365,7 @@ self: { tasty-bench ]; description = "Faster traceEvent and traceMarker, and binary object logging for eventlog"; - license = lib.licensesSpdx."BSD-3-Clause"; + license = lib.meta.getLicenseFromSpdxId "BSD-3-Clause"; } ) { }; @@ -267463,7 +267463,7 @@ self: { temporary ]; description = "Additional type-level operations on GHC.TypeLits.Nat"; - license = lib.licensesSpdx."BSD-2-Clause"; + license = lib.meta.getLicenseFromSpdxId "BSD-2-Clause"; hydraPlatforms = lib.platforms.none; } ) { }; @@ -267544,7 +267544,7 @@ self: { tasty-quickcheck ]; description = "Derive KnownNat constraints from other KnownNat constraints"; - license = lib.licensesSpdx."BSD-2-Clause"; + license = lib.meta.getLicenseFromSpdxId "BSD-2-Clause"; hydraPlatforms = lib.platforms.none; } ) { }; @@ -267666,7 +267666,7 @@ self: { temporary ]; description = "GHC typechecker plugin for types of kind GHC.TypeLits.Nat"; - license = lib.licensesSpdx."BSD-2-Clause"; + license = lib.meta.getLicenseFromSpdxId "BSD-2-Clause"; hydraPlatforms = lib.platforms.none; } ) { }; @@ -267718,7 +267718,7 @@ self: { ]; testToolDepends = [ tasty-discover ]; description = "Presburger Arithmetic Solver for GHC Type-level natural numbers"; - license = lib.licensesSpdx."BSD-3-Clause"; + license = lib.meta.getLicenseFromSpdxId "BSD-3-Clause"; hydraPlatforms = lib.platforms.none; broken = true; } @@ -267802,7 +267802,7 @@ self: { xdot ]; description = "Live visualization of data structures in GHCi"; - license = lib.licensesSpdx."BSD-3-Clause"; + license = lib.meta.getLicenseFromSpdxId "BSD-3-Clause"; maintainers = [ lib.maintainers.dalpd ]; } ) { }; @@ -267826,7 +267826,7 @@ self: { time ]; description = "Dump the ghc flags during compilation"; - license = lib.licensesSpdx."BSD-2-Clause"; + license = lib.meta.getLicenseFromSpdxId "BSD-2-Clause"; } ) { }; @@ -268211,7 +268211,7 @@ self: { tasty-hunit ]; description = "GHC plugin that writes errors to a file for use with quickfix"; - license = lib.licensesSpdx."BSD-3-Clause"; + license = lib.meta.getLicenseFromSpdxId "BSD-3-Clause"; } ) { }; @@ -268246,7 +268246,7 @@ self: { websockets ]; description = "A websocket server that survives GHCi reloads"; - license = lib.licensesSpdx."BSD-3-Clause"; + license = lib.meta.getLicenseFromSpdxId "BSD-3-Clause"; } ) { }; @@ -268307,7 +268307,7 @@ self: { text ]; description = "A GHCi session in LaTeX"; - license = lib.licensesSpdx."BSD-3-Clause"; + license = lib.meta.getLicenseFromSpdxId "BSD-3-Clause"; mainProgram = "ghci4luatex"; } ) { }; @@ -268541,7 +268541,7 @@ self: { optparse-applicative ]; description = "The core of an IDE"; - license = lib.licensesSpdx."Apache-2.0"; + license = lib.meta.getLicenseFromSpdxId "Apache-2.0"; mainProgram = "ghcide"; } ) { }; @@ -268638,7 +268638,7 @@ self: { ]; testToolDepends = [ ghcide ]; description = "An LSP client for running performance experiments on HLS"; - license = lib.licensesSpdx."Apache-2.0"; + license = lib.meta.getLicenseFromSpdxId "Apache-2.0"; hydraPlatforms = lib.platforms.none; mainProgram = "ghcide-bench"; broken = true; @@ -268686,7 +268686,7 @@ self: { text ]; description = "Test utils for ghcide"; - license = lib.licensesSpdx."Apache-2.0"; + license = lib.meta.getLicenseFromSpdxId "Apache-2.0"; hydraPlatforms = lib.platforms.none; broken = true; } @@ -268760,7 +268760,7 @@ self: { ]; doHaddock = false; description = "A Terminal User Interface (TUI) for GHCi"; - license = lib.licensesSpdx."BSD-3-Clause"; + license = lib.meta.getLicenseFromSpdxId "BSD-3-Clause"; mainProgram = "ghcitui"; } ) { }; @@ -268797,7 +268797,7 @@ self: { version = "0.8.0.4"; sha256 = "081w3234jramsmafnl86v37lwbckr2vc93gr9pdwc31yzni9kbml"; description = "base library for GHCJS"; - license = lib.licensesSpdx."MIT"; + license = lib.meta.getLicenseFromSpdxId "MIT"; platforms = [ "javascript-ghcjs" ]; maintainers = [ lib.maintainers.alexfmpe ]; } @@ -268838,7 +268838,7 @@ self: { vector ]; description = "Allow GHCJS projects to compile under GHC and develop using intero"; - license = lib.licensesSpdx."BSD-3-Clause"; + license = lib.meta.getLicenseFromSpdxId "BSD-3-Clause"; hydraPlatforms = lib.platforms.none; broken = true; } @@ -268880,7 +268880,7 @@ self: { transformers ]; description = "DOM library that supports both GHCJS and GHC"; - license = lib.licensesSpdx."MIT"; + license = lib.meta.getLicenseFromSpdxId "MIT"; maintainers = [ lib.maintainers.alexfmpe ]; } ) { }; @@ -268929,7 +268929,7 @@ self: { version = "0.9.9.3"; sha256 = "1k62w5czg544ias8q2kvhp8qnlafzisgx1p0gq8d2kh662w99kcg"; description = "DOM library using JSFFI and GHCJS"; - license = lib.licensesSpdx."MIT"; + license = lib.meta.getLicenseFromSpdxId "MIT"; platforms = [ "javascript-ghcjs" ]; maintainers = [ lib.maintainers.alexfmpe ]; } @@ -268944,7 +268944,7 @@ self: { libraryHaskellDepends = [ jsaddle-dom ]; doHaddock = false; description = "DOM library that supports both GHCJS and GHC using jsaddle"; - license = lib.licensesSpdx."MIT"; + license = lib.meta.getLicenseFromSpdxId "MIT"; maintainers = [ lib.maintainers.alexfmpe ]; } ) { }; @@ -268956,7 +268956,7 @@ self: { version = "0.9.9.0"; sha256 = "0fhcs89x180kw75qgbfh28wjyn55frwdfj4rqlqa1smx0fwhzyy1"; description = "DOM library using JSFFI and GHCJS"; - license = lib.licensesSpdx."MIT"; + license = lib.meta.getLicenseFromSpdxId "MIT"; } ) { }; @@ -269515,7 +269515,7 @@ self: { testToolDepends = [ hspec-discover ]; doHaddock = false; description = "ghc toolchain installer"; - license = lib.licensesSpdx."LGPL-3.0-only"; + license = lib.meta.getLicenseFromSpdxId "LGPL-3.0-only"; hydraPlatforms = lib.platforms.none; mainProgram = "ghcup"; broken = true; @@ -270854,7 +270854,7 @@ self: { haskell-gi-base ]; description = "Haskell implementation of GListModel interface from gi-gio"; - license = lib.licensesSpdx."LGPL-2.1-only"; + license = lib.meta.getLicenseFromSpdxId "LGPL-2.1-only"; hydraPlatforms = lib.platforms.none; broken = true; } @@ -273737,7 +273737,7 @@ self: { ]; doHaddock = false; description = "Generate easy-to-remember, hard-to-guess passwords"; - license = lib.licensesSpdx."MIT"; + license = lib.meta.getLicenseFromSpdxId "MIT"; hydraPlatforms = lib.platforms.none; broken = true; } @@ -273806,7 +273806,7 @@ self: { gauge ]; description = "Refreshed parsec-style library for compatibility with Scala parsley"; - license = lib.licensesSpdx."BSD-3-Clause"; + license = lib.meta.getLicenseFromSpdxId "BSD-3-Clause"; hydraPlatforms = lib.platforms.none; broken = true; } @@ -273921,7 +273921,7 @@ self: { utf8-string ]; description = "An implementation of the Jinja2 template language in Haskell"; - license = lib.licensesSpdx."MIT"; + license = lib.meta.getLicenseFromSpdxId "MIT"; mainProgram = "ginger"; } ) { }; @@ -274011,7 +274011,7 @@ self: { vector ]; description = "Jinja templates for Haskell"; - license = lib.licensesSpdx."MIT"; + license = lib.meta.getLicenseFromSpdxId "MIT"; hydraPlatforms = lib.platforms.none; mainProgram = "ginger2"; broken = true; @@ -274166,7 +274166,7 @@ self: { ]; libraryPkgconfigDepends = [ system-glib ]; description = "Binding to GIO"; - license = lib.licensesSpdx."LGPL-2.1-only"; + license = lib.meta.getLicenseFromSpdxId "LGPL-2.1-only"; } ) { system-glib = pkgs.glib; }; @@ -275357,7 +275357,7 @@ self: { ]; testToolDepends = [ tasty-discover ]; description = "Recover Git repositories from disk recovery tool output (photorec)"; - license = lib.licensesSpdx."BSD-3-Clause"; + license = lib.meta.getLicenseFromSpdxId "BSD-3-Clause"; hydraPlatforms = lib.platforms.none; mainProgram = "git-phoenix"; broken = true; @@ -275450,7 +275450,7 @@ self: { text ]; description = "Git remote helper to store git objects on IPFS"; - license = lib.licensesSpdx."BSD-3-Clause"; + license = lib.meta.getLicenseFromSpdxId "BSD-3-Clause"; hydraPlatforms = lib.platforms.none; mainProgram = "git-remote-ipfs"; } @@ -275998,7 +275998,7 @@ self: { ]; testToolDepends = [ hspec-discover ]; description = "Access to the GitHub API, v3"; - license = lib.licensesSpdx."BSD-3-Clause"; + license = lib.meta.getLicenseFromSpdxId "BSD-3-Clause"; } ) { }; @@ -276062,7 +276062,7 @@ self: { ]; testToolDepends = [ tasty-discover ]; description = "Github Actions"; - license = lib.licensesSpdx."BSD-3-Clause"; + license = lib.meta.getLicenseFromSpdxId "BSD-3-Clause"; } ) { }; @@ -276346,7 +276346,7 @@ self: { ]; executableHaskellDepends = [ base ]; description = "Upload files to GitHub releases"; - license = lib.licensesSpdx."MIT"; + license = lib.meta.getLicenseFromSpdxId "MIT"; mainProgram = "github-release"; } ) { }; @@ -276808,7 +276808,7 @@ self: { tasty-smallcheck ]; description = "Heads up, and you see your GIT context"; - license = lib.licensesSpdx."BSD-3-Clause"; + license = lib.meta.getLicenseFromSpdxId "BSD-3-Clause"; hydraPlatforms = lib.platforms.none; broken = true; } @@ -276877,7 +276877,7 @@ self: { text ]; description = "Library for reading .gitignore files and filtering paths"; - license = lib.licensesSpdx."Apache-2.0"; + license = lib.meta.getLicenseFromSpdxId "Apache-2.0"; } ) { }; @@ -277116,7 +277116,7 @@ self: { vector ]; description = "A Haskell library for the GitLab web API"; - license = lib.licensesSpdx."BSD-3-Clause"; + license = lib.meta.getLicenseFromSpdxId "BSD-3-Clause"; } ) { }; @@ -277178,7 +277178,7 @@ self: { vector ]; description = "A Haskell library for the GitLab web API"; - license = lib.licensesSpdx."BSD-3-Clause"; + license = lib.meta.getLicenseFromSpdxId "BSD-3-Clause"; hydraPlatforms = lib.platforms.none; } ) { }; @@ -277718,7 +277718,7 @@ self: { text ]; description = "Compile git revision info into Haskell projects"; - license = lib.licensesSpdx."BSD-3-Clause"; + license = lib.meta.getLicenseFromSpdxId "BSD-3-Clause"; } ) { }; @@ -278025,7 +278025,7 @@ self: { sha256 = "14wm8wp4jxi4fq75bvr6sl4xmsxjfw30yq7011v28xqpm9015ns0"; libraryHaskellDepends = [ base ]; description = "Haskell bindings for the gl3w library"; - license = lib.licensesSpdx."MIT"; + license = lib.meta.getLicenseFromSpdxId "MIT"; } ) { }; @@ -278614,7 +278614,7 @@ self: { vector-algorithms, wai, warp, - xxHash, + xxhash, yaml, }: mkDerivation { @@ -278715,7 +278715,7 @@ self: { libfolly libunwind rocksdb - xxHash + xxhash ]; libraryToolDepends = [ alex @@ -278845,7 +278845,7 @@ self: { testPkgconfigDepends = [ gtest_main ]; doHaddock = false; description = "A system for collecting, deriving and working with facts about source code"; - license = lib.licensesSpdx."BSD-3-Clause"; + license = lib.meta.getLicenseFromSpdxId "BSD-3-Clause"; hydraPlatforms = lib.platforms.none; } ) @@ -278859,7 +278859,7 @@ self: { libfolly = null; inherit (pkgs) libunwind; inherit (pkgs) rocksdb; - inherit (pkgs) xxHash; + xxhash = null; }; glean-lsp = callPackage ( @@ -278911,7 +278911,7 @@ self: { unordered-containers ]; description = "Generic Glean-based LSP Server"; - license = lib.licensesSpdx."BSD-3-Clause"; + license = lib.meta.getLicenseFromSpdxId "BSD-3-Clause"; hydraPlatforms = lib.platforms.none; mainProgram = "glean-lsp"; } @@ -278945,7 +278945,7 @@ self: { text ]; description = "GLFW package with window groups destroyed together"; - license = lib.licensesSpdx."BSD-3-Clause"; + license = lib.meta.getLicenseFromSpdxId "BSD-3-Clause"; } ) { }; @@ -279033,7 +279033,7 @@ self: { ]; libraryPkgconfigDepends = [ glib ]; description = "Binding to the GLIB library for Gtk2Hs"; - license = lib.licensesSpdx."LGPL-2.1-only"; + license = lib.meta.getLicenseFromSpdxId "LGPL-2.1-only"; } ) { inherit (pkgs) glib; }; @@ -279262,7 +279262,7 @@ self: { HUnit ]; description = "Console IRC client"; - license = lib.licensesSpdx."ISC"; + license = lib.meta.getLicenseFromSpdxId "ISC"; mainProgram = "glirc"; } ) { }; @@ -279573,7 +279573,7 @@ self: { text ]; description = "Globus Data Transfer"; - license = lib.licensesSpdx."BSD-3-Clause"; + license = lib.meta.getLicenseFromSpdxId "BSD-3-Clause"; } ) { }; @@ -280001,7 +280001,7 @@ self: { ]; testHaskellDepends = [ base ]; description = "Massiv-based alternative for gloss-raster"; - license = lib.licensesSpdx."BSD-3-Clause"; + license = lib.meta.getLicenseFromSpdxId "BSD-3-Clause"; hydraPlatforms = lib.platforms.none; broken = true; } @@ -280035,7 +280035,7 @@ self: { ]; executableHaskellDepends = [ base ]; description = "Painless relative-sized pictures in Gloss"; - license = lib.licensesSpdx."BSD-3-Clause"; + license = lib.meta.getLicenseFromSpdxId "BSD-3-Clause"; } ) { }; @@ -280110,7 +280110,7 @@ self: { hspec ]; description = "Low-level Haskell bindings to the GLPK library"; - license = lib.licensesSpdx."BSD-3-Clause"; + license = lib.meta.getLicenseFromSpdxId "BSD-3-Clause"; } ) { inherit (pkgs) glpk; }; @@ -280391,7 +280391,7 @@ self: { tasty-hunit ]; description = "Attempts to fix your syntax erroring Lua files"; - license = lib.licensesSpdx."LGPL-2.1-or-later"; + license = lib.meta.getLicenseFromSpdxId "LGPL-2.1-or-later"; hydraPlatforms = lib.platforms.none; mainProgram = "glualint"; broken = true; @@ -281125,7 +281125,7 @@ self: { utility-ht ]; description = "2D and 3D plots using gnuplot"; - license = lib.licensesSpdx."BSD-3-Clause"; + license = lib.meta.getLicenseFromSpdxId "BSD-3-Clause"; maintainers = [ lib.maintainers.thielema ]; } ) { }; @@ -281244,7 +281244,7 @@ self: { mwc-random ]; description = "Common, non-geometric tools for use with Goal"; - license = lib.licensesSpdx."BSD-3-Clause"; + license = lib.meta.getLicenseFromSpdxId "BSD-3-Clause"; hydraPlatforms = lib.platforms.none; broken = true; } @@ -281273,7 +281273,7 @@ self: { indexed-list-literals ]; description = "The basic geometric type system of Goal"; - license = lib.licensesSpdx."BSD-3-Clause"; + license = lib.meta.getLicenseFromSpdxId "BSD-3-Clause"; hydraPlatforms = lib.platforms.none; } ) { }; @@ -281329,7 +281329,7 @@ self: { goal-probability ]; description = "Optimization of latent variable and dynamical models with Goal"; - license = lib.licensesSpdx."BSD-3-Clause"; + license = lib.meta.getLicenseFromSpdxId "BSD-3-Clause"; hydraPlatforms = lib.platforms.none; } ) { }; @@ -281380,7 +281380,7 @@ self: { goal-geometry ]; description = "Optimization on manifolds of probability distributions with Goal"; - license = lib.licensesSpdx."BSD-3-Clause"; + license = lib.meta.getLicenseFromSpdxId "BSD-3-Clause"; hydraPlatforms = lib.platforms.none; } ) { }; @@ -281695,7 +281695,7 @@ self: { text ]; description = "Megaparsec parser for Godot `tscn` and `gdextension` files"; - license = lib.licensesSpdx."BSD-3-Clause"; + license = lib.meta.getLicenseFromSpdxId "BSD-3-Clause"; hydraPlatforms = lib.platforms.none; mainProgram = "bench"; broken = true; @@ -281891,7 +281891,7 @@ self: { time ]; description = "Comprehensive Google Services SDK"; - license = lib.licensesSpdx."MPL-2.0"; + license = lib.meta.getLicenseFromSpdxId "MPL-2.0"; } ) { }; @@ -281903,7 +281903,7 @@ self: { sha256 = "0h6iwa2z863qgi1vixp28xgq8f2vk0dwlvs3ppbh1f4i9viqvr8b"; libraryHaskellDepends = [ gogol-core ]; description = "Google Abusive Experience Report SDK"; - license = lib.licensesSpdx."MPL-2.0"; + license = lib.meta.getLicenseFromSpdxId "MPL-2.0"; } ) { }; @@ -281915,7 +281915,7 @@ self: { sha256 = "1a1x97xgpmznjgqjrbgz63vfdlgdilzi6y7myxm8v6fin4pf1y2p"; libraryHaskellDepends = [ gogol-core ]; description = "Google Accelerated Mobile Pages (AMP) URL SDK"; - license = lib.licensesSpdx."MPL-2.0"; + license = lib.meta.getLicenseFromSpdxId "MPL-2.0"; } ) { }; @@ -281927,7 +281927,7 @@ self: { sha256 = "0cy8bwkrgwmz2lm1bqq1w3c895x5h6bfd27wlp6zihivj4kmky8j"; libraryHaskellDepends = [ gogol-core ]; description = "Google Access Approval SDK"; - license = lib.licensesSpdx."MPL-2.0"; + license = lib.meta.getLicenseFromSpdxId "MPL-2.0"; } ) { }; @@ -281939,7 +281939,7 @@ self: { sha256 = "1n0llmpcp8da4nzmz6350gnjaj0ir3wl1iqnx9y1wvq99jr1xb4s"; libraryHaskellDepends = [ gogol-core ]; description = "Google Access Context Manager SDK"; - license = lib.licensesSpdx."MPL-2.0"; + license = lib.meta.getLicenseFromSpdxId "MPL-2.0"; } ) { }; @@ -281951,7 +281951,7 @@ self: { sha256 = "1msm75jv2p73fxw9nffjyqyw8zyg0xpna1dhir08pzsmwwyysdx8"; libraryHaskellDepends = [ gogol-core ]; description = "Google Ad Exchange Buyer SDK"; - license = lib.licensesSpdx."MPL-2.0"; + license = lib.meta.getLicenseFromSpdxId "MPL-2.0"; } ) { }; @@ -281963,7 +281963,7 @@ self: { sha256 = "1k2is2alb7d5zdxpqbiv07kxbg86gzkc8zmlndva8p7zrrayanwd"; libraryHaskellDepends = [ gogol-core ]; description = "Google Ad Exchange Seller SDK"; - license = lib.licensesSpdx."MPL-2.0"; + license = lib.meta.getLicenseFromSpdxId "MPL-2.0"; } ) { }; @@ -281975,7 +281975,7 @@ self: { sha256 = "0k8fdnyyd20qis54nnarj7dk17ncfsn1br83mhjsgkp5x956zlzr"; libraryHaskellDepends = [ gogol-core ]; description = "Google Ad Exchange Buyer API II SDK"; - license = lib.licensesSpdx."MPL-2.0"; + license = lib.meta.getLicenseFromSpdxId "MPL-2.0"; } ) { }; @@ -281987,7 +281987,7 @@ self: { sha256 = "0hj5ic3mhigk524d760g9s2xlqfx5aj6rxqwyzfs9hrnvl88m79c"; libraryHaskellDepends = [ gogol-core ]; description = "Google Ad Experience Report SDK"; - license = lib.licensesSpdx."MPL-2.0"; + license = lib.meta.getLicenseFromSpdxId "MPL-2.0"; } ) { }; @@ -281999,7 +281999,7 @@ self: { sha256 = "068ib1s04y39q0llrnn64ha1l1q61jspfgkb3chcb056yiam3z7k"; libraryHaskellDepends = [ gogol-core ]; description = "Google Admin SDK"; - license = lib.licensesSpdx."MPL-2.0"; + license = lib.meta.getLicenseFromSpdxId "MPL-2.0"; } ) { }; @@ -282011,7 +282011,7 @@ self: { sha256 = "1aw1369bb5lqzc8z0aqpghjk4pzqk3747ciiwzjibxp5fw6gp8fb"; libraryHaskellDepends = [ gogol-core ]; description = "Google Admin SDK"; - license = lib.licensesSpdx."MPL-2.0"; + license = lib.meta.getLicenseFromSpdxId "MPL-2.0"; } ) { }; @@ -282044,7 +282044,7 @@ self: { sha256 = "189fx1ih296s26rn7m92rmay6csps1ihnyrm8wif1530xf6i7i9j"; libraryHaskellDepends = [ gogol-core ]; description = "Google Admin SDK"; - license = lib.licensesSpdx."MPL-2.0"; + license = lib.meta.getLicenseFromSpdxId "MPL-2.0"; } ) { }; @@ -282056,7 +282056,7 @@ self: { sha256 = "02qh6rqmbllfj27zi4ddgfy88ck7gayzr9ziw6r2brajwdd7rmcx"; libraryHaskellDepends = [ gogol-core ]; description = "Google AdSense Management SDK"; - license = lib.licensesSpdx."MPL-2.0"; + license = lib.meta.getLicenseFromSpdxId "MPL-2.0"; } ) { }; @@ -282068,7 +282068,7 @@ self: { sha256 = "1h0iv25rpv495qgn021dlxi0cy9v1yxhr6q1l42nb5sp3nfx8j4l"; libraryHaskellDepends = [ gogol-core ]; description = "Google AdSense Host SDK"; - license = lib.licensesSpdx."MPL-2.0"; + license = lib.meta.getLicenseFromSpdxId "MPL-2.0"; } ) { }; @@ -282101,7 +282101,7 @@ self: { sha256 = "0grqgrczqwa3f8ir7yx8rlw1y0alrqz8m4dhbx6268dz5y192421"; libraryHaskellDepends = [ gogol-core ]; description = "Google Workspace Alert Center SDK"; - license = lib.licensesSpdx."MPL-2.0"; + license = lib.meta.getLicenseFromSpdxId "MPL-2.0"; } ) { }; @@ -282113,7 +282113,7 @@ self: { sha256 = "1pqr20s11z75m8lzqq4kx86h8gf9hqmv0n45kbb1v99nmiyl6scq"; libraryHaskellDepends = [ gogol-core ]; description = "Google Analytics SDK"; - license = lib.licensesSpdx."MPL-2.0"; + license = lib.meta.getLicenseFromSpdxId "MPL-2.0"; } ) { }; @@ -282125,7 +282125,7 @@ self: { sha256 = "1ps7lln0z027g0lmg0b8bs14ycz3i607a6ja5kxh9xpqi2bcj1pq"; libraryHaskellDepends = [ gogol-core ]; description = "Google Analytics Reporting SDK"; - license = lib.licensesSpdx."MPL-2.0"; + license = lib.meta.getLicenseFromSpdxId "MPL-2.0"; } ) { }; @@ -282137,7 +282137,7 @@ self: { sha256 = "0l40nv4jfba6h7vpfca548k7y5yya54n237f11gksclyij5xzc5j"; libraryHaskellDepends = [ gogol-core ]; description = "Google Play EMM SDK"; - license = lib.licensesSpdx."MPL-2.0"; + license = lib.meta.getLicenseFromSpdxId "MPL-2.0"; } ) { }; @@ -282149,7 +282149,7 @@ self: { sha256 = "14knrvx11f97jb7z7vbmjmh8zrchds5wzacaaiz68g5pqh44sqqg"; libraryHaskellDepends = [ gogol-core ]; description = "Google Play Android Developer SDK"; - license = lib.licensesSpdx."MPL-2.0"; + license = lib.meta.getLicenseFromSpdxId "MPL-2.0"; } ) { }; @@ -282161,7 +282161,7 @@ self: { sha256 = "0vf3y14bjzs1yb6fsaizsgcjvpk8r3gxavbkkf9cdy3zz6mdfs6y"; libraryHaskellDepends = [ gogol-core ]; description = "Google Android Device Provisioning Partner SDK"; - license = lib.licensesSpdx."MPL-2.0"; + license = lib.meta.getLicenseFromSpdxId "MPL-2.0"; } ) { }; @@ -282173,7 +282173,7 @@ self: { sha256 = "0hcfjz9lz9j4sk5vxsq0a67gbrgi9cmrwblkyslzlc3jqd689grh"; libraryHaskellDepends = [ gogol-core ]; description = "Google Android Management SDK"; - license = lib.licensesSpdx."MPL-2.0"; + license = lib.meta.getLicenseFromSpdxId "MPL-2.0"; } ) { }; @@ -282185,7 +282185,7 @@ self: { sha256 = "1d6nsqd6lynk2cvrb53zd1h74w46f8grjrgawrdczkhn9sjplgg4"; libraryHaskellDepends = [ gogol-core ]; description = "Google App Engine Admin SDK"; - license = lib.licensesSpdx."MPL-2.0"; + license = lib.meta.getLicenseFromSpdxId "MPL-2.0"; } ) { }; @@ -282197,7 +282197,7 @@ self: { sha256 = "0ai1ip5hkqbk0shwhgkjrc81422f0as78spahvyp2b18h9ds3f12"; libraryHaskellDepends = [ gogol-core ]; description = "Google Drive Activity SDK"; - license = lib.licensesSpdx."MPL-2.0"; + license = lib.meta.getLicenseFromSpdxId "MPL-2.0"; } ) { }; @@ -282209,7 +282209,7 @@ self: { sha256 = "119gfvs7wfchf4l50r13pwwqilxfkxbpdsr1hxa0qshx7qs4hdn3"; libraryHaskellDepends = [ gogol-core ]; description = "Google Calendar SDK"; - license = lib.licensesSpdx."MPL-2.0"; + license = lib.meta.getLicenseFromSpdxId "MPL-2.0"; } ) { }; @@ -282221,7 +282221,7 @@ self: { sha256 = "13xr8d87xyv1nif1vm8hx92aqp7w2h68qqpci01jrlgvbwikwg0z"; libraryHaskellDepends = [ gogol-core ]; description = "Google Enterprise License Manager SDK"; - license = lib.licensesSpdx."MPL-2.0"; + license = lib.meta.getLicenseFromSpdxId "MPL-2.0"; } ) { }; @@ -282233,7 +282233,7 @@ self: { sha256 = "02as3zv92pmki03ylcjc999cfk4qwgp066ns5wmvhg71x66wcy97"; libraryHaskellDepends = [ gogol-core ]; description = "Google Workspace Reseller SDK"; - license = lib.licensesSpdx."MPL-2.0"; + license = lib.meta.getLicenseFromSpdxId "MPL-2.0"; } ) { }; @@ -282245,7 +282245,7 @@ self: { sha256 = "1imkjjq2l8j36anzn4rv51mcdr3j1w9wxk2z4ps8py9whz2yfqa3"; libraryHaskellDepends = [ gogol-core ]; description = "Google Tasks SDK"; - license = lib.licensesSpdx."MPL-2.0"; + license = lib.meta.getLicenseFromSpdxId "MPL-2.0"; } ) { }; @@ -282257,7 +282257,7 @@ self: { sha256 = "1ipa3a1d6in8kvk6qrbmpsfns30nci95dlsb2x3ds8jx9rwffsad"; libraryHaskellDepends = [ gogol-core ]; description = "Google App State SDK"; - license = lib.licensesSpdx."MPL-2.0"; + license = lib.meta.getLicenseFromSpdxId "MPL-2.0"; } ) { }; @@ -282290,7 +282290,7 @@ self: { sha256 = "0r19gn2i4bvbacvsaw371nwiif41zi3bqvkv1b92nfyzig9nnnpr"; libraryHaskellDepends = [ gogol-core ]; description = "Google BigQuery SDK"; - license = lib.licensesSpdx."MPL-2.0"; + license = lib.meta.getLicenseFromSpdxId "MPL-2.0"; } ) { }; @@ -282302,7 +282302,7 @@ self: { sha256 = "0vv8jhqk2z1ji8l2k83021ycsbqqf4mkzq13k6yra5k62f886hb0"; libraryHaskellDepends = [ gogol-core ]; description = "Google BigQuery Data Transfer SDK"; - license = lib.licensesSpdx."MPL-2.0"; + license = lib.meta.getLicenseFromSpdxId "MPL-2.0"; } ) { }; @@ -282314,7 +282314,7 @@ self: { sha256 = "1q30h5qgrxwi3vpk28iklmy220lhvpk1bc1cdl2wvj9g87vk3jyg"; libraryHaskellDepends = [ gogol-core ]; description = "Google Cloud Bigtable Admin SDK"; - license = lib.licensesSpdx."MPL-2.0"; + license = lib.meta.getLicenseFromSpdxId "MPL-2.0"; } ) { }; @@ -282326,7 +282326,7 @@ self: { sha256 = "0ws694ymsrlk4hw1jzqi4lpjjmjas8cdvxxz9dcmkbd3yhpsq16z"; libraryHaskellDepends = [ gogol-core ]; description = "Google Cloud Billing SDK"; - license = lib.licensesSpdx."MPL-2.0"; + license = lib.meta.getLicenseFromSpdxId "MPL-2.0"; } ) { }; @@ -282338,7 +282338,7 @@ self: { sha256 = "0m82qlih6dxijd83bsjfbw4dxrn1k1w8gnfdxdxxvccf58xxkb48"; libraryHaskellDepends = [ gogol-core ]; description = "Google Binary Authorization SDK"; - license = lib.licensesSpdx."MPL-2.0"; + license = lib.meta.getLicenseFromSpdxId "MPL-2.0"; } ) { }; @@ -282350,7 +282350,7 @@ self: { sha256 = "02qrqqkhy7v14jygqnwv99bkfmnjpkjbxx33avk3fzx5vfh04phh"; libraryHaskellDepends = [ gogol-core ]; description = "Google Blogger SDK"; - license = lib.licensesSpdx."MPL-2.0"; + license = lib.meta.getLicenseFromSpdxId "MPL-2.0"; } ) { }; @@ -282362,7 +282362,7 @@ self: { sha256 = "0b8r416cg9cy36adv4frndcc64vy1wcqmhpshbs4ba583yqxndw6"; libraryHaskellDepends = [ gogol-core ]; description = "Google Books SDK"; - license = lib.licensesSpdx."MPL-2.0"; + license = lib.meta.getLicenseFromSpdxId "MPL-2.0"; } ) { }; @@ -282374,7 +282374,7 @@ self: { sha256 = "1m5ikfi8gl8xsi1kgv3ca7pfjd56gykw29s4x5mkm76a727sy454"; libraryHaskellDepends = [ gogol-core ]; description = "Google Chat SDK"; - license = lib.licensesSpdx."MPL-2.0"; + license = lib.meta.getLicenseFromSpdxId "MPL-2.0"; } ) { }; @@ -282386,7 +282386,7 @@ self: { sha256 = "1cg0xvxs8hkdzrsal7wn0gchscssvnwpfx2kzqqv3k539vjxb07w"; libraryHaskellDepends = [ gogol-core ]; description = "Google Civic Information SDK"; - license = lib.licensesSpdx."MPL-2.0"; + license = lib.meta.getLicenseFromSpdxId "MPL-2.0"; } ) { }; @@ -282398,7 +282398,7 @@ self: { sha256 = "0d32fmi65cmhallbiwifwzbwald508025crshh951g2l4sypdbsx"; libraryHaskellDepends = [ gogol-core ]; description = "Google Classroom SDK"; - license = lib.licensesSpdx."MPL-2.0"; + license = lib.meta.getLicenseFromSpdxId "MPL-2.0"; } ) { }; @@ -282410,7 +282410,7 @@ self: { sha256 = "1r2ijkzlqi2a34qq6978n8f3iqn2f14srw8cyglhy7if6f23ybp0"; libraryHaskellDepends = [ gogol-core ]; description = "Google Cloud Asset SDK"; - license = lib.licensesSpdx."MPL-2.0"; + license = lib.meta.getLicenseFromSpdxId "MPL-2.0"; } ) { }; @@ -282422,7 +282422,7 @@ self: { sha256 = "16scs0jzk0fbvhchf68f69b3pmipffdvi38ihfdn7495dipikpjp"; libraryHaskellDepends = [ gogol-core ]; description = "Google Error Reporting SDK"; - license = lib.licensesSpdx."MPL-2.0"; + license = lib.meta.getLicenseFromSpdxId "MPL-2.0"; } ) { }; @@ -282434,7 +282434,7 @@ self: { sha256 = "1w5cpsafgks7zhx08bri3sx9m30ad39wxraa296czhvzhlrz95qq"; libraryHaskellDepends = [ gogol-core ]; description = "Google Cloud Functions SDK"; - license = lib.licensesSpdx."MPL-2.0"; + license = lib.meta.getLicenseFromSpdxId "MPL-2.0"; } ) { }; @@ -282446,7 +282446,7 @@ self: { sha256 = "0ygdq4fvgbbjw1jzrvr7r02qjjvr21fjsyvjs5r781bsps9msr66"; libraryHaskellDepends = [ gogol-core ]; description = "Google Cloud Identity SDK"; - license = lib.licensesSpdx."MPL-2.0"; + license = lib.meta.getLicenseFromSpdxId "MPL-2.0"; } ) { }; @@ -282458,7 +282458,7 @@ self: { sha256 = "1dvgygzzyk038p6f5qwgiipiz1466zmm760yi1ci9sh7fl4i4ndp"; libraryHaskellDepends = [ gogol-core ]; description = "Google Cloud IoT SDK"; - license = lib.licensesSpdx."MPL-2.0"; + license = lib.meta.getLicenseFromSpdxId "MPL-2.0"; } ) { }; @@ -282470,7 +282470,7 @@ self: { sha256 = "0wvk6ll7xmlly1bi1kwpj3vp4scg06cjsb1xnpd2rd6j2fhi2vmz"; libraryHaskellDepends = [ gogol-core ]; description = "Google Cloud Key Management Service (KMS) SDK"; - license = lib.licensesSpdx."MPL-2.0"; + license = lib.meta.getLicenseFromSpdxId "MPL-2.0"; } ) { }; @@ -282503,7 +282503,7 @@ self: { sha256 = "18siw287hdcfmcdp0sxd1r94pk4rri71987mi5mjgxgan90lhgxk"; libraryHaskellDepends = [ gogol-core ]; description = "Google Cloud Private Catalog SDK"; - license = lib.licensesSpdx."MPL-2.0"; + license = lib.meta.getLicenseFromSpdxId "MPL-2.0"; } ) { }; @@ -282515,7 +282515,7 @@ self: { sha256 = "12sf1rmiv52gfml3xcv76iza8mry9vhcpk4xzdb80yaw8343idj3"; libraryHaskellDepends = [ gogol-core ]; description = "Google Cloud Private Catalog Producer SDK"; - license = lib.licensesSpdx."MPL-2.0"; + license = lib.meta.getLicenseFromSpdxId "MPL-2.0"; } ) { }; @@ -282527,7 +282527,7 @@ self: { sha256 = "0hwby0sk3rxsii76425hgy9d7p4v5l0infsqj0qbs0197qhwh4zi"; libraryHaskellDepends = [ gogol-core ]; description = "Google Cloud Profiler SDK"; - license = lib.licensesSpdx."MPL-2.0"; + license = lib.meta.getLicenseFromSpdxId "MPL-2.0"; } ) { }; @@ -282539,7 +282539,7 @@ self: { sha256 = "14gbhgyy8g7kaarxpy8llpvgydapq49sr8gzda144gkfq68svabw"; libraryHaskellDepends = [ gogol-core ]; description = "Google Cloud Scheduler SDK"; - license = lib.licensesSpdx."MPL-2.0"; + license = lib.meta.getLicenseFromSpdxId "MPL-2.0"; } ) { }; @@ -282551,7 +282551,7 @@ self: { sha256 = "1nhqkvm5v2m4xbcdi29m8padjzmampcsy3l61vknwfc0n6f89rhf"; libraryHaskellDepends = [ gogol-core ]; description = "Google Cloud Search SDK"; - license = lib.licensesSpdx."MPL-2.0"; + license = lib.meta.getLicenseFromSpdxId "MPL-2.0"; } ) { }; @@ -282563,7 +282563,7 @@ self: { sha256 = "1zi69k64klas18kmq525z52nchc9gqdk7v15x8prdln6x46ic1dn"; libraryHaskellDepends = [ gogol-core ]; description = "Google Cloud Shell SDK"; - license = lib.licensesSpdx."MPL-2.0"; + license = lib.meta.getLicenseFromSpdxId "MPL-2.0"; } ) { }; @@ -282575,7 +282575,7 @@ self: { sha256 = "11ygaka332an20cyl5i9bj5jxkgddc36pfdl07mjab68b6500ggc"; libraryHaskellDepends = [ gogol-core ]; description = "Google Cloud Tasks SDK"; - license = lib.licensesSpdx."MPL-2.0"; + license = lib.meta.getLicenseFromSpdxId "MPL-2.0"; } ) { }; @@ -282587,7 +282587,7 @@ self: { sha256 = "0wnn3pfx28g7iqr8vwk2v5vqh06vwcmgjj0blwi9aznkm1g3qp1k"; libraryHaskellDepends = [ gogol-core ]; description = "Google Cloud Trace SDK"; - license = lib.licensesSpdx."MPL-2.0"; + license = lib.meta.getLicenseFromSpdxId "MPL-2.0"; } ) { }; @@ -282599,7 +282599,7 @@ self: { sha256 = "1vcwyv86a3mpis6d1rgldn61qzxfz8x2ncfv3r7rrpr79zclqhkj"; libraryHaskellDepends = [ gogol-core ]; description = "Google Perspective Comment Analyzer SDK"; - license = lib.licensesSpdx."MPL-2.0"; + license = lib.meta.getLicenseFromSpdxId "MPL-2.0"; } ) { }; @@ -282611,7 +282611,7 @@ self: { sha256 = "0j4kabhl6wlyhqjiiz6qw6hc8q9c8c0x0ylqxfiwxgr8j0m3x17h"; libraryHaskellDepends = [ gogol-core ]; description = "Google Cloud Composer SDK"; - license = lib.licensesSpdx."MPL-2.0"; + license = lib.meta.getLicenseFromSpdxId "MPL-2.0"; } ) { }; @@ -282623,7 +282623,7 @@ self: { sha256 = "094p7nms03jypq44snnsz05z485dz5ynawcnmjjlmwh387i59j4x"; libraryHaskellDepends = [ gogol-core ]; description = "Google Compute Engine SDK"; - license = lib.licensesSpdx."MPL-2.0"; + license = lib.meta.getLicenseFromSpdxId "MPL-2.0"; } ) { }; @@ -282635,7 +282635,7 @@ self: { sha256 = "01q4dmqxwdy8p9ix9dhj0dgqs71z7mmjznybv2r8jmfwxm4nxgka"; libraryHaskellDepends = [ gogol-core ]; description = "Google Consumer Surveys SDK"; - license = lib.licensesSpdx."MPL-2.0"; + license = lib.meta.getLicenseFromSpdxId "MPL-2.0"; } ) { }; @@ -282647,7 +282647,7 @@ self: { sha256 = "0ci3xdl0rb5nq54z6i748gh240ipgp9wa36pncq3yasf58pn9rvp"; libraryHaskellDepends = [ gogol-core ]; description = "Google Kubernetes Engine SDK"; - license = lib.licensesSpdx."MPL-2.0"; + license = lib.meta.getLicenseFromSpdxId "MPL-2.0"; } ) { }; @@ -282659,7 +282659,7 @@ self: { sha256 = "1vzmzbgr88qij6fgi2gsz3iavvbzdxnpjf864l656fkvr5xw83wl"; libraryHaskellDepends = [ gogol-core ]; description = "Google Container Analysis SDK"; - license = lib.licensesSpdx."MPL-2.0"; + license = lib.meta.getLicenseFromSpdxId "MPL-2.0"; } ) { }; @@ -282671,7 +282671,7 @@ self: { sha256 = "12mmiza1sd4fryy86kzy88adw8nkswxpf1r2sryndjkyk9a47knx"; libraryHaskellDepends = [ gogol-core ]; description = "Google Cloud Build SDK"; - license = lib.licensesSpdx."MPL-2.0"; + license = lib.meta.getLicenseFromSpdxId "MPL-2.0"; } ) { }; @@ -282733,7 +282733,7 @@ self: { tasty ]; description = "Core data types and functionality for Gogol libraries"; - license = lib.licensesSpdx."MPL-2.0"; + license = lib.meta.getLicenseFromSpdxId "MPL-2.0"; } ) { }; @@ -282745,7 +282745,7 @@ self: { sha256 = "04yvwb12qpf57p82a7j5h7z0ckxmfircxzyl1a9h8qwmkf2h9g9n"; libraryHaskellDepends = [ gogol-core ]; description = "Google Custom Search SDK"; - license = lib.licensesSpdx."MPL-2.0"; + license = lib.meta.getLicenseFromSpdxId "MPL-2.0"; } ) { }; @@ -282757,7 +282757,7 @@ self: { sha256 = "0qi91p8x8jx3rnz4vpk7mkcms1hqjhwlmrvpjzxx489bazllsz66"; libraryHaskellDepends = [ gogol-core ]; description = "Google Dataflow SDK"; - license = lib.licensesSpdx."MPL-2.0"; + license = lib.meta.getLicenseFromSpdxId "MPL-2.0"; } ) { }; @@ -282769,7 +282769,7 @@ self: { sha256 = "0r28ccchciw067w1gsm9pcfhnmr6ggk0m5p27i3rhwz1v3mhspnf"; libraryHaskellDepends = [ gogol-core ]; description = "Google Cloud Data Fusion SDK"; - license = lib.licensesSpdx."MPL-2.0"; + license = lib.meta.getLicenseFromSpdxId "MPL-2.0"; } ) { }; @@ -282781,7 +282781,7 @@ self: { sha256 = "1gls8g771b7d90a57zz30cwpg0sr9vjmjwkb2sn1syr3q82vz8ba"; libraryHaskellDepends = [ gogol-core ]; description = "Google Cloud Dataproc SDK"; - license = lib.licensesSpdx."MPL-2.0"; + license = lib.meta.getLicenseFromSpdxId "MPL-2.0"; } ) { }; @@ -282793,7 +282793,7 @@ self: { sha256 = "0d727wn1yr4w5svvzsfyvn8ybl6l0ijr1mq86zwpz041709llbfg"; libraryHaskellDepends = [ gogol-core ]; description = "Google Cloud Datastore SDK"; - license = lib.licensesSpdx."MPL-2.0"; + license = lib.meta.getLicenseFromSpdxId "MPL-2.0"; } ) { }; @@ -282805,7 +282805,7 @@ self: { sha256 = "0m71pa6ilqy5s20vmn8q4gn1vikr2fjxvhz8h54qswn5sanjpiz8"; libraryHaskellDepends = [ gogol-core ]; description = "Google Cloud Debugger API (Deprecated) SDK"; - license = lib.licensesSpdx."MPL-2.0"; + license = lib.meta.getLicenseFromSpdxId "MPL-2.0"; } ) { }; @@ -282817,7 +282817,7 @@ self: { sha256 = "143k175i32i4nw54r1w7490wqj9g703a5787aw86r468xfagwmdy"; libraryHaskellDepends = [ gogol-core ]; description = "Google Cloud Deployment Manager V2 SDK"; - license = lib.licensesSpdx."MPL-2.0"; + license = lib.meta.getLicenseFromSpdxId "MPL-2.0"; } ) { }; @@ -282829,7 +282829,7 @@ self: { sha256 = "1vhc4fx78h26hcxhmgijfprsvshqgh8v6q9dialckh7rq226g0mn"; libraryHaskellDepends = [ gogol-core ]; description = "Google Campaign Manager 360 SDK"; - license = lib.licensesSpdx."MPL-2.0"; + license = lib.meta.getLicenseFromSpdxId "MPL-2.0"; } ) { }; @@ -282841,7 +282841,7 @@ self: { sha256 = "1gijb69hmba7dh493zifv5809zri33fmi7fi8wmf3973qaylp7g6"; libraryHaskellDepends = [ gogol-core ]; description = "Google Dialogflow SDK"; - license = lib.licensesSpdx."MPL-2.0"; + license = lib.meta.getLicenseFromSpdxId "MPL-2.0"; } ) { }; @@ -282853,7 +282853,7 @@ self: { sha256 = "1a6r481sxp50x5mpw8inp4904jm0a21m1rcya2wijwrj8xblynpp"; libraryHaskellDepends = [ gogol-core ]; description = "Google Digital Asset Links SDK"; - license = lib.licensesSpdx."MPL-2.0"; + license = lib.meta.getLicenseFromSpdxId "MPL-2.0"; } ) { }; @@ -282865,7 +282865,7 @@ self: { sha256 = "1gyh5fbiv98j74p3bkg0kv1clszdpy8ksb47k4bnpjg8livfgzf4"; libraryHaskellDepends = [ gogol-core ]; description = "Google API Discovery Service SDK"; - license = lib.licensesSpdx."MPL-2.0"; + license = lib.meta.getLicenseFromSpdxId "MPL-2.0"; } ) { }; @@ -282877,7 +282877,7 @@ self: { sha256 = "15q8fr1y21zacz30kjvpxsn2irnzqjl5r2xvhkd2mbcpplyvcbcz"; libraryHaskellDepends = [ gogol-core ]; description = "Google Sensitive Data Protection (DLP) SDK"; - license = lib.licensesSpdx."MPL-2.0"; + license = lib.meta.getLicenseFromSpdxId "MPL-2.0"; } ) { }; @@ -282889,7 +282889,7 @@ self: { sha256 = "1igqrn1w1jda0xplbslwib2mdv9mzhfb4dpqgymlmp5g1ps9qy28"; libraryHaskellDepends = [ gogol-core ]; description = "Google Cloud DNS SDK"; - license = lib.licensesSpdx."MPL-2.0"; + license = lib.meta.getLicenseFromSpdxId "MPL-2.0"; } ) { }; @@ -282901,7 +282901,7 @@ self: { sha256 = "1chxs5a1wlql6vb9wqr9navijis7khbpndy0grwzfcdafcyz71jm"; libraryHaskellDepends = [ gogol-core ]; description = "Google Docs SDK"; - license = lib.licensesSpdx."MPL-2.0"; + license = lib.meta.getLicenseFromSpdxId "MPL-2.0"; } ) { }; @@ -282913,7 +282913,7 @@ self: { sha256 = "01955ainvq9fmmjvkwpgbarmnplw30ilf05shsnjskdhp6b1hqvc"; libraryHaskellDepends = [ gogol-core ]; description = "Google DoubleClick Bid Manager SDK"; - license = lib.licensesSpdx."MPL-2.0"; + license = lib.meta.getLicenseFromSpdxId "MPL-2.0"; } ) { }; @@ -282925,7 +282925,7 @@ self: { sha256 = "1l70nmx86wvixyr84zjhns69l58z1v65aiycmqi3i441c5hjrax2"; libraryHaskellDepends = [ gogol-core ]; description = "Google Search Ads 360 SDK"; - license = lib.licensesSpdx."MPL-2.0"; + license = lib.meta.getLicenseFromSpdxId "MPL-2.0"; } ) { }; @@ -282937,7 +282937,7 @@ self: { sha256 = "0alf3jahdmkjxjzqj2bs5wlrvx7d3414kbhpi1pvdcy8s3fm2b49"; libraryHaskellDepends = [ gogol-core ]; description = "Google Drive SDK"; - license = lib.licensesSpdx."MPL-2.0"; + license = lib.meta.getLicenseFromSpdxId "MPL-2.0"; } ) { }; @@ -282949,7 +282949,7 @@ self: { sha256 = "06lnmdz833wvkh9h2q8q73mnqyp2klmfhg132zabwpcpkywlinvl"; libraryHaskellDepends = [ gogol-core ]; description = "Google Drive Activity SDK"; - license = lib.licensesSpdx."MPL-2.0"; + license = lib.meta.getLicenseFromSpdxId "MPL-2.0"; } ) { }; @@ -282961,7 +282961,7 @@ self: { sha256 = "1v2s3696i71z4pqclqc2x53c51n4llv6wbpvms1mr666zgmchvxr"; libraryHaskellDepends = [ gogol-core ]; description = "Google Fact Check Tools SDK"; - license = lib.licensesSpdx."MPL-2.0"; + license = lib.meta.getLicenseFromSpdxId "MPL-2.0"; } ) { }; @@ -282973,7 +282973,7 @@ self: { sha256 = "0fd23xaqcqn6qq696i1dlrbdlk7yw15h8wq9jsy0l8sqa8f9ygn2"; libraryHaskellDepends = [ gogol-core ]; description = "Google Cloud Filestore SDK"; - license = lib.licensesSpdx."MPL-2.0"; + license = lib.meta.getLicenseFromSpdxId "MPL-2.0"; } ) { }; @@ -282985,7 +282985,7 @@ self: { sha256 = "18ywm1xzr0sqj4pp6lsjw8pbhydimapnxa5xylybc1ii69jqq3xj"; libraryHaskellDepends = [ gogol-core ]; description = "Google Firebase Dynamic Links SDK"; - license = lib.licensesSpdx."MPL-2.0"; + license = lib.meta.getLicenseFromSpdxId "MPL-2.0"; } ) { }; @@ -282997,7 +282997,7 @@ self: { sha256 = "1znwn8xl2yfxarbf6gcmwlhrm7mn4xan89bd2sh1sd520155yw4q"; libraryHaskellDepends = [ gogol-core ]; description = "Google Firebase Rules SDK"; - license = lib.licensesSpdx."MPL-2.0"; + license = lib.meta.getLicenseFromSpdxId "MPL-2.0"; } ) { }; @@ -283009,7 +283009,7 @@ self: { sha256 = "0v0jbgffkxgk17qn79qjbcp3rnnfihcikb9709kwkz5vf246rzs7"; libraryHaskellDepends = [ gogol-core ]; description = "Google Firebase Hosting SDK"; - license = lib.licensesSpdx."MPL-2.0"; + license = lib.meta.getLicenseFromSpdxId "MPL-2.0"; } ) { }; @@ -283021,7 +283021,7 @@ self: { sha256 = "09n8bfaa9spara3yh5awjcfyxdwcag5qi7w01vk9m9snfzdypfrg"; libraryHaskellDepends = [ gogol-core ]; description = "Google Firebase Remote Config SDK"; - license = lib.licensesSpdx."MPL-2.0"; + license = lib.meta.getLicenseFromSpdxId "MPL-2.0"; } ) { }; @@ -283033,7 +283033,7 @@ self: { sha256 = "0fillhmd5xdb45mfg62fr6vhki4gdc8mqvqzs56il3p70ykbrgby"; libraryHaskellDepends = [ gogol-core ]; description = "Google Cloud Firestore SDK"; - license = lib.licensesSpdx."MPL-2.0"; + license = lib.meta.getLicenseFromSpdxId "MPL-2.0"; } ) { }; @@ -283045,7 +283045,7 @@ self: { sha256 = "19a63kbgf8r268ybj1dyd7z4bzaw2dd6ygp3pk4swabjjj1pfrvx"; libraryHaskellDepends = [ gogol-core ]; description = "Google Fitness SDK"; - license = lib.licensesSpdx."MPL-2.0"; + license = lib.meta.getLicenseFromSpdxId "MPL-2.0"; } ) { }; @@ -283057,7 +283057,7 @@ self: { sha256 = "15dsq67qnpnmninklr9pm5yy1xn8a459pvgmhaabbp2x31ghqjiv"; libraryHaskellDepends = [ gogol-core ]; description = "Google Web Fonts Developer SDK"; - license = lib.licensesSpdx."MPL-2.0"; + license = lib.meta.getLicenseFromSpdxId "MPL-2.0"; } ) { }; @@ -283090,7 +283090,7 @@ self: { sha256 = "18scbflas6w5avgsm5ndnj1qyn277mlj3v2fl71mrfjwr6171l5c"; libraryHaskellDepends = [ gogol-core ]; description = "Google Fusion Tables SDK"; - license = lib.licensesSpdx."MPL-2.0"; + license = lib.meta.getLicenseFromSpdxId "MPL-2.0"; } ) { }; @@ -283102,7 +283102,7 @@ self: { sha256 = "0l73pqrsfnwxv3mbg6lxkzmbal1xb5gxcb3rnv16d60ng50xrpc3"; libraryHaskellDepends = [ gogol-core ]; description = "Google Play Game Services SDK"; - license = lib.licensesSpdx."MPL-2.0"; + license = lib.meta.getLicenseFromSpdxId "MPL-2.0"; } ) { }; @@ -283114,7 +283114,7 @@ self: { sha256 = "1qfag0mqyp5fk7p225qlc2551hdyzpmflnx0i59b24vm2yym1y4a"; libraryHaskellDepends = [ gogol-core ]; description = "Google Play Game Services Publishing SDK"; - license = lib.licensesSpdx."MPL-2.0"; + license = lib.meta.getLicenseFromSpdxId "MPL-2.0"; } ) { }; @@ -283126,7 +283126,7 @@ self: { sha256 = "0zy5bqi8lsb6r19bb5sd8fjcqx9v4g0lphxj60p20p94k5vw7wcd"; libraryHaskellDepends = [ gogol-core ]; description = "Google Play Game Management SDK"; - license = lib.licensesSpdx."MPL-2.0"; + license = lib.meta.getLicenseFromSpdxId "MPL-2.0"; } ) { }; @@ -283138,7 +283138,7 @@ self: { sha256 = "0ddyddxan844csb6mflrsq42ivvwrwcm6lhqy7wydysbf1wcfgmm"; libraryHaskellDepends = [ gogol-core ]; description = "Google Genomics SDK"; - license = lib.licensesSpdx."MPL-2.0"; + license = lib.meta.getLicenseFromSpdxId "MPL-2.0"; } ) { }; @@ -283150,7 +283150,7 @@ self: { sha256 = "045hqcyypvi8c2d9lh6szp1crz1xk9ll2ll93w5viyvzz2fzlpza"; libraryHaskellDepends = [ gogol-core ]; description = "Google Gmail SDK"; - license = lib.licensesSpdx."MPL-2.0"; + license = lib.meta.getLicenseFromSpdxId "MPL-2.0"; } ) { }; @@ -283162,7 +283162,7 @@ self: { sha256 = "0gskbydkk39zs6aa8ss4y3ibnsdb69zmm7jbi6ijr56y7qv11fgm"; libraryHaskellDepends = [ gogol-core ]; description = "Google Groups Migration SDK"; - license = lib.licensesSpdx."MPL-2.0"; + license = lib.meta.getLicenseFromSpdxId "MPL-2.0"; } ) { }; @@ -283174,7 +283174,7 @@ self: { sha256 = "0n0j1m01y9k2q07mkrdm5n9pp3ahs9byhl0kpi8na30y4zhscxr8"; libraryHaskellDepends = [ gogol-core ]; description = "Google Groups Settings SDK"; - license = lib.licensesSpdx."MPL-2.0"; + license = lib.meta.getLicenseFromSpdxId "MPL-2.0"; } ) { }; @@ -283186,7 +283186,7 @@ self: { sha256 = "1dskfbpm1mv2dax64izj8sarkssajnbkinc4pwkvgfgjhf9l9sq9"; libraryHaskellDepends = [ gogol-core ]; description = "Google Cloud Healthcare SDK"; - license = lib.licensesSpdx."MPL-2.0"; + license = lib.meta.getLicenseFromSpdxId "MPL-2.0"; } ) { }; @@ -283198,7 +283198,7 @@ self: { sha256 = "0ylryxz1wa8v246mwzpvqkqmggj2gbd9mxmgf5cbnkibmnbcwswg"; libraryHaskellDepends = [ gogol-core ]; description = "Google Identity and Access Management (IAM) SDK"; - license = lib.licensesSpdx."MPL-2.0"; + license = lib.meta.getLicenseFromSpdxId "MPL-2.0"; } ) { }; @@ -283210,7 +283210,7 @@ self: { sha256 = "1jzqijf08jmmavgc5f7vpvs1ixiw6h9k4x8y7q8kwiayp57gcgfh"; libraryHaskellDepends = [ gogol-core ]; description = "Google IAM Service Account Credentials SDK"; - license = lib.licensesSpdx."MPL-2.0"; + license = lib.meta.getLicenseFromSpdxId "MPL-2.0"; } ) { }; @@ -283222,7 +283222,7 @@ self: { sha256 = "0v7xm5qr5im2hcvq34s7c880f6yxnzwc4cax1cwm4f3zjq7galmb"; libraryHaskellDepends = [ gogol-core ]; description = "Google Cloud Identity-Aware Proxy SDK"; - license = lib.licensesSpdx."MPL-2.0"; + license = lib.meta.getLicenseFromSpdxId "MPL-2.0"; } ) { }; @@ -283234,7 +283234,7 @@ self: { sha256 = "1wdm8w4z4iicbla6139501v7ri9k9w6f0b131li0578dxqw411m0"; libraryHaskellDepends = [ gogol-core ]; description = "Google Identity Toolkit SDK"; - license = lib.licensesSpdx."MPL-2.0"; + license = lib.meta.getLicenseFromSpdxId "MPL-2.0"; } ) { }; @@ -283246,7 +283246,7 @@ self: { sha256 = "1hxk0gzk183vjljj57qkgyi5y4j1rigvjxkivxzvzlqyvpbirdrs"; libraryHaskellDepends = [ gogol-core ]; description = "Google Web Search Indexing SDK"; - license = lib.licensesSpdx."MPL-2.0"; + license = lib.meta.getLicenseFromSpdxId "MPL-2.0"; } ) { }; @@ -283258,7 +283258,7 @@ self: { sha256 = "0i9pi31vz2ngk8fpv16cizc2yjhs0pacnwf2c0fk9nylg9x4ms38"; libraryHaskellDepends = [ gogol-core ]; description = "Google Cloud Talent Solution SDK"; - license = lib.licensesSpdx."MPL-2.0"; + license = lib.meta.getLicenseFromSpdxId "MPL-2.0"; } ) { }; @@ -283270,7 +283270,7 @@ self: { sha256 = "02py8n5kk1lxmm7bkxag041rwzip4jxpdmldciq4vyq9fkkxvy57"; libraryHaskellDepends = [ gogol-core ]; description = "Google Knowledge Graph Search SDK"; - license = lib.licensesSpdx."MPL-2.0"; + license = lib.meta.getLicenseFromSpdxId "MPL-2.0"; } ) { }; @@ -283282,7 +283282,7 @@ self: { sha256 = "0y0r5c1kgzxmsply7zksh9dbzs2sd4fxwb4ps4w4lqzjkchdbj4x"; libraryHaskellDepends = [ gogol-core ]; description = "Google Cloud Natural Language SDK"; - license = lib.licensesSpdx."MPL-2.0"; + license = lib.meta.getLicenseFromSpdxId "MPL-2.0"; } ) { }; @@ -283315,7 +283315,7 @@ self: { sha256 = "14s5hw0qby8acqmf9f3kh068iaglmf9lp6p802vf3bg3qqx43857"; libraryHaskellDepends = [ gogol-core ]; description = "Google Library Agent SDK"; - license = lib.licensesSpdx."MPL-2.0"; + license = lib.meta.getLicenseFromSpdxId "MPL-2.0"; } ) { }; @@ -283327,7 +283327,7 @@ self: { sha256 = "1a2w6dyb0h3dy9fxzsrmq81d7vr3z2nk7xc0wkb4jhsdvn3nwkzk"; libraryHaskellDepends = [ gogol-core ]; description = "Google Cloud Logging SDK"; - license = lib.licensesSpdx."MPL-2.0"; + license = lib.meta.getLicenseFromSpdxId "MPL-2.0"; } ) { }; @@ -283339,7 +283339,7 @@ self: { sha256 = "0ydxl3cxrw65bfp708im1mlqgf76bi8m0wl8x295mgzyyvi6q75g"; libraryHaskellDepends = [ gogol-core ]; description = "Google Manufacturer Center SDK"; - license = lib.licensesSpdx."MPL-2.0"; + license = lib.meta.getLicenseFromSpdxId "MPL-2.0"; } ) { }; @@ -283393,7 +283393,7 @@ self: { sha256 = "0si4kk7da0mxgqddjamxa8cmci75rlpl2bivjyqx99awff788376"; libraryHaskellDepends = [ gogol-core ]; description = "Google Mirror SDK"; - license = lib.licensesSpdx."MPL-2.0"; + license = lib.meta.getLicenseFromSpdxId "MPL-2.0"; } ) { }; @@ -283405,7 +283405,7 @@ self: { sha256 = "1vr7kv86b1cz364a5mbcl8w14k3f0rdkya4dqc99j46rqa89hcjs"; libraryHaskellDepends = [ gogol-core ]; description = "Google AI Platform Training & Prediction SDK"; - license = lib.licensesSpdx."MPL-2.0"; + license = lib.meta.getLicenseFromSpdxId "MPL-2.0"; } ) { }; @@ -283417,7 +283417,7 @@ self: { sha256 = "1psii00flwy8yh76ng1ixpzdix4i31gr9nlysvi20m962j2zb8x7"; libraryHaskellDepends = [ gogol-core ]; description = "Google Cloud Monitoring SDK"; - license = lib.licensesSpdx."MPL-2.0"; + license = lib.meta.getLicenseFromSpdxId "MPL-2.0"; } ) { }; @@ -283429,7 +283429,7 @@ self: { sha256 = "1yrzaa7wab67dw7yyz3kv78rka6vrmq4q53rrjda25y5mbzax08j"; libraryHaskellDepends = [ gogol-core ]; description = "Google OAuth2 SDK"; - license = lib.licensesSpdx."MPL-2.0"; + license = lib.meta.getLicenseFromSpdxId "MPL-2.0"; } ) { }; @@ -283441,7 +283441,7 @@ self: { sha256 = "0mwxzx6qqbcybanf8cvdrwi4q2y1rs9wlrs4ivsx5csjk07zrbpy"; libraryHaskellDepends = [ gogol-core ]; description = "Google Cloud OS Login SDK"; - license = lib.licensesSpdx."MPL-2.0"; + license = lib.meta.getLicenseFromSpdxId "MPL-2.0"; } ) { }; @@ -283453,7 +283453,7 @@ self: { sha256 = "000p7lhs82fgw80x2g77bgk0ywhxcj22388a37xfdlvfwk7rxxhp"; libraryHaskellDepends = [ gogol-core ]; description = "Google PageSpeed Insights SDK"; - license = lib.licensesSpdx."MPL-2.0"; + license = lib.meta.getLicenseFromSpdxId "MPL-2.0"; } ) { }; @@ -283465,7 +283465,7 @@ self: { sha256 = "0jcqch35rw33fp3xc24x6063hfxfd6hkdhy8ns1b3ry0x59r42na"; libraryHaskellDepends = [ gogol-core ]; description = "Google Partners SDK"; - license = lib.licensesSpdx."MPL-2.0"; + license = lib.meta.getLicenseFromSpdxId "MPL-2.0"; } ) { }; @@ -283477,7 +283477,7 @@ self: { sha256 = "1qjr57q91kr6gf37y24z0hr4lwkqq5fk474mb53s6ipqiyqxsk1s"; libraryHaskellDepends = [ gogol-core ]; description = "Google People SDK"; - license = lib.licensesSpdx."MPL-2.0"; + license = lib.meta.getLicenseFromSpdxId "MPL-2.0"; } ) { }; @@ -283510,7 +283510,7 @@ self: { sha256 = "05nc0w5v5sgg2z1ldx8y6a06nqy81hsq1bln882gv5595mcz3134"; libraryHaskellDepends = [ gogol-core ]; description = "Google Play Movies Partner SDK"; - license = lib.licensesSpdx."MPL-2.0"; + license = lib.meta.getLicenseFromSpdxId "MPL-2.0"; } ) { }; @@ -283522,7 +283522,7 @@ self: { sha256 = "1mga3ppvlzjw133g8li20hjacp8k280qwpcsrfh1a9srmkflnqpi"; libraryHaskellDepends = [ gogol-core ]; description = "Google Play Custom App Publishing SDK"; - license = lib.licensesSpdx."MPL-2.0"; + license = lib.meta.getLicenseFromSpdxId "MPL-2.0"; } ) { }; @@ -283534,7 +283534,7 @@ self: { sha256 = "1jy99vdjqhlhvgir9h7hfc4w27nql44gqv9bn7g6w77xrh5qbbgg"; libraryHaskellDepends = [ gogol-core ]; description = "Google + SDK"; - license = lib.licensesSpdx."MPL-2.0"; + license = lib.meta.getLicenseFromSpdxId "MPL-2.0"; } ) { }; @@ -283546,7 +283546,7 @@ self: { sha256 = "00nyww46c4fxqvzm8jdl8wnmv0a7inm4hcyp56vl336l5fzw6wid"; libraryHaskellDepends = [ gogol-core ]; description = "Google + Domains SDK"; - license = lib.licensesSpdx."MPL-2.0"; + license = lib.meta.getLicenseFromSpdxId "MPL-2.0"; } ) { }; @@ -283558,7 +283558,7 @@ self: { sha256 = "0i87jzs5vrd7zwmrpkbf0jpw7yhq0y9hhiyay18kl78jkwh8gp9v"; libraryHaskellDepends = [ gogol-core ]; description = "Google Poly SDK"; - license = lib.licensesSpdx."MPL-2.0"; + license = lib.meta.getLicenseFromSpdxId "MPL-2.0"; } ) { }; @@ -283591,7 +283591,7 @@ self: { sha256 = "13yzm104viq54pddz321bh9fknr4i0pywsnmlayav82gy6q70fnn"; libraryHaskellDepends = [ gogol-core ]; description = "Google Proximity Beacon SDK"; - license = lib.licensesSpdx."MPL-2.0"; + license = lib.meta.getLicenseFromSpdxId "MPL-2.0"; } ) { }; @@ -283603,7 +283603,7 @@ self: { sha256 = "0ay6npsyzcq2m6dww8xdima8d19bqnrpi942hpmn5ny1rlxahvnj"; libraryHaskellDepends = [ gogol-core ]; description = "Google Cloud Pub/Sub SDK"; - license = lib.licensesSpdx."MPL-2.0"; + license = lib.meta.getLicenseFromSpdxId "MPL-2.0"; } ) { }; @@ -283615,7 +283615,7 @@ self: { sha256 = "1nvn2c936ia0jzkc6lljcrnxp69y7wj8yk4n95y4wqmibi7v1pc6"; libraryHaskellDepends = [ gogol-core ]; description = "Google QPX Express SDK"; - license = lib.licensesSpdx."MPL-2.0"; + license = lib.meta.getLicenseFromSpdxId "MPL-2.0"; } ) { }; @@ -283627,7 +283627,7 @@ self: { sha256 = "1xcgfz3d34iac66kld3fjszi6zn03hw6i51niyapnmgs7qwvw8xm"; libraryHaskellDepends = [ gogol-core ]; description = "Google reCAPTCHA Enterprise SDK"; - license = lib.licensesSpdx."MPL-2.0"; + license = lib.meta.getLicenseFromSpdxId "MPL-2.0"; } ) { }; @@ -283639,7 +283639,7 @@ self: { sha256 = "1fynpbfhnhpxki81wak3w6256rhb6yj2n6h605zpkmqb6zgdcraw"; libraryHaskellDepends = [ gogol-core ]; description = "Google Cloud Memorystore for Redis SDK"; - license = lib.licensesSpdx."MPL-2.0"; + license = lib.meta.getLicenseFromSpdxId "MPL-2.0"; } ) { }; @@ -283651,7 +283651,7 @@ self: { sha256 = "0316qcavy06s6lc77nd3kvkcivx99a29kybqk2v8gkm3d3hgnay6"; libraryHaskellDepends = [ gogol-core ]; description = "Google Remote Build Execution SDK"; - license = lib.licensesSpdx."MPL-2.0"; + license = lib.meta.getLicenseFromSpdxId "MPL-2.0"; } ) { }; @@ -283663,7 +283663,7 @@ self: { sha256 = "1nx55xgghprwzs81x4xvald37xvjzwrsfq5lrrarig5gsz3crb8h"; libraryHaskellDepends = [ gogol-core ]; description = "Google Replica Pool SDK"; - license = lib.licensesSpdx."MPL-2.0"; + license = lib.meta.getLicenseFromSpdxId "MPL-2.0"; } ) { }; @@ -283675,7 +283675,7 @@ self: { sha256 = "14cwrx4qw002464i913n6hxq7rw962w2kcrw3bzng74ndhaaswd2"; libraryHaskellDepends = [ gogol-core ]; description = "Google Compute Engine Instance Group Updater SDK"; - license = lib.licensesSpdx."MPL-2.0"; + license = lib.meta.getLicenseFromSpdxId "MPL-2.0"; } ) { }; @@ -283687,7 +283687,7 @@ self: { sha256 = "12mhxjw4x9cb5sgpy2z4sk9qkmarhwv8mb8q88qigx4d1abqj5gm"; libraryHaskellDepends = [ gogol-core ]; description = "Google Cloud Resource Manager SDK"; - license = lib.licensesSpdx."MPL-2.0"; + license = lib.meta.getLicenseFromSpdxId "MPL-2.0"; } ) { }; @@ -283720,7 +283720,7 @@ self: { sha256 = "07wqy2cp62d8gs4izqzqv50yaj7b37jfhq5qm67j9dr3s56kzz6q"; libraryHaskellDepends = [ gogol-core ]; description = "Google Cloud Run Admin SDK"; - license = lib.licensesSpdx."MPL-2.0"; + license = lib.meta.getLicenseFromSpdxId "MPL-2.0"; } ) { }; @@ -283732,7 +283732,7 @@ self: { sha256 = "0hrjl2vcbmk3hx38c0alh2lgz10xnsvb90lb5x9fkls2n6l0q3lm"; libraryHaskellDepends = [ gogol-core ]; description = "Google Cloud Runtime Configuration SDK"; - license = lib.licensesSpdx."MPL-2.0"; + license = lib.meta.getLicenseFromSpdxId "MPL-2.0"; } ) { }; @@ -283744,7 +283744,7 @@ self: { sha256 = "13yyab714dpd42j6683p4c6v97apc2qy4ihyhrsjr7yn6ysyc4jy"; libraryHaskellDepends = [ gogol-core ]; description = "Google Safe Browsing SDK"; - license = lib.licensesSpdx."MPL-2.0"; + license = lib.meta.getLicenseFromSpdxId "MPL-2.0"; } ) { }; @@ -283756,7 +283756,7 @@ self: { sha256 = "1a2ppyk9869bkwzfhaznqkja5pkdwjwal276k4mzn0ba7jrq47hs"; libraryHaskellDepends = [ gogol-core ]; description = "Google Apps Script SDK"; - license = lib.licensesSpdx."MPL-2.0"; + license = lib.meta.getLicenseFromSpdxId "MPL-2.0"; } ) { }; @@ -283768,7 +283768,7 @@ self: { sha256 = "0l5q9zj6scj72zg4sd1hkn5jwm4hh4q85wq6y5pm8s1sbqk3wsqz"; libraryHaskellDepends = [ gogol-core ]; description = "Google Search Console SDK"; - license = lib.licensesSpdx."MPL-2.0"; + license = lib.meta.getLicenseFromSpdxId "MPL-2.0"; } ) { }; @@ -283780,7 +283780,7 @@ self: { sha256 = "0vkipvyapjimizikzfgk4q2cdn0my5j85agnnz79hvlkqb412ggp"; libraryHaskellDepends = [ gogol-core ]; description = "Google Security Command Center SDK"; - license = lib.licensesSpdx."MPL-2.0"; + license = lib.meta.getLicenseFromSpdxId "MPL-2.0"; } ) { }; @@ -283792,7 +283792,7 @@ self: { sha256 = "0z5mfig3k7k90r5khcs8is4c278dsp9y6qa5fljfkljkd4bniyv4"; libraryHaskellDepends = [ gogol-core ]; description = "Google Service Broker SDK"; - license = lib.licensesSpdx."MPL-2.0"; + license = lib.meta.getLicenseFromSpdxId "MPL-2.0"; } ) { }; @@ -283804,7 +283804,7 @@ self: { sha256 = "17g49aqdgml3w16mj8qf3m0lz7wa6qhmvz1m7s5q2dly8i7klb9q"; libraryHaskellDepends = [ gogol-core ]; description = "Google Service Consumer Management SDK"; - license = lib.licensesSpdx."MPL-2.0"; + license = lib.meta.getLicenseFromSpdxId "MPL-2.0"; } ) { }; @@ -283816,7 +283816,7 @@ self: { sha256 = "0zw9a5q6nsyar5210ryh3svzv8jgjwjmn6mm1kpiqx32bi0gcb53"; libraryHaskellDepends = [ gogol-core ]; description = "Google Service Control SDK"; - license = lib.licensesSpdx."MPL-2.0"; + license = lib.meta.getLicenseFromSpdxId "MPL-2.0"; } ) { }; @@ -283828,7 +283828,7 @@ self: { sha256 = "0i3v8ryswaz84d27v867v5f3rpa6wa518k9y9sim87l4yvqdd72s"; libraryHaskellDepends = [ gogol-core ]; description = "Google Service Management SDK"; - license = lib.licensesSpdx."MPL-2.0"; + license = lib.meta.getLicenseFromSpdxId "MPL-2.0"; } ) { }; @@ -283840,7 +283840,7 @@ self: { sha256 = "0180yqdgrbsf7zazvdsbi1hwy671qc4m80chv458fgnhl6irqzsj"; libraryHaskellDepends = [ gogol-core ]; description = "Google Service Networking SDK"; - license = lib.licensesSpdx."MPL-2.0"; + license = lib.meta.getLicenseFromSpdxId "MPL-2.0"; } ) { }; @@ -283852,7 +283852,7 @@ self: { sha256 = "0mc44gczmh6acgfp3x0lhd7kv7agqdqskv91bvnrk9lmrhcqchr6"; libraryHaskellDepends = [ gogol-core ]; description = "Google Service Usage SDK"; - license = lib.licensesSpdx."MPL-2.0"; + license = lib.meta.getLicenseFromSpdxId "MPL-2.0"; } ) { }; @@ -283864,7 +283864,7 @@ self: { sha256 = "0gh7flld3vai2fwx9gqw3gcrjwwdk3nkahdxdzrixk96lrvfd2lb"; libraryHaskellDepends = [ gogol-core ]; description = "Google Service User SDK"; - license = lib.licensesSpdx."MPL-2.0"; + license = lib.meta.getLicenseFromSpdxId "MPL-2.0"; } ) { }; @@ -283876,7 +283876,7 @@ self: { sha256 = "0jx155xaa053mp7sdrrjng28vdvls51bqg374bp8015dqx8pq388"; libraryHaskellDepends = [ gogol-core ]; description = "Google Sheets SDK"; - license = lib.licensesSpdx."MPL-2.0"; + license = lib.meta.getLicenseFromSpdxId "MPL-2.0"; } ) { }; @@ -283888,7 +283888,7 @@ self: { sha256 = "09j3a7scawkxq81mghnypwhxi5jfx1w8nircmmhpm6a9543ikbgl"; libraryHaskellDepends = [ gogol-core ]; description = "Google Content API for Shopping SDK"; - license = lib.licensesSpdx."MPL-2.0"; + license = lib.meta.getLicenseFromSpdxId "MPL-2.0"; } ) { }; @@ -283900,7 +283900,7 @@ self: { sha256 = "04nn9382mwi4x83whhp66x99mml2djf97nlvpq0n5d6vs5nl65vf"; libraryHaskellDepends = [ gogol-core ]; description = "Google Site Verification SDK"; - license = lib.licensesSpdx."MPL-2.0"; + license = lib.meta.getLicenseFromSpdxId "MPL-2.0"; } ) { }; @@ -283912,7 +283912,7 @@ self: { sha256 = "06cc335zva6qdqr3mmhgsmhzyg09lipzmcsffwvngmbbk6adqfag"; libraryHaskellDepends = [ gogol-core ]; description = "Google Slides SDK"; - license = lib.licensesSpdx."MPL-2.0"; + license = lib.meta.getLicenseFromSpdxId "MPL-2.0"; } ) { }; @@ -283924,7 +283924,7 @@ self: { sha256 = "1v5wl66rl9kj7ckzvmy65a23s9d3ajfrxc4rsmpx6zzg3xmxjlw0"; libraryHaskellDepends = [ gogol-core ]; description = "Google Cloud Source Repositories SDK"; - license = lib.licensesSpdx."MPL-2.0"; + license = lib.meta.getLicenseFromSpdxId "MPL-2.0"; } ) { }; @@ -283936,7 +283936,7 @@ self: { sha256 = "0wbkqr2f2dha298n3sz007y9jg9c4yxn69m5ln7ffxa135yan6l8"; libraryHaskellDepends = [ gogol-core ]; description = "Google Cloud Spanner SDK"; - license = lib.licensesSpdx."MPL-2.0"; + license = lib.meta.getLicenseFromSpdxId "MPL-2.0"; } ) { }; @@ -283948,7 +283948,7 @@ self: { sha256 = "0z1la9nan5dfdksgkajh1a2smlj4vjqk3r2586cshyn4lf1iswsa"; libraryHaskellDepends = [ gogol-core ]; description = "Google Spectrum Database SDK"; - license = lib.licensesSpdx."MPL-2.0"; + license = lib.meta.getLicenseFromSpdxId "MPL-2.0"; } ) { }; @@ -283960,7 +283960,7 @@ self: { sha256 = "1bg6kqxjgwj5qrkrvl7gk9h9r60z41k9h7zf6y7a74arw1ycnfcs"; libraryHaskellDepends = [ gogol-core ]; description = "Google Cloud Speech-to-Text SDK"; - license = lib.licensesSpdx."MPL-2.0"; + license = lib.meta.getLicenseFromSpdxId "MPL-2.0"; } ) { }; @@ -283972,7 +283972,7 @@ self: { sha256 = "0aamc6i0l1ad9x4fnw1psq37fr8iq4pflmi7r9zpqpqh61225qic"; libraryHaskellDepends = [ gogol-core ]; description = "Google Cloud SQL Admin SDK"; - license = lib.licensesSpdx."MPL-2.0"; + license = lib.meta.getLicenseFromSpdxId "MPL-2.0"; } ) { }; @@ -283984,7 +283984,7 @@ self: { sha256 = "1sdmnkaclgi1n9kip5v3791dbvl992sbf95kp967261cwdm00mw5"; libraryHaskellDepends = [ gogol-core ]; description = "Google Cloud Storage JSON SDK"; - license = lib.licensesSpdx."MPL-2.0"; + license = lib.meta.getLicenseFromSpdxId "MPL-2.0"; } ) { }; @@ -283996,7 +283996,7 @@ self: { sha256 = "14v3gk3pp3cn1r27dc9j6f0a8ska2mdpyarx54607x3y23bl1xc5"; libraryHaskellDepends = [ gogol-core ]; description = "Google Storage Transfer SDK"; - license = lib.licensesSpdx."MPL-2.0"; + license = lib.meta.getLicenseFromSpdxId "MPL-2.0"; } ) { }; @@ -284008,7 +284008,7 @@ self: { sha256 = "03zd6hk87fchc2v7wch7s2jjlp6kk2pdadd3vqapnfai5b4nmi0c"; libraryHaskellDepends = [ gogol-core ]; description = "Google Street View Publish SDK"; - license = lib.licensesSpdx."MPL-2.0"; + license = lib.meta.getLicenseFromSpdxId "MPL-2.0"; } ) { }; @@ -284020,7 +284020,7 @@ self: { sha256 = "1bpybiarlh030k825ikf4sc3wm54qn8jxn9wcycfchz311rahci1"; libraryHaskellDepends = [ gogol-core ]; description = "Google Surveys SDK"; - license = lib.licensesSpdx."MPL-2.0"; + license = lib.meta.getLicenseFromSpdxId "MPL-2.0"; } ) { }; @@ -284032,7 +284032,7 @@ self: { sha256 = "1lfadp570iampv44s8kjykimll2h3jrm7kmg696lc4gvr45ps9iz"; libraryHaskellDepends = [ gogol-core ]; description = "Google Tag Manager SDK"; - license = lib.licensesSpdx."MPL-2.0"; + license = lib.meta.getLicenseFromSpdxId "MPL-2.0"; } ) { }; @@ -284065,7 +284065,7 @@ self: { sha256 = "0spim4pb7l582ydp4p5fz24bdqdl2d3jl75sw90g39fkdhx8b36s"; libraryHaskellDepends = [ gogol-core ]; description = "Google Cloud Testing SDK"; - license = lib.licensesSpdx."MPL-2.0"; + license = lib.meta.getLicenseFromSpdxId "MPL-2.0"; } ) { }; @@ -284077,7 +284077,7 @@ self: { sha256 = "0dal449bcdlr04mllfam1m9n0qz8p3ddlv8vm1xpxzw52090jq3m"; libraryHaskellDepends = [ gogol-core ]; description = "Google Cloud Text-to-Speech SDK"; - license = lib.licensesSpdx."MPL-2.0"; + license = lib.meta.getLicenseFromSpdxId "MPL-2.0"; } ) { }; @@ -284089,7 +284089,7 @@ self: { sha256 = "108x732f9bxsqwj1wnmp3sb19v2hc0amjq3hjpw8f2iciyy4l5ia"; libraryHaskellDepends = [ gogol-core ]; description = "Google Cloud Tool Results SDK"; - license = lib.licensesSpdx."MPL-2.0"; + license = lib.meta.getLicenseFromSpdxId "MPL-2.0"; } ) { }; @@ -284101,7 +284101,7 @@ self: { sha256 = "09hbn03scg5axmfy15d29v5nmqxgsc8289x95rahcy00vjcx0aip"; libraryHaskellDepends = [ gogol-core ]; description = "Google Cloud TPU SDK"; - license = lib.licensesSpdx."MPL-2.0"; + license = lib.meta.getLicenseFromSpdxId "MPL-2.0"; } ) { }; @@ -284113,7 +284113,7 @@ self: { sha256 = "0a98hq71pl3hiv8axaqibs7i5vx9h36zcp4lhj1ckca9mbqps87g"; libraryHaskellDepends = [ gogol-core ]; description = "Google Tracing SDK"; - license = lib.licensesSpdx."MPL-2.0"; + license = lib.meta.getLicenseFromSpdxId "MPL-2.0"; } ) { }; @@ -284125,7 +284125,7 @@ self: { sha256 = "15ai2f66bi5hvfpfqx3kpr7pb9nw5sw13p6igs9a2vmdaqf57mkg"; libraryHaskellDepends = [ gogol-core ]; description = "Google Cloud Translation SDK"; - license = lib.licensesSpdx."MPL-2.0"; + license = lib.meta.getLicenseFromSpdxId "MPL-2.0"; } ) { }; @@ -284137,7 +284137,7 @@ self: { sha256 = "0j846nnb5w2lki10wnvdslds4bi387hxcfrr3m8q156n0dvgzz5q"; libraryHaskellDepends = [ gogol-core ]; description = "Google URL Shortener SDK"; - license = lib.licensesSpdx."MPL-2.0"; + license = lib.meta.getLicenseFromSpdxId "MPL-2.0"; } ) { }; @@ -284170,7 +284170,7 @@ self: { sha256 = "08dyv38d0ga4dc6zlxz41dgba84ylxc336xv0c33jqxhrzdq6654"; libraryHaskellDepends = [ gogol-core ]; description = "Google Vault SDK"; - license = lib.licensesSpdx."MPL-2.0"; + license = lib.meta.getLicenseFromSpdxId "MPL-2.0"; } ) { }; @@ -284182,7 +284182,7 @@ self: { sha256 = "1303p25mdzvk79rhy942f1v27n476cqj1sclycq3mnflf661sbwa"; libraryHaskellDepends = [ gogol-core ]; description = "Google Cloud Video Intelligence SDK"; - license = lib.licensesSpdx."MPL-2.0"; + license = lib.meta.getLicenseFromSpdxId "MPL-2.0"; } ) { }; @@ -284194,7 +284194,7 @@ self: { sha256 = "13llhpsj0lzd4r6mbgzlcqgj8m14i0qk3il3pynxwhzvn1nccjps"; libraryHaskellDepends = [ gogol-core ]; description = "Google Cloud Vision SDK"; - license = lib.licensesSpdx."MPL-2.0"; + license = lib.meta.getLicenseFromSpdxId "MPL-2.0"; } ) { }; @@ -284206,7 +284206,7 @@ self: { sha256 = "1da7zap20g3s8n8pail5sh7wy4i7m718qr1h3dmqpd4413p9ybcn"; libraryHaskellDepends = [ gogol-core ]; description = "Google Search Console SDK"; - license = lib.licensesSpdx."MPL-2.0"; + license = lib.meta.getLicenseFromSpdxId "MPL-2.0"; } ) { }; @@ -284218,7 +284218,7 @@ self: { sha256 = "0asdbgv7n7vcc7z2qxr4aqva0w75wzxba2niyq10648ya1dxrx5d"; libraryHaskellDepends = [ gogol-core ]; description = "Google Web Security Scanner SDK"; - license = lib.licensesSpdx."MPL-2.0"; + license = lib.meta.getLicenseFromSpdxId "MPL-2.0"; } ) { }; @@ -284230,7 +284230,7 @@ self: { sha256 = "1zgfx51z3wxmjkyzg876kfmwb516n5dhaygg1bmjhqc6xwzzp2si"; libraryHaskellDepends = [ gogol-core ]; description = "Google YouTube Data API v3 SDK"; - license = lib.licensesSpdx."MPL-2.0"; + license = lib.meta.getLicenseFromSpdxId "MPL-2.0"; } ) { }; @@ -284242,7 +284242,7 @@ self: { sha256 = "01rcrcj83smzhz9bzdhwrnd799w2gg62ypvkffyd1n06frs6jlaf"; libraryHaskellDepends = [ gogol-core ]; description = "Google YouTube Analytics SDK"; - license = lib.licensesSpdx."MPL-2.0"; + license = lib.meta.getLicenseFromSpdxId "MPL-2.0"; } ) { }; @@ -284254,7 +284254,7 @@ self: { sha256 = "14p05jzz2vpxhgr2gb8pp5i8ni46zy3j5vjhlq3gb2ri7cz76asz"; libraryHaskellDepends = [ gogol-core ]; description = "Google YouTube Reporting SDK"; - license = lib.licensesSpdx."MPL-2.0"; + license = lib.meta.getLicenseFromSpdxId "MPL-2.0"; } ) { }; @@ -284363,7 +284363,7 @@ self: { vector ]; description = "Golden testing framework for performance benchmarks"; - license = lib.licensesSpdx."MIT"; + license = lib.meta.getLicenseFromSpdxId "MIT"; } ) { }; @@ -286544,7 +286544,7 @@ self: { gpu-vulkan-core ]; description = "Thin wrapper for VK_KHR_surface extension of the Vulkan API"; - license = lib.licensesSpdx."BSD-3-Clause"; + license = lib.meta.getLicenseFromSpdxId "BSD-3-Clause"; } ) { }; @@ -286573,7 +286573,7 @@ self: { gpu-vulkan-core-khr-surface ]; description = "Thin wrapper for VK_KHR_swapchain extension of the Vulkan API"; - license = lib.licensesSpdx."BSD-3-Clause"; + license = lib.meta.getLicenseFromSpdxId "BSD-3-Clause"; } ) { }; @@ -286611,7 +286611,7 @@ self: { typelevel-tools-yj ]; description = "VK_KHR_surface extension of the Vulkan API"; - license = lib.licensesSpdx."BSD-3-Clause"; + license = lib.meta.getLicenseFromSpdxId "BSD-3-Clause"; } ) { }; @@ -286655,7 +286655,7 @@ self: { typelevel-tools-yj ]; description = "GLFW surface for Vulkan"; - license = lib.licensesSpdx."BSD-3-Clause"; + license = lib.meta.getLicenseFromSpdxId "BSD-3-Clause"; } ) { }; @@ -286702,7 +286702,7 @@ self: { typelevel-tools-yj ]; description = "VK_KHR_swapchain extension of the Vulkan API"; - license = lib.licensesSpdx."BSD-3-Clause"; + license = lib.meta.getLicenseFromSpdxId "BSD-3-Clause"; } ) { }; @@ -286827,7 +286827,7 @@ self: { typelevel-tools-yj ]; description = "medium wrapper for VK_KHR_surface extension of the Vulkan API"; - license = lib.licensesSpdx."BSD-3-Clause"; + license = lib.meta.getLicenseFromSpdxId "BSD-3-Clause"; } ) { }; @@ -286859,7 +286859,7 @@ self: { typelevel-tools-yj ]; description = "medium wrapper for GLFW surface for the Vulkan API"; - license = lib.licensesSpdx."BSD-3-Clause"; + license = lib.meta.getLicenseFromSpdxId "BSD-3-Clause"; } ) { }; @@ -286906,7 +286906,7 @@ self: { typelevel-tools-yj ]; description = "medium wrapper for VK_KHR_swapchain extension of the Vulkan API"; - license = lib.licensesSpdx."BSD-3-Clause"; + license = lib.meta.getLicenseFromSpdxId "BSD-3-Clause"; } ) { }; @@ -286970,7 +286970,7 @@ self: { criterion ]; description = "Applicative non-linear consumption"; - license = lib.licensesSpdx."MIT"; + license = lib.meta.getLicenseFromSpdxId "MIT"; hydraPlatforms = lib.platforms.none; broken = true; } @@ -287003,7 +287003,7 @@ self: { text ]; description = "Applicative parsers for form parameter lists"; - license = lib.licensesSpdx."MIT"; + license = lib.meta.getLicenseFromSpdxId "MIT"; hydraPlatforms = lib.platforms.none; } ) { }; @@ -287083,7 +287083,7 @@ self: { tasty-hunit ]; description = "API for creating grafana dashboards represented as json"; - license = lib.licensesSpdx."BSD-3-Clause"; + license = lib.meta.getLicenseFromSpdxId "BSD-3-Clause"; hydraPlatforms = lib.platforms.none; broken = true; } @@ -287122,7 +287122,7 @@ self: { unordered-containers ]; description = "Configure grafana dashboards from Dhall expression"; - license = lib.licensesSpdx."Apache-2.0"; + license = lib.meta.getLicenseFromSpdxId "Apache-2.0"; mainProgram = "grafdhall"; } ) { }; @@ -287386,7 +287386,7 @@ self: { ]; testToolDepends = [ hspec-discover ]; description = "Easy terminal plotting"; - license = lib.licensesSpdx."MIT"; + license = lib.meta.getLicenseFromSpdxId "MIT"; mainProgram = "granite"; } ) { }; @@ -287684,7 +287684,7 @@ self: { unordered-containers ]; description = "Native Haskell implementation of the gRPC framework"; - license = lib.licensesSpdx."BSD-3-Clause"; + license = lib.meta.getLicenseFromSpdxId "BSD-3-Clause"; hydraPlatforms = lib.platforms.none; } ) { }; @@ -287708,7 +287708,7 @@ self: { proto-lens-etcd ]; description = "grapesy-etcd - GRPC interface to etcd"; - license = lib.licensesSpdx."Apache-2.0"; + license = lib.meta.getLicenseFromSpdxId "Apache-2.0"; hydraPlatforms = lib.platforms.none; } ) { }; @@ -288215,7 +288215,7 @@ self: { transformers ]; description = "Trace the call graph of a program"; - license = lib.licensesSpdx."MIT"; + license = lib.meta.getLicenseFromSpdxId "MIT"; hydraPlatforms = lib.platforms.none; broken = true; } @@ -288255,7 +288255,7 @@ self: { directory ]; description = "Converts a graph-trace log into a DOT file for use with Graphviz"; - license = lib.licensesSpdx."MIT"; + license = lib.meta.getLicenseFromSpdxId "MIT"; mainProgram = "graph-trace-dot"; } ) { }; @@ -288285,7 +288285,7 @@ self: { process ]; description = "Converts a graph-trace log into an HTML document"; - license = lib.licensesSpdx."MIT"; + license = lib.meta.getLicenseFromSpdxId "MIT"; mainProgram = "graph-trace-viz"; } ) { }; @@ -288958,7 +288958,7 @@ self: { ]; testToolDepends = [ hspec-discover ]; description = "GraphQL with batteries"; - license = lib.licensesSpdx."MPL-2.0"; + license = lib.meta.getLicenseFromSpdxId "MPL-2.0"; } ) { }; @@ -289376,7 +289376,7 @@ self: { ]; testToolDepends = [ tasty-autocollect ]; description = "Monadic DOT graph builder DSL"; - license = lib.licensesSpdx."BSD-3-Clause"; + license = lib.meta.getLicenseFromSpdxId "BSD-3-Clause"; mainProgram = "example"; } ) { }; @@ -289565,7 +289565,7 @@ self: { test-framework-quickcheck2 ]; description = "Gray encoding schemes"; - license = lib.licensesSpdx."BSD-3-Clause"; + license = lib.meta.getLicenseFromSpdxId "BSD-3-Clause"; } ) { }; @@ -290172,7 +290172,7 @@ self: { tasty-bench ]; description = "Uniformly-random pre-factored numbers (Kalai)"; - license = lib.licensesSpdx."BSD-3-Clause"; + license = lib.meta.getLicenseFromSpdxId "BSD-3-Clause"; hydraPlatforms = lib.platforms.none; mainProgram = "grfn-exe"; broken = true; @@ -290203,7 +290203,7 @@ self: { test-framework-quickcheck2 ]; description = "Tools for working with regular grids (graphs, lattices)"; - license = lib.licensesSpdx."BSD-3-Clause"; + license = lib.meta.getLicenseFromSpdxId "BSD-3-Clause"; hydraPlatforms = lib.platforms.none; broken = true; } @@ -290481,7 +290481,7 @@ self: { text ]; description = "Parser for reStructuredText-style grid tables"; - license = lib.licensesSpdx."MIT"; + license = lib.meta.getLicenseFromSpdxId "MIT"; } ) { }; @@ -291281,7 +291281,7 @@ self: { utility-ht ]; description = "Shell command for grouping files by dates into folders"; - license = lib.licensesSpdx."BSD-3-Clause"; + license = lib.meta.getLicenseFromSpdxId "BSD-3-Clause"; mainProgram = "group-by-date"; maintainers = [ lib.maintainers.thielema ]; } @@ -291461,7 +291461,7 @@ self: { sha256 = "0f5c8dg9b74glfw2sdvdcl9c8igs6knz1bayk4gvvzvypsl547nf"; libraryHaskellDepends = [ base ]; description = "Groups"; - license = lib.licensesSpdx."BSD-3-Clause"; + license = lib.meta.getLicenseFromSpdxId "BSD-3-Clause"; } ) { }; @@ -291482,7 +291482,7 @@ self: { groups ]; description = "Generically derive Group instances"; - license = lib.licensesSpdx."BSD-3-Clause"; + license = lib.meta.getLicenseFromSpdxId "BSD-3-Clause"; } ) { }; @@ -291557,7 +291557,7 @@ self: { vector ]; description = "A contiguous growable array type"; - license = lib.licensesSpdx."MIT"; + license = lib.meta.getLicenseFromSpdxId "MIT"; hydraPlatforms = lib.platforms.none; broken = true; } @@ -291924,7 +291924,7 @@ self: { tree-diff ]; description = "Implementation of the pure part of the gRPC spec"; - license = lib.licensesSpdx."BSD-3-Clause"; + license = lib.meta.getLicenseFromSpdxId "BSD-3-Clause"; } ) { }; @@ -292034,7 +292034,7 @@ self: { sha256 = "0if8kvwx51bwsdkwpk9ardmlm9l5v91vfy4g3bj2gmd3184nw6la"; libraryHaskellDepends = [ base ]; description = "Gruvbox colors for use in Haskell"; - license = lib.licensesSpdx."MIT"; + license = lib.meta.getLicenseFromSpdxId "MIT"; } ) { }; @@ -292193,7 +292193,7 @@ self: { X11 ]; description = "A visual generic menu"; - license = lib.licensesSpdx."BSD-3-Clause"; + license = lib.meta.getLicenseFromSpdxId "BSD-3-Clause"; hydraPlatforms = lib.platforms.none; mainProgram = "gsmenu"; } @@ -292474,7 +292474,7 @@ self: { ]; libraryPkgconfigDepends = [ gtk2 ]; description = "Binding to the Gtk+ graphical user interface library"; - license = lib.licensesSpdx."LGPL-2.1-only"; + license = lib.meta.getLicenseFromSpdxId "LGPL-2.1-only"; } ) { inherit (pkgs) gtk2; }; @@ -292911,7 +292911,7 @@ self: { ]; executableHaskellDepends = [ base ]; description = "Tools to build the Gtk2Hs suite of User Interface libraries"; - license = lib.licensesSpdx."GPL-2.0-only"; + license = lib.meta.getLicenseFromSpdxId "GPL-2.0-only"; } ) { }; @@ -293195,7 +293195,7 @@ self: { ]; libraryPkgconfigDepends = [ gtk3 ]; description = "Binding to the Gtk+ 3 graphical user interface library"; - license = lib.licensesSpdx."LGPL-2.1-only"; + license = lib.meta.getLicenseFromSpdxId "LGPL-2.1-only"; } ) { inherit (pkgs) gtk3; }; @@ -293684,7 +293684,7 @@ self: { ]; testToolDepends = [ tasty-discover ]; description = "The border guardian for your package dependencies"; - license = lib.licensesSpdx."BSD-3-Clause"; + license = lib.meta.getLicenseFromSpdxId "BSD-3-Clause"; hydraPlatforms = lib.platforms.none; mainProgram = "guardian"; broken = true; @@ -293837,7 +293837,7 @@ self: { unix ]; description = "ghcWithPackages cmdline util"; - license = lib.licensesSpdx."BSD-3-Clause"; + license = lib.meta.getLicenseFromSpdxId "BSD-3-Clause"; hydraPlatforms = lib.platforms.none; mainProgram = "gw"; broken = true; @@ -294142,7 +294142,7 @@ self: { libxrandr ]; description = "Raylib bindings for Haskell"; - license = lib.licensesSpdx."Apache-2.0"; + license = lib.meta.getLicenseFromSpdxId "Apache-2.0"; badPlatforms = lib.platforms.darwin; } ) @@ -294315,7 +294315,7 @@ self: { test-framework-quickcheck2 ]; description = "A Haskell binding for H3"; - license = lib.licensesSpdx."BSD-3-Clause"; + license = lib.meta.getLicenseFromSpdxId "BSD-3-Clause"; hydraPlatforms = lib.platforms.none; broken = true; } @@ -294383,7 +294383,7 @@ self: { time ]; description = "Control your Arduino board from Haskell"; - license = lib.licensesSpdx."BSD-3-Clause"; + license = lib.meta.getLicenseFromSpdxId "BSD-3-Clause"; } ) { }; @@ -295074,7 +295074,7 @@ self: { zlib ]; description = "native Haskell implementation of OpenPGP (RFC4880)"; - license = lib.licensesSpdx."MIT"; + license = lib.meta.getLicenseFromSpdxId "MIT"; } ) { }; @@ -295566,7 +295566,7 @@ self: { random ]; description = "A Haskell library for Active Automata Learning"; - license = lib.licensesSpdx."BSD-3-Clause"; + license = lib.meta.getLicenseFromSpdxId "BSD-3-Clause"; hydraPlatforms = lib.platforms.none; broken = true; } @@ -295589,7 +295589,7 @@ self: { haal ]; description = "Pre-built Mealy automaton models for haal"; - license = lib.licensesSpdx."BSD-3-Clause"; + license = lib.meta.getLicenseFromSpdxId "BSD-3-Clause"; hydraPlatforms = lib.platforms.none; } ) { }; @@ -296707,7 +296707,7 @@ self: { servant-client ]; description = "An API binding to Hackage API"; - license = lib.licensesSpdx."BSD-3-Clause"; + license = lib.meta.getLicenseFromSpdxId "BSD-3-Clause"; hydraPlatforms = lib.platforms.none; broken = true; } @@ -296794,7 +296794,7 @@ self: { ]; doHaddock = false; description = "CLI tool for Hackage"; - license = lib.licensesSpdx."GPL-3.0-or-later"; + license = lib.meta.getLicenseFromSpdxId "GPL-3.0-or-later"; mainProgram = "hackage-cli"; } ) { }; @@ -297150,7 +297150,7 @@ self: { with-utf8 ]; description = "No frills releasing to Hackage"; - license = lib.licensesSpdx."MIT"; + license = lib.meta.getLicenseFromSpdxId "MIT"; hydraPlatforms = lib.platforms.none; mainProgram = "hackage-publish"; broken = true; @@ -297253,7 +297253,7 @@ self: { time ]; description = "List Hackage reverse dependencies"; - license = lib.licensesSpdx."BSD-3-Clause"; + license = lib.meta.getLicenseFromSpdxId "BSD-3-Clause"; } ) { }; @@ -297305,7 +297305,7 @@ self: { time ]; description = "List Hackage reverse dependencies"; - license = lib.licensesSpdx."BSD-3-Clause"; + license = lib.meta.getLicenseFromSpdxId "BSD-3-Clause"; hydraPlatforms = lib.platforms.none; } ) { }; @@ -298026,7 +298026,7 @@ self: { ]; doHaddock = false; description = "Hackage and Portage integration tool"; - license = lib.licensesSpdx."GPL-3.0-or-later"; + license = lib.meta.getLicenseFromSpdxId "GPL-3.0-or-later"; mainProgram = "hackport"; } ) { }; @@ -298109,7 +298109,7 @@ self: { haddock-test ]; description = "A documentation-generation tool for Haskell libraries"; - license = lib.licensesSpdx."BSD-3-Clause"; + license = lib.meta.getLicenseFromSpdxId "BSD-3-Clause"; hydraPlatforms = lib.platforms.none; mainProgram = "haddock"; } @@ -298185,7 +298185,7 @@ self: { ]; testToolDepends = [ hspec-discover ]; description = "A documentation-generation tool for Haskell libraries"; - license = lib.licensesSpdx."BSD-2-Clause"; + license = lib.meta.getLicenseFromSpdxId "BSD-2-Clause"; hydraPlatforms = lib.platforms.none; broken = true; } @@ -298199,7 +298199,7 @@ self: { sha256 = "1nqq7k8ssl6h1d501d8ayzsdlihnbfrqy4l5z43msc6lr7ffvz2r"; libraryHaskellDepends = [ base ]; description = "A documentation-only package exemplifying haddock markup features"; - license = lib.licensesSpdx."MIT"; + license = lib.meta.getLicenseFromSpdxId "MIT"; } ) { }; @@ -298287,7 +298287,7 @@ self: { ]; testToolDepends = [ hspec-discover ]; description = "Library exposing some functionality of Haddock"; - license = lib.licensesSpdx."BSD-2-Clause"; + license = lib.meta.getLicenseFromSpdxId "BSD-2-Clause"; } ) { }; @@ -298358,7 +298358,7 @@ self: { ]; testToolDepends = [ tasty-discover ]; description = "Eliminate warnings for names referred in Haddock only"; - license = lib.licensesSpdx."BSD-3-Clause"; + license = lib.meta.getLicenseFromSpdxId "BSD-3-Clause"; } ) { }; @@ -298670,7 +298670,7 @@ self: { ]; testToolDepends = [ hspec-discover ]; description = "A simple Hadoop streaming library"; - license = lib.licensesSpdx."BSD-3-Clause"; + license = lib.meta.getLicenseFromSpdxId "BSD-3-Clause"; hydraPlatforms = lib.platforms.none; broken = true; } @@ -298758,7 +298758,7 @@ self: { isExecutable = true; executableHaskellDepends = [ base ]; description = "Confirm delegation of NS and MX records"; - license = lib.licensesSpdx."AGPL-3.0-or-later"; + license = lib.meta.getLicenseFromSpdxId "AGPL-3.0-or-later"; mainProgram = "haeredes"; } ) { }; @@ -299908,7 +299908,7 @@ self: { text ]; description = "Hakyll extension for rendering Coq code using Alectryon"; - license = lib.licensesSpdx."MIT"; + license = lib.meta.getLicenseFromSpdxId "MIT"; } ) { }; @@ -300341,7 +300341,7 @@ self: { text ]; description = "A Hakyll plugin for rendering diagrams figures from embedded Haskell code"; - license = lib.licensesSpdx."BSD-3-Clause"; + license = lib.meta.getLicenseFromSpdxId "BSD-3-Clause"; } ) { }; @@ -300500,7 +300500,7 @@ self: { vector ]; description = "Hakyll utilities to work with images"; - license = lib.licensesSpdx."BSD-3-Clause"; + license = lib.meta.getLicenseFromSpdxId "BSD-3-Clause"; } ) { }; @@ -300715,7 +300715,7 @@ self: { text ]; description = "Use shortcut-links in markdown file for Hakyll"; - license = lib.licensesSpdx."MPL-2.0"; + license = lib.meta.getLicenseFromSpdxId "MPL-2.0"; } ) { }; @@ -301110,7 +301110,7 @@ self: { sha256 = "1y09vl853nsc6fx19bwmmmh9k7di825j4y7rsm06wyk35m911yv7"; libraryHaskellDepends = [ base ]; description = "A library to provide special kind of two-column output for Phladiprelio"; - license = lib.licensesSpdx."MIT"; + license = lib.meta.getLicenseFromSpdxId "MIT"; } ) { }; @@ -301140,7 +301140,7 @@ self: { JuicyPixels ]; description = "Integration between Halide and JuicyPixels"; - license = lib.licensesSpdx."BSD-3-Clause"; + license = lib.meta.getLicenseFromSpdxId "BSD-3-Clause"; platforms = lib.platforms.linux; hydraPlatforms = lib.platforms.none; } @@ -301170,7 +301170,7 @@ self: { hspec ]; description = "Integration between Halide and ArrayFire"; - license = lib.licensesSpdx."BSD-3-Clause"; + license = lib.meta.getLicenseFromSpdxId "BSD-3-Clause"; hydraPlatforms = lib.platforms.none; } ) { }; @@ -301231,7 +301231,7 @@ self: { vector ]; description = "Haskell bindings to Halide"; - license = lib.licensesSpdx."BSD-3-Clause"; + license = lib.meta.getLicenseFromSpdxId "BSD-3-Clause"; platforms = lib.platforms.linux; hydraPlatforms = lib.platforms.none; broken = true; @@ -304206,7 +304206,7 @@ self: { list-tries ]; description = "Support for static URL routing with overlap detection for Happstack"; - license = lib.licensesSpdx."BSD-3-Clause"; + license = lib.meta.getLicenseFromSpdxId "BSD-3-Clause"; } ) { }; @@ -304534,7 +304534,7 @@ self: { Chart-diagrams ]; description = "Generate simple okay-looking bar plots without much effort"; - license = lib.licensesSpdx."MIT"; + license = lib.meta.getLicenseFromSpdxId "MIT"; hydraPlatforms = lib.platforms.none; broken = true; } @@ -304563,7 +304563,7 @@ self: { ]; doHaddock = false; description = "Happy is a parser generator for Haskell implemented using this library"; - license = lib.licensesSpdx."BSD-2-Clause"; + license = lib.meta.getLicenseFromSpdxId "BSD-2-Clause"; } ) { }; @@ -304590,7 +304590,7 @@ self: { ]; doHaddock = false; description = "Happy is a parser generator for Haskell implemented using this library"; - license = lib.licensesSpdx."BSD-2-Clause"; + license = lib.meta.getLicenseFromSpdxId "BSD-2-Clause"; hydraPlatforms = lib.platforms.none; } ) { }; @@ -305048,7 +305048,7 @@ self: { ]; testHaskellDepends = [ base ]; description = "Haskell program configuration using higher kinded data"; - license = lib.licensesSpdx."BSD-3-Clause"; + license = lib.meta.getLicenseFromSpdxId "BSD-3-Clause"; hydraPlatforms = lib.platforms.none; broken = true; } @@ -305277,7 +305277,7 @@ self: { first-class-families ]; description = "Haskell array programming"; - license = lib.licensesSpdx."BSD-3-Clause"; + license = lib.meta.getLicenseFromSpdxId "BSD-3-Clause"; mainProgram = "harpie-bug-issue1"; } ) { }; @@ -305316,7 +305316,7 @@ self: { first-class-families ]; description = "Haskell array programming"; - license = lib.licensesSpdx."BSD-3-Clause"; + license = lib.meta.getLicenseFromSpdxId "BSD-3-Clause"; hydraPlatforms = lib.platforms.none; mainProgram = "harpie-bug-issue1"; } @@ -305345,7 +305345,7 @@ self: { prettyprinter ]; description = "numhask shim for harpie"; - license = lib.licensesSpdx."BSD-3-Clause"; + license = lib.meta.getLicenseFromSpdxId "BSD-3-Clause"; } ) { }; @@ -305372,7 +305372,7 @@ self: { prettyprinter ]; description = "numhask shim for harpie"; - license = lib.licensesSpdx."BSD-3-Clause"; + license = lib.meta.getLicenseFromSpdxId "BSD-3-Clause"; hydraPlatforms = lib.platforms.none; } ) { }; @@ -305526,7 +305526,7 @@ self: { ]; testToolDepends = [ hspec-discover ]; description = "This library 'Has' transformers"; - license = lib.licensesSpdx."MIT"; + license = lib.meta.getLicenseFromSpdxId "MIT"; maintainers = [ lib.maintainers.turion ]; } ) { }; @@ -305693,7 +305693,7 @@ self: { sha256 = "1vgbmlcd33vky1mf9sx6dkbh8yjp7nyr4528y6qz7xn7z1lxfyyx"; libraryHaskellDepends = [ base ]; description = "Haskell to and from Scalameta"; - license = lib.licensesSpdx."MIT"; + license = lib.meta.getLicenseFromSpdxId "MIT"; hydraPlatforms = lib.platforms.none; broken = true; } @@ -306198,7 +306198,7 @@ self: { temporary ]; description = "Hash-addressed file storage"; - license = lib.licensesSpdx."Apache-2.0"; + license = lib.meta.getLicenseFromSpdxId "Apache-2.0"; hydraPlatforms = lib.platforms.none; } ) { }; @@ -306266,7 +306266,7 @@ self: { unordered-containers ]; description = "Hash-addressed file storage app"; - license = lib.licensesSpdx."Apache-2.0"; + license = lib.meta.getLicenseFromSpdxId "Apache-2.0"; hydraPlatforms = lib.platforms.none; mainProgram = "hash-addressed"; } @@ -306460,7 +306460,7 @@ self: { unix ]; description = "A class for types that can be converted to a hash value"; - license = lib.licensesSpdx."BSD-3-Clause"; + license = lib.meta.getLicenseFromSpdxId "BSD-3-Clause"; hydraPlatforms = lib.platforms.none; } ) { }; @@ -306509,7 +306509,7 @@ self: { text ]; description = "A class for types that can be converted to a hash value"; - license = lib.licensesSpdx."BSD-3-Clause"; + license = lib.meta.getLicenseFromSpdxId "BSD-3-Clause"; } ) { }; @@ -306635,7 +306635,7 @@ self: { time-compat ]; description = "Provides instances missing from Hashable"; - license = lib.licensesSpdx."BSD-3-Clause"; + license = lib.meta.getLicenseFromSpdxId "BSD-3-Clause"; hydraPlatforms = lib.platforms.none; broken = true; } @@ -306809,7 +306809,7 @@ self: { vector ]; description = "Hash digests for files and directories"; - license = lib.licensesSpdx."Apache-2.0"; + license = lib.meta.getLicenseFromSpdxId "Apache-2.0"; hydraPlatforms = lib.platforms.none; mainProgram = "hasherize"; broken = true; @@ -306853,7 +306853,7 @@ self: { ]; benchmarkSystemDepends = [ openssl ]; description = "Hash functions"; - license = lib.licensesSpdx."MIT"; + license = lib.meta.getLicenseFromSpdxId "MIT"; } ) { inherit (pkgs) openssl; }; @@ -307157,7 +307157,7 @@ self: { vector ]; description = "Mutable hash tables in the ST monad"; - license = lib.licensesSpdx."BSD-3-Clause"; + license = lib.meta.getLicenseFromSpdxId "BSD-3-Clause"; } ) { }; @@ -307363,7 +307363,7 @@ self: { ]; doHaddock = false; description = "A RESP protocol implementation and multiplexed Redis client library"; - license = lib.licensesSpdx."MIT"; + license = lib.meta.getLicenseFromSpdxId "MIT"; } ) { }; @@ -308316,7 +308316,7 @@ self: { tasty-quickcheck ]; description = "A lightweight library for asynchronous job workers with multiple broker backends"; - license = lib.licensesSpdx."AGPL-3.0-or-later"; + license = lib.meta.getLicenseFromSpdxId "AGPL-3.0-or-later"; } ) { }; @@ -308393,7 +308393,7 @@ self: { text ]; description = "PostgreSQL/PGMQ broker implementation for haskell-bee"; - license = lib.licensesSpdx."AGPL-3.0-or-later"; + license = lib.meta.getLicenseFromSpdxId "AGPL-3.0-or-later"; hydraPlatforms = lib.platforms.none; mainProgram = "simple-worker"; broken = true; @@ -308465,7 +308465,7 @@ self: { unix-time ]; description = "Redis broker implementation for haskell-bee"; - license = lib.licensesSpdx."AGPL-3.0-or-later"; + license = lib.meta.getLicenseFromSpdxId "AGPL-3.0-or-later"; } ) { }; @@ -308531,7 +308531,7 @@ self: { unix-time ]; description = "STM broker implementation for haskell-bee"; - license = lib.licensesSpdx."AGPL-3.0-or-later"; + license = lib.meta.getLicenseFromSpdxId "AGPL-3.0-or-later"; } ) { }; @@ -308570,7 +308570,7 @@ self: { text ]; description = "Reusable test suite for any haskell-bee Broker implementation"; - license = lib.licensesSpdx."AGPL-3.0-or-later"; + license = lib.meta.getLicenseFromSpdxId "AGPL-3.0-or-later"; } ) { }; @@ -308875,7 +308875,7 @@ self: { ]; doHaddock = false; description = "Cabal package script generator for Travis-CI"; - license = lib.licensesSpdx."GPL-3.0-or-later"; + license = lib.meta.getLicenseFromSpdxId "GPL-3.0-or-later"; mainProgram = "haskell-ci"; maintainers = [ lib.maintainers.sternenseemann ]; } @@ -309322,7 +309322,7 @@ self: { unordered-containers ]; description = "A step-through debugger for GHC Haskell"; - license = lib.licensesSpdx."BSD-3-Clause"; + license = lib.meta.getLicenseFromSpdxId "BSD-3-Clause"; hydraPlatforms = lib.platforms.none; mainProgram = "hdb"; maintainers = [ lib.maintainers.alexfmpe ]; @@ -309348,7 +309348,7 @@ self: { text ]; description = "Custom debug visualization instances for @haskell-debugger@"; - license = lib.licensesSpdx."BSD-3-Clause"; + license = lib.meta.getLicenseFromSpdxId "BSD-3-Clause"; hydraPlatforms = lib.platforms.none; broken = true; } @@ -309682,7 +309682,7 @@ self: { hspec-expectations ]; description = "Haskell bindings for ffprobe"; - license = lib.licensesSpdx."BSD-3-Clause"; + license = lib.meta.getLicenseFromSpdxId "BSD-3-Clause"; hydraPlatforms = lib.platforms.none; broken = true; } @@ -310123,7 +310123,7 @@ self: { vector ]; description = "Auto-generated Gemini API Client for Haskell"; - license = lib.licensesSpdx."MIT"; + license = lib.meta.getLicenseFromSpdxId "MIT"; } ) { }; @@ -310269,7 +310269,7 @@ self: { uuid-types ]; description = "Haskell port of purescript-halogen library"; - license = lib.licensesSpdx."Apache-2.0"; + license = lib.meta.getLicenseFromSpdxId "Apache-2.0"; hydraPlatforms = lib.platforms.none; mainProgram = "halogen-core-prototype"; broken = true; @@ -310353,7 +310353,7 @@ self: { tasty-hunit ]; description = "Bindings to the igraph C library (v0.8.5)."; - license = lib.licensesSpdx."MIT"; + license = lib.meta.getLicenseFromSpdxId "MIT"; } ) { }; @@ -310739,7 +310739,7 @@ self: { benchmarkToolDepends = [ eventlog2html ]; doHaddock = false; description = "LSP server for GHC"; - license = lib.licensesSpdx."Apache-2.0"; + license = lib.meta.getLicenseFromSpdxId "Apache-2.0"; maintainers = [ lib.maintainers.maralorn ]; } ) { }; @@ -310752,7 +310752,7 @@ self: { sha256 = "0h8s19j2flby3qrvb93j1d2lpjl1jgin8lj6dqpb7c86h59f2xlx"; libraryHaskellDepends = [ base ]; description = "A fully compliant Haskell 98 lexer"; - license = lib.licensesSpdx."MIT"; + license = lib.meta.getLicenseFromSpdxId "MIT"; } ) { }; @@ -311641,7 +311641,7 @@ self: { text ]; description = "Haskell interface for Tembo's PGMQ PostgreSQL extension"; - license = lib.licensesSpdx."AGPL-3.0-or-later"; + license = lib.meta.getLicenseFromSpdxId "AGPL-3.0-or-later"; } ) { }; @@ -312552,7 +312552,7 @@ self: { ]; testToolDepends = [ hspec-discover ]; description = "haskell-stack-trace-plugin"; - license = lib.licensesSpdx."MIT"; + license = lib.meta.getLicenseFromSpdxId "MIT"; hydraPlatforms = lib.platforms.none; mainProgram = "example"; broken = true; @@ -312593,7 +312593,7 @@ self: { time ]; description = "A simple throttling library, which drops messages from same group"; - license = lib.licensesSpdx."AGPL-3.0-or-later"; + license = lib.meta.getLicenseFromSpdxId "AGPL-3.0-or-later"; hydraPlatforms = lib.platforms.none; broken = true; } @@ -313771,7 +313771,7 @@ self: { process ]; description = "Rebuild Haskell dependencies in Gentoo"; - license = lib.licensesSpdx."GPL-3.0-or-later"; + license = lib.meta.getLicenseFromSpdxId "GPL-3.0-or-later"; mainProgram = "haskell-updater"; } ) { }; @@ -313891,7 +313891,7 @@ self: { base ]; description = "Haskell 2020[draft] Standard Library"; - license = lib.licensesSpdx."BSD-3-Clause"; + license = lib.meta.getLicenseFromSpdxId "BSD-3-Clause"; hydraPlatforms = lib.platforms.none; broken = true; } @@ -315324,7 +315324,7 @@ self: { vector ]; description = "embedded DSL for defining epidemiologic cohorts"; - license = lib.licensesSpdx."BSD-3-Clause"; + license = lib.meta.getLicenseFromSpdxId "BSD-3-Clause"; hydraPlatforms = lib.platforms.none; } ) { }; @@ -316979,7 +316979,7 @@ self: { weigh ]; description = "Haskell bindings to libtorch, supporting both typed and untyped tensors"; - license = lib.licensesSpdx."BSD-3-Clause"; + license = lib.meta.getLicenseFromSpdxId "BSD-3-Clause"; } ) { }; @@ -317034,7 +317034,7 @@ self: { ]; testToolDepends = [ hspec-discover ]; description = "Code generation tools for Hasktorch"; - license = lib.licensesSpdx."BSD-3-Clause"; + license = lib.meta.getLicenseFromSpdxId "BSD-3-Clause"; hydraPlatforms = lib.platforms.none; mainProgram = "ht-codegen"; broken = true; @@ -317064,7 +317064,7 @@ self: { text ]; description = "Testing library for Hasktorch's FFI bindings"; - license = lib.licensesSpdx."BSD-3-Clause"; + license = lib.meta.getLicenseFromSpdxId "BSD-3-Clause"; } ) { }; @@ -317102,7 +317102,7 @@ self: { text ]; description = "Bindings to Torch"; - license = lib.licensesSpdx."BSD-3-Clause"; + license = lib.meta.getLicenseFromSpdxId "BSD-3-Clause"; hydraPlatforms = lib.platforms.none; broken = true; } @@ -317147,7 +317147,7 @@ self: { text ]; description = "Bindings to Cutorch"; - license = lib.licensesSpdx."BSD-3-Clause"; + license = lib.meta.getLicenseFromSpdxId "BSD-3-Clause"; hydraPlatforms = lib.platforms.none; } ) { ATen = null; }; @@ -317216,7 +317216,7 @@ self: { ]; doHaddock = false; description = "Core Hasktorch abstractions wrapping FFI bindings"; - license = lib.licensesSpdx."BSD-3-Clause"; + license = lib.meta.getLicenseFromSpdxId "BSD-3-Clause"; hydraPlatforms = lib.platforms.none; } ) { }; @@ -317256,7 +317256,7 @@ self: { ]; doHaddock = false; description = "Backpack signatures for Tensor operations"; - license = lib.licensesSpdx."BSD-3-Clause"; + license = lib.meta.getLicenseFromSpdxId "BSD-3-Clause"; hydraPlatforms = lib.platforms.none; } ) { }; @@ -317278,7 +317278,7 @@ self: { hasktorch-types-th ]; description = "Functions to partially satisfy tensor signatures"; - license = lib.licensesSpdx."BSD-3-Clause"; + license = lib.meta.getLicenseFromSpdxId "BSD-3-Clause"; hydraPlatforms = lib.platforms.none; broken = true; } @@ -317302,7 +317302,7 @@ self: { ]; doHaddock = false; description = "Signatures for support tensors in hasktorch"; - license = lib.licensesSpdx."BSD-3-Clause"; + license = lib.meta.getLicenseFromSpdxId "BSD-3-Clause"; hydraPlatforms = lib.platforms.none; broken = true; } @@ -317326,7 +317326,7 @@ self: { ]; doHaddock = false; description = "Core types for Hasktorch backpack signatures"; - license = lib.licensesSpdx."BSD-3-Clause"; + license = lib.meta.getLicenseFromSpdxId "BSD-3-Clause"; } ) { }; @@ -317349,7 +317349,7 @@ self: { ]; libraryToolDepends = [ c2hs ]; description = "C-types for Torch"; - license = lib.licensesSpdx."BSD-3-Clause"; + license = lib.meta.getLicenseFromSpdxId "BSD-3-Clause"; } ) { }; @@ -317372,7 +317372,7 @@ self: { ]; libraryToolDepends = [ c2hs ]; description = "C-types for Cutorch"; - license = lib.licensesSpdx."BSD-3-Clause"; + license = lib.meta.getLicenseFromSpdxId "BSD-3-Clause"; } ) { }; @@ -317425,7 +317425,7 @@ self: { vector ]; description = "Neural architectures in hasktorch"; - license = lib.licensesSpdx."BSD-3-Clause"; + license = lib.meta.getLicenseFromSpdxId "BSD-3-Clause"; hydraPlatforms = lib.platforms.none; } ) { }; @@ -317482,7 +317482,7 @@ self: { criterion ]; description = "Haskus binary format manipulation"; - license = lib.licensesSpdx."BSD-3-Clause"; + license = lib.meta.getLicenseFromSpdxId "BSD-3-Clause"; hydraPlatforms = lib.platforms.none; } ) { }; @@ -317646,7 +317646,7 @@ self: { ]; testHaskellDepends = [ base ]; description = "Haskus data utility modules"; - license = lib.licensesSpdx."BSD-3-Clause"; + license = lib.meta.getLicenseFromSpdxId "BSD-3-Clause"; } ) { }; @@ -317666,7 +317666,7 @@ self: { doctest ]; description = "Haskus types utility modules"; - license = lib.licensesSpdx."BSD-3-Clause"; + license = lib.meta.getLicenseFromSpdxId "BSD-3-Clause"; } ) { }; @@ -317718,7 +317718,7 @@ self: { QuickCheck ]; description = "Variant and EADT"; - license = lib.licensesSpdx."BSD-3-Clause"; + license = lib.meta.getLicenseFromSpdxId "BSD-3-Clause"; hydraPlatforms = lib.platforms.none; broken = true; } @@ -317751,7 +317751,7 @@ self: { text ]; description = "Haskus web"; - license = lib.licensesSpdx."BSD-3-Clause"; + license = lib.meta.getLicenseFromSpdxId "BSD-3-Clause"; hydraPlatforms = lib.platforms.none; } ) { }; @@ -318063,7 +318063,7 @@ self: { vector-sized ]; description = "A monad for interfacing with external SMT solvers"; - license = lib.licensesSpdx."GPL-3.0-only"; + license = lib.meta.getLicenseFromSpdxId "GPL-3.0-only"; } ) { }; @@ -318244,7 +318244,7 @@ self: { ]; doHaddock = false; description = "An efficient PostgreSQL driver with a flexible mapping API"; - license = lib.licensesSpdx."MIT"; + license = lib.meta.getLicenseFromSpdxId "MIT"; hydraPlatforms = lib.platforms.none; } ) { }; @@ -318332,7 +318332,7 @@ self: { ]; doHaddock = false; description = "Fast PostgreSQL driver with a flexible mapping API"; - license = lib.licensesSpdx."MIT"; + license = lib.meta.getLicenseFromSpdxId "MIT"; } ) { }; @@ -318434,7 +318434,7 @@ self: { rerebase ]; description = "Fast PostgreSQL driver with a flexible mapping API"; - license = lib.licensesSpdx."MIT"; + license = lib.meta.getLicenseFromSpdxId "MIT"; hydraPlatforms = lib.platforms.none; } ) { }; @@ -318567,7 +318567,7 @@ self: { tasty-hunit ]; description = "A declarative abstraction over PostgreSQL Cursor"; - license = lib.licensesSpdx."MIT"; + license = lib.meta.getLicenseFromSpdxId "MIT"; hydraPlatforms = lib.platforms.none; broken = true; } @@ -318600,7 +318600,7 @@ self: { transformers ]; description = "An abstraction for simultaneous fetching from multiple PostgreSQL cursors"; - license = lib.licensesSpdx."MIT"; + license = lib.meta.getLicenseFromSpdxId "MIT"; hydraPlatforms = lib.platforms.none; broken = true; } @@ -318681,7 +318681,7 @@ self: { tasty-hunit ]; description = "Toolkit for constructing Hasql statements dynamically"; - license = lib.licensesSpdx."MIT"; + license = lib.meta.getLicenseFromSpdxId "MIT"; } ) { }; @@ -318721,7 +318721,7 @@ self: { ]; testToolDepends = [ hspec-discover ]; description = "Hasql extension for dynamic construction of statements"; - license = lib.licensesSpdx."MIT"; + license = lib.meta.getLicenseFromSpdxId "MIT"; hydraPlatforms = lib.platforms.none; } ) { }; @@ -318760,7 +318760,7 @@ self: { ]; testHaskellDepends = [ base ]; description = "Effectful bindings for hasql"; - license = lib.licensesSpdx."MIT"; + license = lib.meta.getLicenseFromSpdxId "MIT"; hydraPlatforms = lib.platforms.none; mainProgram = "hasql-effectful-example"; broken = true; @@ -318800,7 +318800,7 @@ self: { tasty-hunit ]; description = "Hasql queries testing interface"; - license = lib.licensesSpdx."MPL-2.0"; + license = lib.meta.getLicenseFromSpdxId "MPL-2.0"; hydraPlatforms = lib.platforms.none; broken = true; } @@ -318852,7 +318852,7 @@ self: { uuid ]; description = "Compile-time PostgreSQL data generation for hasql"; - license = lib.licensesSpdx."MIT"; + license = lib.meta.getLicenseFromSpdxId "MIT"; hydraPlatforms = lib.platforms.none; broken = true; } @@ -318936,7 +318936,7 @@ self: { vector ]; description = "Implicit definitions for Hasql, such as default codecs for standard types"; - license = lib.licensesSpdx."MIT"; + license = lib.meta.getLicenseFromSpdxId "MIT"; hydraPlatforms = lib.platforms.none; } ) { }; @@ -318974,7 +318974,7 @@ self: { vector ]; description = "Implicit definitions for Hasql, such as default codecs for standard types"; - license = lib.licensesSpdx."MIT"; + license = lib.meta.getLicenseFromSpdxId "MIT"; } ) { }; @@ -319037,7 +319037,7 @@ self: { tmp-postgres ]; description = "QuasiQuoter that supports expression interpolation for hasql"; - license = lib.licensesSpdx."BSD-3-Clause"; + license = lib.meta.getLicenseFromSpdxId "BSD-3-Clause"; } ) { }; @@ -319066,7 +319066,7 @@ self: { text ]; description = "LISTEN/NOTIFY with hasql"; - license = lib.licensesSpdx."BSD-3-Clause"; + license = lib.meta.getLicenseFromSpdxId "BSD-3-Clause"; } ) { }; @@ -319099,7 +319099,7 @@ self: { uuid ]; description = "SDK for defining modular mappings to databases on top of Hasql"; - license = lib.licensesSpdx."MIT"; + license = lib.meta.getLicenseFromSpdxId "MIT"; hydraPlatforms = lib.platforms.none; broken = true; } @@ -319191,7 +319191,7 @@ self: { transformers ]; description = "Hasql migrations library"; - license = lib.licensesSpdx."BSD-3-Clause"; + license = lib.meta.getLicenseFromSpdxId "BSD-3-Clause"; hydraPlatforms = lib.platforms.none; broken = true; } @@ -319359,7 +319359,7 @@ self: { time ]; description = "\"optparse-applicative\" parsers for \"hasql\""; - license = lib.licensesSpdx."MIT"; + license = lib.meta.getLicenseFromSpdxId "MIT"; } ) { }; @@ -319392,7 +319392,7 @@ self: { time ]; description = "\"optparse-applicative\" parsers for \"hasql\""; - license = lib.licensesSpdx."MIT"; + license = lib.meta.getLicenseFromSpdxId "MIT"; hydraPlatforms = lib.platforms.none; } ) { }; @@ -319462,7 +319462,7 @@ self: { rerebase ]; description = "Pool of connections for Hasql"; - license = lib.licensesSpdx."MIT"; + license = lib.meta.getLicenseFromSpdxId "MIT"; hydraPlatforms = lib.platforms.none; } ) { }; @@ -319511,7 +319511,7 @@ self: { ]; testToolDepends = [ hspec-discover ]; description = "Pool of connections for Hasql"; - license = lib.licensesSpdx."MIT"; + license = lib.meta.getLicenseFromSpdxId "MIT"; } ) { }; @@ -319561,7 +319561,7 @@ self: { ]; testToolDepends = [ hspec-discover ]; description = "Pool of connections for Hasql"; - license = lib.licensesSpdx."MIT"; + license = lib.meta.getLicenseFromSpdxId "MIT"; hydraPlatforms = lib.platforms.none; } ) { }; @@ -319737,7 +319737,7 @@ self: { text-builder ]; description = "Integration of \"hasql\" with \"postgresql-types\""; - license = lib.licensesSpdx."MIT"; + license = lib.meta.getLicenseFromSpdxId "MIT"; hydraPlatforms = lib.platforms.none; } ) { }; @@ -319872,7 +319872,7 @@ self: { hspec ]; description = "A pool of connections for Hasql based on resource-pool"; - license = lib.licensesSpdx."MIT"; + license = lib.meta.getLicenseFromSpdxId "MIT"; hydraPlatforms = lib.platforms.none; broken = true; } @@ -319936,7 +319936,7 @@ self: { transformers ]; description = "Stream Hasql queries with Conduit"; - license = lib.licensesSpdx."MIT"; + license = lib.meta.getLicenseFromSpdxId "MIT"; hydraPlatforms = lib.platforms.none; broken = true; } @@ -319959,7 +319959,7 @@ self: { hasql-transaction-io ]; description = "Stream Hasql queries"; - license = lib.licensesSpdx."MIT"; + license = lib.meta.getLicenseFromSpdxId "MIT"; hydraPlatforms = lib.platforms.none; } ) { }; @@ -320017,7 +320017,7 @@ self: { unliftio-core ]; description = "An example program that shows how to use Hasql streams with Rel8"; - license = lib.licensesSpdx."MIT"; + license = lib.meta.getLicenseFromSpdxId "MIT"; hydraPlatforms = lib.platforms.none; mainProgram = "hasql-streaming"; } @@ -320046,7 +320046,7 @@ self: { transformers ]; description = "Stream Hasql queries with Pipes"; - license = lib.licensesSpdx."MIT"; + license = lib.meta.getLicenseFromSpdxId "MIT"; hydraPlatforms = lib.platforms.none; broken = true; } @@ -320075,7 +320075,7 @@ self: { transformers ]; description = "Stream Hasql queries with Streaming"; - license = lib.licensesSpdx."MIT"; + license = lib.meta.getLicenseFromSpdxId "MIT"; hydraPlatforms = lib.platforms.none; broken = true; } @@ -320104,7 +320104,7 @@ self: { transformers ]; description = "Stream Hasql queries with Streamly"; - license = lib.licensesSpdx."MIT"; + license = lib.meta.getLicenseFromSpdxId "MIT"; hydraPlatforms = lib.platforms.none; broken = true; } @@ -320145,7 +320145,7 @@ self: { vector ]; description = "Template Haskell utilities for Hasql"; - license = lib.licensesSpdx."MIT"; + license = lib.meta.getLicenseFromSpdxId "MIT"; } ) { }; @@ -320182,7 +320182,7 @@ self: { vector ]; description = "Template Haskell utilities for Hasql"; - license = lib.licensesSpdx."MIT"; + license = lib.meta.getLicenseFromSpdxId "MIT"; hydraPlatforms = lib.platforms.none; } ) { }; @@ -320259,7 +320259,7 @@ self: { rerebase ]; description = "Composable abstraction over retryable transactions for Hasql"; - license = lib.licensesSpdx."MIT"; + license = lib.meta.getLicenseFromSpdxId "MIT"; } ) { }; @@ -320297,7 +320297,7 @@ self: { rerebase ]; description = "Composable abstraction over retryable transactions for Hasql"; - license = lib.licensesSpdx."MIT"; + license = lib.meta.getLicenseFromSpdxId "MIT"; hydraPlatforms = lib.platforms.none; } ) { }; @@ -320333,7 +320333,7 @@ self: { unliftio-core ]; description = "Perform IO actions during transactions for Hasql"; - license = lib.licensesSpdx."MIT"; + license = lib.meta.getLicenseFromSpdxId "MIT"; hydraPlatforms = lib.platforms.none; broken = true; } @@ -320368,7 +320368,7 @@ self: { tasty-quickcheck ]; description = "Parse PostgreSQL connection URI into Hasql.Connection Settings"; - license = lib.licensesSpdx."MIT"; + license = lib.meta.getLicenseFromSpdxId "MIT"; hydraPlatforms = lib.platforms.none; broken = true; } @@ -321116,7 +321116,7 @@ self: { isExecutable = true; executableHaskellDepends = [ base ]; description = "Manipulates network blocks in CIDR notation"; - license = lib.licensesSpdx."AGPL-3.0-or-later"; + license = lib.meta.getLicenseFromSpdxId "AGPL-3.0-or-later"; mainProgram = "hath"; } ) { }; @@ -321288,7 +321288,7 @@ self: { text ]; description = "Library for checking for weak/compromised passwords"; - license = lib.licensesSpdx."BSD-3-Clause"; + license = lib.meta.getLicenseFromSpdxId "BSD-3-Clause"; mainProgram = "readme"; } ) { }; @@ -321982,7 +321982,7 @@ self: { mmap ]; description = "A command line tool to compute BLAKE3 hashes"; - license = lib.licensesSpdx."AGPL-3.0-only"; + license = lib.meta.getLicenseFromSpdxId "AGPL-3.0-only"; platforms = lib.platforms.x86; mainProgram = "hb3sum"; } @@ -322451,7 +322451,7 @@ self: { hspec ]; description = "Blosc (numerical compression library) bindings for Haskell"; - license = lib.licensesSpdx."MIT"; + license = lib.meta.getLicenseFromSpdxId "MIT"; } ) { }; @@ -322781,7 +322781,7 @@ self: { witherable ]; description = "2d Delaunay triangulation"; - license = lib.licensesSpdx."BSD-3-Clause"; + license = lib.meta.getLicenseFromSpdxId "BSD-3-Clause"; } ) { }; @@ -323288,7 +323288,7 @@ self: { string-interpolate ]; description = "Haskell artifact name counts"; - license = lib.licensesSpdx."BSD-3-Clause"; + license = lib.meta.getLicenseFromSpdxId "BSD-3-Clause"; hydraPlatforms = lib.platforms.none; mainProgram = "hcount"; broken = true; @@ -324641,7 +324641,7 @@ self: { selective ]; description = "More informative parser"; - license = lib.licensesSpdx."MIT"; + license = lib.meta.getLicenseFromSpdxId "MIT"; } ) { }; @@ -324771,7 +324771,7 @@ self: { ]; testToolDepends = [ hspec-discover ]; description = "License Header Manager"; - license = lib.licensesSpdx."BSD-3-Clause"; + license = lib.meta.getLicenseFromSpdxId "BSD-3-Clause"; mainProgram = "headroom"; } ) { }; @@ -324832,7 +324832,7 @@ self: { ]; testToolDepends = [ hspec-discover ]; description = "interactively inspect Haskell values at runtime"; - license = lib.licensesSpdx."BSD-3-Clause"; + license = lib.meta.getLicenseFromSpdxId "BSD-3-Clause"; hydraPlatforms = lib.platforms.none; broken = true; } @@ -325421,7 +325421,7 @@ self: { sha256 = "00lnlv0hwlsq5y5r0b2y0v18l7kcwbfn8w5gnphrw3rihdp70ik8"; libraryHaskellDepends = [ base ]; description = "Abstract unit test interface"; - license = lib.licensesSpdx."0BSD"; + license = lib.meta.getLicenseFromSpdxId "0BSD"; } ) { }; @@ -325571,7 +325571,7 @@ self: { microlens ]; description = "Reddit API bindings"; - license = lib.licensesSpdx."BSD-3-Clause"; + license = lib.meta.getLicenseFromSpdxId "BSD-3-Clause"; hydraPlatforms = lib.platforms.none; broken = true; } @@ -325847,7 +325847,7 @@ self: { vector ]; description = "Hedgehog will eat your typeclass bugs"; - license = lib.licensesSpdx."BSD-3-Clause"; + license = lib.meta.getLicenseFromSpdxId "BSD-3-Clause"; } ) { }; @@ -325959,7 +325959,7 @@ self: { ]; testToolDepends = [ tasty-discover ]; description = "Supplemental library for hedgehog"; - license = lib.licensesSpdx."Apache-2.0"; + license = lib.meta.getLicenseFromSpdxId "Apache-2.0"; hydraPlatforms = lib.platforms.none; broken = true; } @@ -326045,7 +326045,7 @@ self: { typerep-map ]; description = "Customizable Gen for ADT using Generics"; - license = lib.licensesSpdx."BSD-3-Clause"; + license = lib.meta.getLicenseFromSpdxId "BSD-3-Clause"; hydraPlatforms = lib.platforms.none; broken = true; } @@ -326138,7 +326138,7 @@ self: { hedgehog ]; description = "GHC Generics automatically derived hedgehog generators"; - license = lib.licensesSpdx."BSD-3-Clause"; + license = lib.meta.getLicenseFromSpdxId "BSD-3-Clause"; hydraPlatforms = lib.platforms.none; broken = true; } @@ -326180,7 +326180,7 @@ self: { hedgehog ]; description = "Golden testing capabilities for hedgehog using Aeson"; - license = lib.licensesSpdx."BSD-3-Clause"; + license = lib.meta.getLicenseFromSpdxId "BSD-3-Clause"; hydraPlatforms = lib.platforms.none; broken = true; } @@ -326203,7 +326203,7 @@ self: { lens ]; description = "Hedgehog properties for lens laws"; - license = lib.licensesSpdx."MIT"; + license = lib.meta.getLicenseFromSpdxId "MIT"; hydraPlatforms = lib.platforms.none; broken = true; } @@ -326226,7 +326226,7 @@ self: { optics-core ]; description = "Hedgehog properties for optics laws"; - license = lib.licensesSpdx."MIT"; + license = lib.meta.getLicenseFromSpdxId "MIT"; hydraPlatforms = lib.platforms.none; broken = true; } @@ -326348,7 +326348,7 @@ self: { ]; testToolDepends = [ hspec-discover ]; description = "Utilities for Hedgehog"; - license = lib.licensesSpdx."MIT"; + license = lib.meta.getLicenseFromSpdxId "MIT"; } ) { }; @@ -326481,7 +326481,7 @@ self: { hedis ]; description = "Adaptation of the hedis library for the effectful ecosystem"; - license = lib.licensesSpdx."BSD-3-Clause"; + license = lib.meta.getLicenseFromSpdxId "BSD-3-Clause"; } ) { }; @@ -326505,7 +326505,7 @@ self: { scientific time ]; - license = lib.licensesSpdx."BSD-3-Clause"; + license = lib.meta.getLicenseFromSpdxId "BSD-3-Clause"; } ) { }; @@ -326831,7 +326831,7 @@ self: { ]; testToolDepends = [ tasty-discover ]; description = "higher-order algebraic effects done right"; - license = lib.licensesSpdx."MPL-2.0"; + license = lib.meta.getLicenseFromSpdxId "MPL-2.0"; } ) { }; @@ -326933,7 +326933,7 @@ self: { unliftio ]; description = "higher-order algebraic effects done right"; - license = lib.licensesSpdx."MPL-2.0"; + license = lib.meta.getLicenseFromSpdxId "MPL-2.0"; } ) { }; @@ -326975,7 +326975,7 @@ self: { tasty-quickcheck ]; description = "Fast equality saturation in Haskell"; - license = lib.licensesSpdx."BSD-3-Clause"; + license = lib.meta.getLicenseFromSpdxId "BSD-3-Clause"; hydraPlatforms = lib.platforms.none; broken = true; } @@ -327224,7 +327224,7 @@ self: { xmlhtml ]; description = "An Haskell template system supporting both HTML5 and XML"; - license = lib.licensesSpdx."BSD-3-Clause"; + license = lib.meta.getLicenseFromSpdxId "BSD-3-Clause"; } ) { }; @@ -327468,7 +327468,7 @@ self: { xmlhtml ]; description = "Extra heist functionality"; - license = lib.licensesSpdx."MIT"; + license = lib.meta.getLicenseFromSpdxId "MIT"; } ) { }; @@ -327615,7 +327615,7 @@ self: { zeugma ]; description = "Clipboard Manager"; - license = lib.licensesSpdx."BSD-2-Clause-Patent"; + license = lib.meta.getLicenseFromSpdxId "BSD-2-Clause-Patent"; hydraPlatforms = lib.platforms.none; mainProgram = "hel"; } @@ -328476,7 +328476,7 @@ self: { ]; doHaddock = false; description = "GHC plugin to enforce user specified rules on code"; - license = lib.licensesSpdx."MIT"; + license = lib.meta.getLicenseFromSpdxId "MIT"; hydraPlatforms = lib.platforms.none; broken = true; } @@ -328557,7 +328557,7 @@ self: { ]; testToolDepends = [ tasty-discover ]; description = "Generically derive Storable instances suitable for CPU-GPU transfer"; - license = lib.licensesSpdx."BSD-3-Clause"; + license = lib.meta.getLicenseFromSpdxId "BSD-3-Clause"; } ) { }; @@ -328614,7 +328614,7 @@ self: { vector ]; description = "Really fast mutable sparse sets"; - license = lib.licensesSpdx."BSD-3-Clause"; + license = lib.meta.getLicenseFromSpdxId "BSD-3-Clause"; } ) { }; @@ -328655,7 +328655,7 @@ self: { uuid ]; description = "Generate UUIDv7 values"; - license = lib.licensesSpdx."MIT"; + license = lib.meta.getLicenseFromSpdxId "MIT"; } ) { }; @@ -328740,7 +328740,7 @@ self: { QuickCheck ]; description = "Accessible format for structured data serialization"; - license = lib.licensesSpdx."BSD-2-Clause"; + license = lib.meta.getLicenseFromSpdxId "BSD-2-Clause"; mainProgram = "herb-format"; } ) { }; @@ -329033,7 +329033,7 @@ self: { ]; testToolDepends = [ hspec-discover ]; description = "Runs Continuous Integration tasks on your machines"; - license = lib.licensesSpdx."Apache-2.0"; + license = lib.meta.getLicenseFromSpdxId "Apache-2.0"; maintainers = [ lib.maintainers.roberth ]; } ) @@ -329165,7 +329165,7 @@ self: { vector ]; description = "Hercules CI API definition with Servant"; - license = lib.licensesSpdx."Apache-2.0"; + license = lib.meta.getLicenseFromSpdxId "Apache-2.0"; mainProgram = "hercules-gen-swagger"; maintainers = [ lib.maintainers.roberth ]; } @@ -329556,7 +329556,7 @@ self: { ]; testToolDepends = [ hspec-discover ]; description = "Bindings for the Nix evaluator"; - license = lib.licensesSpdx."Apache-2.0"; + license = lib.meta.getLicenseFromSpdxId "Apache-2.0"; maintainers = [ lib.maintainers.roberth ]; } ) @@ -329629,7 +329629,7 @@ self: { ]; testToolDepends = [ hspec-discover ]; description = "Haskell bindings for Nix's libstore"; - license = lib.licensesSpdx."Apache-2.0"; + license = lib.meta.getLicenseFromSpdxId "Apache-2.0"; maintainers = [ lib.maintainers.roberth ]; } ) @@ -329752,7 +329752,7 @@ self: { text ]; description = "Heredocument on Haskell"; - license = lib.licensesSpdx."BSD-3-Clause"; + license = lib.meta.getLicenseFromSpdxId "BSD-3-Clause"; } ) { }; @@ -329840,7 +329840,7 @@ self: { vector ]; description = "Fast JSON decoding via simdjson C++ bindings"; - license = lib.licensesSpdx."MIT"; + license = lib.meta.getLicenseFromSpdxId "MIT"; } ) { }; @@ -330435,7 +330435,7 @@ self: { infinite-list ]; description = "Zip lists with Traversables"; - license = lib.licensesSpdx."BSD-3-Clause"; + license = lib.meta.getLicenseFromSpdxId "BSD-3-Clause"; } ) { }; @@ -330508,7 +330508,7 @@ self: { stm ]; description = "Comparison of distinctly typed values with evidence capture"; - license = lib.licensesSpdx."BSD-3-Clause"; + license = lib.meta.getLicenseFromSpdxId "BSD-3-Clause"; } ) { }; @@ -330880,7 +330880,7 @@ self: { ]; doHaddock = false; description = "Symbolic EVM Evaluator"; - license = lib.licensesSpdx."AGPL-3.0-only"; + license = lib.meta.getLicenseFromSpdxId "AGPL-3.0-only"; mainProgram = "hevm"; maintainers = [ lib.maintainers.arturcygan ]; } @@ -331001,7 +331001,7 @@ self: { text ]; description = "ByteString-Text hexidecimal conversions"; - license = lib.licensesSpdx."MIT"; + license = lib.meta.getLicenseFromSpdxId "MIT"; } ) { }; @@ -331166,7 +331166,7 @@ self: { wreq ]; description = "Lenses for the hexml package"; - license = lib.licensesSpdx."BSD-3-Clause"; + license = lib.meta.getLicenseFromSpdxId "BSD-3-Clause"; hydraPlatforms = lib.platforms.none; broken = true; } @@ -331667,7 +331667,7 @@ self: { text ]; description = "Streaming-friendly XML parsers"; - license = lib.licensesSpdx."CC0-1.0"; + license = lib.meta.getLicenseFromSpdxId "CC0-1.0"; hydraPlatforms = lib.platforms.none; broken = true; } @@ -332231,7 +332231,7 @@ self: { text ]; description = "File/folder watching for OS X"; - license = lib.licensesSpdx."BSD-3-Clause"; + license = lib.meta.getLicenseFromSpdxId "BSD-3-Clause"; platforms = lib.platforms.darwin; } ) { }; @@ -332388,7 +332388,7 @@ self: { ]; libraryPkgconfigDepends = [ gdal ]; description = "Haskell binding to the GDAL library"; - license = lib.licensesSpdx."BSD-3-Clause"; + license = lib.meta.getLicenseFromSpdxId "BSD-3-Clause"; } ) { inherit (pkgs) gdal; }; @@ -332638,7 +332638,7 @@ self: { vinyl ]; description = "Geometric Algorithms, Data structures, and Data types"; - license = lib.licensesSpdx."BSD-3-Clause"; + license = lib.meta.getLicenseFromSpdxId "BSD-3-Clause"; hydraPlatforms = lib.platforms.none; } ) { }; @@ -332869,7 +332869,7 @@ self: { ]; testToolDepends = [ hspec-discover ]; description = "Reading and Writing ipe7 files"; - license = lib.licensesSpdx."BSD-3-Clause"; + license = lib.meta.getLicenseFromSpdxId "BSD-3-Clause"; hydraPlatforms = lib.platforms.none; } ) { }; @@ -333292,7 +333292,7 @@ self: { network ]; description = "Haskell module to interact with the greetd daemon trough it's IPC protocol"; - license = lib.licensesSpdx."GPL-3.0-or-later"; + license = lib.meta.getLicenseFromSpdxId "GPL-3.0-or-later"; hydraPlatforms = lib.platforms.none; broken = true; } @@ -334116,7 +334116,7 @@ self: { yaml ]; description = "Set up a GHC API session"; - license = lib.licensesSpdx."BSD-3-Clause"; + license = lib.meta.getLicenseFromSpdxId "BSD-3-Clause"; mainProgram = "hie-bios"; } ) { }; @@ -334211,7 +334211,7 @@ self: { yaml ]; description = "Set up a GHC API session"; - license = lib.licensesSpdx."BSD-3-Clause"; + license = lib.meta.getLicenseFromSpdxId "BSD-3-Clause"; hydraPlatforms = lib.platforms.none; mainProgram = "hie-bios"; } @@ -334438,7 +334438,7 @@ self: { temporary ]; description = "Generates a references DB from .hie files"; - license = lib.licensesSpdx."BSD-3-Clause"; + license = lib.meta.getLicenseFromSpdxId "BSD-3-Clause"; mainProgram = "hiedb"; } ) { }; @@ -334508,7 +334508,7 @@ self: { temporary ]; description = "Generates a references DB from .hie files"; - license = lib.licensesSpdx."BSD-3-Clause"; + license = lib.meta.getLicenseFromSpdxId "BSD-3-Clause"; hydraPlatforms = lib.platforms.none; mainProgram = "hiedb"; } @@ -334676,7 +334676,7 @@ self: { ]; testToolDepends = [ hspec-discover ]; description = "hierarchical environments for dependency injection"; - license = lib.licensesSpdx."BSD-3-Clause"; + license = lib.meta.getLicenseFromSpdxId "BSD-3-Clause"; hydraPlatforms = lib.platforms.none; } ) { }; @@ -334965,7 +334965,7 @@ self: { ]; testToolDepends = [ markdown-unlit ]; description = "Partial types as a type constructor"; - license = lib.licensesSpdx."MIT"; + license = lib.meta.getLicenseFromSpdxId "MIT"; hydraPlatforms = lib.platforms.none; broken = true; } @@ -335075,7 +335075,7 @@ self: { ftcqueue ]; description = "This package is used by package yaftee"; - license = lib.licensesSpdx."BSD-3-Clause"; + license = lib.meta.getLicenseFromSpdxId "BSD-3-Clause"; } ) { }; @@ -335098,7 +335098,7 @@ self: { freer-base-classes ]; description = "This package is used by package yaftee"; - license = lib.licensesSpdx."BSD-3-Clause"; + license = lib.meta.getLicenseFromSpdxId "BSD-3-Clause"; } ) { }; @@ -335538,7 +335538,7 @@ self: { utility-ht ]; description = "Linear Programming using HiGHS and comfort-array"; - license = lib.licensesSpdx."BSD-3-Clause"; + license = lib.meta.getLicenseFromSpdxId "BSD-3-Clause"; } ) { inherit (pkgs) highs; }; @@ -335577,7 +335577,7 @@ self: { text ]; description = "Haskell wrapper for Pikchr, a PIC-like markup language for diagrams"; - license = lib.licensesSpdx."BSD-3-Clause"; + license = lib.meta.getLicenseFromSpdxId "BSD-3-Clause"; hydraPlatforms = lib.platforms.none; mainProgram = "hikchr"; broken = true; @@ -335717,7 +335717,7 @@ self: { ]; testToolDepends = [ hlint ]; description = "A standard library for Haskell as an alternative to rio"; - license = lib.licensesSpdx."Apache-2.0"; + license = lib.meta.getLicenseFromSpdxId "Apache-2.0"; hydraPlatforms = lib.platforms.none; broken = true; } @@ -336330,7 +336330,7 @@ self: { quickcheck-text ]; description = "Generic project initialization tool"; - license = lib.licensesSpdx."BSD-3-Clause"; + license = lib.meta.getLicenseFromSpdxId "BSD-3-Clause"; mainProgram = "hi"; maintainers = [ lib.maintainers.poscat ]; } @@ -336613,7 +336613,7 @@ self: { relude ]; description = "Helper for using hint with Nix package databases"; - license = lib.licensesSpdx."AGPL-3.0-or-later"; + license = lib.meta.getLicenseFromSpdxId "AGPL-3.0-or-later"; hydraPlatforms = lib.platforms.none; broken = true; } @@ -337835,7 +337835,7 @@ self: { text ]; description = "Haskell Git Helper Tool"; - license = lib.licensesSpdx."MPL-2.0"; + license = lib.meta.getLicenseFromSpdxId "MPL-2.0"; hydraPlatforms = lib.platforms.none; mainProgram = "hit"; broken = true; @@ -337951,7 +337951,7 @@ self: { ]; doHaddock = false; description = "Haskell/Nix development build tools"; - license = lib.licensesSpdx."BSD-2-Clause-Patent"; + license = lib.meta.getLicenseFromSpdxId "BSD-2-Clause-Patent"; hydraPlatforms = lib.platforms.none; mainProgram = "hix"; broken = true; @@ -339070,7 +339070,7 @@ self: { wizards ]; description = "Command-line interface for the hledger accounting system"; - license = lib.licensesSpdx."GPL-3.0-or-later"; + license = lib.meta.getLicenseFromSpdxId "GPL-3.0-or-later"; mainProgram = "hledger"; maintainers = [ lib.maintainers.maralorn @@ -339603,7 +339603,7 @@ self: { utf8-string ]; description = "A library providing the core functionality of hledger"; - license = lib.licensesSpdx."GPL-3.0-or-later"; + license = lib.meta.getLicenseFromSpdxId "GPL-3.0-or-later"; } ) { }; @@ -339807,7 +339807,7 @@ self: { ]; executableHaskellDepends = [ base ]; description = "Terminal interface for the hledger accounting system"; - license = lib.licensesSpdx."GPL-3.0-or-later"; + license = lib.meta.getLicenseFromSpdxId "GPL-3.0-or-later"; mainProgram = "hledger-ui"; maintainers = [ lib.maintainers.maralorn ]; } @@ -339962,7 +339962,7 @@ self: { executableHaskellDepends = [ base ]; testHaskellDepends = [ base ]; description = "Web user interface for the hledger accounting system"; - license = lib.licensesSpdx."GPL-3.0-or-later"; + license = lib.meta.getLicenseFromSpdxId "GPL-3.0-or-later"; mainProgram = "hledger-web"; maintainers = [ lib.maintainers.maralorn ]; } @@ -340384,7 +340384,7 @@ self: { containers ]; description = "GHC plugin for hlint"; - license = lib.licensesSpdx."BSD-3-Clause"; + license = lib.meta.getLicenseFromSpdxId "BSD-3-Clause"; hydraPlatforms = lib.platforms.none; broken = true; } @@ -340690,7 +340690,7 @@ self: { text ]; description = "Provide Alternate Number Formats plugin for Haskell Language Server"; - license = lib.licensesSpdx."Apache-2.0"; + license = lib.meta.getLicenseFromSpdxId "Apache-2.0"; hydraPlatforms = lib.platforms.none; broken = true; } @@ -340703,7 +340703,7 @@ self: { version = "1.1.0.0"; sha256 = "11hnkbpg13zvnq69svm46zm5k55yshgz97kjjx1g3jcb9ah1brm1"; description = "Integration with the Brittany code formatter"; - license = lib.licensesSpdx."AGPL-3.0-only"; + license = lib.meta.getLicenseFromSpdxId "AGPL-3.0-only"; } ) { }; @@ -340747,7 +340747,7 @@ self: { hls-test-utils ]; description = "Integration with the cabal-fmt code formatter"; - license = lib.licensesSpdx."Apache-2.0"; + license = lib.meta.getLicenseFromSpdxId "Apache-2.0"; hydraPlatforms = lib.platforms.none; broken = true; } @@ -340826,7 +340826,7 @@ self: { transformers ]; description = "Cabal integration plugin with Haskell Language Server"; - license = lib.licensesSpdx."MIT"; + license = lib.meta.getLicenseFromSpdxId "MIT"; hydraPlatforms = lib.platforms.none; broken = true; } @@ -340884,7 +340884,7 @@ self: { text ]; description = "Call hierarchy plugin for Haskell Language Server"; - license = lib.licensesSpdx."Apache-2.0"; + license = lib.meta.getLicenseFromSpdxId "Apache-2.0"; hydraPlatforms = lib.platforms.none; } ) { }; @@ -340933,7 +340933,7 @@ self: { text ]; description = "Change a declarations type signature with a Code Action"; - license = lib.licensesSpdx."Apache-2.0"; + license = lib.meta.getLicenseFromSpdxId "Apache-2.0"; hydraPlatforms = lib.platforms.none; broken = true; } @@ -340946,7 +340946,7 @@ self: { version = "2.6.0.0"; sha256 = "0jib2y256fb5b8wgsi9rjsdb3ywwpcbcnbbxmg6q3gwnglrdb1lx"; description = "Class/instance management plugin for Haskell Language Server"; - license = lib.licensesSpdx."Apache-2.0"; + license = lib.meta.getLicenseFromSpdxId "Apache-2.0"; } ) { }; @@ -341012,7 +341012,7 @@ self: { vector ]; description = "HLS Plugin to support smart selection range and Folding range"; - license = lib.licensesSpdx."Apache-2.0"; + license = lib.meta.getLicenseFromSpdxId "Apache-2.0"; hydraPlatforms = lib.platforms.none; broken = true; } @@ -341109,7 +341109,7 @@ self: { text ]; description = "Eval plugin for Haskell Language Server"; - license = lib.licensesSpdx."Apache-2.0"; + license = lib.meta.getLicenseFromSpdxId "Apache-2.0"; hydraPlatforms = lib.platforms.none; broken = true; } @@ -341148,7 +341148,7 @@ self: { transformers ]; description = "Common utilities to interaction between ghc-exactprint and HLS plugins"; - license = lib.licensesSpdx."Apache-2.0"; + license = lib.meta.getLicenseFromSpdxId "Apache-2.0"; hydraPlatforms = lib.platforms.none; } ) { }; @@ -341194,7 +341194,7 @@ self: { text ]; description = "Show fixity explicitly while hovering"; - license = lib.licensesSpdx."Apache-2.0"; + license = lib.meta.getLicenseFromSpdxId "Apache-2.0"; hydraPlatforms = lib.platforms.none; broken = true; } @@ -341254,7 +341254,7 @@ self: { text ]; description = "Explicit imports plugin for Haskell Language Server"; - license = lib.licensesSpdx."Apache-2.0"; + license = lib.meta.getLicenseFromSpdxId "Apache-2.0"; hydraPlatforms = lib.platforms.none; broken = true; } @@ -341309,7 +341309,7 @@ self: { text ]; description = "Explicit record fields plugin for Haskell Language Server"; - license = lib.licensesSpdx."BSD-3-Clause"; + license = lib.meta.getLicenseFromSpdxId "BSD-3-Clause"; hydraPlatforms = lib.platforms.none; broken = true; } @@ -341322,7 +341322,7 @@ self: { version = "2.6.0.0"; sha256 = "1wyk88lynchhzriqj7m9ph0s2c2ivkqg1nmhgb1knkvp8ag27iik"; description = "Integration with the Floskell code formatter"; - license = lib.licensesSpdx."Apache-2.0"; + license = lib.meta.getLicenseFromSpdxId "Apache-2.0"; } ) { }; @@ -341377,7 +341377,7 @@ self: { ]; testToolDepends = [ fourmolu ]; description = "Integration with the Fourmolu code formatter"; - license = lib.licensesSpdx."Apache-2.0"; + license = lib.meta.getLicenseFromSpdxId "Apache-2.0"; hydraPlatforms = lib.platforms.none; broken = true; } @@ -341390,7 +341390,7 @@ self: { version = "2.6.0.0"; sha256 = "0aa602m024s3ch23np2iixmkwv6474va20bjdgiwdgc8vahg4grg"; description = "Convert to GADT syntax plugin"; - license = lib.licensesSpdx."Apache-2.0"; + license = lib.meta.getLicenseFromSpdxId "Apache-2.0"; } ) { }; @@ -341468,7 +341468,7 @@ self: { ]; testToolDepends = [ hspec-discover ]; description = "Haskell Language Server internal graph API"; - license = lib.licensesSpdx."Apache-2.0"; + license = lib.meta.getLicenseFromSpdxId "Apache-2.0"; } ) { }; @@ -341479,7 +341479,7 @@ self: { version = "2.2.0.0"; sha256 = "0wp8hk5hwl43z5mjcas332z92y3zv9g8wrc5zhzli8pa37ab6r8x"; description = "Haddock comments plugin for Haskell Language Server"; - license = lib.licensesSpdx."Apache-2.0"; + license = lib.meta.getLicenseFromSpdxId "Apache-2.0"; } ) { }; @@ -341490,7 +341490,7 @@ self: { version = "2.6.0.0"; sha256 = "0ix89wp8nq3iywh6d3w8j7lnfm2g3l9gks8sxkww0z0mfhfxvywc"; description = "Hlint integration plugin with Haskell Language Server"; - license = lib.licensesSpdx."Apache-2.0"; + license = lib.meta.getLicenseFromSpdxId "Apache-2.0"; } ) { }; @@ -341533,7 +341533,7 @@ self: { hls-test-utils ]; description = "Module name plugin for Haskell Language Server"; - license = lib.licensesSpdx."Apache-2.0"; + license = lib.meta.getLicenseFromSpdxId "Apache-2.0"; hydraPlatforms = lib.platforms.none; broken = true; } @@ -341594,7 +341594,7 @@ self: { ]; testToolDepends = [ ormolu ]; description = "Integration with the Ormolu code formatter"; - license = lib.licensesSpdx."Apache-2.0"; + license = lib.meta.getLicenseFromSpdxId "Apache-2.0"; hydraPlatforms = lib.platforms.none; broken = true; } @@ -341656,7 +341656,7 @@ self: { text ]; description = "Overloaded record dot plugin for Haskell Language Server"; - license = lib.licensesSpdx."BSD-3-Clause"; + license = lib.meta.getLicenseFromSpdxId "BSD-3-Clause"; hydraPlatforms = lib.platforms.none; broken = true; } @@ -341769,7 +341769,7 @@ self: { random-fu ]; description = "Haskell Language Server API for plugin communication"; - license = lib.licensesSpdx."Apache-2.0"; + license = lib.meta.getLicenseFromSpdxId "Apache-2.0"; } ) { }; @@ -341821,7 +341821,7 @@ self: { text ]; description = "Pragmas plugin for Haskell Language Server"; - license = lib.licensesSpdx."Apache-2.0"; + license = lib.meta.getLicenseFromSpdxId "Apache-2.0"; hydraPlatforms = lib.platforms.none; broken = true; } @@ -341874,7 +341874,7 @@ self: { text ]; description = "A Haskell Language Server plugin that qualifies imported names"; - license = lib.licensesSpdx."Apache-2.0"; + license = lib.meta.getLicenseFromSpdxId "Apache-2.0"; hydraPlatforms = lib.platforms.none; broken = true; } @@ -341887,7 +341887,7 @@ self: { version = "2.6.0.0"; sha256 = "0lqy7c3vqn832gs9z86n4clsqb6g73rhnlrvn3sg3h8hkxasfzjf"; description = "Exactprint refactorings for Haskell Language Server"; - license = lib.licensesSpdx."Apache-2.0"; + license = lib.meta.getLicenseFromSpdxId "Apache-2.0"; } ) { }; @@ -341934,7 +341934,7 @@ self: { text ]; description = "Refine imports plugin for Haskell Language Server"; - license = lib.licensesSpdx."Apache-2.0"; + license = lib.meta.getLicenseFromSpdxId "Apache-2.0"; hydraPlatforms = lib.platforms.none; broken = true; } @@ -341947,7 +341947,7 @@ self: { version = "2.6.0.0"; sha256 = "15gjh7r9cc43yz1zp52q349fag4nxv25vhzn5pdma4ch366xyr4g"; description = "Rename plugin for Haskell Language Server"; - license = lib.licensesSpdx."Apache-2.0"; + license = lib.meta.getLicenseFromSpdxId "Apache-2.0"; } ) { }; @@ -341958,7 +341958,7 @@ self: { version = "2.6.0.0"; sha256 = "11cl4q79jxl73s62ccdarp1570k95picgn3q8lgnqznc6ywdv3zh"; description = "Retrie integration plugin for Haskell Language Server"; - license = lib.licensesSpdx."Apache-2.0"; + license = lib.meta.getLicenseFromSpdxId "Apache-2.0"; } ) { }; @@ -342013,7 +342013,7 @@ self: { text ]; description = "HLS Plugin to support smart selection range"; - license = lib.licensesSpdx."Apache-2.0"; + license = lib.meta.getLicenseFromSpdxId "Apache-2.0"; hydraPlatforms = lib.platforms.none; broken = true; } @@ -342098,7 +342098,7 @@ self: { text-rope ]; description = "Call hierarchy plugin for Haskell Language Server"; - license = lib.licensesSpdx."Apache-2.0"; + license = lib.meta.getLicenseFromSpdxId "Apache-2.0"; hydraPlatforms = lib.platforms.none; } ) { }; @@ -342110,7 +342110,7 @@ self: { version = "2.6.0.0"; sha256 = "00fx8rxdnmam0672vb0az2lw5inqyc22cjfrh8wiwx36i28r8zqj"; description = "HLS Plugin to expand TemplateHaskell Splices and QuasiQuotes"; - license = lib.licensesSpdx."Apache-2.0"; + license = lib.meta.getLicenseFromSpdxId "Apache-2.0"; } ) { }; @@ -342121,7 +342121,7 @@ self: { version = "2.6.0.0"; sha256 = "1zhw2ysf5ccsrz1vahff6hr683b581v4py2pyf9xfnjfay5gl0id"; description = "Stan integration plugin with Haskell Language Server"; - license = lib.licensesSpdx."Apache-2.0"; + license = lib.meta.getLicenseFromSpdxId "Apache-2.0"; } ) { }; @@ -342132,7 +342132,7 @@ self: { version = "2.6.0.0"; sha256 = "171068mmb7sdk14s5v794jc0n0mrrq8fkzp2z2wlrmk38mqi3773"; description = "Integration with the Stylish Haskell code formatter"; - license = lib.licensesSpdx."Apache-2.0"; + license = lib.meta.getLicenseFromSpdxId "Apache-2.0"; } ) { }; @@ -342143,7 +342143,7 @@ self: { version = "2.2.0.0"; sha256 = "05rgapkpr3giln245aswlcgwqpfglifsjq1n8sgwgi04bn2w6vng"; description = "Wingman plugin for Haskell Language Server"; - license = lib.licensesSpdx."Apache-2.0"; + license = lib.meta.getLicenseFromSpdxId "Apache-2.0"; } ) { }; @@ -342208,7 +342208,7 @@ self: { text-rope ]; description = "Utilities used in the tests of Haskell Language Server"; - license = lib.licensesSpdx."Apache-2.0"; + license = lib.meta.getLicenseFromSpdxId "Apache-2.0"; } ) { }; @@ -342692,7 +342692,7 @@ self: { mkDerivation, base, hmatrix, - QuadProgpp, + quadprogpp, vector, }: mkDerivation { @@ -342704,11 +342704,11 @@ self: { hmatrix vector ]; - librarySystemDepends = [ QuadProgpp ]; + librarySystemDepends = [ quadprogpp ]; description = "Bindings to the QuadProg++ quadratic programming library"; license = lib.licenses.bsd3; } - ) { inherit (pkgs) QuadProgpp; }; + ) { quadprogpp = null; }; hmatrix-repa = callPackage ( { @@ -343409,7 +343409,7 @@ self: { ]; doHaddock = false; description = "Hidden Markov Models using LAPACK primitives"; - license = lib.licensesSpdx."BSD-3-Clause"; + license = lib.meta.getLicenseFromSpdxId "BSD-3-Clause"; maintainers = [ lib.maintainers.thielema ]; } ) { }; @@ -343503,7 +343503,7 @@ self: { ]; executableSystemDepends = [ ncurses ]; description = "A 2019 fork of an ncurses mp3 player written in Haskell"; - license = lib.licensesSpdx."GPL-2.0-or-later"; + license = lib.meta.getLicenseFromSpdxId "GPL-2.0-or-later"; mainProgram = "hmp3"; } ) { inherit (pkgs) ncurses; }; @@ -343522,7 +343522,7 @@ self: { libraryHaskellDepends = [ base ]; librarySystemDepends = [ mpfr ]; description = "Haskell binding to the MPFR library"; - license = lib.licensesSpdx."BSD-3-Clause"; + license = lib.meta.getLicenseFromSpdxId "BSD-3-Clause"; } ) { inherit (pkgs) mpfr; }; @@ -343584,7 +343584,7 @@ self: { time ]; description = "Haskell Music Theory"; - license = lib.licensesSpdx."GPL-3.0-only"; + license = lib.meta.getLicenseFromSpdxId "GPL-3.0-only"; } ) { }; @@ -343630,7 +343630,7 @@ self: { time ]; description = "Haskell Music Theory Base"; - license = lib.licensesSpdx."GPL-3.0-only"; + license = lib.meta.getLicenseFromSpdxId "GPL-3.0-only"; } ) { }; @@ -343973,7 +343973,7 @@ self: { time ]; description = "Haskell implementation of the Nix language"; - license = lib.licensesSpdx."BSD-3-Clause"; + license = lib.meta.getLicenseFromSpdxId "BSD-3-Clause"; mainProgram = "hnix"; maintainers = [ lib.maintainers.Anton-Latukha @@ -344075,7 +344075,7 @@ self: { ]; testToolDepends = [ tasty-discover ]; description = "Core effects for interacting with the Nix store"; - license = lib.licensesSpdx."Apache-2.0"; + license = lib.meta.getLicenseFromSpdxId "Apache-2.0"; maintainers = [ lib.maintainers.Anton-Latukha lib.maintainers.sorki @@ -344157,7 +344157,7 @@ self: { ]; testToolDepends = [ tasty-discover ]; description = "Core types used for interacting with the Nix store"; - license = lib.licensesSpdx."Apache-2.0"; + license = lib.meta.getLicenseFromSpdxId "Apache-2.0"; hydraPlatforms = lib.platforms.none; maintainers = [ lib.maintainers.Anton-Latukha @@ -344212,7 +344212,7 @@ self: { ]; testHaskellDepends = [ base ]; description = "Nix store database support"; - license = lib.licensesSpdx."Apache-2.0"; + license = lib.meta.getLicenseFromSpdxId "Apache-2.0"; } ) { }; @@ -344254,7 +344254,7 @@ self: { ]; testToolDepends = [ hspec-discover ]; description = "JSON serialization for core types"; - license = lib.licensesSpdx."Apache-2.0"; + license = lib.meta.getLicenseFromSpdxId "Apache-2.0"; } ) { }; @@ -344327,7 +344327,7 @@ self: { ]; testToolDepends = [ tasty-discover ]; description = "NAR file format"; - license = lib.licensesSpdx."Apache-2.0"; + license = lib.meta.getLicenseFromSpdxId "Apache-2.0"; } ) { }; @@ -344371,7 +344371,7 @@ self: { ]; testToolDepends = [ hspec-discover ]; description = "Read-only Nix store"; - license = lib.licensesSpdx."Apache-2.0"; + license = lib.meta.getLicenseFromSpdxId "Apache-2.0"; } ) { }; @@ -344414,7 +344414,7 @@ self: { unordered-containers ]; description = "Remote hnix store"; - license = lib.licensesSpdx."Apache-2.0"; + license = lib.meta.getLicenseFromSpdxId "Apache-2.0"; maintainers = [ lib.maintainers.Anton-Latukha lib.maintainers.sorki @@ -344506,7 +344506,7 @@ self: { ]; testToolDepends = [ hspec-discover ]; description = "Remote hnix store"; - license = lib.licensesSpdx."Apache-2.0"; + license = lib.meta.getLicenseFromSpdxId "Apache-2.0"; hydraPlatforms = lib.platforms.none; maintainers = [ lib.maintainers.Anton-Latukha @@ -344564,7 +344564,7 @@ self: { ]; testToolDepends = [ hspec-discover ]; description = "Test utilities and instances"; - license = lib.licensesSpdx."Apache-2.0"; + license = lib.meta.getLicenseFromSpdxId "Apache-2.0"; } ) { }; @@ -344833,7 +344833,7 @@ self: { stm ]; description = "Simple tools for communicating sequential processes"; - license = lib.licensesSpdx."Zlib"; + license = lib.meta.getLicenseFromSpdxId "Zlib"; } ) { }; @@ -344939,7 +344939,7 @@ self: { ]; testToolDepends = [ hspec-discover ]; description = "Haskell OAuth2 authentication client"; - license = lib.licensesSpdx."MIT"; + license = lib.meta.getLicenseFromSpdxId "MIT"; } ) { }; @@ -345001,7 +345001,7 @@ self: { ]; testToolDepends = [ hspec-discover ]; description = "Haskell OAuth2 authentication client"; - license = lib.licensesSpdx."MIT"; + license = lib.meta.getLicenseFromSpdxId "MIT"; hydraPlatforms = lib.platforms.none; } ) { }; @@ -345060,7 +345060,7 @@ self: { warp ]; description = "hoauth2 demo application"; - license = lib.licensesSpdx."MIT"; + license = lib.meta.getLicenseFromSpdxId "MIT"; hydraPlatforms = lib.platforms.none; mainProgram = "hoauth2-demo"; broken = true; @@ -345119,7 +345119,7 @@ self: { ]; testToolDepends = [ hspec-discover ]; description = "OAuth2 Identity Providers"; - license = lib.licensesSpdx."MIT"; + license = lib.meta.getLicenseFromSpdxId "MIT"; hydraPlatforms = lib.platforms.none; broken = true; } @@ -345161,7 +345161,7 @@ self: { ]; executableHaskellDepends = [ base ]; description = "tutorial for hoauth2-providers module"; - license = lib.licensesSpdx."MIT"; + license = lib.meta.getLicenseFromSpdxId "MIT"; hydraPlatforms = lib.platforms.none; mainProgram = "hoauth2-providers-tutorial"; broken = true; @@ -345203,7 +345203,7 @@ self: { uri-bytestring ]; description = "Tutorial for using hoauth2"; - license = lib.licensesSpdx."MIT"; + license = lib.meta.getLicenseFromSpdxId "MIT"; hydraPlatforms = lib.platforms.none; broken = true; } @@ -345399,7 +345399,7 @@ self: { ]; testToolDepends = [ hspec-discover ]; description = "OpenOCD Haskell interface"; - license = lib.licensesSpdx."BSD-3-Clause"; + license = lib.meta.getLicenseFromSpdxId "BSD-3-Clause"; mainProgram = "hocd-read-mem"; } ) { }; @@ -346160,7 +346160,7 @@ self: { time ]; description = "Library for country public holidays"; - license = lib.licensesSpdx."MIT"; + license = lib.meta.getLicenseFromSpdxId "MIT"; hydraPlatforms = lib.platforms.none; broken = true; } @@ -346223,7 +346223,7 @@ self: { tasty-discover ]; description = "Tools and combinators for solving constraint problems"; - license = lib.licensesSpdx."MIT"; + license = lib.meta.getLicenseFromSpdxId "MIT"; hydraPlatforms = lib.platforms.none; broken = true; } @@ -346397,7 +346397,7 @@ self: { text ]; description = "Client library for the Home Assistant API"; - license = lib.licensesSpdx."BSD-3-Clause"; + license = lib.meta.getLicenseFromSpdxId "BSD-3-Clause"; mainProgram = "ha-client"; } ) { }; @@ -346529,7 +346529,7 @@ self: { single-tuple ]; description = "Homotuple, all whose elements are the same type"; - license = lib.licensesSpdx."Apache-2.0"; + license = lib.meta.getLicenseFromSpdxId "Apache-2.0"; hydraPlatforms = lib.platforms.none; } ) { }; @@ -347744,7 +347744,7 @@ self: { stm ]; description = "Abstraction over creating network connections with SOCKS5 and TLS"; - license = lib.licensesSpdx."ISC"; + license = lib.meta.getLicenseFromSpdxId "ISC"; } ) { }; @@ -348066,7 +348066,7 @@ self: { happy ]; description = "hOpenPGP-based command-line tools"; - license = lib.licensesSpdx."AGPL-3.0-or-later"; + license = lib.meta.getLicenseFromSpdxId "AGPL-3.0-or-later"; } ) { }; @@ -348635,7 +348635,7 @@ self: { ]; doHaddock = false; description = "Higher Order Reverse Derivatives Efficiently - Automatic Differentiation"; - license = lib.licensesSpdx."BSD-3-Clause"; + license = lib.meta.getLicenseFromSpdxId "BSD-3-Clause"; hydraPlatforms = lib.platforms.none; } ) { }; @@ -348717,7 +348717,7 @@ self: { sydtest ]; description = "Generate nix expressions from horizon-spec definitions"; - license = lib.licensesSpdx."MIT"; + license = lib.meta.getLicenseFromSpdxId "MIT"; hydraPlatforms = lib.platforms.none; broken = true; } @@ -348750,7 +348750,7 @@ self: { th-lift ]; description = "Horizon Stable Package Set Type Definitions"; - license = lib.licensesSpdx."MIT"; + license = lib.meta.getLicenseFromSpdxId "MIT"; hydraPlatforms = lib.platforms.none; broken = true; } @@ -348773,7 +348773,7 @@ self: { lens ]; description = "Horizon Stable Package Set Lenses"; - license = lib.licensesSpdx."MIT"; + license = lib.meta.getLicenseFromSpdxId "MIT"; hydraPlatforms = lib.platforms.none; broken = true; } @@ -348806,7 +348806,7 @@ self: { text ]; description = "Horizon Stable Package Set Pretty Printer"; - license = lib.licensesSpdx."MIT"; + license = lib.meta.getLicenseFromSpdxId "MIT"; hydraPlatforms = lib.platforms.none; broken = true; } @@ -348848,7 +348848,7 @@ self: { tasty-hunit ]; description = "horizontal rule for the terminal"; - license = lib.licensesSpdx."MIT"; + license = lib.meta.getLicenseFromSpdxId "MIT"; mainProgram = "hr"; } ) { }; @@ -348923,7 +348923,7 @@ self: { transformers ]; description = "Haskell Open Sound Control"; - license = lib.licensesSpdx."GPL-3.0-only"; + license = lib.meta.getLicenseFromSpdxId "GPL-3.0-only"; } ) { }; @@ -349046,7 +349046,7 @@ self: { text ]; description = "Network Host Addresses"; - license = lib.licensesSpdx."MIT"; + license = lib.meta.getLicenseFromSpdxId "MIT"; } ) { }; @@ -350787,7 +350787,7 @@ self: { time ]; description = "Code Coverage Library for Haskell"; - license = lib.licensesSpdx."BSD-3-Clause"; + license = lib.meta.getLicenseFromSpdxId "BSD-3-Clause"; hydraPlatforms = lib.platforms.none; } ) { }; @@ -351127,7 +351127,7 @@ self: { utf8-string ]; description = "A tool for looking through PDF file using Haskell"; - license = lib.licensesSpdx."MIT"; + license = lib.meta.getLicenseFromSpdxId "MIT"; hydraPlatforms = lib.platforms.none; mainProgram = "hpdft"; broken = true; @@ -351546,7 +351546,7 @@ self: { vector ]; description = "Haskell bindings to libpqtypes"; - license = lib.licensesSpdx."BSD-3-Clause"; + license = lib.meta.getLicenseFromSpdxId "BSD-3-Clause"; } ) { inherit (pkgs) libpq; }; @@ -351629,7 +351629,7 @@ self: { vector ]; description = "Haskell bindings to libpqtypes"; - license = lib.licensesSpdx."BSD-3-Clause"; + license = lib.meta.getLicenseFromSpdxId "BSD-3-Clause"; hydraPlatforms = lib.platforms.none; } ) { inherit (pkgs) libpq; }; @@ -351665,7 +351665,7 @@ self: { text ]; description = "Adaptation of the hpqtypes library for the effectful ecosystem"; - license = lib.licensesSpdx."BSD-3-Clause"; + license = lib.meta.getLicenseFromSpdxId "BSD-3-Clause"; hydraPlatforms = lib.platforms.none; broken = true; } @@ -351729,7 +351729,7 @@ self: { tasty-bench ]; description = "Extra utilities for hpqtypes library"; - license = lib.licensesSpdx."BSD-3-Clause"; + license = lib.meta.getLicenseFromSpdxId "BSD-3-Clause"; } ) { }; @@ -351793,7 +351793,7 @@ self: { tasty-bench ]; description = "Extra utilities for hpqtypes library"; - license = lib.licensesSpdx."BSD-3-Clause"; + license = lib.meta.getLicenseFromSpdxId "BSD-3-Clause"; hydraPlatforms = lib.platforms.none; } ) { }; @@ -352356,7 +352356,7 @@ self: { hspec-expectations ]; description = "Quantitative Library"; - license = lib.licensesSpdx."BSD-3-Clause"; + license = lib.meta.getLicenseFromSpdxId "BSD-3-Clause"; hydraPlatforms = lib.platforms.none; } ) { inherit (pkgs) gsl; }; @@ -352385,7 +352385,7 @@ self: { random ]; description = "A library for simulating quantum circuits"; - license = lib.licensesSpdx."BSD-3-Clause"; + license = lib.meta.getLicenseFromSpdxId "BSD-3-Clause"; hydraPlatforms = lib.platforms.none; mainProgram = "hqcsim-exe"; broken = true; @@ -352451,7 +352451,7 @@ self: { test-framework-quickcheck2 ]; description = "HQuantLib is a port of essencial parts of QuantLib to Haskell"; - license = lib.licensesSpdx."LGPL-3.0-only"; + license = lib.meta.getLicenseFromSpdxId "LGPL-3.0-only"; hydraPlatforms = lib.platforms.none; mainProgram = "mctest"; broken = true; @@ -352473,7 +352473,7 @@ self: { time ]; description = "HQuantLib Time is a business calendar functions extracted from HQuantLib"; - license = lib.licensesSpdx."LGPL-3.0-or-later"; + license = lib.meta.getLicenseFromSpdxId "LGPL-3.0-or-later"; } ) { }; @@ -353106,7 +353106,7 @@ self: { time ]; description = "Haskell bindings for ASAP:O"; - license = lib.licensesSpdx."MIT"; + license = lib.meta.getLicenseFromSpdxId "MIT"; hydraPlatforms = lib.platforms.none; broken = true; } @@ -353427,7 +353427,7 @@ self: { void ]; description = "Conllu validating parser and utils"; - license = lib.licensesSpdx."LGPL-3.0-only"; + license = lib.meta.getLicenseFromSpdxId "LGPL-3.0-only"; hydraPlatforms = lib.platforms.none; mainProgram = "hs-conllu"; broken = true; @@ -354127,7 +354127,7 @@ self: { hspec ]; description = "A tool to highlight terminal strings"; - license = lib.licensesSpdx."MIT"; + license = lib.meta.getLicenseFromSpdxId "MIT"; mainProgram = "test-exe"; } ) { }; @@ -354477,7 +354477,7 @@ self: { ]; libraryPkgconfigDepends = [ libonnxruntime ]; description = "Low-level bindings for ONNX Runtime"; - license = lib.licensesSpdx."AGPL-3.0-only"; + license = lib.meta.getLicenseFromSpdxId "AGPL-3.0-only"; hydraPlatforms = lib.platforms.none; broken = true; } @@ -354778,7 +354778,7 @@ self: { unordered-containers ]; description = "Plugin for instrumenting an application"; - license = lib.licensesSpdx."BSD-3-Clause"; + license = lib.meta.getLicenseFromSpdxId "BSD-3-Clause"; hydraPlatforms = lib.platforms.none; broken = true; } @@ -354935,7 +354935,7 @@ self: { unliftio-core ]; description = "OpenTelemetry instrumentation for hw-kafka-client"; - license = lib.licensesSpdx."BSD-3-Clause"; + license = lib.meta.getLicenseFromSpdxId "BSD-3-Clause"; } ) { }; @@ -355010,7 +355010,7 @@ self: { unordered-containers ]; description = "OpenTelemetry instrumentation for persistent-mysql"; - license = lib.licensesSpdx."BSD-3-Clause"; + license = lib.meta.getLicenseFromSpdxId "BSD-3-Clause"; hydraPlatforms = lib.platforms.none; } ) { }; @@ -355255,7 +355255,7 @@ self: { primitive ]; description = "Datadog Propagator for OpenTelemetry"; - license = lib.licensesSpdx."BSD-3-Clause"; + license = lib.meta.getLicenseFromSpdxId "BSD-3-Clause"; } ) { }; @@ -355400,7 +355400,7 @@ self: { yaml ]; description = "OpenTelemetry Semantic Conventions for Haskell"; - license = lib.licensesSpdx."BSD-3-Clause"; + license = lib.meta.getLicenseFromSpdxId "BSD-3-Clause"; mainProgram = "generate"; } ) { }; @@ -355889,7 +355889,7 @@ self: { hspec ]; description = "Read and write SAM, BAM, and CRAM files"; - license = lib.licensesSpdx."BSD-3-Clause"; + license = lib.meta.getLicenseFromSpdxId "BSD-3-Clause"; hydraPlatforms = lib.platforms.none; broken = true; } @@ -355996,7 +355996,7 @@ self: { ]; executableHaskellDepends = [ base ]; description = "Terminal Emulator written in Haskell, SDL2 Backend"; - license = lib.licensesSpdx."MIT"; + license = lib.meta.getLicenseFromSpdxId "MIT"; hydraPlatforms = lib.platforms.none; mainProgram = "hs-sdl-term-emulator"; } @@ -356099,7 +356099,7 @@ self: { ]; executableHaskellDepends = [ base ]; description = "Convert an eventlog into the speedscope json format"; - license = lib.licensesSpdx."BSD-3-Clause"; + license = lib.meta.getLicenseFromSpdxId "BSD-3-Clause"; mainProgram = "hs-speedscope"; } ) { }; @@ -356206,7 +356206,7 @@ self: { warp ]; description = "Bindings to the Tango Controls system"; - license = lib.licensesSpdx."MIT"; + license = lib.meta.getLicenseFromSpdxId "MIT"; hydraPlatforms = lib.platforms.none; broken = true; } @@ -356256,7 +356256,7 @@ self: { criterion ]; description = "Terminal Emulator written in 100% Haskell"; - license = lib.licensesSpdx."MIT"; + license = lib.meta.getLicenseFromSpdxId "MIT"; hydraPlatforms = lib.platforms.none; broken = true; } @@ -356284,7 +356284,7 @@ self: { ]; doHaddock = false; description = "High-level bindings for tree-sitter"; - license = lib.licensesSpdx."AGPL-3.0-only"; + license = lib.meta.getLicenseFromSpdxId "AGPL-3.0-only"; } ) { }; @@ -356315,7 +356315,7 @@ self: { tree-sitter-while ]; description = "Low-level bindings for tree-sitter"; - license = lib.licensesSpdx."AGPL-3.0-only"; + license = lib.meta.getLicenseFromSpdxId "AGPL-3.0-only"; hydraPlatforms = lib.platforms.none; broken = true; } @@ -357422,7 +357422,7 @@ self: { ]; testToolDepends = [ tasty-discover ]; description = "Haskell bindings to BLST"; - license = lib.licensesSpdx."MPL-2.0"; + license = lib.meta.getLicenseFromSpdxId "MPL-2.0"; } ) { }; @@ -357516,7 +357516,7 @@ self: { vector ]; description = "Haskell SuperCollider"; - license = lib.licensesSpdx."GPL-3.0-only"; + license = lib.meta.getLicenseFromSpdxId "GPL-3.0-only"; } ) { }; @@ -358428,7 +358428,7 @@ self: { text ]; description = "Haskell bindings to the libcdio disc-reading library"; - license = lib.licensesSpdx."GPL-3.0-or-later"; + license = lib.meta.getLicenseFromSpdxId "GPL-3.0-or-later"; hydraPlatforms = lib.platforms.none; broken = true; } @@ -358926,7 +358926,7 @@ self: { time ]; description = "Haskell shell script templates"; - license = lib.licensesSpdx."ISC"; + license = lib.meta.getLicenseFromSpdxId "ISC"; } ) { }; @@ -359408,7 +359408,7 @@ self: { text ]; description = "Core package representing Haskell advisories"; - license = lib.licensesSpdx."BSD-3-Clause"; + license = lib.meta.getLicenseFromSpdxId "BSD-3-Clause"; } ) { }; @@ -359480,7 +359480,7 @@ self: { time ]; description = "Synchronize with the Haskell security advisory database"; - license = lib.licensesSpdx."BSD-3-Clause"; + license = lib.meta.getLicenseFromSpdxId "BSD-3-Clause"; hydraPlatforms = lib.platforms.none; mainProgram = "hsec-sync"; broken = true; @@ -359615,7 +359615,7 @@ self: { toml-parser ]; description = "Tools for working with the Haskell security advisory database"; - license = lib.licensesSpdx."BSD-3-Clause"; + license = lib.meta.getLicenseFromSpdxId "BSD-3-Clause"; hydraPlatforms = lib.platforms.none; mainProgram = "hsec-tools"; broken = true; @@ -359714,7 +359714,7 @@ self: { tls ]; description = "sendxmpp clone, sending XMPP messages via CLI"; - license = lib.licensesSpdx."AGPL-3.0-only"; + license = lib.meta.getLicenseFromSpdxId "AGPL-3.0-only"; mainProgram = "hsendxmpp"; } ) { }; @@ -360065,7 +360065,7 @@ self: { yaml ]; description = "A SFTP client tool for secure file transfer operations"; - license = lib.licensesSpdx."BSD-3-Clause"; + license = lib.meta.getLicenseFromSpdxId "BSD-3-Clause"; hydraPlatforms = lib.platforms.none; mainProgram = "hsftp"; broken = true; @@ -360395,7 +360395,7 @@ self: { tasty-th ]; description = "ini configuration files"; - license = lib.licensesSpdx."BSD-3-Clause"; + license = lib.meta.getLicenseFromSpdxId "BSD-3-Clause"; } ) { }; @@ -360441,7 +360441,7 @@ self: { transformers ]; description = "Inspect Haskell source files"; - license = lib.licensesSpdx."GPL-3.0-or-later"; + license = lib.meta.getLicenseFromSpdxId "GPL-3.0-or-later"; hydraPlatforms = lib.platforms.none; mainProgram = "hsinspect"; broken = true; @@ -360531,7 +360531,7 @@ self: { ]; testToolDepends = [ hspec-discover ]; description = "LSP interface over the hsinspect binary"; - license = lib.licensesSpdx."GPL-3.0-or-later"; + license = lib.meta.getLicenseFromSpdxId "GPL-3.0-or-later"; hydraPlatforms = lib.platforms.none; mainProgram = "hsinspect-lsp"; } @@ -360579,7 +360579,7 @@ self: { transformers ]; description = "Install Haskell software"; - license = lib.licensesSpdx."ISC"; + license = lib.meta.getLicenseFromSpdxId "ISC"; mainProgram = "hsinstall"; } ) { }; @@ -360626,7 +360626,7 @@ self: { transformers ]; description = "Install Haskell software"; - license = lib.licensesSpdx."ISC"; + license = lib.meta.getLicenseFromSpdxId "ISC"; hydraPlatforms = lib.platforms.none; mainProgram = "hsinstall"; } @@ -361009,7 +361009,7 @@ self: { text ]; description = "Bindings to Lua, an embeddable scripting language"; - license = lib.licensesSpdx."MIT"; + license = lib.meta.getLicenseFromSpdxId "MIT"; } ) { }; @@ -361058,7 +361058,7 @@ self: { text ]; description = "Bindings to Lua, an embeddable scripting language"; - license = lib.licensesSpdx."MIT"; + license = lib.meta.getLicenseFromSpdxId "MIT"; hydraPlatforms = lib.platforms.none; } ) { }; @@ -361108,7 +361108,7 @@ self: { vector ]; description = "Allow aeson data types to be used with Lua"; - license = lib.licensesSpdx."MIT"; + license = lib.meta.getLicenseFromSpdxId "MIT"; } ) { }; @@ -361156,7 +361156,7 @@ self: { text ]; description = "Type classes for HsLua"; - license = lib.licensesSpdx."MIT"; + license = lib.meta.getLicenseFromSpdxId "MIT"; } ) { }; @@ -361189,7 +361189,7 @@ self: { unix ]; description = "Command-line interface for Lua"; - license = lib.licensesSpdx."MIT"; + license = lib.meta.getLicenseFromSpdxId "MIT"; } ) { }; @@ -361231,7 +361231,7 @@ self: { tasty-quickcheck ]; description = "Bindings to Lua, an embeddable scripting language"; - license = lib.licensesSpdx."MIT"; + license = lib.meta.getLicenseFromSpdxId "MIT"; } ) { }; @@ -361258,7 +361258,7 @@ self: { text ]; description = "Examples of how to combine Haskell and Lua"; - license = lib.licensesSpdx."MIT"; + license = lib.meta.getLicenseFromSpdxId "MIT"; } ) { }; @@ -361287,7 +361287,7 @@ self: { tasty-lua ]; description = "Opinionated, but extensible Lua list type"; - license = lib.licensesSpdx."MIT"; + license = lib.meta.getLicenseFromSpdxId "MIT"; } ) { }; @@ -361333,7 +361333,7 @@ self: { text ]; description = "Marshalling of values between Haskell and Lua"; - license = lib.licensesSpdx."MIT"; + license = lib.meta.getLicenseFromSpdxId "MIT"; } ) { }; @@ -361368,7 +361368,7 @@ self: { text ]; description = "Lua module wrapping Text.DocLayout."; - license = lib.licensesSpdx."MIT"; + license = lib.meta.getLicenseFromSpdxId "MIT"; } ) { }; @@ -361403,7 +361403,7 @@ self: { text ]; description = "Lua module wrapping Text.DocLayout."; - license = lib.licensesSpdx."MIT"; + license = lib.meta.getLicenseFromSpdxId "MIT"; hydraPlatforms = lib.platforms.none; } ) { }; @@ -361445,7 +361445,7 @@ self: { text ]; description = "Lua module to work with file paths"; - license = lib.licensesSpdx."MIT"; + license = lib.meta.getLicenseFromSpdxId "MIT"; } ) { }; @@ -361483,7 +361483,7 @@ self: { tasty-lua ]; description = "Lua module to work with file paths"; - license = lib.licensesSpdx."MIT"; + license = lib.meta.getLicenseFromSpdxId "MIT"; hydraPlatforms = lib.platforms.none; } ) { }; @@ -361529,7 +361529,7 @@ self: { text ]; description = "Lua module wrapper around Haskell's System module"; - license = lib.licensesSpdx."MIT"; + license = lib.meta.getLicenseFromSpdxId "MIT"; } ) { }; @@ -361579,7 +361579,7 @@ self: { tasty-lua ]; description = "Lua module wrapper around Haskell's System module"; - license = lib.licensesSpdx."MIT"; + license = lib.meta.getLicenseFromSpdxId "MIT"; hydraPlatforms = lib.platforms.none; } ) { }; @@ -361617,7 +361617,7 @@ self: { text ]; description = "Lua module for text"; - license = lib.licensesSpdx."MIT"; + license = lib.meta.getLicenseFromSpdxId "MIT"; } ) { }; @@ -361653,7 +361653,7 @@ self: { tasty-lua ]; description = "Lua module for text"; - license = lib.licensesSpdx."MIT"; + license = lib.meta.getLicenseFromSpdxId "MIT"; hydraPlatforms = lib.platforms.none; } ) { }; @@ -361695,7 +361695,7 @@ self: { text ]; description = "Lua module to work with version specifiers"; - license = lib.licensesSpdx."MIT"; + license = lib.meta.getLicenseFromSpdxId "MIT"; } ) { }; @@ -361731,7 +361731,7 @@ self: { tasty-lua ]; description = "Lua module to work with version specifiers"; - license = lib.licensesSpdx."MIT"; + license = lib.meta.getLicenseFromSpdxId "MIT"; hydraPlatforms = lib.platforms.none; } ) { }; @@ -361780,7 +361780,7 @@ self: { tasty-lua ]; description = "Lua module to work with file zips"; - license = lib.licensesSpdx."MIT"; + license = lib.meta.getLicenseFromSpdxId "MIT"; } ) { }; @@ -361824,7 +361824,7 @@ self: { tasty-lua ]; description = "Lua module to work with file zips"; - license = lib.licensesSpdx."MIT"; + license = lib.meta.getLicenseFromSpdxId "MIT"; hydraPlatforms = lib.platforms.none; } ) { }; @@ -361883,7 +361883,7 @@ self: { text ]; description = "Object orientation tools for HsLua"; - license = lib.licensesSpdx."MIT"; + license = lib.meta.getLicenseFromSpdxId "MIT"; } ) { }; @@ -361922,7 +361922,7 @@ self: { tasty-hslua ]; description = "Object orientation tools for HsLua"; - license = lib.licensesSpdx."MIT"; + license = lib.meta.getLicenseFromSpdxId "MIT"; hydraPlatforms = lib.platforms.none; } ) { }; @@ -361971,7 +361971,7 @@ self: { text ]; description = "Utilities to build Lua modules"; - license = lib.licensesSpdx."MIT"; + license = lib.meta.getLicenseFromSpdxId "MIT"; } ) { }; @@ -362013,7 +362013,7 @@ self: { tasty-hunit ]; description = "Utilities to build Lua modules"; - license = lib.licensesSpdx."MIT"; + license = lib.meta.getLicenseFromSpdxId "MIT"; hydraPlatforms = lib.platforms.none; } ) { }; @@ -362043,7 +362043,7 @@ self: { text ]; description = "Isocline-based Lua REPL"; - license = lib.licensesSpdx."MIT"; + license = lib.meta.getLicenseFromSpdxId "MIT"; } ) { }; @@ -362085,7 +362085,7 @@ self: { tasty-quickcheck ]; description = "Type specifiers for Lua"; - license = lib.licensesSpdx."MIT"; + license = lib.meta.getLicenseFromSpdxId "MIT"; } ) { }; @@ -362125,7 +362125,7 @@ self: { tasty-quickcheck ]; description = "Type specifiers for Lua"; - license = lib.licensesSpdx."MIT"; + license = lib.meta.getLicenseFromSpdxId "MIT"; hydraPlatforms = lib.platforms.none; } ) { }; @@ -362269,7 +362269,7 @@ self: { temporary ]; description = "Haskell source code minifier for LLM token reduction"; - license = lib.licensesSpdx."MIT"; + license = lib.meta.getLicenseFromSpdxId "MIT"; mainProgram = "hsmin"; } ) { }; @@ -363410,7 +363410,7 @@ self: { text ]; testToolDepends = [ hspec-discover ]; - license = lib.licensesSpdx."BSD-3-Clause"; + license = lib.meta.getLicenseFromSpdxId "BSD-3-Clause"; mainProgram = "hspec-discover-discover"; } ) { }; @@ -363695,7 +363695,7 @@ self: { hspec-core ]; description = "A Formatter for hspec that provides Github Actions Annotations"; - license = lib.licensesSpdx."BSD-3-Clause"; + license = lib.meta.getLicenseFromSpdxId "BSD-3-Clause"; } ) { }; @@ -364037,7 +364037,7 @@ self: { megaparsec ]; description = "Utility functions for testing Megaparsec parsers with Hspec"; - license = lib.licensesSpdx."BSD-3-Clause"; + license = lib.meta.getLicenseFromSpdxId "BSD-3-Clause"; } ) { }; @@ -364626,7 +364626,7 @@ self: { hspec-core ]; description = "Table-driven (by-example) HSpec tests"; - license = lib.licensesSpdx."MIT"; + license = lib.meta.getLicenseFromSpdxId "MIT"; hydraPlatforms = lib.platforms.none; broken = true; } @@ -364750,7 +364750,7 @@ self: { markdown-unlit ]; description = "A custom hspec formatter for easy-to-read terminal output"; - license = lib.licensesSpdx."MIT"; + license = lib.meta.getLicenseFromSpdxId "MIT"; } ) { }; @@ -364771,7 +364771,7 @@ self: { tmp-proc ]; description = "Simplify use of tmp-proc from hspec tests"; - license = lib.licensesSpdx."BSD-3-Clause"; + license = lib.meta.getLicenseFromSpdxId "BSD-3-Clause"; } ) { }; @@ -365272,7 +365272,7 @@ self: { doctest ]; description = "My opinionated Haskell project formatter"; - license = lib.licensesSpdx."BSD-3-Clause"; + license = lib.meta.getLicenseFromSpdxId "BSD-3-Clause"; hydraPlatforms = lib.platforms.none; mainProgram = "hspretty"; broken = true; @@ -365395,7 +365395,7 @@ self: { base, hsql, old-time, - unixODBC, + unixodbc, }: mkDerivation { pname = "hsql-odbc"; @@ -365406,12 +365406,12 @@ self: { hsql old-time ]; - librarySystemDepends = [ unixODBC ]; + librarySystemDepends = [ unixodbc ]; description = "A Haskell Interface to ODBC"; license = lib.licenses.bsd3; hydraPlatforms = lib.platforms.none; } - ) { unixODBC = null; }; + ) { inherit (pkgs) unixodbc; }; hsql-postgresql = callPackage ( { @@ -365512,7 +365512,7 @@ self: { text ]; description = "Haskell binding for Qt Quick"; - license = lib.licensesSpdx."BSD-3-Clause"; + license = lib.meta.getLicenseFromSpdxId "BSD-3-Clause"; hydraPlatforms = lib.platforms.none; } ) @@ -365815,7 +365815,7 @@ self: { utf8-string ]; description = "RELP (Reliable Event Logging Protocol) server implementation"; - license = lib.licensesSpdx."BSD-3-Clause"; + license = lib.meta.getLicenseFromSpdxId "BSD-3-Clause"; } ) { }; @@ -365920,7 +365920,7 @@ self: { unix ]; description = "Using Haskell for Unix shell scripting tasks"; - license = lib.licensesSpdx."LGPL-3.0-or-later"; + license = lib.meta.getLicenseFromSpdxId "LGPL-3.0-or-later"; hydraPlatforms = lib.platforms.none; broken = true; } @@ -367013,7 +367013,7 @@ self: { ]; testToolDepends = [ hspec-discover ]; description = "Bindings to TagLib, audio meta-data library"; - license = lib.licensesSpdx."BSD-3-Clause"; + license = lib.meta.getLicenseFromSpdxId "BSD-3-Clause"; } ) { inherit (pkgs) taglib; }; @@ -367512,7 +367512,7 @@ self: { unordered-containers ]; description = "A codec library for HTML-escaped text and HTML-entities"; - license = lib.licensesSpdx."MIT"; + license = lib.meta.getLicenseFromSpdxId "MIT"; } ) { }; @@ -367978,7 +367978,7 @@ self: { text ]; description = "Use htmx with various haskell libraries"; - license = lib.licensesSpdx."MIT"; + license = lib.meta.getLicenseFromSpdxId "MIT"; } ) { }; @@ -368001,7 +368001,7 @@ self: { text ]; description = "Use htmx with lucid"; - license = lib.licensesSpdx."MIT"; + license = lib.meta.getLicenseFromSpdxId "MIT"; } ) { }; @@ -368028,7 +368028,7 @@ self: { text ]; description = "Use htmx with servant"; - license = lib.licensesSpdx."MIT"; + license = lib.meta.getLicenseFromSpdxId "MIT"; } ) { }; @@ -368252,7 +368252,7 @@ self: { vector ]; description = "Parse TOML values produced by htoml-megaparsec package"; - license = lib.licensesSpdx."Apache-2.0"; + license = lib.meta.getLicenseFromSpdxId "Apache-2.0"; hydraPlatforms = lib.platforms.none; } ) { }; @@ -368295,7 +368295,7 @@ self: { th-compat ]; description = "a library to build and work with heterogeneous, type level indexed rose trees"; - license = lib.licensesSpdx."AGPL-3.0-or-later"; + license = lib.meta.getLicenseFromSpdxId "AGPL-3.0-or-later"; maintainers = [ lib.maintainers.mangoiv ]; } ) { }; @@ -368678,7 +368678,7 @@ self: { text ]; description = "Code for using the ip package with http-api-data"; - license = lib.licensesSpdx."BSD-3-Clause"; + license = lib.meta.getLicenseFromSpdxId "BSD-3-Clause"; } ) { }; @@ -368773,7 +368773,7 @@ self: { ]; testHaskellDepends = [ base ]; description = "a library to make http requests without worrying much"; - license = lib.licensesSpdx."AGPL-3.0-or-later"; + license = lib.meta.getLicenseFromSpdxId "AGPL-3.0-or-later"; maintainers = [ lib.maintainers.mangoiv ]; } ) { }; @@ -369247,7 +369247,7 @@ self: { temporary ]; description = "http-client TLS backend using Rustls"; - license = lib.licensesSpdx."CC0-1.0"; + license = lib.meta.getLicenseFromSpdxId "CC0-1.0"; hydraPlatforms = lib.platforms.none; } ) { }; @@ -369475,7 +369475,7 @@ self: { websockets ]; description = "Glue code for http-client and websockets"; - license = lib.licensesSpdx."CC0-1.0"; + license = lib.meta.getLicenseFromSpdxId "CC0-1.0"; } ) { }; @@ -369734,7 +369734,7 @@ self: { zlib ]; description = "HTTP downloader tailored for web-crawler needs"; - license = lib.licensesSpdx."BSD-3-Clause"; + license = lib.meta.getLicenseFromSpdxId "BSD-3-Clause"; hydraPlatforms = lib.platforms.none; broken = true; } @@ -370065,7 +370065,7 @@ self: { ]; doHaddock = false; description = "Perform HTTP Requests"; - license = lib.licensesSpdx."BSD-3-Clause"; + license = lib.meta.getLicenseFromSpdxId "BSD-3-Clause"; } ) { }; @@ -370113,7 +370113,7 @@ self: { ]; doHaddock = false; description = "Instantiations of http-exchange"; - license = lib.licensesSpdx."BSD-3-Clause"; + license = lib.meta.getLicenseFromSpdxId "BSD-3-Clause"; hydraPlatforms = lib.platforms.none; broken = true; } @@ -370136,7 +370136,7 @@ self: { bytestring ]; description = "Attoparsec-based parsers for the RFC-2616 HTTP grammar rules"; - license = lib.licensesSpdx."Apache-2.0"; + license = lib.meta.getLicenseFromSpdxId "Apache-2.0"; } ) { }; @@ -370182,7 +370182,7 @@ self: { tasty-golden ]; description = "Types and serialization for HTTP"; - license = lib.licensesSpdx."BSD-3-Clause"; + license = lib.meta.getLicenseFromSpdxId "BSD-3-Clause"; } ) { }; @@ -371084,7 +371084,7 @@ self: { utf8-string ]; description = "HTTP senmatics libarry"; - license = lib.licensesSpdx."BSD-3-Clause"; + license = lib.meta.getLicenseFromSpdxId "BSD-3-Clause"; } ) { }; @@ -371117,7 +371117,7 @@ self: { utf8-string ]; description = "HTTP semantics library"; - license = lib.licensesSpdx."BSD-3-Clause"; + license = lib.meta.getLicenseFromSpdxId "BSD-3-Clause"; hydraPlatforms = lib.platforms.none; } ) { }; @@ -371426,7 +371426,7 @@ self: { text ]; description = "Generic HTTP types for Haskell (for both client and server code)"; - license = lib.licensesSpdx."BSD-3-Clause"; + license = lib.meta.getLicenseFromSpdxId "BSD-3-Clause"; } ) { }; @@ -372005,7 +372005,7 @@ self: { ]; testToolDepends = [ hspec-discover ]; description = "HTTP/3 library"; - license = lib.licensesSpdx."BSD-3-Clause"; + license = lib.meta.getLicenseFromSpdxId "BSD-3-Clause"; hydraPlatforms = lib.platforms.none; } ) { }; @@ -372596,7 +372596,7 @@ self: { fingertree ]; description = "Pure Haskell implementation of the Huffman encoding algorithm"; - license = lib.licensesSpdx."BSD-2-Clause"; + license = lib.meta.getLicenseFromSpdxId "BSD-2-Clause"; } ) { }; @@ -372680,7 +372680,7 @@ self: { doctest-parallel ]; description = "uiua port"; - license = lib.licensesSpdx."BSD-3-Clause"; + license = lib.meta.getLicenseFromSpdxId "BSD-3-Clause"; } ) { }; @@ -372866,7 +372866,7 @@ self: { witherable ]; description = "A TUI MPD client, inspired by ncmpcpp"; - license = lib.licensesSpdx."GPL-2.0-or-later"; + license = lib.meta.getLicenseFromSpdxId "GPL-2.0-or-later"; hydraPlatforms = lib.platforms.none; mainProgram = "hum"; broken = true; @@ -372965,7 +372965,7 @@ self: { text ]; description = "Redefinition-free prelude alternative"; - license = lib.licensesSpdx."BSD-3-Clause"; + license = lib.meta.getLicenseFromSpdxId "BSD-3-Clause"; hydraPlatforms = lib.platforms.none; broken = true; } @@ -374129,7 +374129,7 @@ self: { hspec-discover ]; description = "Convenience functions for Aeson"; - license = lib.licensesSpdx."BSD-3-Clause"; + license = lib.meta.getLicenseFromSpdxId "BSD-3-Clause"; hydraPlatforms = lib.platforms.none; broken = true; } @@ -374214,7 +374214,7 @@ self: { hw-xml ]; description = "Demo library"; - license = lib.licensesSpdx."BSD-3-Clause"; + license = lib.meta.getLicenseFromSpdxId "BSD-3-Clause"; hydraPlatforms = lib.platforms.none; } ) { }; @@ -374344,7 +374344,7 @@ self: { ]; doHaddock = false; description = "Balanced parentheses"; - license = lib.licensesSpdx."BSD-3-Clause"; + license = lib.meta.getLicenseFromSpdxId "BSD-3-Clause"; hydraPlatforms = lib.platforms.none; mainProgram = "hw-balancedparens"; } @@ -374407,7 +374407,7 @@ self: { vector ]; description = "Bit manipulation"; - license = lib.licensesSpdx."BSD-3-Clause"; + license = lib.meta.getLicenseFromSpdxId "BSD-3-Clause"; hydraPlatforms = lib.platforms.none; } ) { }; @@ -374444,7 +374444,7 @@ self: { testToolDepends = [ hspec-discover ]; doHaddock = false; description = "CI Assistant for Haskell projects"; - license = lib.licensesSpdx."BSD-3-Clause"; + license = lib.meta.getLicenseFromSpdxId "BSD-3-Clause"; hydraPlatforms = lib.platforms.none; mainProgram = "hw-ci-assist"; broken = true; @@ -374509,7 +374509,7 @@ self: { vector ]; description = "Conduits for tokenizing streams"; - license = lib.licensesSpdx."MIT"; + license = lib.meta.getLicenseFromSpdxId "MIT"; hydraPlatforms = lib.platforms.none; broken = true; } @@ -374550,7 +374550,7 @@ self: { ]; testToolDepends = [ hspec-discover ]; description = "Additional merges and joins for Conduit"; - license = lib.licensesSpdx."BSD-3-Clause"; + license = lib.meta.getLicenseFromSpdxId "BSD-3-Clause"; hydraPlatforms = lib.platforms.none; broken = true; } @@ -374577,7 +374577,7 @@ self: { ]; testToolDepends = [ doctest-discover ]; description = "Diagnostics library"; - license = lib.licensesSpdx."BSD-3-Clause"; + license = lib.meta.getLicenseFromSpdxId "BSD-3-Clause"; hydraPlatforms = lib.platforms.none; broken = true; } @@ -374703,7 +374703,7 @@ self: { vector ]; description = "Unbelievably fast streaming DSV file parser"; - license = lib.licensesSpdx."BSD-3-Clause"; + license = lib.meta.getLicenseFromSpdxId "BSD-3-Clause"; hydraPlatforms = lib.platforms.none; mainProgram = "hw-dsv"; broken = true; @@ -374788,7 +374788,7 @@ self: { vector ]; description = "File Dump"; - license = lib.licensesSpdx."BSD-3-Clause"; + license = lib.meta.getLicenseFromSpdxId "BSD-3-Clause"; hydraPlatforms = lib.platforms.none; mainProgram = "hw-dump"; broken = true; @@ -374896,7 +374896,7 @@ self: { vector ]; description = "Elias-Fano"; - license = lib.licensesSpdx."BSD-3-Clause"; + license = lib.meta.getLicenseFromSpdxId "BSD-3-Clause"; hydraPlatforms = lib.platforms.none; mainProgram = "hw-eliasfano"; } @@ -374959,7 +374959,7 @@ self: { vector ]; description = "Excess"; - license = lib.licensesSpdx."BSD-3-Clause"; + license = lib.meta.getLicenseFromSpdxId "BSD-3-Clause"; hydraPlatforms = lib.platforms.none; } ) { }; @@ -375002,7 +375002,7 @@ self: { hspec-discover ]; description = "Generic finger-tree structure, with example instances"; - license = lib.licensesSpdx."BSD-3-Clause"; + license = lib.meta.getLicenseFromSpdxId "BSD-3-Clause"; } ) { }; @@ -375051,7 +375051,7 @@ self: { hspec-discover ]; description = "Generic strict finger-tree structure"; - license = lib.licensesSpdx."BSD-3-Clause"; + license = lib.meta.getLicenseFromSpdxId "BSD-3-Clause"; hydraPlatforms = lib.platforms.none; broken = true; } @@ -375084,7 +375084,7 @@ self: { ]; testToolDepends = [ doctest-discover ]; description = "Extra hedgehog functionality"; - license = lib.licensesSpdx."BSD-3-Clause"; + license = lib.meta.getLicenseFromSpdxId "BSD-3-Clause"; hydraPlatforms = lib.platforms.none; broken = true; } @@ -375131,7 +375131,7 @@ self: { hspec-discover ]; description = "Interoperability between hspec and hedgehog"; - license = lib.licensesSpdx."BSD-3-Clause"; + license = lib.meta.getLicenseFromSpdxId "BSD-3-Clause"; } ) { }; @@ -375168,7 +375168,7 @@ self: { hspec-discover ]; description = "Additional facilities for Integers"; - license = lib.licensesSpdx."BSD-3-Clause"; + license = lib.meta.getLicenseFromSpdxId "BSD-3-Clause"; hydraPlatforms = lib.platforms.none; } ) { }; @@ -375240,7 +375240,7 @@ self: { ]; doHaddock = false; description = "Library for manipulating IP addresses and CIDR blocks"; - license = lib.licensesSpdx."BSD-3-Clause"; + license = lib.meta.getLicenseFromSpdxId "BSD-3-Clause"; hydraPlatforms = lib.platforms.none; mainProgram = "hw-ip"; } @@ -375378,7 +375378,7 @@ self: { ]; doHaddock = false; description = "Memory efficient JSON parser"; - license = lib.licensesSpdx."BSD-3-Clause"; + license = lib.meta.getLicenseFromSpdxId "BSD-3-Clause"; hydraPlatforms = lib.platforms.none; mainProgram = "hw-json"; } @@ -375426,7 +375426,7 @@ self: { ]; doHaddock = false; description = "Memory efficient JSON parser"; - license = lib.licensesSpdx."BSD-3-Clause"; + license = lib.meta.getLicenseFromSpdxId "BSD-3-Clause"; hydraPlatforms = lib.platforms.none; } ) { }; @@ -375501,7 +375501,7 @@ self: { lens ]; description = "Lens for hw-json"; - license = lib.licensesSpdx."BSD-3-Clause"; + license = lib.meta.getLicenseFromSpdxId "BSD-3-Clause"; hydraPlatforms = lib.platforms.none; } ) { }; @@ -375554,7 +375554,7 @@ self: { ]; testToolDepends = [ doctest-discover ]; description = "SIMD-based JSON semi-indexer"; - license = lib.licensesSpdx."BSD-3-Clause"; + license = lib.meta.getLicenseFromSpdxId "BSD-3-Clause"; mainProgram = "hw-json-simd"; } ) { }; @@ -375647,7 +375647,7 @@ self: { mmap ]; description = "Memory efficient JSON parser"; - license = lib.licensesSpdx."BSD-3-Clause"; + license = lib.meta.getLicenseFromSpdxId "BSD-3-Clause"; hydraPlatforms = lib.platforms.none; mainProgram = "hw-json"; } @@ -375748,7 +375748,7 @@ self: { mmap ]; description = "Memory efficient JSON parser"; - license = lib.licensesSpdx."BSD-3-Clause"; + license = lib.meta.getLicenseFromSpdxId "BSD-3-Clause"; hydraPlatforms = lib.platforms.none; mainProgram = "hw-json-standard-cursor"; } @@ -375814,7 +375814,7 @@ self: { hw-hspec-hedgehog ]; description = "Avro support for Kafka infrastructure"; - license = lib.licensesSpdx."BSD-3-Clause"; + license = lib.meta.getLicenseFromSpdxId "BSD-3-Clause"; hydraPlatforms = lib.platforms.none; } ) { }; @@ -375865,7 +375865,7 @@ self: { ]; testToolDepends = [ hspec-discover ]; description = "Kafka bindings for Haskell"; - license = lib.licensesSpdx."MIT"; + license = lib.meta.getLicenseFromSpdxId "MIT"; } ) { inherit (pkgs) rdkafka; }; @@ -375924,7 +375924,7 @@ self: { ]; testToolDepends = [ hspec-discover ]; description = "Conduit bindings for hw-kafka-client"; - license = lib.licensesSpdx."MIT"; + license = lib.meta.getLicenseFromSpdxId "MIT"; hydraPlatforms = lib.platforms.none; broken = true; } @@ -375969,7 +375969,7 @@ self: { hspec-discover ]; description = "Combinators for lazy IO"; - license = lib.licensesSpdx."BSD-3-Clause"; + license = lib.meta.getLicenseFromSpdxId "BSD-3-Clause"; hydraPlatforms = lib.platforms.none; broken = true; } @@ -376017,7 +376017,7 @@ self: { hspec-discover ]; description = "Monadic query DSL"; - license = lib.licensesSpdx."BSD-3-Clause"; + license = lib.meta.getLicenseFromSpdxId "BSD-3-Clause"; mainProgram = "hw-mquery-example"; } ) { }; @@ -376099,7 +376099,7 @@ self: { vector ]; description = "Packed Vector"; - license = lib.licensesSpdx."BSD-3-Clause"; + license = lib.meta.getLicenseFromSpdxId "BSD-3-Clause"; hydraPlatforms = lib.platforms.none; mainProgram = "hw-packed-vector"; broken = true; @@ -376147,7 +376147,7 @@ self: { hspec-discover ]; description = "Simple parser support"; - license = lib.licensesSpdx."BSD-3-Clause"; + license = lib.meta.getLicenseFromSpdxId "BSD-3-Clause"; hydraPlatforms = lib.platforms.none; broken = true; } @@ -376183,7 +376183,7 @@ self: { ]; testToolDepends = [ hspec-discover ]; description = "Primitive functions and data types"; - license = lib.licensesSpdx."BSD-3-Clause"; + license = lib.meta.getLicenseFromSpdxId "BSD-3-Clause"; hydraPlatforms = lib.platforms.none; broken = true; } @@ -376292,7 +376292,7 @@ self: { testToolDepends = [ tasty-discover ]; doHaddock = false; description = "Opinionated polysemy library"; - license = lib.licensesSpdx."Apache-2.0"; + license = lib.meta.getLicenseFromSpdxId "Apache-2.0"; hydraPlatforms = lib.platforms.none; broken = true; } @@ -376339,7 +376339,7 @@ self: { unliftio ]; description = "Opinionated prelude library"; - license = lib.licensesSpdx."Apache-2.0"; + license = lib.meta.getLicenseFromSpdxId "Apache-2.0"; } ) { }; @@ -376409,7 +376409,7 @@ self: { vector ]; description = "Primitive functions and data types"; - license = lib.licensesSpdx."BSD-3-Clause"; + license = lib.meta.getLicenseFromSpdxId "BSD-3-Clause"; } ) { }; @@ -376456,7 +376456,7 @@ self: { vector ]; description = "Primitive support for bit manipulation"; - license = lib.licensesSpdx."BSD-3-Clause"; + license = lib.meta.getLicenseFromSpdxId "BSD-3-Clause"; platforms = lib.platforms.x86; hydraPlatforms = lib.platforms.none; mainProgram = "hw-prim-bits-exe"; @@ -376564,7 +376564,7 @@ self: { ]; doHaddock = false; description = "Rank-select"; - license = lib.licensesSpdx."BSD-3-Clause"; + license = lib.meta.getLicenseFromSpdxId "BSD-3-Clause"; hydraPlatforms = lib.platforms.none; mainProgram = "hw-rankselect"; } @@ -376635,7 +376635,7 @@ self: { vector ]; description = "Rank-select base"; - license = lib.licensesSpdx."BSD-3-Clause"; + license = lib.meta.getLicenseFromSpdxId "BSD-3-Clause"; hydraPlatforms = lib.platforms.none; broken = true; } @@ -376731,7 +376731,7 @@ self: { vector ]; description = "SIMD library"; - license = lib.licensesSpdx."BSD-3-Clause"; + license = lib.meta.getLicenseFromSpdxId "BSD-3-Clause"; hydraPlatforms = lib.platforms.none; } ) { }; @@ -376813,7 +376813,7 @@ self: { ]; testToolDepends = [ doctest-discover ]; description = "SIMD library"; - license = lib.licensesSpdx."BSD-3-Clause"; + license = lib.meta.getLicenseFromSpdxId "BSD-3-Clause"; hydraPlatforms = lib.platforms.none; mainProgram = "hw-simd"; broken = true; @@ -376894,7 +376894,7 @@ self: { vector ]; description = "Primitive functions and data types"; - license = lib.licensesSpdx."BSD-3-Clause"; + license = lib.meta.getLicenseFromSpdxId "BSD-3-Clause"; hydraPlatforms = lib.platforms.none; } ) { }; @@ -376932,7 +376932,7 @@ self: { hspec-discover ]; description = "String parser"; - license = lib.licensesSpdx."BSD-3-Clause"; + license = lib.meta.getLicenseFromSpdxId "BSD-3-Clause"; hydraPlatforms = lib.platforms.none; broken = true; } @@ -377013,7 +377013,7 @@ self: { ]; testToolDepends = [ hspec-discover ]; description = "Library for creating and extracting tar archives"; - license = lib.licensesSpdx."BSD-3-Clause"; + license = lib.meta.getLicenseFromSpdxId "BSD-3-Clause"; hydraPlatforms = lib.platforms.none; mainProgram = "hw-tar"; broken = true; @@ -377112,7 +377112,7 @@ self: { ]; testToolDepends = [ hspec-discover ]; description = "Supports IO on URIs"; - license = lib.licensesSpdx."BSD-3-Clause"; + license = lib.meta.getLicenseFromSpdxId "BSD-3-Clause"; hydraPlatforms = lib.platforms.none; mainProgram = "hw-uri"; } @@ -377270,7 +377270,7 @@ self: { vector ]; description = "XML parser based on succinct data structures"; - license = lib.licensesSpdx."BSD-3-Clause"; + license = lib.meta.getLicenseFromSpdxId "BSD-3-Clause"; hydraPlatforms = lib.platforms.none; mainProgram = "hw-xml"; broken = true; @@ -378565,7 +378565,7 @@ self: { random ]; description = "A Yahtzee game implementation in Haskell"; - license = lib.licensesSpdx."BSD-3-Clause"; + license = lib.meta.getLicenseFromSpdxId "BSD-3-Clause"; mainProgram = "hyahtzee"; } ) { }; @@ -379406,7 +379406,7 @@ self: { text ]; description = "Display class for the HyperHaskell graphical Haskell interpreter"; - license = lib.licensesSpdx."BSD-3-Clause"; + license = lib.meta.getLicenseFromSpdxId "BSD-3-Clause"; } ) { }; @@ -379439,7 +379439,7 @@ self: { text ]; description = "Display instances for the HyperHaskell graphical Haskell interpreter"; - license = lib.licensesSpdx."BSD-3-Clause"; + license = lib.meta.getLicenseFromSpdxId "BSD-3-Clause"; } ) { }; @@ -379480,7 +379480,7 @@ self: { transformers ]; description = "Server back-end for the HyperHaskell graphical Haskell interpreter"; - license = lib.licensesSpdx."BSD-3-Clause"; + license = lib.meta.getLicenseFromSpdxId "BSD-3-Clause"; mainProgram = "hyper-haskell-server"; } ) { }; @@ -379560,7 +379560,7 @@ self: { websockets ]; description = "Interactive HTML apps using type-safe serverside Haskell"; - license = lib.licensesSpdx."BSD-3-Clause"; + license = lib.meta.getLicenseFromSpdxId "BSD-3-Clause"; hydraPlatforms = lib.platforms.none; } ) { }; @@ -379665,7 +379665,7 @@ self: { ]; testToolDepends = [ skeletest ]; description = "Interactive HTML apps using type-safe serverside Haskell"; - license = lib.licensesSpdx."BSD-3-Clause"; + license = lib.meta.getLicenseFromSpdxId "BSD-3-Clause"; hydraPlatforms = lib.platforms.none; } ) { }; @@ -379759,7 +379759,7 @@ self: { tasty-hunit ]; description = "Hypergeometric function of a matrix argument"; - license = lib.licensesSpdx."BSD-3-Clause"; + license = lib.meta.getLicenseFromSpdxId "BSD-3-Clause"; hydraPlatforms = lib.platforms.none; broken = true; } @@ -380567,7 +380567,7 @@ self: { tasty-hunit ]; description = "Haskell interval types. Bounds checking."; - license = lib.licensesSpdx."Apache-2.0"; + license = lib.meta.getLicenseFromSpdxId "Apache-2.0"; hydraPlatforms = lib.platforms.none; broken = true; } @@ -380744,7 +380744,7 @@ self: { time ]; description = "iCalendar data types, parser, and printer"; - license = lib.licensesSpdx."BSD-3-Clause"; + license = lib.meta.getLicenseFromSpdxId "BSD-3-Clause"; } ) { }; @@ -381777,7 +381777,7 @@ self: { tf-random ]; description = "Flexible generation of identicons"; - license = lib.licensesSpdx."BSD-3-Clause"; + license = lib.meta.getLicenseFromSpdxId "BSD-3-Clause"; } ) { }; @@ -381993,7 +381993,7 @@ self: { text ]; description = "Pure Haskell IDN and Punycode implementation"; - license = lib.licensesSpdx."BSD-3-Clause"; + license = lib.meta.getLicenseFromSpdxId "BSD-3-Clause"; } ) { }; @@ -382229,7 +382229,7 @@ self: { transformers ]; description = "Functional Programming Language with Dependent Types"; - license = lib.licensesSpdx."BSD-3-Clause"; + license = lib.meta.getLicenseFromSpdxId "BSD-3-Clause"; } ) { inherit (pkgs) gmp; }; @@ -382380,7 +382380,7 @@ self: { ]; doHaddock = false; description = "Branch on whether a constraint is satisfied"; - license = lib.licensesSpdx."BSD-3-Clause"; + license = lib.meta.getLicenseFromSpdxId "BSD-3-Clause"; hydraPlatforms = lib.platforms.none; broken = true; } @@ -382435,7 +382435,7 @@ self: { bytestring ]; description = "Constructing and dissecting IFF files"; - license = lib.licensesSpdx."GPL-3.0-only"; + license = lib.meta.getLicenseFromSpdxId "GPL-3.0-only"; maintainers = [ lib.maintainers.thielema ]; } ) { }; @@ -383121,7 +383121,7 @@ self: { ihaskell text ]; - license = lib.licensesSpdx."BSD-3-Clause"; + license = lib.meta.getLicenseFromSpdxId "BSD-3-Clause"; mainProgram = "ihaskell-dataframe-exe"; } ) { }; @@ -383988,7 +383988,7 @@ self: { wreq ]; description = "Haskell Web Framework"; - license = lib.licensesSpdx."MIT"; + license = lib.meta.getLicenseFromSpdxId "MIT"; hydraPlatforms = lib.platforms.none; maintainers = [ lib.maintainers.mpscholten ]; } @@ -384009,7 +384009,7 @@ self: { typerep-map ]; description = "Minimal typed context container for IHP"; - license = lib.licensesSpdx."MIT"; + license = lib.meta.getLicenseFromSpdxId "MIT"; } ) { }; @@ -384157,7 +384157,7 @@ self: { websockets ]; description = "IHP DataSync Framework"; - license = lib.licensesSpdx."MIT"; + license = lib.meta.getLicenseFromSpdxId "MIT"; hydraPlatforms = lib.platforms.none; } ) { }; @@ -384199,7 +384199,7 @@ self: { neat-interpolation ]; description = "TypeScript code generation for IHP DataSync"; - license = lib.licensesSpdx."MIT"; + license = lib.meta.getLicenseFromSpdxId "MIT"; hydraPlatforms = lib.platforms.none; mainProgram = "generate-datasync-types"; } @@ -384254,7 +384254,7 @@ self: { unordered-containers ]; description = "GraphQL support for IHP"; - license = lib.licensesSpdx."MIT"; + license = lib.meta.getLicenseFromSpdxId "MIT"; hydraPlatforms = lib.platforms.none; } ) { }; @@ -384292,7 +384292,7 @@ self: { wai-request-params ]; description = "Test helpers for IHP apps"; - license = lib.licensesSpdx."MIT"; + license = lib.meta.getLicenseFromSpdxId "MIT"; hydraPlatforms = lib.platforms.none; } ) { }; @@ -384351,7 +384351,7 @@ self: { ]; doHaddock = false; description = "JSX-like but for Haskell"; - license = lib.licensesSpdx."MIT"; + license = lib.meta.getLicenseFromSpdxId "MIT"; maintainers = [ lib.maintainers.mpscholten ]; } ) { }; @@ -384630,7 +384630,7 @@ self: { wreq ]; description = "Dev tools for IHP"; - license = lib.licensesSpdx."MIT"; + license = lib.meta.getLicenseFromSpdxId "MIT"; hydraPlatforms = lib.platforms.none; maintainers = [ lib.maintainers.mpscholten ]; } @@ -384659,7 +384659,7 @@ self: { wai-extra ]; description = "ImageMagick preprocessing for IHP file uploads"; - license = lib.licensesSpdx."MIT"; + license = lib.meta.getLicenseFromSpdxId "MIT"; } ) { }; @@ -384702,7 +384702,7 @@ self: { wai-request-params ]; description = "Dashboard for IHP job runners"; - license = lib.licensesSpdx."MIT"; + license = lib.meta.getLicenseFromSpdxId "MIT"; hydraPlatforms = lib.platforms.none; } ) { }; @@ -384734,7 +384734,7 @@ self: { wai-extra ]; description = "Lightweight logging for IHP applications"; - license = lib.licensesSpdx."MIT"; + license = lib.meta.getLicenseFromSpdxId "MIT"; } ) { }; @@ -384775,7 +384775,7 @@ self: { typerep-map ]; description = "Email support for IHP"; - license = lib.licensesSpdx."MIT"; + license = lib.meta.getLicenseFromSpdxId "MIT"; hydraPlatforms = lib.platforms.none; } ) { }; @@ -384797,7 +384797,7 @@ self: { with-utf8 ]; description = "Provides the IHP migrate binary"; - license = lib.licensesSpdx."MIT"; + license = lib.meta.getLicenseFromSpdxId "MIT"; hydraPlatforms = lib.platforms.none; mainProgram = "migrate"; maintainers = [ lib.maintainers.mpscholten ]; @@ -384829,7 +384829,7 @@ self: { wai ]; description = "Modal dialog support for IHP applications"; - license = lib.licensesSpdx."MIT"; + license = lib.meta.getLicenseFromSpdxId "MIT"; } ) { }; @@ -384875,7 +384875,7 @@ self: { text ]; description = "Call GPT4 from your Haskell apps"; - license = lib.licensesSpdx."MIT"; + license = lib.meta.getLicenseFromSpdxId "MIT"; maintainers = [ lib.maintainers.mpscholten ]; } ) { }; @@ -384905,7 +384905,7 @@ self: { wai ]; description = "Page title and meta tags for IHP"; - license = lib.licensesSpdx."MIT"; + license = lib.meta.getLicenseFromSpdxId "MIT"; } ) { }; @@ -384969,7 +384969,7 @@ self: { uuid ]; description = "PostgreSQL LISTEN/NOTIFY channel manager for IHP"; - license = lib.licensesSpdx."MIT"; + license = lib.meta.getLicenseFromSpdxId "MIT"; } ) { }; @@ -385009,7 +385009,7 @@ self: { text ]; description = "PostgreSQL DDL parser and compiler"; - license = lib.licensesSpdx."MIT"; + license = lib.meta.getLicenseFromSpdxId "MIT"; } ) { }; @@ -385061,7 +385061,7 @@ self: { ]; testToolDepends = [ hspec-discover ]; description = "Extra data types for postgresql-simple"; - license = lib.licensesSpdx."MIT"; + license = lib.meta.getLicenseFromSpdxId "MIT"; maintainers = [ lib.maintainers.mpscholten ]; } ) { }; @@ -385124,7 +385124,7 @@ self: { with-utf8 ]; description = "Lightweight schema compiler for IHP"; - license = lib.licensesSpdx."MIT"; + license = lib.meta.getLicenseFromSpdxId "MIT"; hydraPlatforms = lib.platforms.none; mainProgram = "build-generated-code"; } @@ -385168,7 +385168,7 @@ self: { wai-extra ]; description = "SEO"; - license = lib.licensesSpdx."MIT"; + license = lib.meta.getLicenseFromSpdxId "MIT"; hydraPlatforms = lib.platforms.none; } ) { }; @@ -385214,7 +385214,7 @@ self: { websockets ]; description = "Server Side Components for IHP"; - license = lib.licensesSpdx."MIT"; + license = lib.meta.getLicenseFromSpdxId "MIT"; hydraPlatforms = lib.platforms.none; } ) { }; @@ -385283,7 +385283,7 @@ self: { text ]; description = "Compile-time typed SQL quasiquoter for IHP"; - license = lib.licensesSpdx."MIT"; + license = lib.meta.getLicenseFromSpdxId "MIT"; hydraPlatforms = lib.platforms.none; } ) { }; @@ -385311,7 +385311,7 @@ self: { text ]; description = "IHP Welcome Controller"; - license = lib.licensesSpdx."MIT"; + license = lib.meta.getLicenseFromSpdxId "MIT"; hydraPlatforms = lib.platforms.none; } ) { }; @@ -385408,7 +385408,7 @@ self: { vector ]; description = "Optimised list functions for doing index-related things"; - license = lib.licensesSpdx."MPL-2.0"; + license = lib.meta.getLicenseFromSpdxId "MPL-2.0"; } ) { }; @@ -386200,7 +386200,7 @@ self: { xml-types ]; description = "Execute arbitrary actions for each item from RSS/Atom feeds"; - license = lib.licensesSpdx."CC0-1.0"; + license = lib.meta.getLicenseFromSpdxId "CC0-1.0"; hydraPlatforms = lib.platforms.none; broken = true; } @@ -386464,7 +386464,7 @@ self: { wires ]; description = "Immutaball platformer game (prototype version)"; - license = lib.licensesSpdx."0BSD"; + license = lib.meta.getLicenseFromSpdxId "0BSD"; hydraPlatforms = lib.platforms.none; } ) { }; @@ -386499,7 +386499,7 @@ self: { hspec ]; description = "A GHC plugin for automatically importing modules"; - license = lib.licensesSpdx."MIT"; + license = lib.meta.getLicenseFromSpdxId "MIT"; } ) { }; @@ -386691,7 +386691,7 @@ self: { ]; doHaddock = false; description = "Framework for defaulting superclasses"; - license = lib.licensesSpdx."MIT"; + license = lib.meta.getLicenseFromSpdxId "MIT"; hydraPlatforms = lib.platforms.none; broken = true; } @@ -386781,7 +386781,7 @@ self: { parsec ]; description = "A math-inspired programmatic 2D & 3D CAD system"; - license = lib.licensesSpdx."AGPL-3.0-or-later"; + license = lib.meta.getLicenseFromSpdxId "AGPL-3.0-or-later"; maintainers = [ lib.maintainers.sorki ]; } ) { }; @@ -386874,7 +386874,7 @@ self: { ]; testHaskellDepends = [ base ]; description = "Auto generate hie-bios cradles"; - license = lib.licensesSpdx."BSD-3-Clause"; + license = lib.meta.getLicenseFromSpdxId "BSD-3-Clause"; hydraPlatforms = lib.platforms.none; broken = true; } @@ -386949,7 +386949,7 @@ self: { yaml ]; description = "Helps maintain consistency of imports"; - license = lib.licensesSpdx."MIT"; + license = lib.meta.getLicenseFromSpdxId "MIT"; hydraPlatforms = lib.platforms.none; broken = true; } @@ -387553,7 +387553,7 @@ self: { polysemy-time ]; description = "A Prelude for Polysemy"; - license = lib.licensesSpdx."BSD-2-Clause-Patent"; + license = lib.meta.getLicenseFromSpdxId "BSD-2-Clause-Patent"; } ) { }; @@ -387580,7 +387580,7 @@ self: { text ]; description = "A Prelude for Polysemy – Base Reexports"; - license = lib.licensesSpdx."BSD-2-Clause-Patent"; + license = lib.meta.getLicenseFromSpdxId "BSD-2-Clause-Patent"; } ) { }; @@ -387601,7 +387601,7 @@ self: { polysemy ]; description = "A Prelude for Polysemy"; - license = lib.licensesSpdx."BSD-2-Clause-Patent"; + license = lib.meta.getLicenseFromSpdxId "BSD-2-Clause-Patent"; } ) { }; @@ -388223,7 +388223,7 @@ self: { ]; testToolDepends = [ hspec-discover ]; description = "Simple, no-frills indexed lists"; - license = lib.licensesSpdx."BSD-3-Clause"; + license = lib.meta.getLicenseFromSpdxId "BSD-3-Clause"; hydraPlatforms = lib.platforms.none; broken = true; } @@ -388334,7 +388334,7 @@ self: { sha256 = "166329a5jmrs4q1ycb132gq7kbrdyzrvrxzzzwp5czmv00lvns9f"; libraryHaskellDepends = [ base ]; description = "Utilities for indexed profunctors"; - license = lib.licensesSpdx."BSD-3-Clause"; + license = lib.meta.getLicenseFromSpdxId "BSD-3-Clause"; } ) { }; @@ -388382,7 +388382,7 @@ self: { transformers ]; description = "Atkey indexed monad transformers"; - license = lib.licensesSpdx."BSD-3-Clause"; + license = lib.meta.getLicenseFromSpdxId "BSD-3-Clause"; } ) { }; @@ -388728,7 +388728,7 @@ self: { ]; testToolDepends = [ tasty-discover ]; description = "Convenient imperative eDSL over Lorentz"; - license = lib.licensesSpdx."MIT"; + license = lib.meta.getLicenseFromSpdxId "MIT"; hydraPlatforms = lib.platforms.none; mainProgram = "indigo"; } @@ -389105,7 +389105,7 @@ self: { text ]; description = "A statically-typed functional scripting language"; - license = lib.licensesSpdx."MIT"; + license = lib.meta.getLicenseFromSpdxId "MIT"; hydraPlatforms = lib.platforms.none; } ) { }; @@ -389379,7 +389379,7 @@ self: { tasty-quickcheck ]; description = "Infinite lists"; - license = lib.licensesSpdx."BSD-3-Clause"; + license = lib.meta.getLicenseFromSpdxId "BSD-3-Clause"; } ) { }; @@ -389818,7 +389818,7 @@ self: { sha256 = "0k3bl5adj512bzqysapnggvf6fmi0hs3mvxkymsh9af7gan8y504"; libraryHaskellDepends = [ base ]; description = "Initialization and Deinitialization of 'Storable' values"; - license = lib.licensesSpdx."BSD-3-Clause"; + license = lib.meta.getLicenseFromSpdxId "BSD-3-Clause"; hydraPlatforms = lib.platforms.none; broken = true; } @@ -389940,7 +389940,7 @@ self: { text ]; description = "Canonical categorical conversions (injections and projections)"; - license = lib.licensesSpdx."BSD-3-Clause"; + license = lib.meta.getLicenseFromSpdxId "BSD-3-Clause"; hydraPlatforms = lib.platforms.none; broken = true; } @@ -390108,7 +390108,7 @@ self: { vector ]; description = "Lets you embed C++ code into Haskell"; - license = lib.licensesSpdx."MIT"; + license = lib.meta.getLicenseFromSpdxId "MIT"; maintainers = [ lib.maintainers.roberth ]; } ) { }; @@ -390157,7 +390157,7 @@ self: { vector ]; description = "Lets you embed CUDA code into Haskell"; - license = lib.licensesSpdx."MIT"; + license = lib.meta.getLicenseFromSpdxId "MIT"; hydraPlatforms = lib.platforms.none; broken = true; } @@ -390188,7 +390188,7 @@ self: { inline-c ]; description = "Lets you embed Objective-C code into Haskell"; - license = lib.licensesSpdx."MIT"; + license = lib.meta.getLicenseFromSpdxId "MIT"; hydraPlatforms = lib.platforms.none; broken = true; } @@ -390346,7 +390346,7 @@ self: { ]; doHaddock = false; description = "Python interpreter embedded into haskell"; - license = lib.licensesSpdx."BSD-3-Clause"; + license = lib.meta.getLicenseFromSpdxId "BSD-3-Clause"; } ) { inherit (pkgs) python3; }; @@ -390445,7 +390445,7 @@ self: { template-haskell ]; description = "Seamlessly call R from Haskell and vice versa. No FFI required."; - license = lib.licensesSpdx."BSD-3-Clause"; + license = lib.meta.getLicenseFromSpdxId "BSD-3-Clause"; } ) { inherit (pkgs) R; }; @@ -390608,7 +390608,7 @@ self: { unordered-containers ]; description = "Associative containers retaining insertion order for traversals"; - license = lib.licensesSpdx."BSD-3-Clause"; + license = lib.meta.getLicenseFromSpdxId "BSD-3-Clause"; } ) { }; @@ -390660,7 +390660,7 @@ self: { unordered-containers ]; description = "Associative containers retaining insertion order for traversals"; - license = lib.licensesSpdx."BSD-3-Clause"; + license = lib.meta.getLicenseFromSpdxId "BSD-3-Clause"; hydraPlatforms = lib.platforms.none; } ) { }; @@ -391453,7 +391453,7 @@ self: { tasty-quickcheck ]; description = "Direct conversion functions between Ints and Words"; - license = lib.licensesSpdx."BSD-3-Clause"; + license = lib.meta.getLicenseFromSpdxId "BSD-3-Clause"; } ) { }; @@ -391583,7 +391583,7 @@ self: { editedCabalFile = "0xrz0pp0lxq16vw62ad6rnzx6xbkxngdn58h63sjfwnwd1fp960x"; libraryHaskellDepends = [ base ]; description = "A simple, efficient supply of integers using atomic fetch-and-add"; - license = lib.licensesSpdx."BSD-3-Clause"; + license = lib.meta.getLicenseFromSpdxId "BSD-3-Clause"; } ) { }; @@ -391613,7 +391613,7 @@ self: { primitive ]; description = "Advent of Code 2019 intcode interpreter"; - license = lib.licensesSpdx."ISC"; + license = lib.meta.getLicenseFromSpdxId "ISC"; hydraPlatforms = lib.platforms.none; broken = true; } @@ -391658,7 +391658,7 @@ self: { text ]; description = "Conversion from strings to Integer"; - license = lib.licensesSpdx."BSD-3-Clause"; + license = lib.meta.getLicenseFromSpdxId "BSD-3-Clause"; } ) { }; @@ -391810,7 +391810,7 @@ self: { quaalude ]; description = "Integer, Natural, and Positive"; - license = lib.licensesSpdx."Apache-2.0"; + license = lib.meta.getLicenseFromSpdxId "Apache-2.0"; hydraPlatforms = lib.platforms.none; broken = true; } @@ -391977,7 +391977,7 @@ self: { unix ]; description = "Poll modern Intel/AMD CPU power consumption on Linux via RAPL"; - license = lib.licensesSpdx."AGPL-3.0-only"; + license = lib.meta.getLicenseFromSpdxId "AGPL-3.0-only"; mainProgram = "intel-powermon"; } ) { }; @@ -392083,7 +392083,7 @@ self: { vector ]; description = "Type level prompt with LLMs via louter"; - license = lib.licensesSpdx."MIT"; + license = lib.meta.getLicenseFromSpdxId "MIT"; hydraPlatforms = lib.platforms.none; broken = true; } @@ -392126,7 +392126,7 @@ self: { testHaskellDepends = [ base ]; doHaddock = false; description = "A GHC Core plugin for intensional datatype refinement checking"; - license = lib.licensesSpdx."BSD-3-Clause"; + license = lib.meta.getLicenseFromSpdxId "BSD-3-Clause"; hydraPlatforms = lib.platforms.none; broken = true; } @@ -392348,7 +392348,7 @@ self: { sha256 = "1wf6g0a1pz6xiixqnkrdjlb2xr4ck2vab9vd0w6kp0pbhqc6qysp"; libraryHaskellDepends = [ base ]; description = "Some simple functions to deal with transformations from structures to other ones, basically lists"; - license = lib.licensesSpdx."MIT"; + license = lib.meta.getLicenseFromSpdxId "MIT"; } ) { }; @@ -392802,7 +392802,7 @@ self: { utility-ht ]; description = "piecewise linear and cubic Hermite interpolation"; - license = lib.licensesSpdx."BSD-3-Clause"; + license = lib.meta.getLicenseFromSpdxId "BSD-3-Clause"; maintainers = [ lib.maintainers.thielema ]; } ) { }; @@ -392889,7 +392889,7 @@ self: { typed-process ]; description = "Shared memory and control structures for IPC"; - license = lib.licensesSpdx."BSD-3-Clause"; + license = lib.meta.getLicenseFromSpdxId "BSD-3-Clause"; } ) { }; @@ -393031,7 +393031,7 @@ self: { ]; testToolDepends = [ hspec-discover ]; description = "An implementation of Allen's interval algebra for temporal logic"; - license = lib.licensesSpdx."BSD-3-Clause"; + license = lib.meta.getLicenseFromSpdxId "BSD-3-Clause"; hydraPlatforms = lib.platforms.none; mainProgram = "tutorial"; broken = true; @@ -393058,7 +393058,7 @@ self: { hedgehog ]; description = "Intervals of functors"; - license = lib.licensesSpdx."BSD-3-Clause"; + license = lib.meta.getLicenseFromSpdxId "BSD-3-Clause"; } ) { }; @@ -393116,7 +393116,7 @@ self: { time-compat ]; description = "Intervals, and monoids thereof"; - license = lib.licensesSpdx."BSD-3-Clause"; + license = lib.meta.getLicenseFromSpdxId "BSD-3-Clause"; } ) { }; @@ -393138,7 +393138,7 @@ self: { QuickCheck ]; description = "Interval Tree Clocks"; - license = lib.licensesSpdx."MIT"; + license = lib.meta.getLicenseFromSpdxId "MIT"; hydraPlatforms = lib.platforms.none; broken = true; } @@ -393259,7 +393259,7 @@ self: { vector ]; description = "A game of competitive puzzle-design"; - license = lib.licensesSpdx."GPL-3.0-or-later"; + license = lib.meta.getLicenseFromSpdxId "GPL-3.0-or-later"; badPlatforms = lib.platforms.darwin; hydraPlatforms = lib.platforms.none; mainProgram = "intricacy"; @@ -393701,7 +393701,7 @@ self: { vector ]; description = "Automatically generate a function’s inverse"; - license = lib.licensesSpdx."Apache-2.0"; + license = lib.meta.getLicenseFromSpdxId "Apache-2.0"; hydraPlatforms = lib.platforms.none; broken = true; } @@ -393993,7 +393993,7 @@ self: { ]; doHaddock = false; description = "Type classes for concurrency with STM, ST and timing"; - license = lib.licensesSpdx."Apache-2.0"; + license = lib.meta.getLicenseFromSpdxId "Apache-2.0"; } ) { }; @@ -394020,7 +394020,7 @@ self: { si-timers ]; description = "Experimental MTL instances for io-classes"; - license = lib.licensesSpdx."Apache-2.0"; + license = lib.meta.getLicenseFromSpdxId "Apache-2.0"; hydraPlatforms = lib.platforms.none; } ) { }; @@ -394050,7 +394050,7 @@ self: { template-haskell ]; description = "Use Template Haskell to embed the result of an IO computation"; - license = lib.licensesSpdx."BSD-3-Clause"; + license = lib.meta.getLicenseFromSpdxId "BSD-3-Clause"; } ) { }; @@ -394223,7 +394223,7 @@ self: { io-classes ]; description = "A pure simulator for monadic concurrency with STM"; - license = lib.licensesSpdx."Apache-2.0"; + license = lib.meta.getLicenseFromSpdxId "Apache-2.0"; } ) { }; @@ -394648,7 +394648,7 @@ self: { text ]; description = "Library for IP and MAC addresses"; - license = lib.licensesSpdx."BSD-3-Clause"; + license = lib.meta.getLicenseFromSpdxId "BSD-3-Clause"; } ) { }; @@ -394842,7 +394842,7 @@ self: { text ]; description = "Internal Phonetic Alphabet (IPA)"; - license = lib.licensesSpdx."BSD-3-Clause"; + license = lib.meta.getLicenseFromSpdxId "BSD-3-Clause"; } ) { }; @@ -394989,7 +394989,7 @@ self: { temporary ]; description = "Generate a database for IPE data"; - license = lib.licensesSpdx."BSD-3-Clause"; + license = lib.meta.getLicenseFromSpdxId "BSD-3-Clause"; mainProgram = "ipedb"; } ) { }; @@ -395110,7 +395110,7 @@ self: { text ]; description = "Auto-generated IPFS HTTP API"; - license = lib.licensesSpdx."BSD-3-Clause"; + license = lib.meta.getLicenseFromSpdxId "BSD-3-Clause"; } ) { }; @@ -395155,7 +395155,7 @@ self: { text ]; description = "IPLD Content-IDentifiers "; - license = lib.licensesSpdx."BSD-3-Clause"; + license = lib.meta.getLicenseFromSpdxId "BSD-3-Clause"; hydraPlatforms = lib.platforms.none; } ) { }; @@ -395763,7 +395763,7 @@ self: { text ]; description = "IRC core library for glirc"; - license = lib.licensesSpdx."ISC"; + license = lib.meta.getLicenseFromSpdxId "ISC"; } ) { }; @@ -396166,7 +396166,7 @@ self: { ]; doHaddock = false; description = "RFC-compliant universal resource identifier library (URL, URI, IRI)"; - license = lib.licensesSpdx."MIT"; + license = lib.meta.getLicenseFromSpdxId "MIT"; } ) { }; @@ -396336,7 +396336,7 @@ self: { text ]; description = "Haskell CLI framework"; - license = lib.licensesSpdx."MPL-2.0"; + license = lib.meta.getLicenseFromSpdxId "MPL-2.0"; hydraPlatforms = lib.platforms.none; broken = true; } @@ -396508,7 +396508,7 @@ self: { text ]; description = "ISBN Validation and Manipulation"; - license = lib.licensesSpdx."Apache-2.0"; + license = lib.meta.getLicenseFromSpdxId "Apache-2.0"; } ) { }; @@ -397056,7 +397056,7 @@ self: { text ]; description = "Isomorphism typeclass as a lawful solution to the conversion problem"; - license = lib.licensesSpdx."MIT"; + license = lib.meta.getLicenseFromSpdxId "MIT"; } ) { }; @@ -398886,7 +398886,7 @@ self: { ]; doHaddock = false; description = "Functional, expression-oriented data processing language"; - license = lib.licensesSpdx."AGPL-3.0-only"; + license = lib.meta.getLicenseFromSpdxId "AGPL-3.0-only"; mainProgram = "ja"; maintainers = [ lib.maintainers.sternenseemann ]; } @@ -398929,7 +398929,7 @@ self: { ]; libraryPkgconfigDepends = [ libjack2 ]; description = "Bindings for the JACK Audio Connection Kit"; - license = lib.licensesSpdx."GPL-2.0-only"; + license = lib.meta.getLicenseFromSpdxId "GPL-2.0-only"; maintainers = [ lib.maintainers.thielema ]; } ) { inherit (pkgs) libjack2; }; @@ -399173,7 +399173,7 @@ self: { ]; testToolDepends = [ tasty-discover ]; description = "Generate flamegraphs from Jaeger .json dumps."; - license = lib.licensesSpdx."BSD-3-Clause"; + license = lib.meta.getLicenseFromSpdxId "BSD-3-Clause"; hydraPlatforms = lib.platforms.none; mainProgram = "jaeger-flamegraph"; broken = true; @@ -399429,7 +399429,7 @@ self: { ]; testToolDepends = [ hspec-discover ]; description = "Japanese holidays utility"; - license = lib.licensesSpdx."BSD-3-Clause"; + license = lib.meta.getLicenseFromSpdxId "BSD-3-Clause"; } ) { }; @@ -399541,7 +399541,7 @@ self: { ]; testToolDepends = [ hspec-discover ]; description = "Stack-based concatenative language embedded in Haskell"; - license = lib.licensesSpdx."MIT"; + license = lib.meta.getLicenseFromSpdxId "MIT"; hydraPlatforms = lib.platforms.none; broken = true; } @@ -400087,7 +400087,7 @@ self: { vector ]; description = "Labeled one-dimensional arrays"; - license = lib.licensesSpdx."MIT"; + license = lib.meta.getLicenseFromSpdxId "MIT"; mainProgram = "bench-report"; } ) { }; @@ -400136,7 +400136,7 @@ self: { vector ]; description = "Type-safe data frames based on higher-kinded types"; - license = lib.licensesSpdx."MIT"; + license = lib.meta.getLicenseFromSpdxId "MIT"; } ) { }; @@ -400183,7 +400183,7 @@ self: { vector ]; description = "IO operations for the `javelin` package"; - license = lib.licensesSpdx."MIT"; + license = lib.meta.getLicenseFromSpdxId "MIT"; } ) { }; @@ -400638,7 +400638,7 @@ self: { time ]; description = "Yet another streaming library"; - license = lib.licensesSpdx."BSD-3-Clause"; + license = lib.meta.getLicenseFromSpdxId "BSD-3-Clause"; } ) { }; @@ -400733,7 +400733,7 @@ self: { text ]; description = "Handle Jira wiki markup"; - license = lib.licensesSpdx."MIT"; + license = lib.meta.getLicenseFromSpdxId "MIT"; mainProgram = "jira-wiki-markup"; } ) { }; @@ -401151,7 +401151,7 @@ self: { time ]; description = "Job queue"; - license = lib.licensesSpdx."Apache-2.0"; + license = lib.meta.getLicenseFromSpdxId "Apache-2.0"; } ) { }; @@ -401511,7 +401511,7 @@ self: { text ]; description = "JSON with Structure"; - license = lib.licensesSpdx."MIT"; + license = lib.meta.getLicenseFromSpdxId "MIT"; hydraPlatforms = lib.platforms.none; broken = true; } @@ -401565,7 +401565,7 @@ self: { text ]; description = "OpenAPI Definitions for Jordan, Automatically"; - license = lib.licensesSpdx."MIT"; + license = lib.meta.getLicenseFromSpdxId "MIT"; hydraPlatforms = lib.platforms.none; } ) { }; @@ -401625,7 +401625,7 @@ self: { transformers ]; description = "Servant Combinators for Jordan"; - license = lib.licensesSpdx."MIT"; + license = lib.meta.getLicenseFromSpdxId "MIT"; hydraPlatforms = lib.platforms.none; } ) { }; @@ -401679,7 +401679,7 @@ self: { transformers ]; description = "Servant Client Instances for Jordan Servant Types"; - license = lib.licensesSpdx."MIT"; + license = lib.meta.getLicenseFromSpdxId "MIT"; hydraPlatforms = lib.platforms.none; } ) { }; @@ -401745,7 +401745,7 @@ self: { transformers ]; description = "OpenAPI schemas for Jordan-Powered Servant APIs"; - license = lib.licensesSpdx."MIT"; + license = lib.meta.getLicenseFromSpdxId "MIT"; hydraPlatforms = lib.platforms.none; } ) { }; @@ -401802,7 +401802,7 @@ self: { wai ]; description = "Servers for Jordan-Based Servant Combinators"; - license = lib.licensesSpdx."MIT"; + license = lib.meta.getLicenseFromSpdxId "MIT"; hydraPlatforms = lib.platforms.none; } ) { }; @@ -401904,7 +401904,7 @@ self: { time ]; description = "JSON Object Signing and Encryption (JOSE) and JSON Web Token (JWT) library"; - license = lib.licensesSpdx."Apache-2.0"; + license = lib.meta.getLicenseFromSpdxId "Apache-2.0"; } ) { }; @@ -401979,7 +401979,7 @@ self: { time ]; description = "JSON Object Signing and Encryption (JOSE) and JSON Web Token (JWT) library"; - license = lib.licensesSpdx."Apache-2.0"; + license = lib.meta.getLicenseFromSpdxId "Apache-2.0"; hydraPlatforms = lib.platforms.none; } ) { }; @@ -402149,7 +402149,7 @@ self: { hspec ]; description = "Transform Joy code using conditional rewrite rules"; - license = lib.licensesSpdx."BSD-2-Clause"; + license = lib.meta.getLicenseFromSpdxId "BSD-2-Clause"; hydraPlatforms = lib.platforms.none; broken = true; } @@ -402202,7 +402202,7 @@ self: { ]; testToolDepends = [ tasty-discover ]; description = "FFI bindings to libjpeg-turbo"; - license = lib.licensesSpdx."BSD-3-Clause"; + license = lib.meta.getLicenseFromSpdxId "BSD-3-Clause"; } ) { }; @@ -402484,7 +402484,7 @@ self: { transformers ]; description = "DOM library that uses jsaddle to support both GHCJS and GHC"; - license = lib.licensesSpdx."MIT"; + license = lib.meta.getLicenseFromSpdxId "MIT"; maintainers = [ lib.maintainers.alexfmpe ]; } ) { }; @@ -402519,7 +402519,7 @@ self: { text ]; description = "JSaddle Hello World, an example package"; - license = lib.licensesSpdx."MIT"; + license = lib.meta.getLicenseFromSpdxId "MIT"; hydraPlatforms = lib.platforms.none; } ) { }; @@ -402584,7 +402584,7 @@ self: { websockets ]; description = "Interface for JavaScript that works with GHCJS and GHC"; - license = lib.licensesSpdx."MIT"; + license = lib.meta.getLicenseFromSpdxId "MIT"; maintainers = [ lib.maintainers.alexfmpe lib.maintainers.maralorn @@ -402612,7 +402612,7 @@ self: { ]; doHaddock = false; description = "Run JSaddle JSM with the GHC Wasm backend"; - license = lib.licensesSpdx."CC0-1.0"; + license = lib.meta.getLicenseFromSpdxId "CC0-1.0"; } ) { }; @@ -402712,7 +402712,7 @@ self: { version = "0.9.9.3"; sha256 = "1icj9cll7ifrharpngwhzgfyxixckd6viwk94f8wmqbf4yyyfsmv"; description = "Interface for JavaScript that works with GHCJS and GHC"; - license = lib.licensesSpdx."MIT"; + license = lib.meta.getLicenseFromSpdxId "MIT"; platforms = lib.platforms.darwin; maintainers = [ lib.maintainers.alexfmpe ]; } @@ -402771,7 +402771,7 @@ self: { text ]; description = "Convenience utilities for JSDOM"; - license = lib.licensesSpdx."BSD-3-Clause"; + license = lib.meta.getLicenseFromSpdxId "BSD-3-Clause"; } ) { }; @@ -402828,7 +402828,7 @@ self: { text ]; description = "Support for serialising Haskell to and from JSON"; - license = lib.licensesSpdx."BSD-3-Clause"; + license = lib.meta.getLicenseFromSpdxId "BSD-3-Clause"; } ) { }; @@ -403346,7 +403346,7 @@ self: { text ]; description = "Load JSON from files in a directory structure"; - license = lib.licensesSpdx."BSD-3-Clause"; + license = lib.meta.getLicenseFromSpdxId "BSD-3-Clause"; mainProgram = "jsondir"; } ) { }; @@ -403486,7 +403486,7 @@ self: { hspec ]; description = "JSON Feed"; - license = lib.licensesSpdx."MIT"; + license = lib.meta.getLicenseFromSpdxId "MIT"; } ) { }; @@ -403911,7 +403911,7 @@ self: { text ]; description = "Kitchen sink for querying JSON"; - license = lib.licensesSpdx."BSD-3-Clause"; + license = lib.meta.getLicenseFromSpdxId "BSD-3-Clause"; hydraPlatforms = lib.platforms.none; } ) { }; @@ -404305,7 +404305,7 @@ self: { vector ]; description = "Type-level JSON specification"; - license = lib.licensesSpdx."MIT"; + license = lib.meta.getLicenseFromSpdxId "MIT"; } ) { }; @@ -404349,7 +404349,7 @@ self: { vector ]; description = "Type-level JSON specification"; - license = lib.licensesSpdx."MIT"; + license = lib.meta.getLicenseFromSpdxId "MIT"; hydraPlatforms = lib.platforms.none; } ) { }; @@ -404386,7 +404386,7 @@ self: { text ]; description = "Elm code generate for `json-spec`"; - license = lib.licensesSpdx."MIT"; + license = lib.meta.getLicenseFromSpdxId "MIT"; } ) { }; @@ -404422,7 +404422,7 @@ self: { text ]; description = "Elm code generate for `json-spec`"; - license = lib.licensesSpdx."MIT"; + license = lib.meta.getLicenseFromSpdxId "MIT"; hydraPlatforms = lib.platforms.none; } ) { }; @@ -404499,7 +404499,7 @@ self: { uuid ]; description = "Generated elm code for servant APIs"; - license = lib.licensesSpdx."MIT"; + license = lib.meta.getLicenseFromSpdxId "MIT"; } ) { }; @@ -404575,7 +404575,7 @@ self: { uuid ]; description = "Generated elm code for servant APIs"; - license = lib.licensesSpdx."MIT"; + license = lib.meta.getLicenseFromSpdxId "MIT"; hydraPlatforms = lib.platforms.none; } ) { }; @@ -404618,7 +404618,7 @@ self: { time ]; description = "json-spec-openapi"; - license = lib.licensesSpdx."MIT"; + license = lib.meta.getLicenseFromSpdxId "MIT"; } ) { }; @@ -404660,7 +404660,7 @@ self: { time ]; description = "json-spec-openapi"; - license = lib.licensesSpdx."MIT"; + license = lib.meta.getLicenseFromSpdxId "MIT"; hydraPlatforms = lib.platforms.none; } ) { }; @@ -404826,7 +404826,7 @@ self: { text ]; description = "High-performance JSON parser and encoder"; - license = lib.licensesSpdx."BSD-3-Clause"; + license = lib.meta.getLicenseFromSpdxId "BSD-3-Clause"; hydraPlatforms = lib.platforms.none; broken = true; } @@ -405020,7 +405020,7 @@ self: { vector ]; description = "Automatic type declaration for JSON input data"; - license = lib.licensesSpdx."BSD-3-Clause"; + license = lib.meta.getLicenseFromSpdxId "BSD-3-Clause"; hydraPlatforms = lib.platforms.none; mainProgram = "json-to-type"; broken = true; @@ -405124,7 +405124,7 @@ self: { text ]; description = "Tokenize JSON"; - license = lib.licensesSpdx."BSD-3-Clause"; + license = lib.meta.getLicenseFromSpdxId "BSD-3-Clause"; hydraPlatforms = lib.platforms.none; broken = true; } @@ -405536,7 +405536,7 @@ self: { text-builder ]; description = "Fast and simple JSON encoding toolkit"; - license = lib.licensesSpdx."MIT"; + license = lib.meta.getLicenseFromSpdxId "MIT"; } ) { }; @@ -405623,7 +405623,7 @@ self: { tasty-hunit ]; description = "JsonLogic Evaluation"; - license = lib.licensesSpdx."MIT"; + license = lib.meta.getLicenseFromSpdxId "MIT"; hydraPlatforms = lib.platforms.none; broken = true; } @@ -405673,7 +405673,7 @@ self: { tasty-hunit ]; description = "JsonLogic Aeson Support"; - license = lib.licensesSpdx."MIT"; + license = lib.meta.getLicenseFromSpdxId "MIT"; hydraPlatforms = lib.platforms.none; broken = true; } @@ -405772,7 +405772,7 @@ self: { text ]; description = "Jsonnet implementaton in pure Haskell"; - license = lib.licensesSpdx."BSD-3-Clause"; + license = lib.meta.getLicenseFromSpdxId "BSD-3-Clause"; hydraPlatforms = lib.platforms.none; mainProgram = "hs-jsonnet"; broken = true; @@ -405935,7 +405935,7 @@ self: { hspec ]; description = "JSON-RPC 2.0 types and type classes for Haskell"; - license = lib.licensesSpdx."MPL-2.0"; + license = lib.meta.getLicenseFromSpdxId "MPL-2.0"; } ) { }; @@ -406145,7 +406145,7 @@ self: { vector ]; description = "JSON Schema derivation and validation"; - license = lib.licensesSpdx."MPL-2.0"; + license = lib.meta.getLicenseFromSpdxId "MPL-2.0"; hydraPlatforms = lib.platforms.none; broken = true; } @@ -407357,7 +407357,7 @@ self: { text ]; description = "Application wrapper for the k8s environment"; - license = lib.licensesSpdx."MPL-2.0"; + license = lib.meta.getLicenseFromSpdxId "MPL-2.0"; hydraPlatforms = lib.platforms.none; broken = true; } @@ -407424,7 +407424,7 @@ self: { sha256 = "07x6dsc4d4f3vksi21fxd1vix9wqsydrl17f2xq8858m2ay0j28j"; doHaddock = false; description = "TBA"; - license = lib.licensesSpdx."BSD-3-Clause"; + license = lib.meta.getLicenseFromSpdxId "BSD-3-Clause"; } ) { }; @@ -407810,7 +407810,7 @@ self: { wide-word ]; description = "Serialization for kafka wire protocol"; - license = lib.licensesSpdx."BSD-3-Clause"; + license = lib.meta.getLicenseFromSpdxId "BSD-3-Clause"; hydraPlatforms = lib.platforms.none; broken = true; } @@ -408001,7 +408001,7 @@ self: { text ]; description = "Perform 漢字検定 (Japan Kanji Aptitude Test) level analysis on Japanese Kanji"; - license = lib.licensesSpdx."BSD-3-Clause"; + license = lib.meta.getLicenseFromSpdxId "BSD-3-Clause"; hydraPlatforms = lib.platforms.none; broken = true; } @@ -408632,7 +408632,7 @@ self: { ]; testToolDepends = [ tasty-discover ]; description = "Katip integration for Effectful"; - license = lib.licensesSpdx."BSD-3-Clause"; + license = lib.meta.getLicenseFromSpdxId "BSD-3-Clause"; hydraPlatforms = lib.platforms.none; broken = true; } @@ -408918,7 +408918,7 @@ self: { unordered-containers ]; description = "Katip scribe for raven (https://sentry.io)"; - license = lib.licensesSpdx."Apache-2.0"; + license = lib.meta.getLicenseFromSpdxId "Apache-2.0"; } ) { }; @@ -409087,7 +409087,7 @@ self: { ]; testToolDepends = [ hspec-discover ]; description = "WAI middleware for logging request and response info through katip"; - license = lib.licensesSpdx."BSD-3-Clause"; + license = lib.meta.getLicenseFromSpdxId "BSD-3-Clause"; } ) { }; @@ -409540,7 +409540,7 @@ self: { unliftio ]; description = "Unicode segmentation and shaping using kb_text_shape"; - license = lib.licensesSpdx."BSD-3-Clause"; + license = lib.meta.getLicenseFromSpdxId "BSD-3-Clause"; hydraPlatforms = lib.platforms.none; broken = true; } @@ -409760,7 +409760,7 @@ self: { ]; testToolDepends = [ skeletest ]; description = "KDL language parser and API"; - license = lib.licensesSpdx."BSD-3-Clause"; + license = lib.meta.getLicenseFromSpdxId "BSD-3-Clause"; mainProgram = "kdl-hs-test-decoder"; } ) { }; @@ -411146,7 +411146,7 @@ self: { ]; doHaddock = false; description = "Kempe compiler"; - license = lib.licensesSpdx."BSD-3-Clause"; + license = lib.meta.getLicenseFromSpdxId "BSD-3-Clause"; hydraPlatforms = lib.platforms.none; mainProgram = "kc"; broken = true; @@ -411400,7 +411400,7 @@ self: { wreq ]; description = "Web application deployment manager, focusing on Haskell web frameworks. It mitigates downtime."; - license = lib.licensesSpdx."MIT"; + license = lib.meta.getLicenseFromSpdxId "MIT"; mainProgram = "keter"; } ) { }; @@ -411555,7 +411555,7 @@ self: { yaml ]; description = "Web application deployment manager, focusing on Haskell web frameworks. It mitigates downtime."; - license = lib.licensesSpdx."MIT"; + license = lib.meta.getLicenseFromSpdxId "MIT"; hydraPlatforms = lib.platforms.none; mainProgram = "keter"; } @@ -411657,7 +411657,7 @@ self: { wai-extra ]; description = "Simple Keter rate limiting plugin"; - license = lib.licensesSpdx."MIT"; + license = lib.meta.getLicenseFromSpdxId "MIT"; } ) { inherit (pkgs) zlib; }; @@ -411783,7 +411783,7 @@ self: { split ]; description = "CLI and library to generate QR codes"; - license = lib.licensesSpdx."MIT"; + license = lib.meta.getLicenseFromSpdxId "MIT"; mainProgram = "kewar"; } ) { }; @@ -411993,7 +411993,7 @@ self: { text ]; description = "An abstract Handle for accessing collections in stores like Redis"; - license = lib.licensesSpdx."BSD-3-Clause"; + license = lib.meta.getLicenseFromSpdxId "BSD-3-Clause"; } ) { }; @@ -412026,7 +412026,7 @@ self: { text ]; description = "Validate a keyed-vals Handle"; - license = lib.licensesSpdx."BSD-3-Clause"; + license = lib.meta.getLicenseFromSpdxId "BSD-3-Clause"; } ) { }; @@ -412062,7 +412062,7 @@ self: { keyed-vals-hspec-tests ]; description = "Implements a keyed-vals Handle using in-process memory"; - license = lib.licensesSpdx."BSD-3-Clause"; + license = lib.meta.getLicenseFromSpdxId "BSD-3-Clause"; } ) { }; @@ -412110,7 +412110,7 @@ self: { tmp-proc-redis ]; description = "Access Redis using a keyed-vals Handle"; - license = lib.licensesSpdx."BSD-3-Clause"; + license = lib.meta.getLicenseFromSpdxId "BSD-3-Clause"; } ) { }; @@ -412556,7 +412556,7 @@ self: { tasty-hunit ]; description = "A lightweight structured concurrency library"; - license = lib.licensesSpdx."BSD-3-Clause"; + license = lib.meta.getLicenseFromSpdxId "BSD-3-Clause"; } ) { }; @@ -412588,7 +412588,7 @@ self: { tasty-hunit ]; description = "Adaptation of the ki library for the effectful ecosystem"; - license = lib.licensesSpdx."MIT"; + license = lib.meta.getLicenseFromSpdxId "MIT"; hydraPlatforms = lib.platforms.none; broken = true; } @@ -412613,7 +412613,7 @@ self: { unliftio-core ]; description = "A lightweight structured concurrency library"; - license = lib.licensesSpdx."BSD-3-Clause"; + license = lib.meta.getLicenseFromSpdxId "BSD-3-Clause"; } ) { }; @@ -412809,7 +412809,7 @@ self: { hspec-core ]; description = "Boolean strong typing"; - license = lib.licensesSpdx."ISC"; + license = lib.meta.getLicenseFromSpdxId "ISC"; } ) { }; @@ -412934,7 +412934,7 @@ self: { singletons-base ]; description = "Type-level integers. Like KnownNat, but for integers."; - license = lib.licensesSpdx."BSD-3-Clause"; + license = lib.meta.getLicenseFromSpdxId "BSD-3-Clause"; } ) { }; @@ -412963,7 +412963,7 @@ self: { singletons-base ]; description = "Type-level rationals. Like KnownNat, but for rationals."; - license = lib.licensesSpdx."BSD-3-Clause"; + license = lib.meta.getLicenseFromSpdxId "BSD-3-Clause"; } ) { }; @@ -412995,7 +412995,7 @@ self: { hspec ]; description = "A category polymorphic `Functor` typeclass"; - license = lib.licensesSpdx."MIT"; + license = lib.meta.getLicenseFromSpdxId "MIT"; hydraPlatforms = lib.platforms.none; broken = true; } @@ -413333,7 +413333,7 @@ self: { ]; testToolDepends = [ hspec-discover ]; description = "Advanced keyboard remapping utility"; - license = lib.licensesSpdx."MIT"; + license = lib.meta.getLicenseFromSpdxId "MIT"; mainProgram = "kmonad"; maintainers = [ lib.maintainers.auscyber @@ -413622,7 +413622,7 @@ self: { transformers ]; description = "Memory-backed handles"; - license = lib.licensesSpdx."MIT"; + license = lib.meta.getLicenseFromSpdxId "MIT"; } ) { }; @@ -413688,7 +413688,7 @@ self: { bifunctors ]; description = "Easy type-level lists with term-level membership proofs"; - license = lib.licensesSpdx."BSD-3-Clause"; + license = lib.meta.getLicenseFromSpdxId "BSD-3-Clause"; } ) { }; @@ -413945,7 +413945,7 @@ self: { vector ]; description = "a concatenative not-quite-lisp for kittens"; - license = lib.licensesSpdx."GPL-3.0-or-later"; + license = lib.meta.getLicenseFromSpdxId "GPL-3.0-or-later"; hydraPlatforms = lib.platforms.none; mainProgram = "koneko"; broken = true; @@ -413980,7 +413980,7 @@ self: { ]; testHaskellDepends = [ base ]; description = "Formalising the rules of Konnakol, an Indian percussional art form"; - license = lib.licensesSpdx."GPL-3.0-only"; + license = lib.meta.getLicenseFromSpdxId "GPL-3.0-only"; hydraPlatforms = lib.platforms.none; broken = true; } @@ -414056,7 +414056,7 @@ self: { transformers-base ]; description = "Utilities for working with many HStringTemplate templates from files"; - license = lib.licensesSpdx."BSD-3-Clause"; + license = lib.meta.getLicenseFromSpdxId "BSD-3-Clause"; } ) { }; @@ -414334,7 +414334,7 @@ self: { ]; testToolDepends = [ hspec-discover ]; description = "Krank checks issue tracker link status in your source code"; - license = lib.licensesSpdx."BSD-3-Clause"; + license = lib.meta.getLicenseFromSpdxId "BSD-3-Clause"; mainProgram = "krank"; maintainers = [ lib.maintainers.sternenseemann ]; } @@ -414622,7 +414622,7 @@ self: { zstd ]; description = "GPU-ready rasterized fonts"; - license = lib.licensesSpdx."BSD-3-Clause"; + license = lib.meta.getLicenseFromSpdxId "BSD-3-Clause"; hydraPlatforms = lib.platforms.none; } ) { }; @@ -415112,7 +415112,7 @@ self: { executableHaskellDepends = [ base ]; testHaskellDepends = [ base ]; description = "coverage driven random testing framework"; - license = lib.licensesSpdx."BSD-3-Clause"; + license = lib.meta.getLicenseFromSpdxId "BSD-3-Clause"; hydraPlatforms = lib.platforms.none; mainProgram = "kudzu"; broken = true; @@ -415294,7 +415294,7 @@ self: { ]; testHaskellDepends = [ base ]; description = "Find the alpha emoji"; - license = lib.licensesSpdx."BSD-3-Clause"; + license = lib.meta.getLicenseFromSpdxId "BSD-3-Clause"; hydraPlatforms = lib.platforms.none; } ) { }; @@ -415787,7 +415787,7 @@ self: { text ]; description = "Generate Ruby clients from Servant APIs"; - license = lib.licensesSpdx."MIT"; + license = lib.meta.getLicenseFromSpdxId "MIT"; } ) { }; @@ -415830,7 +415830,7 @@ self: { base ]; description = "Concurrent logging"; - license = lib.licensesSpdx."MIT"; + license = lib.meta.getLicenseFromSpdxId "MIT"; } ) { }; @@ -415934,7 +415934,7 @@ self: { text ]; description = "Interpreters for lambda calculus, calculus of constructions, and more"; - license = lib.licensesSpdx."MIT"; + license = lib.meta.getLicenseFromSpdxId "MIT"; hydraPlatforms = lib.platforms.none; mainProgram = "lambda"; broken = true; @@ -416201,7 +416201,7 @@ self: { read-bounded ]; description = "Declarative command-line parser with type-driven pattern matching"; - license = lib.licensesSpdx."BSD-3-Clause"; + license = lib.meta.getLicenseFromSpdxId "BSD-3-Clause"; hydraPlatforms = lib.platforms.none; } ) { }; @@ -416860,7 +416860,7 @@ self: { mtl ]; description = "Lambdabot for Telegram"; - license = lib.licensesSpdx."GPL-2.0-or-later"; + license = lib.meta.getLicenseFromSpdxId "GPL-2.0-or-later"; hydraPlatforms = lib.platforms.none; mainProgram = "telegram-lambdabot"; broken = true; @@ -417625,7 +417625,7 @@ self: { tasty-bench ]; description = "A libary for generating low-level sounds with high-level combinators"; - license = lib.licensesSpdx."MIT"; + license = lib.meta.getLicenseFromSpdxId "MIT"; hydraPlatforms = lib.platforms.none; broken = true; } @@ -417850,7 +417850,7 @@ self: { ]; testToolDepends = [ hspec-discover ]; description = "A high-level binding to the LAME encoder"; - license = lib.licensesSpdx."BSD-3-Clause"; + license = lib.meta.getLicenseFromSpdxId "BSD-3-Clause"; hydraPlatforms = lib.platforms.none; broken = true; } @@ -417919,7 +417919,7 @@ self: { tasty-hunit ]; description = "Run dependent IO actions asynchronously"; - license = lib.licensesSpdx."MIT"; + license = lib.meta.getLicenseFromSpdxId "MIT"; hydraPlatforms = lib.platforms.none; broken = true; } @@ -417979,7 +417979,7 @@ self: { testToolDepends = [ markdown-unlit ]; doHaddock = false; description = "Haskell bindings for the Linux Landlock API"; - license = lib.licensesSpdx."BSD-3-Clause"; + license = lib.meta.getLicenseFromSpdxId "BSD-3-Clause"; hydraPlatforms = lib.platforms.none; mainProgram = "landlocked"; } @@ -418163,7 +418163,7 @@ self: { text ]; description = "Parser, pretty-printer, and more for the Modula-2 programming language"; - license = lib.licensesSpdx."GPL-3.0-or-later"; + license = lib.meta.getLicenseFromSpdxId "GPL-3.0-or-later"; hydraPlatforms = lib.platforms.none; mainProgram = "parse"; } @@ -418200,7 +418200,7 @@ self: { vector ]; description = "ASN.1 encoding and decoding"; - license = lib.licensesSpdx."BSD-3-Clause"; + license = lib.meta.getLicenseFromSpdxId "BSD-3-Clause"; hydraPlatforms = lib.platforms.none; broken = true; } @@ -418389,7 +418389,7 @@ self: { tasty-quickcheck ]; description = "Parsing and pretty-printing Bash shell scripts"; - license = lib.licensesSpdx."BSD-3-Clause"; + license = lib.meta.getLicenseFromSpdxId "BSD-3-Clause"; } ) { }; @@ -418515,7 +418515,7 @@ self: { process ]; description = "Analysis and generation of C code"; - license = lib.licensesSpdx."BSD-3-Clause"; + license = lib.meta.getLicenseFromSpdxId "BSD-3-Clause"; } ) { }; @@ -419018,7 +419018,7 @@ self: { ]; testToolDepends = [ hspec-discover ]; description = "Dockerfile parser, pretty-printer and embedded DSL"; - license = lib.licensesSpdx."GPL-3.0-or-later"; + license = lib.meta.getLicenseFromSpdxId "GPL-3.0-or-later"; } ) { }; @@ -419075,7 +419075,7 @@ self: { ]; testToolDepends = [ hspec-discover ]; description = "Dockerfile parser, pretty-printer and embedded DSL"; - license = lib.licensesSpdx."GPL-3.0-or-later"; + license = lib.meta.getLicenseFromSpdxId "GPL-3.0-or-later"; hydraPlatforms = lib.platforms.none; } ) { }; @@ -419200,7 +419200,7 @@ self: { pretty ]; description = "A library for the analysis and creation of Graphviz DOT files"; - license = lib.licensesSpdx."BSD-3-Clause"; + license = lib.meta.getLicenseFromSpdxId "BSD-3-Clause"; mainProgram = "ppdot"; } ) { }; @@ -419466,7 +419466,7 @@ self: { text ]; description = "Datatypes and parsing/printing functions to represent the Gemini markup language"; - license = lib.licensesSpdx."BSD-3-Clause"; + license = lib.meta.getLicenseFromSpdxId "BSD-3-Clause"; } ) { }; @@ -419863,7 +419863,7 @@ self: { parsec ]; description = "javascript parser for es6 and es7"; - license = lib.licensesSpdx."MIT"; + license = lib.meta.getLicenseFromSpdxId "MIT"; hydraPlatforms = lib.platforms.none; broken = true; } @@ -419973,7 +419973,7 @@ self: { text ]; description = "Lua parser and pretty-printer"; - license = lib.licensesSpdx."BSD-3-Clause"; + license = lib.meta.getLicenseFromSpdxId "BSD-3-Clause"; hydraPlatforms = lib.platforms.none; broken = true; } @@ -421401,7 +421401,7 @@ self: { QuickCheck ]; description = "Matrix programming library"; - license = lib.licensesSpdx."MIT"; + license = lib.meta.getLicenseFromSpdxId "MIT"; hydraPlatforms = lib.platforms.none; broken = true; } @@ -421493,7 +421493,7 @@ self: { utility-ht ]; description = "Numerical Linear Algebra using LAPACK"; - license = lib.licensesSpdx."BSD-3-Clause"; + license = lib.meta.getLicenseFromSpdxId "BSD-3-Clause"; maintainers = [ lib.maintainers.thielema ]; } ) { }; @@ -421658,7 +421658,7 @@ self: { vector ]; description = "Conversion of objects between 'lapack' and 'hmatrix'"; - license = lib.licensesSpdx."BSD-3-Clause"; + license = lib.meta.getLicenseFromSpdxId "BSD-3-Clause"; maintainers = [ lib.maintainers.thielema ]; } ) { }; @@ -421741,7 +421741,7 @@ self: { validation-selective ]; description = "Scalable anonymous records"; - license = lib.licensesSpdx."BSD-3-Clause"; + license = lib.meta.getLicenseFromSpdxId "BSD-3-Clause"; hydraPlatforms = lib.platforms.none; broken = true; } @@ -421790,7 +421790,7 @@ self: { tasty-quickcheck ]; description = "Generic programming API for large-records and large-anon"; - license = lib.licensesSpdx."BSD-3-Clause"; + license = lib.meta.getLicenseFromSpdxId "BSD-3-Clause"; maintainers = [ lib.maintainers.alexfmpe ]; } ) { }; @@ -421944,7 +421944,7 @@ self: { transformers ]; description = "Efficient compilation for large records, linear in the size of the record"; - license = lib.licensesSpdx."BSD-3-Clause"; + license = lib.meta.getLicenseFromSpdxId "BSD-3-Clause"; maintainers = [ lib.maintainers.alexfmpe ]; } ) { }; @@ -422391,7 +422391,7 @@ self: { pandoc-types ]; description = "Use actual LaTeX to render formulae inside Hakyll pages"; - license = lib.licensesSpdx."BSD-3-Clause"; + license = lib.meta.getLicenseFromSpdxId "BSD-3-Clause"; hydraPlatforms = lib.platforms.none; } ) { }; @@ -422429,7 +422429,7 @@ self: { transformers ]; description = "A library for rendering LaTeX formulae as SVG using an actual LaTeX"; - license = lib.licensesSpdx."BSD-3-Clause"; + license = lib.meta.getLicenseFromSpdxId "BSD-3-Clause"; hydraPlatforms = lib.platforms.none; broken = true; } @@ -422467,7 +422467,7 @@ self: { pandoc-types ]; description = "Render LaTeX formulae in pandoc documents to images with an actual LaTeX"; - license = lib.licensesSpdx."BSD-3-Clause"; + license = lib.meta.getLicenseFromSpdxId "BSD-3-Clause"; hydraPlatforms = lib.platforms.none; mainProgram = "latex-svg-filter"; } @@ -422501,7 +422501,7 @@ self: { random ]; description = "Pure incremental byte parser"; - license = lib.licensesSpdx."BSD-3-Clause"; + license = lib.meta.getLicenseFromSpdxId "BSD-3-Clause"; } ) { }; @@ -422532,7 +422532,7 @@ self: { time ]; description = "lathe + time"; - license = lib.licensesSpdx."BSD-3-Clause"; + license = lib.meta.getLicenseFromSpdxId "BSD-3-Clause"; } ) { }; @@ -422830,7 +422830,7 @@ self: { transformers ]; description = "Hedgehog support for lawful-classes"; - license = lib.licensesSpdx."Apache-2.0"; + license = lib.meta.getLicenseFromSpdxId "Apache-2.0"; hydraPlatforms = lib.platforms.none; } ) { }; @@ -422869,7 +422869,7 @@ self: { transformers ]; description = "QuickCheck support for lawful-classes"; - license = lib.licensesSpdx."Apache-2.0"; + license = lib.meta.getLicenseFromSpdxId "Apache-2.0"; hydraPlatforms = lib.platforms.none; } ) { }; @@ -422882,7 +422882,7 @@ self: { sha256 = "0dza7qrq54k0p50bv7hj9y0c12kl3x51j6kh9k7aammfnl14hrri"; libraryHaskellDepends = [ base ]; description = "Types for lawful-classes"; - license = lib.licensesSpdx."Apache-2.0"; + license = lib.meta.getLicenseFromSpdxId "Apache-2.0"; hydraPlatforms = lib.platforms.none; broken = true; } @@ -422937,7 +422937,7 @@ self: { text ]; description = "Lawful typeclasses for bidirectional conversion between types"; - license = lib.licensesSpdx."MIT"; + license = lib.meta.getLicenseFromSpdxId "MIT"; } ) { }; @@ -422986,7 +422986,7 @@ self: { text ]; description = "Lawful typeclasses for bidirectional conversion between types"; - license = lib.licensesSpdx."MIT"; + license = lib.meta.getLicenseFromSpdxId "MIT"; hydraPlatforms = lib.platforms.none; } ) { }; @@ -423347,7 +423347,7 @@ self: { tasty-hunit ]; description = "Simple, beautiful CLI output"; - license = lib.licensesSpdx."Apache-2.0"; + license = lib.meta.getLicenseFromSpdxId "Apache-2.0"; } ) { }; @@ -423369,7 +423369,7 @@ self: { tasty-hunit ]; description = "Simple, beautiful CLI output for Haskell"; - license = lib.licensesSpdx."Apache-2.0"; + license = lib.meta.getLicenseFromSpdxId "Apache-2.0"; } ) { }; @@ -423462,7 +423462,7 @@ self: { transformers-base ]; description = "Asynchronous actions that don't start right away"; - license = lib.licensesSpdx."MIT"; + license = lib.meta.getLicenseFromSpdxId "MIT"; hydraPlatforms = lib.platforms.none; broken = true; } @@ -423493,7 +423493,7 @@ self: { tasty-hunit ]; description = "A bracket with lazy resource allocation"; - license = lib.licensesSpdx."BSD-3-Clause"; + license = lib.meta.getLicenseFromSpdxId "BSD-3-Clause"; hydraPlatforms = lib.platforms.none; broken = true; } @@ -423752,7 +423752,7 @@ self: { ]; testToolDepends = [ tasty-discover ]; description = "Alternative lazy ByteString and ST-like IO Handle"; - license = lib.licensesSpdx."BSD-3-Clause"; + license = lib.meta.getLicenseFromSpdxId "BSD-3-Clause"; hydraPlatforms = lib.platforms.none; } ) { }; @@ -423869,7 +423869,7 @@ self: { sha256 = "1p0qhdbcnmx17j069n3w89jv8wpxzari4ihylrjk2x78k4b3p1cb"; libraryHaskellDepends = [ base ]; description = "LazyIO applicative for asymptotic performance"; - license = lib.licensesSpdx."MIT"; + license = lib.meta.getLicenseFromSpdxId "MIT"; } ) { }; @@ -424265,7 +424265,7 @@ self: { yaml ]; description = "See README for synopsis"; - license = lib.licensesSpdx."AGPL-3.0-or-later"; + license = lib.meta.getLicenseFromSpdxId "AGPL-3.0-or-later"; hydraPlatforms = lib.platforms.none; mainProgram = "ldap-scim-bridge"; } @@ -424959,7 +424959,7 @@ self: { text ]; description = "Signed and unsigned LEB128 codec for binary library"; - license = lib.licensesSpdx."Apache-2.0"; + license = lib.meta.getLicenseFromSpdxId "Apache-2.0"; } ) { }; @@ -426009,7 +426009,7 @@ self: { lens-action ]; description = "Lens interface for your filesystem; still a bit experimental"; - license = lib.licensesSpdx."BSD-3-Clause"; + license = lib.meta.getLicenseFromSpdxId "BSD-3-Clause"; hydraPlatforms = lib.platforms.none; broken = true; } @@ -426030,7 +426030,7 @@ self: { lens ]; description = "Indexed version of Plated"; - license = lib.licensesSpdx."BSD-2-Clause"; + license = lib.meta.getLicenseFromSpdxId "BSD-2-Clause"; hydraPlatforms = lib.platforms.none; broken = true; } @@ -426361,7 +426361,7 @@ self: { tell ]; description = "MonadTell-based lens combinators"; - license = lib.licensesSpdx."BSD-3-Clause"; + license = lib.meta.getLicenseFromSpdxId "BSD-3-Clause"; hydraPlatforms = lib.platforms.none; broken = true; } @@ -426586,7 +426586,7 @@ self: { witherable ]; description = "lens-compatible tools for working with witherable"; - license = lib.licensesSpdx."MIT"; + license = lib.meta.getLicenseFromSpdxId "MIT"; hydraPlatforms = lib.platforms.none; broken = true; } @@ -426746,7 +426746,7 @@ self: { ]; testToolDepends = [ hspec-discover ]; description = "frugal issue tracker"; - license = lib.licensesSpdx."GPL-3.0-only"; + license = lib.meta.getLicenseFromSpdxId "GPL-3.0-only"; mainProgram = "lentil"; maintainers = [ lib.maintainers.rvl ]; } @@ -426935,7 +426935,7 @@ self: { ]; executableSystemDepends = [ openssl ]; description = "The Stateless Password Manager"; - license = lib.licensesSpdx."GPL-3.0-only"; + license = lib.meta.getLicenseFromSpdxId "GPL-3.0-only"; mainProgram = "lesspass"; } ) { inherit (pkgs) openssl; }; @@ -427194,7 +427194,7 @@ self: { util ]; description = "See README for more info"; - license = lib.licensesSpdx."BSD-3-Clause"; + license = lib.meta.getLicenseFromSpdxId "BSD-3-Clause"; hydraPlatforms = lib.platforms.none; } ) { }; @@ -427298,7 +427298,7 @@ self: { tasty-bench ]; description = "Pure LFUDA, GDSF, and LFU cache implementations"; - license = lib.licensesSpdx."Apache-2.0"; + license = lib.meta.getLicenseFromSpdxId "Apache-2.0"; mainProgram = "lfuda-demo"; } ) { }; @@ -427569,7 +427569,7 @@ self: { regex-compat ]; description = "Preprocessor for typesetting Haskell sources with LaTeX"; - license = lib.licensesSpdx."GPL-2.0-or-later"; + license = lib.meta.getLicenseFromSpdxId "GPL-2.0-or-later"; mainProgram = "lhs2TeX"; maintainers = [ lib.maintainers.nomeata ]; } @@ -427629,7 +427629,7 @@ self: { tasty-hunit ]; description = "A binding to the libBF library"; - license = lib.licensesSpdx."MIT"; + license = lib.meta.getLicenseFromSpdxId "MIT"; } ) { }; @@ -427739,7 +427739,7 @@ self: { temporary ]; description = "Haskell interface to libarchive"; - license = lib.licensesSpdx."BSD-3-Clause"; + license = lib.meta.getLicenseFromSpdxId "BSD-3-Clause"; } ) { inherit (pkgs) libarchive; }; @@ -427946,7 +427946,7 @@ self: { sha256 = "12wsws5fsq3khfxakppagi5730c38ahh1ngax3gyh9ppqhzgfqmn"; doHaddock = false; description = "libffi clibs"; - license = lib.licensesSpdx."MIT"; + license = lib.meta.getLicenseFromSpdxId "MIT"; } ) { }; @@ -428399,7 +428399,7 @@ self: { uuid ]; description = "A Haskell implementation of JSON Web Token (JWT)"; - license = lib.licensesSpdx."MPL-2.0"; + license = lib.meta.getLicenseFromSpdxId "MPL-2.0"; hydraPlatforms = lib.platforms.none; broken = true; } @@ -428886,7 +428886,7 @@ self: { ]; testToolDepends = [ hspec-discover ]; description = "An MPD client library"; - license = lib.licensesSpdx."MIT"; + license = lib.meta.getLicenseFromSpdxId "MIT"; } ) { }; @@ -429145,7 +429145,7 @@ self: { QuickCheck ]; description = "Parsing, formatting, and validating international phone numbers"; - license = lib.licensesSpdx."MIT"; + license = lib.meta.getLicenseFromSpdxId "MIT"; hydraPlatforms = lib.platforms.none; broken = true; } @@ -429454,7 +429454,7 @@ self: { ]; testToolDepends = [ hspec-discover ]; description = "Move/rename according a set of rules"; - license = lib.licensesSpdx."ISC"; + license = lib.meta.getLicenseFromSpdxId "ISC"; hydraPlatforms = lib.platforms.none; mainProgram = "librarian-exe"; } @@ -429552,7 +429552,7 @@ self: { sha256 = "09iyvp3271l5a1idklzxdcs3wxmjxqigkn1cjjv4vk8vww6zwzkb"; doHaddock = false; description = "TBA"; - license = lib.licensesSpdx."BSD-3-Clause"; + license = lib.meta.getLicenseFromSpdxId "BSD-3-Clause"; } ) { }; @@ -429613,7 +429613,7 @@ self: { transformers ]; description = "libremidi bindings for haskell"; - license = lib.licensesSpdx."BSD-3-Clause"; + license = lib.meta.getLicenseFromSpdxId "BSD-3-Clause"; hydraPlatforms = lib.platforms.none; mainProgram = "libremidi-exe"; broken = true; @@ -429660,7 +429660,7 @@ self: { libressl ]; description = "libtls bindings"; - license = lib.licensesSpdx."BSD-2-Clause"; + license = lib.meta.getLicenseFromSpdxId "BSD-2-Clause"; hydraPlatforms = lib.platforms.none; broken = true; } @@ -429733,7 +429733,7 @@ self: { ]; doHaddock = false; description = "A versatile, flexible and executable formal model for the RISC-V architecture"; - license = lib.licensesSpdx."MIT"; + license = lib.meta.getLicenseFromSpdxId "MIT"; hydraPlatforms = lib.platforms.none; mainProgram = "riscv-tiny"; maintainers = [ lib.maintainers.sternenseemann ]; @@ -429857,7 +429857,7 @@ self: { testPkgconfigDepends = [ libsodium ]; testToolDepends = [ c2hs ]; description = "Low-level bindings to the libsodium C library"; - license = lib.licensesSpdx."ISC"; + license = lib.meta.getLicenseFromSpdxId "ISC"; hydraPlatforms = lib.platforms.none; broken = true; } @@ -429876,7 +429876,7 @@ self: { libraryHaskellDepends = [ base ]; librarySystemDepends = [ libsodium ]; description = "FFI bindings to libsodium"; - license = lib.licensesSpdx."BSD-3-Clause"; + license = lib.meta.getLicenseFromSpdxId "BSD-3-Clause"; maintainers = [ lib.maintainers.mangoiv ]; } ) { inherit (pkgs) libsodium; }; @@ -430091,7 +430091,7 @@ self: { ]; libraryPkgconfigDepends = [ systemd ]; description = "Haskell bindings to libsystemd-journal"; - license = lib.licensesSpdx."BSD-3-Clause"; + license = lib.meta.getLicenseFromSpdxId "BSD-3-Clause"; badPlatforms = lib.platforms.darwin; } ) { inherit (pkgs) systemd; }; @@ -430144,7 +430144,7 @@ self: { ]; libraryPkgconfigDepends = [ libtelnet ]; description = "Bindings to libtelnet"; - license = lib.licensesSpdx."GPL-3.0-or-later"; + license = lib.meta.getLicenseFromSpdxId "GPL-3.0-or-later"; badPlatforms = lib.platforms.darwin; hydraPlatforms = lib.platforms.none; broken = true; @@ -430218,7 +430218,7 @@ self: { safe-exceptions ]; description = "Haskell bindings for PyTorch"; - license = lib.licensesSpdx."BSD-3-Clause"; + license = lib.meta.getLicenseFromSpdxId "BSD-3-Clause"; } ) { @@ -430242,7 +430242,7 @@ self: { ghc ]; description = "Helpers for integrating libtorch-ffi with Hasktorch"; - license = lib.licensesSpdx."BSD-3-Clause"; + license = lib.meta.getLicenseFromSpdxId "BSD-3-Clause"; } ) { }; @@ -430263,7 +430263,7 @@ self: { ]; libraryPkgconfigDepends = [ libversion ]; description = "Haskell binding to libversion"; - license = lib.licensesSpdx."BSD-3-Clause"; + license = lib.meta.getLicenseFromSpdxId "BSD-3-Clause"; } ) { inherit (pkgs) libversion; }; @@ -430288,7 +430288,7 @@ self: { libraryPkgconfigDepends = [ libvirt ]; libraryToolDepends = [ cpphs ]; description = "FFI bindings to libvirt virtualization API (http://libvirt.org)"; - license = lib.licensesSpdx."BSD-3-Clause"; + license = lib.meta.getLicenseFromSpdxId "BSD-3-Clause"; badPlatforms = lib.platforms.darwin; hydraPlatforms = lib.platforms.none; broken = true; @@ -430514,7 +430514,7 @@ self: { sha256 = "0jaif8y10ql8rmkfhm6nwfk65q8rnpk58a6j5cf4gksz9v2nnlh4"; doHaddock = false; description = "libyaml clibs"; - license = lib.licensesSpdx."MIT"; + license = lib.meta.getLicenseFromSpdxId "MIT"; } ) { }; @@ -430541,7 +430541,7 @@ self: { ]; libraryPkgconfigDepends = [ libyaml ]; description = "Low-level, streaming YAML interface via streamly"; - license = lib.licensesSpdx."BSD-3-Clause"; + license = lib.meta.getLicenseFromSpdxId "BSD-3-Clause"; } ) { inherit (pkgs) libyaml; }; @@ -430636,7 +430636,7 @@ self: { directory ]; description = "A license compatibility helper"; - license = lib.licensesSpdx."MIT"; + license = lib.meta.getLicenseFromSpdxId "MIT"; hydraPlatforms = lib.platforms.none; mainProgram = "licensor"; broken = true; @@ -430749,7 +430749,7 @@ self: { tomland ]; description = "Synchronize personal configs across multiple machines"; - license = lib.licensesSpdx."MPL-2.0"; + license = lib.meta.getLicenseFromSpdxId "MPL-2.0"; hydraPlatforms = lib.platforms.none; mainProgram = "life"; broken = true; @@ -430794,7 +430794,7 @@ self: { zenhack-prelude ]; description = "Flexible manual resource management"; - license = lib.licensesSpdx."Apache-2.0"; + license = lib.meta.getLicenseFromSpdxId "Apache-2.0"; hydraPlatforms = lib.platforms.none; broken = true; } @@ -431258,7 +431258,7 @@ self: { transformers ]; description = "LIFX LAN API"; - license = lib.licensesSpdx."BSD-3-Clause"; + license = lib.meta.getLicenseFromSpdxId "BSD-3-Clause"; } ) { }; @@ -431468,7 +431468,7 @@ self: { ]; testToolDepends = [ tasty-discover ]; description = "LightStep OpenTracing client library"; - license = lib.licensesSpdx."Apache-2.0"; + license = lib.meta.getLicenseFromSpdxId "Apache-2.0"; hydraPlatforms = lib.platforms.none; mainProgram = "lightstep-haskell-stress-test"; } @@ -432056,7 +432056,7 @@ self: { random ]; description = "Line-indexed file reader"; - license = lib.licensesSpdx."MIT"; + license = lib.meta.getLicenseFromSpdxId "MIT"; hydraPlatforms = lib.platforms.none; broken = true; } @@ -432326,7 +432326,7 @@ self: { ]; doHaddock = false; description = "Standard library for linear types"; - license = lib.licensesSpdx."MIT"; + license = lib.meta.getLicenseFromSpdxId "MIT"; } ) { }; @@ -432404,7 +432404,7 @@ self: { ]; doHaddock = false; description = "Standard library for linear types"; - license = lib.licensesSpdx."MIT"; + license = lib.meta.getLicenseFromSpdxId "MIT"; hydraPlatforms = lib.platforms.none; } ) { }; @@ -432549,7 +432549,7 @@ self: { text ]; description = "Linear core validates optimizations wrt linearity"; - license = lib.licensesSpdx."BSD-3-Clause"; + license = lib.meta.getLicenseFromSpdxId "BSD-3-Clause"; hydraPlatforms = lib.platforms.none; broken = true; } @@ -432580,7 +432580,7 @@ self: { QuickCheck ]; description = "Linear free monads"; - license = lib.licensesSpdx."MIT"; + license = lib.meta.getLicenseFromSpdxId "MIT"; hydraPlatforms = lib.platforms.none; broken = true; } @@ -432650,7 +432650,7 @@ self: { reflection ]; description = "Geographic coordinates, built on the linear package"; - license = lib.licensesSpdx."MIT"; + license = lib.meta.getLicenseFromSpdxId "MIT"; } ) { }; @@ -432758,7 +432758,7 @@ self: { vector ]; description = "Type-safe numerical linear algebra backed by massiv arrays"; - license = lib.licensesSpdx."BSD-3-Clause"; + license = lib.meta.getLicenseFromSpdxId "BSD-3-Clause"; hydraPlatforms = lib.platforms.none; broken = true; } @@ -432822,7 +432822,7 @@ self: { utility-ht ]; description = "Linear Programming basic definitions"; - license = lib.licensesSpdx."BSD-3-Clause"; + license = lib.meta.getLicenseFromSpdxId "BSD-3-Clause"; maintainers = [ lib.maintainers.thielema ]; } ) { }; @@ -432849,7 +432849,7 @@ self: { constraints ]; description = "Build SMC morphisms using linear types"; - license = lib.licensesSpdx."LGPL-3.0-or-later"; + license = lib.meta.getLicenseFromSpdxId "LGPL-3.0-or-later"; } ) { }; @@ -433242,7 +433242,7 @@ self: { hspec ]; description = "File extension based programming language detection"; - license = lib.licensesSpdx."BSD-3-Clause"; + license = lib.meta.getLicenseFromSpdxId "BSD-3-Clause"; hydraPlatforms = lib.platforms.none; mainProgram = "generate"; broken = true; @@ -433320,7 +433320,7 @@ self: { text ]; description = "URL canonicalization library for semantic link identity"; - license = lib.licensesSpdx."MIT"; + license = lib.meta.getLicenseFromSpdxId "MIT"; } ) { }; @@ -433356,7 +433356,7 @@ self: { tasty-hunit ]; description = "Effectful integration for link-canonical"; - license = lib.licensesSpdx."MIT"; + license = lib.meta.getLicenseFromSpdxId "MIT"; } ) { }; @@ -433935,7 +433935,7 @@ self: { sha256 = "0j5q4ddsg3bmkhb82da39rj3h1knhxm74z3jknprzwhavz2wxcn6"; libraryHaskellDepends = [ base ]; description = "Linux capabilities Haskell data type"; - license = lib.licensesSpdx."Apache-2.0"; + license = lib.meta.getLicenseFromSpdxId "Apache-2.0"; } ) { }; @@ -434463,7 +434463,7 @@ self: { mtl ]; description = "RISC-V Core"; - license = lib.licensesSpdx."BSD-3-Clause"; + license = lib.meta.getLicenseFromSpdxId "BSD-3-Clause"; hydraPlatforms = lib.platforms.none; } ) { }; @@ -434793,7 +434793,7 @@ self: { unordered-containers ]; description = "Predicate Abstraction-based Horn-Clause/Implication Constraint Solver"; - license = lib.licensesSpdx."BSD-3-Clause"; + license = lib.meta.getLicenseFromSpdxId "BSD-3-Clause"; mainProgram = "fixpoint"; maintainers = [ lib.maintainers.artem ]; } @@ -434915,7 +434915,7 @@ self: { unordered-containers ]; description = "Predicate Abstraction-based Horn-Clause/Implication Constraint Solver"; - license = lib.licensesSpdx."BSD-3-Clause"; + license = lib.meta.getLicenseFromSpdxId "BSD-3-Clause"; hydraPlatforms = lib.platforms.none; mainProgram = "fixpoint"; maintainers = [ lib.maintainers.artem ]; @@ -435113,7 +435113,7 @@ self: { ]; testSystemDepends = [ z3 ]; description = "Liquid Types for Haskell"; - license = lib.licensesSpdx."BSD-3-Clause"; + license = lib.meta.getLicenseFromSpdxId "BSD-3-Clause"; maintainers = [ lib.maintainers.artem ]; } ) { inherit (pkgs) z3; }; @@ -435147,7 +435147,7 @@ self: { ]; testSystemDepends = [ z3 ]; description = "Liquid Types for Haskell"; - license = lib.licensesSpdx."BSD-3-Clause"; + license = lib.meta.getLicenseFromSpdxId "BSD-3-Clause"; hydraPlatforms = lib.platforms.none; maintainers = [ lib.maintainers.artem ]; } @@ -435267,7 +435267,7 @@ self: { unordered-containers ]; description = "Liquid Types for Haskell"; - license = lib.licensesSpdx."BSD-3-Clause"; + license = lib.meta.getLicenseFromSpdxId "BSD-3-Clause"; maintainers = [ lib.maintainers.artem ]; } ) { }; @@ -435384,7 +435384,7 @@ self: { unordered-containers ]; description = "Liquid Types for Haskell"; - license = lib.licensesSpdx."BSD-3-Clause"; + license = lib.meta.getLicenseFromSpdxId "BSD-3-Clause"; hydraPlatforms = lib.platforms.none; maintainers = [ lib.maintainers.artem ]; } @@ -435499,7 +435499,7 @@ self: { sha256 = "13nnajdnbby0zj95y6ccq5ipf6ilaq0zckjj8m9hbk8ci558kbh8"; libraryHaskellDepends = [ base ]; description = "Common not-so-common functions for lists"; - license = lib.licensesSpdx."BSD-3-Clause"; + license = lib.meta.getLicenseFromSpdxId "BSD-3-Clause"; } ) { }; @@ -435648,7 +435648,7 @@ self: { isExecutable = true; executableHaskellDepends = [ base ]; description = "List all remote forwards for mail accounts stored in a SQL database"; - license = lib.licensesSpdx."AGPL-3.0-or-later"; + license = lib.meta.getLicenseFromSpdxId "AGPL-3.0-or-later"; mainProgram = "list-remote-forwards"; } ) { }; @@ -435686,7 +435686,7 @@ self: { tasty-bench ]; description = "List shuffling and sampling"; - license = lib.licensesSpdx."BSD-3-Clause"; + license = lib.meta.getLicenseFromSpdxId "BSD-3-Clause"; } ) { }; @@ -435698,7 +435698,7 @@ self: { sha256 = "1n1b1fk8zn9hz162lmy9d123icd2i6cnlvpkk2ypbphmnam0xr43"; libraryHaskellDepends = [ base ]; description = "Easily and clearly create lists with only one element in them"; - license = lib.licensesSpdx."MIT"; + license = lib.meta.getLicenseFromSpdxId "MIT"; hydraPlatforms = lib.platforms.none; broken = true; } @@ -435740,7 +435740,7 @@ self: { mtl-prelude ]; description = "ListT done right"; - license = lib.licensesSpdx."MIT"; + license = lib.meta.getLicenseFromSpdxId "MIT"; } ) { }; @@ -436005,7 +436005,7 @@ self: { test-framework-quickcheck2 ]; description = "Tries and Patricia tries: finite sets and maps for list keys"; - license = lib.licensesSpdx."BSD-3-Clause"; + license = lib.meta.getLicenseFromSpdxId "BSD-3-Clause"; } ) { }; @@ -436052,7 +436052,7 @@ self: { ]; testToolDepends = [ hspec-discover ]; description = "List-like operations for tuples"; - license = lib.licensesSpdx."Apache-2.0"; + license = lib.meta.getLicenseFromSpdxId "Apache-2.0"; hydraPlatforms = lib.platforms.none; } ) { }; @@ -436167,7 +436167,7 @@ self: { sha256 = "1kyl7gg0prq7cyr0radwqcwdmqj3d0w2rjs1406nkryjfibsxgkh"; libraryHaskellDepends = [ base ]; description = "Helpers for working with NonEmpty lists"; - license = lib.licensesSpdx."BSD-3-Clause"; + license = lib.meta.getLicenseFromSpdxId "BSD-3-Clause"; } ) { }; @@ -436533,7 +436533,7 @@ self: { ]; testToolDepends = [ tasty-discover ]; description = "Web service converting URLs into archived nix attrsets"; - license = lib.licensesSpdx."BSD-3-Clause"; + license = lib.meta.getLicenseFromSpdxId "BSD-3-Clause"; hydraPlatforms = lib.platforms.none; broken = true; } @@ -436547,7 +436547,7 @@ self: { sha256 = "1hhasxqq0wj1qh9i8a29lpg0shxwj38fhflypkz0rq67vfigilmg"; libraryHaskellDepends = [ base ]; description = "Type-safe conversion of type literals into runtime values"; - license = lib.licensesSpdx."0BSD"; + license = lib.meta.getLicenseFromSpdxId "0BSD"; } ) { }; @@ -436613,7 +436613,7 @@ self: { unliftio ]; description = "transform literate source code to Markdown"; - license = lib.licensesSpdx."MIT"; + license = lib.meta.getLicenseFromSpdxId "MIT"; mainProgram = "literatex"; } ) { }; @@ -436646,7 +436646,7 @@ self: { tasty-hunit ]; description = "Simple implementation of Earley parsing"; - license = lib.licensesSpdx."MIT"; + license = lib.meta.getLicenseFromSpdxId "MIT"; hydraPlatforms = lib.platforms.none; broken = true; } @@ -436953,7 +436953,7 @@ self: { text ]; description = "Haskell bindings for the llama.cpp llama-server and a simple CLI"; - license = lib.licensesSpdx."AGPL-3.0-only"; + license = lib.meta.getLicenseFromSpdxId "AGPL-3.0-only"; mainProgram = "llamacall"; } ) { }; @@ -437031,7 +437031,7 @@ self: { transformers ]; description = "Typified interactions with LLMs"; - license = lib.licensesSpdx."MIT"; + license = lib.meta.getLicenseFromSpdxId "MIT"; } ) { }; @@ -437472,7 +437472,7 @@ self: { transformers ]; description = "Support for writing an EDSL with LLVM-JIT as target"; - license = lib.licensesSpdx."BSD-3-Clause"; + license = lib.meta.getLicenseFromSpdxId "BSD-3-Clause"; } ) { }; @@ -437511,7 +437511,7 @@ self: { utility-ht ]; description = "Processor specific intrinsics for the llvm interface"; - license = lib.licensesSpdx."BSD-3-Clause"; + license = lib.meta.getLicenseFromSpdxId "BSD-3-Clause"; hydraPlatforms = lib.platforms.none; broken = true; } @@ -437573,7 +437573,7 @@ self: { ]; doHaddock = false; description = "Utility functions for the llvm interface"; - license = lib.licensesSpdx."BSD-3-Clause"; + license = lib.meta.getLicenseFromSpdxId "BSD-3-Clause"; } ) { }; @@ -437596,7 +437596,7 @@ self: { ]; librarySystemDepends = [ LLVM ]; description = "FFI bindings to the LLVM compiler toolkit"; - license = lib.licensesSpdx."BSD-3-Clause"; + license = lib.meta.getLicenseFromSpdxId "BSD-3-Clause"; maintainers = [ lib.maintainers.thielema ]; } ) { LLVM = null; }; @@ -438057,7 +438057,7 @@ self: { transformers ]; description = "General purpose LLVM bindings"; - license = lib.licensesSpdx."BSD-3-Clause"; + license = lib.meta.getLicenseFromSpdxId "BSD-3-Clause"; hydraPlatforms = lib.platforms.none; broken = true; } @@ -438091,7 +438091,7 @@ self: { utility-ht ]; description = "Generate Pkg-Config configuration file for LLVM"; - license = lib.licensesSpdx."BSD-3-Clause"; + license = lib.meta.getLicenseFromSpdxId "BSD-3-Clause"; mainProgram = "llvm-pkg-config"; } ) { }; @@ -438138,7 +438138,7 @@ self: { text ]; description = "A pretty printing library inspired by the llvm binding"; - license = lib.licensesSpdx."BSD-3-Clause"; + license = lib.meta.getLicenseFromSpdxId "BSD-3-Clause"; } ) { }; @@ -438237,7 +438237,7 @@ self: { versions ]; description = "LLVM bitcode parsing library"; - license = lib.licensesSpdx."BSD-3-Clause"; + license = lib.meta.getLicenseFromSpdxId "BSD-3-Clause"; mainProgram = "llvm-disasm"; } ) { }; @@ -438383,7 +438383,7 @@ self: { sha256 = "1n4qql3lsr4hcwyg6cbdg8rkdqw27dqkglrk1r4dfp30q8k62qzw"; doHaddock = false; description = "Lightning Memory-Mapped Database"; - license = lib.licensesSpdx."BSD-3-Clause"; + license = lib.meta.getLicenseFromSpdxId "BSD-3-Clause"; } ) { }; @@ -438721,7 +438721,7 @@ self: { text ]; description = "Support for developing against the LNURL protocol"; - license = lib.licensesSpdx."BSD-3-Clause"; + license = lib.meta.getLicenseFromSpdxId "BSD-3-Clause"; hydraPlatforms = lib.platforms.none; broken = true; } @@ -438779,7 +438779,7 @@ self: { optparse-applicative ]; description = "A command line tool to manage LNURL auth identities"; - license = lib.licensesSpdx."BSD-3-Clause"; + license = lib.meta.getLicenseFromSpdxId "BSD-3-Clause"; hydraPlatforms = lib.platforms.none; mainProgram = "lnurl-authenticator"; } @@ -438913,7 +438913,7 @@ self: { integer-types ]; description = "Line and column positions and ranges in text files"; - license = lib.licensesSpdx."Apache-2.0"; + license = lib.meta.getLicenseFromSpdxId "Apache-2.0"; hydraPlatforms = lib.platforms.none; } ) { }; @@ -438937,7 +438937,7 @@ self: { loc ]; description = "Hedgehog generators for loc"; - license = lib.licensesSpdx."Apache-2.0"; + license = lib.meta.getLicenseFromSpdxId "Apache-2.0"; hydraPlatforms = lib.platforms.none; broken = true; } @@ -439470,7 +439470,7 @@ self: { unordered-containers ]; description = "Structured logging solution (base package)"; - license = lib.licensesSpdx."BSD-3-Clause"; + license = lib.meta.getLicenseFromSpdxId "BSD-3-Clause"; } ) { }; @@ -439613,7 +439613,7 @@ self: { text ]; description = "Adaptation of the log library for the effectful ecosystem"; - license = lib.licensesSpdx."BSD-3-Clause"; + license = lib.meta.getLicenseFromSpdxId "BSD-3-Clause"; } ) { }; @@ -439666,7 +439666,7 @@ self: { vector ]; description = "Structured logging solution (Elasticsearch back end)"; - license = lib.licensesSpdx."BSD-3-Clause"; + license = lib.meta.getLicenseFromSpdxId "BSD-3-Clause"; } ) { }; @@ -440074,7 +440074,7 @@ self: { base ]; description = "Log-domain floating point numbers"; - license = lib.licensesSpdx."BSD-3-Clause"; + license = lib.meta.getLicenseFromSpdxId "BSD-3-Clause"; } ) { }; @@ -440642,7 +440642,7 @@ self: { sha256 = "1jw64bajnz1fizgkw9b01fpk7iyf5w7b8rd1zmhkqxg85npx3kql"; libraryHaskellDepends = [ base ]; description = "Simple logical constraints 'syntax-sugar' writing library"; - license = lib.licensesSpdx."MIT"; + license = lib.meta.getLicenseFromSpdxId "MIT"; } ) { }; @@ -441789,7 +441789,7 @@ self: { vector ]; description = "monadic loop dsl"; - license = lib.licensesSpdx."MIT"; + license = lib.meta.getLicenseFromSpdxId "MIT"; hydraPlatforms = lib.platforms.none; broken = true; } @@ -442469,7 +442469,7 @@ self: { unordered-containers ]; description = "Multi-protocol LLM router and client library"; - license = lib.licensesSpdx."MIT"; + license = lib.meta.getLicenseFromSpdxId "MIT"; } ) { }; @@ -442626,7 +442626,7 @@ self: { tasty-hunit ]; description = "LPeg – Parsing Expression Grammars For Lua"; - license = lib.licensesSpdx."MIT"; + license = lib.meta.getLicenseFromSpdxId "MIT"; } ) { }; @@ -442663,7 +442663,7 @@ self: { groups ]; description = "Left and right actions, semidirect products and torsors"; - license = lib.licensesSpdx."BSD-3-Clause"; + license = lib.meta.getLicenseFromSpdxId "BSD-3-Clause"; } ) { }; @@ -442700,7 +442700,7 @@ self: { groups ]; description = "Left and right actions, semidirect products and torsors"; - license = lib.licensesSpdx."BSD-3-Clause"; + license = lib.meta.getLicenseFromSpdxId "BSD-3-Clause"; hydraPlatforms = lib.platforms.none; } ) { }; @@ -442745,7 +442745,7 @@ self: { tasty-hunit ]; description = "A Haskell client for the LrcLib API (lyrics database)"; - license = lib.licensesSpdx."GPL-3.0-only"; + license = lib.meta.getLicenseFromSpdxId "GPL-3.0-only"; } ) { }; @@ -443187,7 +443187,7 @@ self: { ]; doHaddock = false; description = "Log-structured merge-trees"; - license = lib.licensesSpdx."Apache-2.0"; + license = lib.meta.getLicenseFromSpdxId "Apache-2.0"; hydraPlatforms = lib.platforms.none; } ) { inherit (pkgs) rocksdb; }; @@ -443271,7 +443271,7 @@ self: { ]; testToolDepends = [ hspec-discover ]; description = "Haskell library for the Microsoft Language Server Protocol"; - license = lib.licensesSpdx."MIT"; + license = lib.meta.getLicenseFromSpdxId "MIT"; } ) { }; @@ -443354,7 +443354,7 @@ self: { ]; testToolDepends = [ hspec-discover ]; description = "Haskell library for the Microsoft Language Server Protocol"; - license = lib.licensesSpdx."MIT"; + license = lib.meta.getLicenseFromSpdxId "MIT"; hydraPlatforms = lib.platforms.none; } ) { }; @@ -443435,7 +443435,7 @@ self: { unliftio ]; description = "Haskell library for Language Server Protocol clients"; - license = lib.licensesSpdx."Apache-2.0"; + license = lib.meta.getLicenseFromSpdxId "Apache-2.0"; } ) { }; @@ -443535,7 +443535,7 @@ self: { process ]; description = "Functional test framework for LSP servers"; - license = lib.licensesSpdx."BSD-3-Clause"; + license = lib.meta.getLicenseFromSpdxId "BSD-3-Clause"; } ) { }; @@ -443635,7 +443635,7 @@ self: { process ]; description = "Functional test framework for LSP servers"; - license = lib.licensesSpdx."BSD-3-Clause"; + license = lib.meta.getLicenseFromSpdxId "BSD-3-Clause"; hydraPlatforms = lib.platforms.none; } ) { }; @@ -443739,7 +443739,7 @@ self: { testToolDepends = [ hspec-discover ]; doHaddock = false; description = "Haskell library for the Microsoft Language Server Protocol, data types"; - license = lib.licensesSpdx."MIT"; + license = lib.meta.getLicenseFromSpdxId "MIT"; mainProgram = "generator"; } ) { }; @@ -443843,7 +443843,7 @@ self: { testToolDepends = [ hspec-discover ]; doHaddock = false; description = "Haskell library for the Microsoft Language Server Protocol, data types"; - license = lib.licensesSpdx."MIT"; + license = lib.meta.getLicenseFromSpdxId "MIT"; hydraPlatforms = lib.platforms.none; mainProgram = "generator"; } @@ -444240,7 +444240,7 @@ self: { tasty-hunit ]; description = "Lua, an embeddable scripting language"; - license = lib.licensesSpdx."MIT"; + license = lib.meta.getLicenseFromSpdxId "MIT"; } ) { inherit (pkgs) lua5_4; }; @@ -444261,7 +444261,7 @@ self: { QuickCheck ]; description = "Arbitrary instances for Lua types"; - license = lib.licensesSpdx."MIT"; + license = lib.meta.getLicenseFromSpdxId "MIT"; } ) { }; @@ -444550,7 +444550,7 @@ self: { lucid ]; description = "Provides ARIA attributes for Lucid templates"; - license = lib.licensesSpdx."Apache-2.0"; + license = lib.meta.getLicenseFromSpdxId "Apache-2.0"; hydraPlatforms = lib.platforms.none; broken = true; } @@ -444596,7 +444596,7 @@ self: { vector ]; description = "Helper functions for using lucid with colonnade"; - license = lib.licensesSpdx."BSD-3-Clause"; + license = lib.meta.getLicenseFromSpdxId "BSD-3-Clause"; hydraPlatforms = lib.platforms.none; } ) { }; @@ -444948,7 +444948,7 @@ self: { QuickCheck ]; description = "An implementation of Luhn's check digit algorithm"; - license = lib.licensesSpdx."BSD-3-Clause"; + license = lib.meta.getLicenseFromSpdxId "BSD-3-Clause"; } ) { }; @@ -445270,7 +445270,7 @@ self: { stm ]; description = "TMVar that can be listened to"; - license = lib.licensesSpdx."BSD-3-Clause"; + license = lib.meta.getLicenseFromSpdxId "BSD-3-Clause"; } ) { }; @@ -445685,7 +445685,7 @@ self: { tasty-quickcheck ]; description = "Bindings to LZ4"; - license = lib.licensesSpdx."BSD-3-Clause"; + license = lib.meta.getLicenseFromSpdxId "BSD-3-Clause"; } ) { }; @@ -445835,7 +445835,7 @@ self: { temporary ]; description = "lz4 bindings for Haskell"; - license = lib.licensesSpdx."BSD-3-Clause"; + license = lib.meta.getLicenseFromSpdxId "BSD-3-Clause"; } ) { }; @@ -445931,7 +445931,7 @@ self: { tasty-quickcheck ]; description = "LZMA/XZ compression and decompression"; - license = lib.licensesSpdx."BSD-3-Clause"; + license = lib.meta.getLicenseFromSpdxId "BSD-3-Clause"; } ) { inherit (pkgs) xz; }; @@ -446067,7 +446067,7 @@ self: { tasty-quickcheck ]; description = "LZMA/XZ compression and decompression (static)"; - license = lib.licensesSpdx."BSD-3-Clause"; + license = lib.meta.getLicenseFromSpdxId "BSD-3-Clause"; } ) { }; @@ -446285,7 +446285,7 @@ self: { transformers ]; description = "A toolkit for working with macaroons"; - license = lib.licensesSpdx."BSD-3-Clause"; + license = lib.meta.getLicenseFromSpdxId "BSD-3-Clause"; } ) { }; @@ -446606,7 +446606,7 @@ self: { text ]; description = "Parse machines streams with attoparsec parsers"; - license = lib.licensesSpdx."BSD-3-Clause"; + license = lib.meta.getLicenseFromSpdxId "BSD-3-Clause"; hydraPlatforms = lib.platforms.none; broken = true; } @@ -446707,7 +446707,7 @@ self: { text ]; description = "Transcode encodings with machines"; - license = lib.licensesSpdx."BSD-3-Clause"; + license = lib.meta.getLicenseFromSpdxId "BSD-3-Clause"; hydraPlatforms = lib.platforms.none; broken = true; } @@ -447519,7 +447519,7 @@ self: { ghc-prim ]; description = "magma is an algebraic structure"; - license = lib.licensesSpdx."BSD-3-Clause"; + license = lib.meta.getLicenseFromSpdxId "BSD-3-Clause"; hydraPlatforms = lib.platforms.none; broken = true; } @@ -447669,7 +447669,7 @@ self: { optparse-applicative ]; description = "Preconfigured email connection pool on top of smtp"; - license = lib.licensesSpdx."MIT"; + license = lib.meta.getLicenseFromSpdxId "MIT"; mainProgram = "exe"; } ) { }; @@ -447717,7 +447717,7 @@ self: { isExecutable = true; executableHaskellDepends = [ base ]; description = "Count mailboxes in a SQL database"; - license = lib.licensesSpdx."AGPL-3.0-or-later"; + license = lib.meta.getLicenseFromSpdxId "AGPL-3.0-or-later"; mainProgram = "mailbox-count"; } ) { }; @@ -447859,7 +447859,7 @@ self: { wreq ]; description = "API binding for Mailgun"; - license = lib.licensesSpdx."BSD-3-Clause"; + license = lib.meta.getLicenseFromSpdxId "BSD-3-Clause"; hydraPlatforms = lib.platforms.none; } ) { }; @@ -449459,7 +449459,7 @@ self: { HUnit ]; description = "Convert C++ type signatures to their mangled form"; - license = lib.licensesSpdx."BSD-3-Clause"; + license = lib.meta.getLicenseFromSpdxId "BSD-3-Clause"; hydraPlatforms = lib.platforms.none; mainProgram = "mangle"; } @@ -449639,7 +449639,7 @@ self: { utility-ht ]; description = "A parser for web documents according to the HTML5 specification"; - license = lib.licensesSpdx."MPL-2.0"; + license = lib.meta.getLicenseFromSpdxId "MPL-2.0"; hydraPlatforms = lib.platforms.none; } ) { }; @@ -449921,7 +449921,7 @@ self: { unordered-containers ]; description = "foldl wrappers for map-reduce"; - license = lib.licensesSpdx."BSD-3-Clause"; + license = lib.meta.getLicenseFromSpdxId "BSD-3-Clause"; hydraPlatforms = lib.platforms.none; broken = true; } @@ -450009,7 +450009,7 @@ self: { vector ]; description = "Efficient, polymorphic Map Algebra"; - license = lib.licensesSpdx."BSD-3-Clause"; + license = lib.meta.getLicenseFromSpdxId "BSD-3-Clause"; hydraPlatforms = lib.platforms.none; broken = true; } @@ -450060,7 +450060,7 @@ self: { ]; testToolDepends = [ hspec-discover ]; description = "Types which represent functions k -> v"; - license = lib.licensesSpdx."BSD-3-Clause"; + license = lib.meta.getLicenseFromSpdxId "BSD-3-Clause"; mainProgram = "view"; } ) { }; @@ -450118,7 +450118,7 @@ self: { ]; testToolDepends = [ hspec-discover ]; description = "Types which represent functions k -> v"; - license = lib.licensesSpdx."BSD-3-Clause"; + license = lib.meta.getLicenseFromSpdxId "BSD-3-Clause"; hydraPlatforms = lib.platforms.none; mainProgram = "view"; } @@ -450826,7 +450826,7 @@ self: { tasty-golden ]; description = "A markup parser"; - license = lib.licensesSpdx."BSD-3-Clause"; + license = lib.meta.getLicenseFromSpdxId "BSD-3-Clause"; } ) { }; @@ -451394,7 +451394,7 @@ self: { text ]; description = "Fast and extensible bytestring builder"; - license = lib.licensesSpdx."BSD-3-Clause"; + license = lib.meta.getLicenseFromSpdxId "BSD-3-Clause"; } ) { }; @@ -451804,7 +451804,7 @@ self: { executableHaskellDepends = [ base ]; testHaskellDepends = [ base ]; description = "A micro web framework based on pattern matching"; - license = lib.licensesSpdx."BSD-3-Clause"; + license = lib.meta.getLicenseFromSpdxId "BSD-3-Clause"; hydraPlatforms = lib.platforms.none; mainProgram = "matcha-exe"; broken = true; @@ -451955,7 +451955,7 @@ self: { hedgehog ]; description = "A variety of mathematical utilities"; - license = lib.licensesSpdx."BSD-3-Clause"; + license = lib.meta.getLicenseFromSpdxId "BSD-3-Clause"; } ) { }; @@ -452069,7 +452069,7 @@ self: { sha256 = "0l8jv0zm1mar6848n5jyd6dzy02q0cvkgvgnry9db382i1r4g9bq"; libraryHaskellDepends = [ base ]; description = "Class for interpolation of values"; - license = lib.licensesSpdx."BSD-3-Clause"; + license = lib.meta.getLicenseFromSpdxId "BSD-3-Clause"; hydraPlatforms = lib.platforms.none; broken = true; } @@ -452083,7 +452083,7 @@ self: { sha256 = "092qbl1x0l6hcm9vn3nx3gyxnqcfx3z2kkfkqw5zmmmyn9zkjsgx"; libraryHaskellDepends = [ base ]; description = "Typeclass for metric spaces"; - license = lib.licensesSpdx."BSD-3-Clause"; + license = lib.meta.getLicenseFromSpdxId "BSD-3-Clause"; hydraPlatforms = lib.platforms.none; broken = true; } @@ -452121,7 +452121,7 @@ self: { text ]; description = "A library for formulating and solving math programs"; - license = lib.licensesSpdx."BSD-3-Clause"; + license = lib.meta.getLicenseFromSpdxId "BSD-3-Clause"; hydraPlatforms = lib.platforms.none; broken = true; } @@ -452161,7 +452161,7 @@ self: { unliftio ]; description = "A GLPK backend to the math-programming library"; - license = lib.licensesSpdx."BSD-3-Clause"; + license = lib.meta.getLicenseFromSpdxId "BSD-3-Clause"; hydraPlatforms = lib.platforms.none; } ) { }; @@ -452199,7 +452199,7 @@ self: { text ]; description = "Utility functions for testing implementations of the math-programming library"; - license = lib.licensesSpdx."BSD-3-Clause"; + license = lib.meta.getLicenseFromSpdxId "BSD-3-Clause"; hydraPlatforms = lib.platforms.none; } ) { }; @@ -452670,7 +452670,7 @@ self: { criterion ]; description = "A native implementation of matrix operations"; - license = lib.licensesSpdx."MIT"; + license = lib.meta.getLicenseFromSpdxId "MIT"; } ) { }; @@ -452778,7 +452778,7 @@ self: { unordered-containers ]; description = "A matrix client library"; - license = lib.licensesSpdx."Apache-2.0"; + license = lib.meta.getLicenseFromSpdxId "Apache-2.0"; maintainers = [ lib.maintainers.maralorn ]; } ) { }; @@ -452947,7 +452947,7 @@ self: { vector ]; description = "Haskell matrix library with interface to C++ linear algebra libraries"; - license = lib.licensesSpdx."BSD-3-Clause"; + license = lib.meta.getLicenseFromSpdxId "BSD-3-Clause"; hydraPlatforms = lib.platforms.none; broken = true; } @@ -454097,7 +454097,7 @@ self: { vector ]; description = "Sample from a posterior using Markov chain Monte Carlo"; - license = lib.licensesSpdx."GPL-3.0-or-later"; + license = lib.meta.getLicenseFromSpdxId "GPL-3.0-or-later"; maintainers = [ lib.maintainers.dschrempf ]; } ) { }; @@ -454243,7 +454243,7 @@ self: { wai-test ]; description = "A Servant-based Model Context Protocol (MCP) server for Haskell"; - license = lib.licensesSpdx."MPL-2.0"; + license = lib.meta.getLicenseFromSpdxId "MPL-2.0"; hydraPlatforms = lib.platforms.none; broken = true; } @@ -454297,7 +454297,7 @@ self: { text ]; description = "Library for building Model Context Protocol (MCP) servers"; - license = lib.licensesSpdx."BSD-3-Clause"; + license = lib.meta.getLicenseFromSpdxId "BSD-3-Clause"; } ) { }; @@ -454330,7 +454330,7 @@ self: { jsonrpc ]; description = "Core types and protocol definitions for the Model Context Protocol (MCP)"; - license = lib.licensesSpdx."MPL-2.0"; + license = lib.meta.getLicenseFromSpdxId "MPL-2.0"; } ) { }; @@ -454392,7 +454392,7 @@ self: { primitive ]; description = "MD5 Hash"; - license = lib.licensesSpdx."BSD-3-Clause"; + license = lib.meta.getLicenseFromSpdxId "BSD-3-Clause"; } ) { }; @@ -454589,7 +454589,7 @@ self: { uuid ]; description = "Manipulate FSMs and store them in PostgreSQL"; - license = lib.licensesSpdx."MIT"; + license = lib.meta.getLicenseFromSpdxId "MIT"; hydraPlatforms = lib.platforms.none; broken = true; } @@ -454632,7 +454632,7 @@ self: { vector-algorithms ]; description = "Mealy machines for processing time-series and ordered data"; - license = lib.licensesSpdx."BSD-3-Clause"; + license = lib.meta.getLicenseFromSpdxId "BSD-3-Clause"; } ) { }; @@ -454839,7 +454839,7 @@ self: { vector ]; description = "A schema language for JSON"; - license = lib.licensesSpdx."MIT"; + license = lib.meta.getLicenseFromSpdxId "MIT"; hydraPlatforms = lib.platforms.none; } ) { }; @@ -455516,7 +455516,7 @@ self: { weigh ]; description = "Monadic parser combinators"; - license = lib.licensesSpdx."BSD-2-Clause"; + license = lib.meta.getLicenseFromSpdxId "BSD-2-Clause"; } ) { }; @@ -455535,7 +455535,7 @@ self: { megaparsec ]; description = "A megaparsec library for CSV files"; - license = lib.licensesSpdx."BSD-3-Clause"; + license = lib.meta.getLicenseFromSpdxId "BSD-3-Clause"; } ) { }; @@ -455592,7 +455592,7 @@ self: { ]; testToolDepends = [ hspec-discover ]; description = "Test utilities and the test suite of Megaparsec"; - license = lib.licensesSpdx."BSD-2-Clause"; + license = lib.meta.getLicenseFromSpdxId "BSD-2-Clause"; } ) { }; @@ -456165,7 +456165,7 @@ self: { unix ]; description = "Print the core memory usage of programs"; - license = lib.licensesSpdx."BSD-3-Clause"; + license = lib.meta.getLicenseFromSpdxId "BSD-3-Clause"; } ) { }; @@ -456194,7 +456194,7 @@ self: { th-lift ]; description = "Indices for type level lists"; - license = lib.licensesSpdx."BSD-3-Clause"; + license = lib.meta.getLicenseFromSpdxId "BSD-3-Clause"; } ) { }; @@ -456224,7 +456224,7 @@ self: { type-spec ]; description = "Type-safe memory units"; - license = lib.licensesSpdx."MPL-2.0"; + license = lib.meta.getLicenseFromSpdxId "MPL-2.0"; hydraPlatforms = lib.platforms.none; broken = true; } @@ -456508,7 +456508,7 @@ self: { transformers ]; description = "Open temporary anonymous Linux file handles"; - license = lib.licensesSpdx."Apache-2.0"; + license = lib.meta.getLicenseFromSpdxId "Apache-2.0"; platforms = lib.platforms.linux; hydraPlatforms = lib.platforms.none; broken = true; @@ -456735,7 +456735,7 @@ self: { ]; testHaskellDepends = [ base ]; description = "A memoization library"; - license = lib.licensesSpdx."BSD-3-Clause"; + license = lib.meta.getLicenseFromSpdxId "BSD-3-Clause"; hydraPlatforms = lib.platforms.none; broken = true; } @@ -457164,7 +457164,7 @@ self: { transformers ]; description = "Securely erase memory contents by writing zeros to it"; - license = lib.licensesSpdx."Apache-2.0"; + license = lib.meta.getLicenseFromSpdxId "Apache-2.0"; } ) { }; @@ -457337,7 +457337,7 @@ self: { ]; testHaskellDepends = [ base ]; description = "A functor for consistent merging of information"; - license = lib.licensesSpdx."MIT"; + license = lib.meta.getLicenseFromSpdxId "MIT"; } ) { }; @@ -457626,7 +457626,7 @@ self: { random-bytestring ]; description = "Merkle Tree Logs"; - license = lib.licensesSpdx."BSD-3-Clause"; + license = lib.meta.getLicenseFromSpdxId "BSD-3-Clause"; } ) { }; @@ -457825,7 +457825,7 @@ self: { typed-process ]; description = "Temporary message-db for integration testing"; - license = lib.licensesSpdx."MIT"; + license = lib.meta.getLicenseFromSpdxId "MIT"; hydraPlatforms = lib.platforms.none; } ) { }; @@ -458256,7 +458256,7 @@ self: { ]; testToolDepends = [ hspec-discover ]; description = "rebindable methods for improving testability"; - license = lib.licensesSpdx."BSD-3-Clause"; + license = lib.meta.getLicenseFromSpdxId "BSD-3-Clause"; hydraPlatforms = lib.platforms.none; broken = true; } @@ -458697,7 +458697,7 @@ self: { ]; doHaddock = false; description = "Implements multiformats specification"; - license = lib.licensesSpdx."AGPL-3.0-or-later"; + license = lib.meta.getLicenseFromSpdxId "AGPL-3.0-or-later"; hydraPlatforms = lib.platforms.none; } ) { }; @@ -459082,7 +459082,7 @@ self: { warp-tls ]; description = "a minimalistic DNS-authoritative server"; - license = lib.licensesSpdx."BSD-3-Clause"; + license = lib.meta.getLicenseFromSpdxId "BSD-3-Clause"; hydraPlatforms = lib.platforms.none; mainProgram = "microdns"; broken = true; @@ -459302,7 +459302,7 @@ self: { vector ]; description = "Law-abiding lenses for Aeson, using microlens"; - license = lib.licensesSpdx."MIT"; + license = lib.meta.getLicenseFromSpdxId "MIT"; } ) { }; @@ -459896,7 +459896,7 @@ self: { text ]; description = "Mustache templates for Haskell"; - license = lib.licensesSpdx."BSD-3-Clause"; + license = lib.meta.getLicenseFromSpdxId "BSD-3-Clause"; } ) { }; @@ -460299,7 +460299,7 @@ self: { wxcore ]; description = "A Memory-like (Concentration, Pairs, ...) game for tones"; - license = lib.licensesSpdx."BSD-3-Clause"; + license = lib.meta.getLicenseFromSpdxId "BSD-3-Clause"; hydraPlatforms = lib.platforms.none; mainProgram = "midimory"; } @@ -460971,7 +460971,7 @@ self: { text ]; description = "Semi-automatic database schema migrations"; - license = lib.licensesSpdx."BSD-3-Clause"; + license = lib.meta.getLicenseFromSpdxId "BSD-3-Clause"; } ) { }; @@ -461016,7 +461016,7 @@ self: { text ]; description = "Semi-automatic database schema migrations"; - license = lib.licensesSpdx."BSD-3-Clause"; + license = lib.meta.getLicenseFromSpdxId "BSD-3-Clause"; } ) { }; @@ -461059,7 +461059,7 @@ self: { text ]; description = "Semi-automatic database schema migrations"; - license = lib.licensesSpdx."BSD-3-Clause"; + license = lib.meta.getLicenseFromSpdxId "BSD-3-Clause"; } ) { }; @@ -461098,7 +461098,7 @@ self: { text ]; description = "Semi-automatic database schema migrations"; - license = lib.licensesSpdx."BSD-3-Clause"; + license = lib.meta.getLicenseFromSpdxId "BSD-3-Clause"; } ) { }; @@ -461542,7 +461542,7 @@ self: { random ]; description = "Double-ended priority queues"; - license = lib.licensesSpdx."BSD-3-Clause"; + license = lib.meta.getLicenseFromSpdxId "BSD-3-Clause"; hydraPlatforms = lib.platforms.none; broken = true; } @@ -461556,7 +461556,7 @@ self: { sha256 = "07h6hgq4k1wm4ldwb29fgmmbl9ygrlbq3qv3ymfvc25l5rvgss4h"; doHaddock = false; description = "TBA"; - license = lib.licensesSpdx."BSD-3-Clause"; + license = lib.meta.getLicenseFromSpdxId "BSD-3-Clause"; } ) { }; @@ -461693,7 +461693,7 @@ self: { sha256 = "18vxnsn1lgrqc2clnygi68y7234z0jlqlz4cqjdpy0v0xspy90mf"; libraryHaskellDepends = [ base ]; description = "Minimal essentials"; - license = lib.licensesSpdx."MIT"; + license = lib.meta.getLicenseFromSpdxId "MIT"; } ) { }; @@ -461815,7 +461815,7 @@ self: { unix ]; description = "Minimalist CI framework to run checks on local machine"; - license = lib.licensesSpdx."GPL-3.0-only"; + license = lib.meta.getLicenseFromSpdxId "GPL-3.0-only"; mainProgram = "minici"; } ) { }; @@ -461845,7 +461845,7 @@ self: { HUnit ]; description = "Minimal bindings to libcurl"; - license = lib.licensesSpdx."BSD-3-Clause"; + license = lib.meta.getLicenseFromSpdxId "BSD-3-Clause"; hydraPlatforms = lib.platforms.none; broken = true; } @@ -462021,7 +462021,7 @@ self: { ]; testToolDepends = [ tasty-discover ]; description = "A SDL2-based graphics library, batteries-included"; - license = lib.licensesSpdx."MIT"; + license = lib.meta.getLicenseFromSpdxId "MIT"; hydraPlatforms = lib.platforms.none; } ) { }; @@ -462071,7 +462071,7 @@ self: { mtl ]; description = "A binding library of minilight for Lua langauge"; - license = lib.licensesSpdx."MIT"; + license = lib.meta.getLicenseFromSpdxId "MIT"; hydraPlatforms = lib.platforms.none; mainProgram = "example"; } @@ -462279,7 +462279,7 @@ self: { xml-conduit ]; description = "A MinIO Haskell Library for Amazon S3 compatible cloud storage"; - license = lib.licensesSpdx."Apache-2.0"; + license = lib.meta.getLicenseFromSpdxId "Apache-2.0"; maintainers = [ lib.maintainers.mpscholten ]; } ) { }; @@ -462334,7 +462334,7 @@ self: { warp ]; description = "A Haskell introspectable web router"; - license = lib.licensesSpdx."MIT"; + license = lib.meta.getLicenseFromSpdxId "MIT"; } ) { }; @@ -462372,7 +462372,7 @@ self: { warp ]; description = "Minion conduit support"; - license = lib.licensesSpdx."MIT"; + license = lib.meta.getLicenseFromSpdxId "MIT"; mainProgram = "minion-conduit-example"; } ) { }; @@ -462398,7 +462398,7 @@ self: { text ]; description = "Minion HTMX support"; - license = lib.licensesSpdx."MIT"; + license = lib.meta.getLicenseFromSpdxId "MIT"; } ) { }; @@ -462442,7 +462442,7 @@ self: { warp ]; description = "Minion JWT support"; - license = lib.licensesSpdx."MIT"; + license = lib.meta.getLicenseFromSpdxId "MIT"; mainProgram = "minion-jwt-example"; } ) { }; @@ -462492,7 +462492,7 @@ self: { text ]; description = "Minion openapi3 support"; - license = lib.licensesSpdx."MIT"; + license = lib.meta.getLicenseFromSpdxId "MIT"; } ) { }; @@ -462538,7 +462538,7 @@ self: { warp ]; description = "Minion wrappers for wai-extra"; - license = lib.licensesSpdx."MIT"; + license = lib.meta.getLicenseFromSpdxId "MIT"; } ) { }; @@ -462695,7 +462695,7 @@ self: { system-cxx-std-lib ]; description = "A Haskell bundle of the Minisat SAT solver"; - license = lib.licensesSpdx."BSD-3-Clause"; + license = lib.meta.getLicenseFromSpdxId "BSD-3-Clause"; } ) { }; @@ -462794,7 +462794,7 @@ self: { ]; benchmarkHaskellDepends = [ base ]; description = "Simple and lightweight benchmarking utilities"; - license = lib.licensesSpdx."MIT"; + license = lib.meta.getLicenseFromSpdxId "MIT"; } ) { }; @@ -463136,7 +463136,7 @@ self: { vector ]; description = "fortune-mod clone"; - license = lib.licensesSpdx."MIT"; + license = lib.meta.getLicenseFromSpdxId "MIT"; } ) { }; @@ -463488,7 +463488,7 @@ self: { transformers ]; description = "A tasty Haskell front-end web framework"; - license = lib.licensesSpdx."BSD-3-Clause"; + license = lib.meta.getLicenseFromSpdxId "BSD-3-Clause"; } ) { }; @@ -463525,7 +463525,7 @@ self: { isLibrary = false; isExecutable = true; description = "A tasty Haskell front-end web framework"; - license = lib.licensesSpdx."BSD-3-Clause"; + license = lib.meta.getLicenseFromSpdxId "BSD-3-Clause"; platforms = [ "javascript-ghcjs" ]; } ) { }; @@ -463643,7 +463643,7 @@ self: { unix ]; description = "A Haskell git implimentation"; - license = lib.licensesSpdx."BSD-3-Clause"; + license = lib.meta.getLicenseFromSpdxId "BSD-3-Clause"; hydraPlatforms = lib.platforms.none; } ) { }; @@ -463677,7 +463677,7 @@ self: { posix-paths ]; description = "Useability extras built on top of miss"; - license = lib.licensesSpdx."BSD-3-Clause"; + license = lib.meta.getLicenseFromSpdxId "BSD-3-Clause"; hydraPlatforms = lib.platforms.none; } ) { }; @@ -463769,7 +463769,7 @@ self: { ]; executableHaskellDepends = [ base ]; description = "A git wrapper with a streamlined UX"; - license = lib.licensesSpdx."MIT"; + license = lib.meta.getLicenseFromSpdxId "MIT"; hydraPlatforms = lib.platforms.none; mainProgram = "mit"; broken = true; @@ -463836,7 +463836,7 @@ self: { hspec ]; description = "Vim plugin manager written in Haskell"; - license = lib.licensesSpdx."MIT"; + license = lib.meta.getLicenseFromSpdxId "MIT"; mainProgram = "miv"; } ) { }; @@ -464161,7 +464161,7 @@ self: { ram ]; description = "Module-Lattice-based Key-Encapsulation Mechanism"; - license = lib.licensesSpdx."BSD-3-Clause"; + license = lib.meta.getLicenseFromSpdxId "BSD-3-Clause"; hydraPlatforms = lib.platforms.none; broken = true; } @@ -464339,7 +464339,7 @@ self: { weigh ]; description = "Strict markdown processor for writers"; - license = lib.licensesSpdx."BSD-3-Clause"; + license = lib.meta.getLicenseFromSpdxId "BSD-3-Clause"; maintainers = [ lib.maintainers.mpscholten ]; } ) { }; @@ -464383,7 +464383,7 @@ self: { text ]; description = "Command line interface to the MMark markdown processor"; - license = lib.licensesSpdx."BSD-3-Clause"; + license = lib.meta.getLicenseFromSpdxId "BSD-3-Clause"; mainProgram = "mmark"; } ) { }; @@ -464431,7 +464431,7 @@ self: { ]; testToolDepends = [ hspec-discover ]; description = "Commonly useful extensions for the MMark markdown processor"; - license = lib.licensesSpdx."BSD-3-Clause"; + license = lib.meta.getLicenseFromSpdxId "BSD-3-Clause"; maintainers = [ lib.maintainers.mpscholten ]; } ) { }; @@ -465033,7 +465033,7 @@ self: { ]; testToolDepends = [ hspec-discover ]; description = "Read environment variables into a user-defined data type"; - license = lib.licensesSpdx."MIT"; + license = lib.meta.getLicenseFromSpdxId "MIT"; hydraPlatforms = lib.platforms.none; } ) { }; @@ -465093,7 +465093,7 @@ self: { uuid-types ]; description = "A TypeID and UUIDv7 implementation for Haskell"; - license = lib.licensesSpdx."MIT"; + license = lib.meta.getLicenseFromSpdxId "MIT"; } ) { }; @@ -465246,7 +465246,7 @@ self: { yaml ]; description = "A HTTP server for testing HTTP clients"; - license = lib.licensesSpdx."BSD-2-Clause"; + license = lib.meta.getLicenseFromSpdxId "BSD-2-Clause"; hydraPlatforms = lib.platforms.none; mainProgram = "mock-httpd"; broken = true; @@ -465706,7 +465706,7 @@ self: { weigh ]; description = "Modern library for working with URIs"; - license = lib.licensesSpdx."BSD-3-Clause"; + license = lib.meta.getLicenseFromSpdxId "BSD-3-Clause"; } ) { }; @@ -465838,7 +465838,7 @@ self: { doctest ]; description = "A type for integers modulo some constant"; - license = lib.licensesSpdx."BSD-3-Clause"; + license = lib.meta.getLicenseFromSpdxId "BSD-3-Clause"; } ) { }; @@ -466253,7 +466253,7 @@ self: { type-set ]; description = "Monadic Functional Reactive Programming"; - license = lib.licensesSpdx."BSD-3-Clause"; + license = lib.meta.getLicenseFromSpdxId "BSD-3-Clause"; } ) { }; @@ -466312,7 +466312,7 @@ self: { unordered-containers ]; description = "Samples of moffy"; - license = lib.licensesSpdx."BSD-3-Clause"; + license = lib.meta.getLicenseFromSpdxId "BSD-3-Clause"; } ) { }; @@ -466380,7 +466380,7 @@ self: { union-color ]; description = "Events for sample codes of moffy"; - license = lib.licensesSpdx."BSD-3-Clause"; + license = lib.meta.getLicenseFromSpdxId "BSD-3-Clause"; } ) { }; @@ -466408,7 +466408,7 @@ self: { moffy-samples-gtk3-run ]; description = "Sample executables of moffy - GTK3 version"; - license = lib.licensesSpdx."BSD-3-Clause"; + license = lib.meta.getLicenseFromSpdxId "BSD-3-Clause"; hydraPlatforms = lib.platforms.none; mainProgram = "moffy_samples_gtk3"; } @@ -466474,7 +466474,7 @@ self: { union-color ]; description = "Package to run moffy samples - GTK3 version"; - license = lib.licensesSpdx."BSD-3-Clause"; + license = lib.meta.getLicenseFromSpdxId "BSD-3-Clause"; hydraPlatforms = lib.platforms.none; broken = true; } @@ -466502,7 +466502,7 @@ self: { ]; testHaskellDepends = [ base ]; description = "Sample executables of moffy - GTK4 version"; - license = lib.licensesSpdx."BSD-3-Clause"; + license = lib.meta.getLicenseFromSpdxId "BSD-3-Clause"; hydraPlatforms = lib.platforms.none; mainProgram = "moffy_samples_gtk4"; } @@ -466571,7 +466571,7 @@ self: { union-color ]; description = "Package to run moffy samples - Gtk4 version"; - license = lib.licensesSpdx."BSD-3-Clause"; + license = lib.meta.getLicenseFromSpdxId "BSD-3-Clause"; hydraPlatforms = lib.platforms.none; broken = true; } @@ -466637,7 +466637,7 @@ self: { bytestring ]; description = "Modular Haskell Web Server"; - license = lib.licensesSpdx."BSD-3-Clause"; + license = lib.meta.getLicenseFromSpdxId "BSD-3-Clause"; hydraPlatforms = lib.platforms.none; mainProgram = "hws"; broken = true; @@ -466872,7 +466872,7 @@ self: { transformers ]; description = "Actions of monads on functors"; - license = lib.licensesSpdx."LGPL-2.0-or-later"; + license = lib.meta.getLicenseFromSpdxId "LGPL-2.0-or-later"; } ) { }; @@ -467146,7 +467146,7 @@ self: { vty-unix ]; description = "A library for probabilistic programming"; - license = lib.licensesSpdx."MIT"; + license = lib.meta.getLicenseFromSpdxId "MIT"; mainProgram = "example"; maintainers = [ lib.maintainers.turion ]; } @@ -467585,7 +467585,7 @@ self: { unix ]; description = "A fast and lightweight effect system"; - license = lib.licensesSpdx."BSD-3-Clause"; + license = lib.meta.getLicenseFromSpdxId "BSD-3-Clause"; } ) { }; @@ -467628,7 +467628,7 @@ self: { time ]; description = "A flexible logging system utilizing the `monad-effect` effect system"; - license = lib.licensesSpdx."BSD-3-Clause"; + license = lib.meta.getLicenseFromSpdxId "BSD-3-Clause"; hydraPlatforms = lib.platforms.none; broken = true; } @@ -467863,7 +467863,7 @@ self: { comonad ]; description = "Ideal Monads and coproduct of them"; - license = lib.licensesSpdx."BSD-3-Clause"; + license = lib.meta.getLicenseFromSpdxId "BSD-3-Clause"; } ) { }; @@ -467875,7 +467875,7 @@ self: { sha256 = "0ajn06f3q181nf6xa4kish04bv74crqmsmk7i1ny4kw1m9ag139d"; libraryHaskellDepends = [ base ]; description = "Monads with an unsaveInterleaveIO-like operation"; - license = lib.licensesSpdx."BSD-3-Clause"; + license = lib.meta.getLicenseFromSpdxId "BSD-3-Clause"; } ) { }; @@ -469033,7 +469033,7 @@ self: { ]; testToolDepends = [ hspec-discover ]; description = "Railway-oriented error handling for Haskell"; - license = lib.licensesSpdx."BSD-3-Clause"; + license = lib.meta.getLicenseFromSpdxId "BSD-3-Clause"; } ) { }; @@ -469165,7 +469165,7 @@ self: { transformers ]; description = "A new, simple, composable concurrency abstraction"; - license = lib.licensesSpdx."MIT"; + license = lib.meta.getLicenseFromSpdxId "MIT"; maintainers = [ lib.maintainers.turion ]; } ) { }; @@ -469218,7 +469218,7 @@ self: { transformers ]; description = "A new, simple, composable concurrency abstraction"; - license = lib.licensesSpdx."MIT"; + license = lib.meta.getLicenseFromSpdxId "MIT"; hydraPlatforms = lib.platforms.none; maintainers = [ lib.maintainers.turion ]; } @@ -469232,7 +469232,7 @@ self: { sha256 = "0hqlwimwdhxwcikmy41qlkzr09dxx7ibpzr2g4czlv07c6fwlm3q"; libraryHaskellDepends = [ base ]; description = "Monads of program skeleta"; - license = lib.licensesSpdx."BSD-3-Clause"; + license = lib.meta.getLicenseFromSpdxId "BSD-3-Clause"; hydraPlatforms = lib.platforms.none; broken = true; } @@ -469489,7 +469489,7 @@ self: { typed-process ]; description = "Functions to exit the program anywhere in MonadThrow monads"; - license = lib.licensesSpdx."Apache-2.0"; + license = lib.meta.getLicenseFromSpdxId "Apache-2.0"; hydraPlatforms = lib.platforms.none; broken = true; } @@ -469540,7 +469540,7 @@ self: { time ]; description = "Adaptation of the monad-time library for the effectful ecosystem"; - license = lib.licensesSpdx."MIT"; + license = lib.meta.getLicenseFromSpdxId "MIT"; } ) { }; @@ -469757,7 +469757,7 @@ self: { ]; testToolDepends = [ hspec-discover ]; description = "A monad transformer for data validation"; - license = lib.licensesSpdx."ISC"; + license = lib.meta.getLicenseFromSpdxId "ISC"; } ) { }; @@ -469832,7 +469832,7 @@ self: { sha256 = "048xk3zr7237c0mzr6lfca3qsgh60icnp8vw3vg2pj12z8id62ka"; libraryHaskellDepends = [ base ]; description = "A collection of monad transformers"; - license = lib.licensesSpdx."ISC"; + license = lib.meta.getLicenseFromSpdxId "ISC"; } ) { }; @@ -469872,7 +469872,7 @@ self: { transformers ]; description = "The Acme and AcmeT monads"; - license = lib.licensesSpdx."BSD-3-Clause"; + license = lib.meta.getLicenseFromSpdxId "BSD-3-Clause"; hydraPlatforms = lib.platforms.none; broken = true; } @@ -470008,7 +470008,7 @@ self: { transformers ]; description = "GHC plugin to desugar ! into do-notation"; - license = lib.licensesSpdx."MIT"; + license = lib.meta.getLicenseFromSpdxId "MIT"; } ) { }; @@ -470038,7 +470038,7 @@ self: { ]; testHaskellDepends = [ base ]; description = "Recursion Schemes for Monadic version"; - license = lib.licensesSpdx."BSD-3-Clause"; + license = lib.meta.getLicenseFromSpdxId "BSD-3-Clause"; hydraPlatforms = lib.platforms.none; broken = true; } @@ -470310,7 +470310,7 @@ self: { text ]; description = "The best ideas in monad-related classes and types"; - license = lib.licensesSpdx."BSD-2-Clause"; + license = lib.meta.getLicenseFromSpdxId "BSD-2-Clause"; } ) { }; @@ -470368,7 +470368,7 @@ self: { transformers ]; description = "Monad classes, using type families"; - license = lib.licensesSpdx."BSD-3-Clause"; + license = lib.meta.getLicenseFromSpdxId "BSD-3-Clause"; } ) { }; @@ -470509,7 +470509,7 @@ self: { text ]; description = "Pure Haskell library for audio metadata parsing and writing"; - license = lib.licensesSpdx."GPL-3.0-only"; + license = lib.meta.getLicenseFromSpdxId "GPL-3.0-only"; mainProgram = "monatone"; } ) { }; @@ -471235,7 +471235,7 @@ self: { witherable ]; description = "A monoidal map with the right group instance"; - license = lib.licensesSpdx."BSD-3-Clause"; + license = lib.meta.getLicenseFromSpdxId "BSD-3-Clause"; } ) { }; @@ -471474,7 +471474,7 @@ self: { mtl ]; description = "Monoidal Functors Library"; - license = lib.licensesSpdx."MIT"; + license = lib.meta.getLicenseFromSpdxId "MIT"; mainProgram = "co-log"; } ) { }; @@ -471494,7 +471494,7 @@ self: { ghc ]; description = "A monoidal interface for aggregating GHC plugins"; - license = lib.licensesSpdx."BSD-3-Clause"; + license = lib.meta.getLicenseFromSpdxId "BSD-3-Clause"; } ) { }; @@ -471523,7 +471523,7 @@ self: { nothunks ]; description = "Monoidal map type"; - license = lib.licensesSpdx."Apache-2.0"; + license = lib.meta.getLicenseFromSpdxId "Apache-2.0"; } ) { }; @@ -471552,7 +471552,7 @@ self: { nothunks ]; description = "Monoidal map type"; - license = lib.licensesSpdx."Apache-2.0"; + license = lib.meta.getLicenseFromSpdxId "Apache-2.0"; hydraPlatforms = lib.platforms.none; } ) { }; @@ -471599,7 +471599,7 @@ self: { ]; testToolDepends = [ hspec-discover ]; description = "JSON support for monoidmap"; - license = lib.licensesSpdx."Apache-2.0"; + license = lib.meta.getLicenseFromSpdxId "Apache-2.0"; } ) { }; @@ -471632,7 +471632,7 @@ self: { ]; testToolDepends = [ hspec-discover ]; description = "Examples for monoidmap"; - license = lib.licensesSpdx."Apache-2.0"; + license = lib.meta.getLicenseFromSpdxId "Apache-2.0"; } ) { }; @@ -471655,7 +471655,7 @@ self: { monoidmap ]; description = "Hashing support for monoidmap"; - license = lib.licensesSpdx."Apache-2.0"; + license = lib.meta.getLicenseFromSpdxId "Apache-2.0"; } ) { }; @@ -471715,7 +471715,7 @@ self: { tasty-hunit ]; description = "Internal support for monoidmap"; - license = lib.licensesSpdx."Apache-2.0"; + license = lib.meta.getLicenseFromSpdxId "Apache-2.0"; } ) { }; @@ -471775,7 +471775,7 @@ self: { tasty-hunit ]; description = "Internal support for monoidmap"; - license = lib.licensesSpdx."Apache-2.0"; + license = lib.meta.getLicenseFromSpdxId "Apache-2.0"; hydraPlatforms = lib.platforms.none; } ) { }; @@ -471801,7 +471801,7 @@ self: { QuickCheck ]; description = "QuickCheck support for monoidmap"; - license = lib.licensesSpdx."Apache-2.0"; + license = lib.meta.getLicenseFromSpdxId "Apache-2.0"; } ) { }; @@ -472343,7 +472343,7 @@ self: { time-compat ]; description = "MonthName"; - license = lib.licensesSpdx."BSD-3-Clause"; + license = lib.meta.getLicenseFromSpdxId "BSD-3-Clause"; } ) { }; @@ -472374,7 +472374,7 @@ self: { tasty-smallcheck ]; description = "a 'Monus' is a commutative monoid that allows a notion of substraction"; - license = lib.licensesSpdx."BSD-3-Clause"; + license = lib.meta.getLicenseFromSpdxId "BSD-3-Clause"; hydraPlatforms = lib.platforms.none; broken = true; } @@ -472579,7 +472579,7 @@ self: { ]; doHaddock = false; description = "Invocation helpers for the ReaderT-record-of-functions style"; - license = lib.licensesSpdx."BSD-3-Clause"; + license = lib.meta.getLicenseFromSpdxId "BSD-3-Clause"; hydraPlatforms = lib.platforms.none; } ) { }; @@ -473133,7 +473133,7 @@ self: { ]; testToolDepends = [ tasty-discover ]; description = "Upgradeability infrastructure based on Morley"; - license = lib.licensesSpdx."MIT"; + license = lib.meta.getLicenseFromSpdxId "MIT"; hydraPlatforms = lib.platforms.none; mainProgram = "morley-ustore-reader"; } @@ -474691,7 +474691,7 @@ self: { optparse-applicative ]; description = "Print current MPD song and status as JSON"; - license = lib.licensesSpdx."Unlicense"; + license = lib.meta.getLicenseFromSpdxId "Unlicense"; mainProgram = "mpd-current-json"; } ) { }; @@ -475210,7 +475210,7 @@ self: { text ]; description = "Datastructures to describe TCP and MPTCP connections"; - license = lib.licensesSpdx."GPL-3.0-only"; + license = lib.meta.getLicenseFromSpdxId "GPL-3.0-only"; hydraPlatforms = lib.platforms.none; } ) { }; @@ -475317,7 +475317,7 @@ self: { text ]; description = "A Multipath TCP path manager"; - license = lib.licensesSpdx."GPL-3.0-only"; + license = lib.meta.getLicenseFromSpdxId "GPL-3.0-only"; badPlatforms = lib.platforms.darwin; hydraPlatforms = lib.platforms.none; mainProgram = "mptcp-pm"; @@ -475497,7 +475497,7 @@ self: { QuickCheck ]; description = "A Multipath TCP analyzer"; - license = lib.licensesSpdx."GPL-3.0-only"; + license = lib.meta.getLicenseFromSpdxId "GPL-3.0-only"; hydraPlatforms = lib.platforms.none; mainProgram = "mptcpanalyzer"; } @@ -475740,7 +475740,7 @@ self: { hspec ]; description = "A simple way to read environment variables in Haskell"; - license = lib.licensesSpdx."MIT"; + license = lib.meta.getLicenseFromSpdxId "MIT"; } ) { }; @@ -476079,7 +476079,7 @@ self: { zstd ]; description = "Types and parser for the MSDF atlas layout"; - license = lib.licensesSpdx."BSD-3-Clause"; + license = lib.meta.getLicenseFromSpdxId "BSD-3-Clause"; hydraPlatforms = lib.platforms.none; broken = true; } @@ -476937,7 +476937,7 @@ self: { transformers ]; description = "Monad classes for transformers, using functional dependencies"; - license = lib.licensesSpdx."BSD-3-Clause"; + license = lib.meta.getLicenseFromSpdxId "BSD-3-Clause"; hydraPlatforms = lib.platforms.none; } ) { }; @@ -477050,7 +477050,7 @@ self: { transformers ]; description = "Monad classes for transformers, using functional dependencies"; - license = lib.licensesSpdx."BSD-3-Clause"; + license = lib.meta.getLicenseFromSpdxId "BSD-3-Clause"; } ) { }; @@ -477182,7 +477182,7 @@ self: { mtl ]; description = "Lift substacks of monad transformer stacks"; - license = lib.licensesSpdx."MIT"; + license = lib.meta.getLicenseFromSpdxId "MIT"; hydraPlatforms = lib.platforms.none; broken = true; } @@ -477291,7 +477291,7 @@ self: { mtl ]; description = "Reified monad transformer stacks"; - license = lib.licensesSpdx."MIT"; + license = lib.meta.getLicenseFromSpdxId "MIT"; hydraPlatforms = lib.platforms.none; broken = true; } @@ -478421,7 +478421,7 @@ self: { ]; testToolDepends = [ hspec-discover ]; description = "A few multimap variants"; - license = lib.licensesSpdx."BSD-3-Clause"; + license = lib.meta.getLicenseFromSpdxId "BSD-3-Clause"; hydraPlatforms = lib.platforms.none; broken = true; } @@ -478449,7 +478449,7 @@ self: { ]; doHaddock = false; description = "Multiple Exceptions"; - license = lib.licensesSpdx."MIT"; + license = lib.meta.getLicenseFromSpdxId "MIT"; } ) { }; @@ -478469,7 +478469,7 @@ self: { hedgehog ]; description = "Typeclasses augmented with a phantom type parameter"; - license = lib.licensesSpdx."Apache-2.0"; + license = lib.meta.getLicenseFromSpdxId "Apache-2.0"; hydraPlatforms = lib.platforms.none; broken = true; } @@ -478632,7 +478632,7 @@ self: { template-haskell ]; description = "Self-identifying base encodings, implementation of "; - license = lib.licensesSpdx."BSD-3-Clause"; + license = lib.meta.getLicenseFromSpdxId "BSD-3-Clause"; hydraPlatforms = lib.platforms.none; } ) { }; @@ -478658,7 +478658,7 @@ self: { sop-core ]; description = "Uncurry functions with multiple arguments"; - license = lib.licensesSpdx."BSD-3-Clause"; + license = lib.meta.getLicenseFromSpdxId "BSD-3-Clause"; hydraPlatforms = lib.platforms.none; broken = true; } @@ -478725,7 +478725,7 @@ self: { toml-reader ]; description = "Simple tool for running commands in multiple directories"; - license = lib.licensesSpdx."BSD-3-Clause"; + license = lib.meta.getLicenseFromSpdxId "BSD-3-Clause"; hydraPlatforms = lib.platforms.none; mainProgram = "muld"; broken = true; @@ -478921,7 +478921,7 @@ self: { hedgehog ]; description = "Self-identifying hashes, implementation of "; - license = lib.licensesSpdx."BSD-3-Clause"; + license = lib.meta.getLicenseFromSpdxId "BSD-3-Clause"; } ) { }; @@ -478957,7 +478957,7 @@ self: { serialise ]; description = "CBOR encoding of multihashes"; - license = lib.licensesSpdx."BSD-3-Clause"; + license = lib.meta.getLicenseFromSpdxId "BSD-3-Clause"; hydraPlatforms = lib.platforms.none; } ) { }; @@ -479826,7 +479826,7 @@ self: { haskeline ]; description = "A framework for multiverse debugging"; - license = lib.licensesSpdx."BSD-3-Clause"; + license = lib.meta.getLicenseFromSpdxId "BSD-3-Clause"; mainProgram = "multiverse-debugging-exe"; } ) { }; @@ -479870,7 +479870,7 @@ self: { transformers ]; description = "Traverse data types via generics, acting on multiple types simultaneously"; - license = lib.licensesSpdx."GPL-3.0-or-later"; + license = lib.meta.getLicenseFromSpdxId "GPL-3.0-or-later"; hydraPlatforms = lib.platforms.none; broken = true; } @@ -480983,7 +480983,7 @@ self: { ppad-secp256k1 ]; description = "MuSig2 library"; - license = lib.licensesSpdx."MIT"; + license = lib.meta.getLicenseFromSpdxId "MIT"; hydraPlatforms = lib.platforms.none; } ) { }; @@ -481289,7 +481289,7 @@ self: { vector ]; description = "Mutable Fenwick trees"; - license = lib.licensesSpdx."MIT"; + license = lib.meta.getLicenseFromSpdxId "MIT"; } ) { }; @@ -481360,7 +481360,7 @@ self: { primitive ]; description = "Interoperate mutable references with regular lens"; - license = lib.licensesSpdx."Apache-2.0"; + license = lib.meta.getLicenseFromSpdxId "Apache-2.0"; } ) { }; @@ -481414,7 +481414,7 @@ self: { safe-exceptions ]; description = "A trivial lock based on MVar"; - license = lib.licensesSpdx."Apache-2.0"; + license = lib.meta.getLicenseFromSpdxId "Apache-2.0"; hydraPlatforms = lib.platforms.none; broken = true; } @@ -481650,7 +481650,7 @@ self: { ]; doCheck = false; description = "Fast, high quality pseudo random number generation"; - license = lib.licensesSpdx."BSD-2-Clause"; + license = lib.meta.getLicenseFromSpdxId "BSD-2-Clause"; } ) { }; @@ -482567,7 +482567,7 @@ self: { vector ]; description = "pure haskell MySQL driver"; - license = lib.licensesSpdx."BSD-3-Clause"; + license = lib.meta.getLicenseFromSpdxId "BSD-3-Clause"; } ) { }; @@ -482782,7 +482782,7 @@ self: { vector ]; description = "pure haskell MySQL driver"; - license = lib.licensesSpdx."BSD-3-Clause"; + license = lib.meta.getLicenseFromSpdxId "BSD-3-Clause"; hydraPlatforms = lib.platforms.none; broken = true; } @@ -483052,7 +483052,7 @@ self: { vty ]; description = "Tool to keep track of what you have been working on and where"; - license = lib.licensesSpdx."ISC"; + license = lib.meta.getLicenseFromSpdxId "ISC"; hydraPlatforms = lib.platforms.none; mainProgram = "mywork"; broken = true; @@ -483122,7 +483122,7 @@ self: { text ]; description = "A Haskell client for the Myxine GUI server"; - license = lib.licensesSpdx."MIT"; + license = lib.meta.getLicenseFromSpdxId "MIT"; hydraPlatforms = lib.platforms.none; broken = true; } @@ -483373,7 +483373,7 @@ self: { libraryHaskellDepends = [ base ]; testHaskellDepends = [ base ]; description = "Domain-specific languages for describing composable web services"; - license = lib.licensesSpdx."BSD-3-Clause"; + license = lib.meta.getLicenseFromSpdxId "BSD-3-Clause"; } ) { }; @@ -483722,7 +483722,7 @@ self: { libraryHaskellDepends = [ base ]; testHaskellDepends = [ base ]; description = "Named parameters (keyword arguments) for Haskell"; - license = lib.licensesSpdx."BSD-3-Clause"; + license = lib.meta.getLicenseFromSpdxId "BSD-3-Clause"; } ) { }; @@ -483762,7 +483762,7 @@ self: { text ]; description = "NBT (named binary tag) serialization and deserialization"; - license = lib.licensesSpdx."MIT"; + license = lib.meta.getLicenseFromSpdxId "MIT"; hydraPlatforms = lib.platforms.none; broken = true; } @@ -483998,7 +483998,7 @@ self: { unordered-containers ]; description = "A parameterized named text type and associated functionality"; - license = lib.licensesSpdx."ISC"; + license = lib.meta.getLicenseFromSpdxId "ISC"; } ) { }; @@ -484388,7 +484388,7 @@ self: { transformers ]; description = "Create compilers using small passes and many intermediate representations"; - license = lib.licensesSpdx."BSD-3-Clause"; + license = lib.meta.getLicenseFromSpdxId "BSD-3-Clause"; hydraPlatforms = lib.platforms.none; mainProgram = "dumb-nanopass-example"; broken = true; @@ -484724,7 +484724,7 @@ self: { text ]; description = "Refinement types for natural numbers with an optics interface"; - license = lib.licensesSpdx."MIT"; + license = lib.meta.getLicenseFromSpdxId "MIT"; hydraPlatforms = lib.platforms.none; broken = true; } @@ -485042,7 +485042,7 @@ self: { ]; testToolDepends = [ doctest ]; description = "Natural number"; - license = lib.licensesSpdx."BSD-3-Clause"; + license = lib.meta.getLicenseFromSpdxId "BSD-3-Clause"; hydraPlatforms = lib.platforms.none; broken = true; } @@ -485063,7 +485063,7 @@ self: { unlifted ]; description = "Arithmetic of natural numbers"; - license = lib.licensesSpdx."BSD-3-Clause"; + license = lib.meta.getLicenseFromSpdxId "BSD-3-Clause"; } ) { }; @@ -485242,7 +485242,7 @@ self: { transformers ]; description = "Parse/encode graph6, digraph6 and sparse6 formats (nauty)"; - license = lib.licensesSpdx."MIT"; + license = lib.meta.getLicenseFromSpdxId "MIT"; hydraPlatforms = lib.platforms.none; broken = true; } @@ -485374,7 +485374,7 @@ self: { ]; testToolDepends = [ hspec-discover ]; description = "Unpack a Jupyter notebook into its sources, metadata and outputs"; - license = lib.licensesSpdx."Apache-2.0"; + license = lib.meta.getLicenseFromSpdxId "Apache-2.0"; hydraPlatforms = lib.platforms.none; mainProgram = "nbparts"; broken = true; @@ -485586,7 +485586,7 @@ self: { tasty-hunit ]; description = "Quasiquoter for neat and simple multiline text interpolation"; - license = lib.licensesSpdx."MIT"; + license = lib.meta.getLicenseFromSpdxId "MIT"; } ) { }; @@ -485771,7 +485771,7 @@ self: { sha256 = "08jk7hn5mp89vxfkh9cl7rj5b9sjjwil4lic5gpgsbwpvy8rd8a8"; libraryHaskellDepends = [ base ]; description = "The Neither datatype"; - license = lib.licensesSpdx."MIT"; + license = lib.meta.getLicenseFromSpdxId "MIT"; hydraPlatforms = lib.platforms.none; broken = true; } @@ -485912,7 +485912,7 @@ self: { random ]; description = "Unofficial nekos.best API wrapper"; - license = lib.licensesSpdx."MIT"; + license = lib.meta.getLicenseFromSpdxId "MIT"; hydraPlatforms = lib.platforms.none; broken = true; } @@ -486036,7 +486036,7 @@ self: { hedgehog ]; description = "NonEmpty lists that look [more, like, this]"; - license = lib.licensesSpdx."BSD-3-Clause"; + license = lib.meta.getLicenseFromSpdxId "BSD-3-Clause"; } ) { }; @@ -486153,7 +486153,7 @@ self: { vector ]; description = "Neptune Client"; - license = lib.licensesSpdx."BSD-3-Clause"; + license = lib.meta.getLicenseFromSpdxId "BSD-3-Clause"; hydraPlatforms = lib.platforms.none; mainProgram = "example-app"; broken = true; @@ -486168,7 +486168,7 @@ self: { sha256 = "0nbgb9lz0ibha72gyh0q86rbssik2fxphab6f1asm0r5kz5va3ly"; libraryHaskellDepends = [ base ]; description = "Nerd Font Icons for use in haskell"; - license = lib.licensesSpdx."MIT"; + license = lib.meta.getLicenseFromSpdxId "MIT"; } ) { }; @@ -486626,7 +486626,7 @@ self: { ]; testToolDepends = [ tasty-discover ]; description = "NestedText: A Human Friendly Data Format"; - license = lib.licensesSpdx."Apache-2.0"; + license = lib.meta.getLicenseFromSpdxId "Apache-2.0"; } ) { }; @@ -487936,7 +487936,7 @@ self: { unix ]; description = "Binding to C socket API operating on bytearrays"; - license = lib.licensesSpdx."GPL-3.0-or-later"; + license = lib.meta.getLicenseFromSpdxId "GPL-3.0-or-later"; hydraPlatforms = lib.platforms.none; broken = true; } @@ -488389,7 +488389,7 @@ self: { ]; testToolDepends = [ hspec-discover ]; description = "Arbitrary Instances for Network Types"; - license = lib.licensesSpdx."MIT"; + license = lib.meta.getLicenseFromSpdxId "MIT"; } ) { }; @@ -488673,7 +488673,7 @@ self: { ]; testToolDepends = [ hspec-discover ]; description = "CAN bus networking"; - license = lib.licensesSpdx."BSD-3-Clause"; + license = lib.meta.getLicenseFromSpdxId "BSD-3-Clause"; } ) { }; @@ -488833,7 +488833,7 @@ self: { ]; testToolDepends = [ hspec-discover ]; description = "Library to control network protocols"; - license = lib.licensesSpdx."BSD-3-Clause"; + license = lib.meta.getLicenseFromSpdxId "BSD-3-Clause"; } ) { }; @@ -488962,7 +488962,7 @@ self: { network ]; description = "Adaptation of the network library for the effectful ecosystem"; - license = lib.licensesSpdx."BSD-3-Clause"; + license = lib.meta.getLicenseFromSpdxId "BSD-3-Clause"; } ) { }; @@ -489518,7 +489518,7 @@ self: { ]; testToolDepends = [ hspec-discover ]; description = "Types for working with Linux packet sockets"; - license = lib.licensesSpdx."BSD-3-Clause"; + license = lib.meta.getLicenseFromSpdxId "BSD-3-Clause"; hydraPlatforms = lib.platforms.none; broken = true; } @@ -489852,7 +489852,7 @@ self: { transformers ]; description = "Simple interface to TLS secured network sockets"; - license = lib.licensesSpdx."BSD-3-Clause"; + license = lib.meta.getLicenseFromSpdxId "BSD-3-Clause"; } ) { }; @@ -489881,7 +489881,7 @@ self: { websockets ]; description = "Simple interface to WebSockets"; - license = lib.licensesSpdx."BSD-3-Clause"; + license = lib.meta.getLicenseFromSpdxId "BSD-3-Clause"; } ) { }; @@ -489910,7 +489910,7 @@ self: { websockets ]; description = "Simple interface to TLS secured WebSockets"; - license = lib.licensesSpdx."BSD-3-Clause"; + license = lib.meta.getLicenseFromSpdxId "BSD-3-Clause"; } ) { }; @@ -490046,7 +490046,7 @@ self: { transformers ]; description = "Network abstraction layer"; - license = lib.licensesSpdx."BSD-3-Clause"; + license = lib.meta.getLicenseFromSpdxId "BSD-3-Clause"; } ) { }; @@ -490160,7 +490160,7 @@ self: { network-transport-tests ]; description = "In-memory instantiation of Network.Transport"; - license = lib.licensesSpdx."BSD-3-Clause"; + license = lib.meta.getLicenseFromSpdxId "BSD-3-Clause"; } ) { }; @@ -490233,7 +490233,7 @@ self: { tasty-bench ]; description = "Networking layer for Cloud Haskell based on QUIC"; - license = lib.licensesSpdx."BSD-3-Clause"; + license = lib.meta.getLicenseFromSpdxId "BSD-3-Clause"; hydraPlatforms = lib.platforms.none; } ) { }; @@ -490273,7 +490273,7 @@ self: { network-transport-tests ]; description = "TCP instantiation of Network.Transport"; - license = lib.licensesSpdx."BSD-3-Clause"; + license = lib.meta.getLicenseFromSpdxId "BSD-3-Clause"; } ) { }; @@ -490302,7 +490302,7 @@ self: { random ]; description = "Unit tests for Network.Transport implementations"; - license = lib.licensesSpdx."BSD-3-Clause"; + license = lib.meta.getLicenseFromSpdxId "BSD-3-Clause"; } ) { }; @@ -490438,7 +490438,7 @@ self: { stm ]; description = "Network functions that do not throw exceptions"; - license = lib.licensesSpdx."BSD-3-Clause"; + license = lib.meta.getLicenseFromSpdxId "BSD-3-Clause"; badPlatforms = lib.platforms.darwin; } ) { }; @@ -491255,7 +491255,7 @@ self: { ]; doHaddock = false; description = "Future-proof system for plain-text notes"; - license = lib.licensesSpdx."AGPL-3.0-only"; + license = lib.meta.getLicenseFromSpdxId "AGPL-3.0-only"; hydraPlatforms = lib.platforms.none; mainProgram = "neuron"; } @@ -491394,7 +491394,7 @@ self: { text ]; description = "newline specifications as values"; - license = lib.licensesSpdx."BSD-3-Clause"; + license = lib.meta.getLicenseFromSpdxId "BSD-3-Clause"; hydraPlatforms = lib.platforms.none; broken = true; } @@ -491506,7 +491506,7 @@ self: { warp ]; description = "A basic newsletter implimentation, using various backends"; - license = lib.licensesSpdx."BSD-3-Clause"; + license = lib.meta.getLicenseFromSpdxId "BSD-3-Clause"; hydraPlatforms = lib.platforms.none; mainProgram = "newsletter-server"; broken = true; @@ -491542,7 +491542,7 @@ self: { text ]; description = "A mailgun backend for the newsletter package"; - license = lib.licensesSpdx."BSD-3-Clause"; + license = lib.meta.getLicenseFromSpdxId "BSD-3-Clause"; hydraPlatforms = lib.platforms.none; } ) { }; @@ -491766,7 +491766,7 @@ self: { random ]; description = "Newtype Wrapper Zoo"; - license = lib.licensesSpdx."BSD-3-Clause"; + license = lib.meta.getLicenseFromSpdxId "BSD-3-Clause"; } ) { }; @@ -493084,7 +493084,7 @@ self: { typed-process ]; description = "Explain why two Nix derivations differ"; - license = lib.licensesSpdx."BSD-3-Clause"; + license = lib.meta.getLicenseFromSpdxId "BSD-3-Clause"; mainProgram = "nix-diff"; maintainers = [ lib.maintainers.Gabriella439 @@ -493187,7 +493187,7 @@ self: { testToolDepends = [ tasty-discover ]; doHaddock = false; description = "Convert a tree of files into fixed-output derivations"; - license = lib.licensesSpdx."AGPL-3.0-or-later"; + license = lib.meta.getLicenseFromSpdxId "AGPL-3.0-or-later"; hydraPlatforms = lib.platforms.none; mainProgram = "nix-freeze-tree"; broken = true; @@ -493237,7 +493237,7 @@ self: { optparse-applicative ]; description = "Reify the Nix build graph into a Haskell graph data structure"; - license = lib.licensesSpdx."BSD-3-Clause"; + license = lib.meta.getLicenseFromSpdxId "BSD-3-Clause"; mainProgram = "nix-graph"; } ) { }; @@ -493281,7 +493281,7 @@ self: { ]; testToolDepends = [ hspec-discover ]; description = "Parse and render .narinfo files"; - license = lib.licensesSpdx."BSD-3-Clause"; + license = lib.meta.getLicenseFromSpdxId "BSD-3-Clause"; mainProgram = "pretty-narinfo"; maintainers = [ lib.maintainers.sorki ]; } @@ -493392,7 +493392,7 @@ self: { vector ]; description = "A drop-in replacement for nix-serve that's faster and more stable"; - license = lib.licensesSpdx."BSD-3-Clause"; + license = lib.meta.getLicenseFromSpdxId "BSD-3-Clause"; mainProgram = "nix-serve"; maintainers = [ lib.maintainers.sternenseemann ]; } @@ -493662,7 +493662,7 @@ self: { vty ]; description = "Interactively browse a Nix store paths dependencies"; - license = lib.licensesSpdx."BSD-3-Clause"; + license = lib.meta.getLicenseFromSpdxId "BSD-3-Clause"; mainProgram = "nix-tree"; maintainers = [ lib.maintainers.utdemir ]; } @@ -494045,7 +494045,7 @@ self: { ]; testToolDepends = [ hspec-discover ]; description = "Tool for semi-automatic updating of nixpkgs repository"; - license = lib.licensesSpdx."CC0-1.0"; + license = lib.meta.getLicenseFromSpdxId "CC0-1.0"; hydraPlatforms = lib.platforms.none; mainProgram = "nixpkgs-update"; broken = true; @@ -494089,7 +494089,7 @@ self: { ]; doHaddock = false; description = "Nkeys ed25519 encoding for use with NATS"; - license = lib.licensesSpdx."Apache-2.0"; + license = lib.meta.getLicenseFromSpdxId "Apache-2.0"; hydraPlatforms = lib.platforms.none; broken = true; } @@ -494407,7 +494407,7 @@ self: { doctest ]; description = "A GHC plugin to remove support for recursion"; - license = lib.licensesSpdx."AGPL-3.0-or-later"; + license = lib.meta.getLicenseFromSpdxId "AGPL-3.0-or-later"; maintainers = [ lib.maintainers.sellout ]; } ) { }; @@ -495199,7 +495199,7 @@ self: { utility-ht ]; description = "List-like structures with static restrictions on the number of elements"; - license = lib.licensesSpdx."BSD-3-Clause"; + license = lib.meta.getLicenseFromSpdxId "BSD-3-Clause"; maintainers = [ lib.maintainers.thielema ]; } ) { }; @@ -495362,7 +495362,7 @@ self: { time ]; description = "type safe diffUTCTime"; - license = lib.licensesSpdx."BSD-3-Clause"; + license = lib.meta.getLicenseFromSpdxId "BSD-3-Clause"; } ) { }; @@ -495527,7 +495527,7 @@ self: { hedgehog-classes ]; description = "nonempty structure"; - license = lib.licensesSpdx."BSD-3-Clause"; + license = lib.meta.getLicenseFromSpdxId "BSD-3-Clause"; hydraPlatforms = lib.platforms.none; broken = true; } @@ -495562,7 +495562,7 @@ self: { vector ]; description = "Non-empty vectors"; - license = lib.licensesSpdx."BSD-3-Clause"; + license = lib.meta.getLicenseFromSpdxId "BSD-3-Clause"; } ) { }; @@ -495591,7 +495591,7 @@ self: { ]; testToolDepends = [ hspec-discover ]; description = "Create NonEmpty version of any container"; - license = lib.licensesSpdx."ISC"; + license = lib.meta.getLicenseFromSpdxId "ISC"; } ) { }; @@ -495626,7 +495626,7 @@ self: { ]; testToolDepends = [ hspec-discover ]; description = "aeson instances for 'NonEmpty'"; - license = lib.licensesSpdx."ISC"; + license = lib.meta.getLicenseFromSpdxId "ISC"; } ) { }; @@ -495647,7 +495647,7 @@ self: { QuickCheck ]; description = "QuickCheck instance for 'NonEmpty'"; - license = lib.licensesSpdx."ISC"; + license = lib.meta.getLicenseFromSpdxId "ISC"; } ) { }; @@ -495670,7 +495670,7 @@ self: { text ]; description = "'NonEmpty' wrappers for text"; - license = lib.licensesSpdx."ISC"; + license = lib.meta.getLicenseFromSpdxId "ISC"; } ) { }; @@ -496152,7 +496152,7 @@ self: { transformers ]; description = "An opinionated Prelude replacement library"; - license = lib.licensesSpdx."MIT"; + license = lib.meta.getLicenseFromSpdxId "MIT"; hydraPlatforms = lib.platforms.none; broken = true; } @@ -496229,7 +496229,7 @@ self: { tasty-hedgehog ]; description = "Examine values for unexpected thunks"; - license = lib.licensesSpdx."Apache-2.0"; + license = lib.meta.getLicenseFromSpdxId "Apache-2.0"; } ) { }; @@ -496401,7 +496401,7 @@ self: { vector ]; description = "Type-safe Haskell client for the Notion API"; - license = lib.licensesSpdx."MIT"; + license = lib.meta.getLicenseFromSpdxId "MIT"; mainProgram = "notion-client-example"; } ) { }; @@ -496447,7 +496447,7 @@ self: { ]; libraryToolDepends = [ c2hs ]; description = "Haskell binding to Notmuch, the mail indexer"; - license = lib.licensesSpdx."GPL-3.0-or-later"; + license = lib.meta.getLicenseFromSpdxId "GPL-3.0-or-later"; } ) { @@ -496700,7 +496700,7 @@ self: { text ]; description = "Pure Nix binary cache protocol library"; - license = lib.licensesSpdx."BSD-3-Clause"; + license = lib.meta.getLicenseFromSpdxId "BSD-3-Clause"; hydraPlatforms = lib.platforms.none; broken = true; } @@ -496748,7 +496748,7 @@ self: { deepseq ]; description = "General-purpose reliable UDP with C99 hot path and Haskell protocol logic"; - license = lib.licensesSpdx."BSD-3-Clause"; + license = lib.meta.getLicenseFromSpdxId "BSD-3-Clause"; } ) { }; @@ -496821,7 +496821,7 @@ self: { text ]; description = "Windows-native Nix implementation in pure Haskell"; - license = lib.licensesSpdx."BSD-3-Clause"; + license = lib.meta.getLicenseFromSpdxId "BSD-3-Clause"; hydraPlatforms = lib.platforms.none; mainProgram = "nova-nix"; broken = true; @@ -497695,7 +497695,7 @@ self: { ]; testToolDepends = [ hspec-discover ]; description = "Efficient, infinite-precision 2D and 3D spatial containers"; - license = lib.licensesSpdx."BSD-3-Clause"; + license = lib.meta.getLicenseFromSpdxId "BSD-3-Clause"; } ) { }; @@ -497822,7 +497822,7 @@ self: { these ]; description = "A heterogeneous, n-ary generalisation of These"; - license = lib.licensesSpdx."BSD-3-Clause"; + license = lib.meta.getLicenseFromSpdxId "BSD-3-Clause"; } ) { }; @@ -498158,7 +498158,7 @@ self: { tasty-bench ]; description = "Create number walls and save them as images"; - license = lib.licensesSpdx."MIT"; + license = lib.meta.getLicenseFromSpdxId "MIT"; hydraPlatforms = lib.platforms.none; broken = true; } @@ -498679,7 +498679,7 @@ self: { utility-ht ]; description = "An experimental alternative hierarchy of numeric type classes"; - license = lib.licensesSpdx."BSD-3-Clause"; + license = lib.meta.getLicenseFromSpdxId "BSD-3-Clause"; maintainers = [ lib.maintainers.thielema ]; } ) { }; @@ -498841,7 +498841,7 @@ self: { vector ]; description = "core package for Numerical Haskell project"; - license = lib.licensesSpdx."BSD-2-Clause"; + license = lib.meta.getLicenseFromSpdxId "BSD-2-Clause"; hydraPlatforms = lib.platforms.none; } ) { }; @@ -498861,7 +498861,7 @@ self: { system-cxx-std-lib ]; description = "Numerical integration"; - license = lib.licensesSpdx."BSD-3-Clause"; + license = lib.meta.getLicenseFromSpdxId "BSD-3-Clause"; } ) { }; @@ -498885,7 +498885,7 @@ self: { sha256 = "1sh6k2b90p2gwxspqpv3v5bl8pbs5nfzkpsxmsk59ag852klhbci"; libraryHaskellDepends = [ base ]; description = "A numeric class hierarchy"; - license = lib.licensesSpdx."BSD-3-Clause"; + license = lib.meta.getLicenseFromSpdxId "BSD-3-Clause"; } ) { }; @@ -498910,7 +498910,7 @@ self: { vector ]; description = "Multi-dimensional arrays"; - license = lib.licensesSpdx."BSD-3-Clause"; + license = lib.meta.getLicenseFromSpdxId "BSD-3-Clause"; hydraPlatforms = lib.platforms.none; broken = true; } @@ -498945,7 +498945,7 @@ self: { numhask ]; description = "numerical free algebras"; - license = lib.licensesSpdx."BSD-3-Clause"; + license = lib.meta.getLicenseFromSpdxId "BSD-3-Clause"; hydraPlatforms = lib.platforms.none; broken = true; } @@ -498978,7 +498978,7 @@ self: { numhask-prelude ]; description = "Laws and tests for numhask"; - license = lib.licensesSpdx."BSD-3-Clause"; + license = lib.meta.getLicenseFromSpdxId "BSD-3-Clause"; hydraPlatforms = lib.platforms.none; } ) { }; @@ -499034,7 +499034,7 @@ self: { ]; testHaskellDepends = [ doctest ]; description = "A numeric prelude"; - license = lib.licensesSpdx."BSD-3-Clause"; + license = lib.meta.getLicenseFromSpdxId "BSD-3-Clause"; hydraPlatforms = lib.platforms.none; broken = true; } @@ -499111,7 +499111,7 @@ self: { vector ]; description = "Numerical spaces"; - license = lib.licensesSpdx."BSD-3-Clause"; + license = lib.meta.getLicenseFromSpdxId "BSD-3-Clause"; } ) { }; @@ -499404,7 +499404,7 @@ self: { ]; testToolDepends = [ hspec-discover ]; description = "Generate nix sources expr for the latest version of packages"; - license = lib.licensesSpdx."MIT"; + license = lib.meta.getLicenseFromSpdxId "MIT"; mainProgram = "nvfetcher"; maintainers = [ lib.maintainers.berberman ]; } @@ -499498,7 +499498,7 @@ self: { ]; testToolDepends = [ hspec-discover ]; description = "Haskell plugin backend for neovim"; - license = lib.licensesSpdx."Apache-2.0"; + license = lib.meta.getLicenseFromSpdxId "Apache-2.0"; } ) { }; @@ -499983,7 +499983,7 @@ self: { markdown-unlit ]; description = "Type-safe time library"; - license = lib.licensesSpdx."MPL-2.0"; + license = lib.meta.getLicenseFromSpdxId "MPL-2.0"; hydraPlatforms = lib.platforms.none; mainProgram = "play-o-clock"; broken = true; @@ -500205,7 +500205,7 @@ self: { tasty-bench ]; description = "Composable concurrent computation done right"; - license = lib.licensesSpdx."BSD-3-Clause"; + license = lib.meta.getLicenseFromSpdxId "BSD-3-Clause"; hydraPlatforms = lib.platforms.none; } ) { }; @@ -500412,7 +500412,7 @@ self: { warp ]; description = "OAuth 2.1 authorization server implementation"; - license = lib.licensesSpdx."MPL-2.0"; + license = lib.meta.getLicenseFromSpdxId "MPL-2.0"; } ) { }; @@ -500532,7 +500532,7 @@ self: { ]; testHaskellDepends = [ base ]; description = "Live in-memory sync of Obsidian Markdown notes"; - license = lib.licensesSpdx."BSD-3-Clause"; + license = lib.meta.getLicenseFromSpdxId "BSD-3-Clause"; hydraPlatforms = lib.platforms.none; broken = true; } @@ -500626,7 +500626,7 @@ self: { text ]; description = "Ordered Reduced Binary Decision Diagrams"; - license = lib.licensesSpdx."GPL-3.0-only"; + license = lib.meta.getLicenseFromSpdxId "GPL-3.0-only"; hydraPlatforms = lib.platforms.none; } ) { }; @@ -500780,7 +500780,7 @@ self: { witherable ]; description = "Composable objects"; - license = lib.licensesSpdx."BSD-3-Clause"; + license = lib.meta.getLicenseFromSpdxId "BSD-3-Clause"; hydraPlatforms = lib.platforms.none; } ) { }; @@ -500965,7 +500965,7 @@ self: { libraryHaskellDepends = [ base ]; testHaskellDepends = [ base ]; description = "Object capability based IO"; - license = lib.licensesSpdx."Apache-2.0"; + license = lib.meta.getLicenseFromSpdxId "Apache-2.0"; } ) { }; @@ -501300,7 +501300,7 @@ self: { text, time, transformers, - unixODBC, + unixodbc, unliftio-core, weigh, }: @@ -501327,7 +501327,7 @@ self: { transformers unliftio-core ]; - librarySystemDepends = [ unixODBC ]; + librarySystemDepends = [ unixodbc ]; executableHaskellDepends = [ base bytestring @@ -501354,7 +501354,7 @@ self: { license = lib.licenses.bsd3; mainProgram = "odbc"; } - ) { unixODBC = null; }; + ) { inherit (pkgs) unixodbc; }; odd-jobs = callPackage ( { @@ -502841,7 +502841,7 @@ self: { xml-types ]; description = "An Entity-Component-Systems engine core"; - license = lib.licensesSpdx."AGPL-3.0-or-later"; + license = lib.meta.getLicenseFromSpdxId "AGPL-3.0-or-later"; hydraPlatforms = lib.platforms.none; broken = true; } @@ -503251,7 +503251,7 @@ self: { text ]; description = "A typed-hole plugin that uses LLMs to generate valid hole-fits"; - license = lib.licensesSpdx."MIT"; + license = lib.meta.getLicenseFromSpdxId "MIT"; hydraPlatforms = lib.platforms.none; broken = true; } @@ -503362,7 +503362,7 @@ self: { text ]; description = "om-doh"; - license = lib.licensesSpdx."MIT"; + license = lib.meta.getLicenseFromSpdxId "MIT"; } ) { }; @@ -503401,7 +503401,7 @@ self: { wai ]; description = "Haskell utilities for building embedded Elm programs"; - license = lib.licensesSpdx."MIT"; + license = lib.meta.getLicenseFromSpdxId "MIT"; } ) { }; @@ -503424,7 +503424,7 @@ self: { transformers ]; description = "Monad transformer providing MonadFail"; - license = lib.licensesSpdx."MIT"; + license = lib.meta.getLicenseFromSpdxId "MIT"; } ) { }; @@ -503465,7 +503465,7 @@ self: { unliftio ]; description = "Concurrency utilities"; - license = lib.licensesSpdx."MIT"; + license = lib.meta.getLicenseFromSpdxId "MIT"; } ) { }; @@ -503526,7 +503526,7 @@ self: { warp ]; description = "Http utilities"; - license = lib.licensesSpdx."MIT"; + license = lib.meta.getLicenseFromSpdxId "MIT"; hydraPlatforms = lib.platforms.none; broken = true; } @@ -503589,7 +503589,7 @@ self: { warp ]; description = "Http utilities"; - license = lib.licensesSpdx."MIT"; + license = lib.meta.getLicenseFromSpdxId "MIT"; hydraPlatforms = lib.platforms.none; broken = true; } @@ -503667,7 +503667,7 @@ self: { x509-store ]; description = "om-kubernetes"; - license = lib.licensesSpdx."MIT"; + license = lib.meta.getLicenseFromSpdxId "MIT"; hydraPlatforms = lib.platforms.none; } ) { }; @@ -503737,7 +503737,7 @@ self: { uuid ]; description = "Legion Framework"; - license = lib.licensesSpdx."MIT"; + license = lib.meta.getLicenseFromSpdxId "MIT"; } ) { }; @@ -503770,7 +503770,7 @@ self: { time ]; description = "Opinionated logging utilities"; - license = lib.licensesSpdx."MIT"; + license = lib.meta.getLicenseFromSpdxId "MIT"; } ) { }; @@ -503814,7 +503814,7 @@ self: { time ]; description = "Plugin-based explicit import generation"; - license = lib.licensesSpdx."MIT"; + license = lib.meta.getLicenseFromSpdxId "MIT"; hydraPlatforms = lib.platforms.none; broken = true; } @@ -503837,7 +503837,7 @@ self: { text ]; description = "Utilities for showing string-like things"; - license = lib.licensesSpdx."MIT"; + license = lib.meta.getLicenseFromSpdxId "MIT"; } ) { }; @@ -503901,7 +503901,7 @@ self: { unliftio-core ]; description = "Socket utilities"; - license = lib.licensesSpdx."MIT"; + license = lib.meta.getLicenseFromSpdxId "MIT"; } ) { }; @@ -503928,7 +503928,7 @@ self: { transformers ]; description = "Misc. time utilites"; - license = lib.licensesSpdx."MIT"; + license = lib.meta.getLicenseFromSpdxId "MIT"; } ) { }; @@ -504323,7 +504323,7 @@ self: { ]; testToolDepends = [ doctest ]; description = "One"; - license = lib.licensesSpdx."BSD-3-Clause"; + license = lib.meta.getLicenseFromSpdxId "BSD-3-Clause"; } ) { }; @@ -504349,7 +504349,7 @@ self: { text ]; description = "Pretty-printing short Aeson values as text"; - license = lib.licensesSpdx."Apache-2.0"; + license = lib.meta.getLicenseFromSpdxId "Apache-2.0"; hydraPlatforms = lib.platforms.none; broken = true; } @@ -504478,7 +504478,7 @@ self: { torsor ]; description = "HMAC-Based and Time-Based One-Time Passwords"; - license = lib.licensesSpdx."MIT"; + license = lib.meta.getLicenseFromSpdxId "MIT"; mainProgram = "one-time-password"; } ) { }; @@ -504564,7 +504564,7 @@ self: { numhask ]; description = "See readme.md"; - license = lib.licensesSpdx."BSD-3-Clause"; + license = lib.meta.getLicenseFromSpdxId "BSD-3-Clause"; hydraPlatforms = lib.platforms.none; broken = true; } @@ -504607,7 +504607,7 @@ self: { numhask-prelude ]; description = "See readme.md"; - license = lib.licensesSpdx."BSD-3-Clause"; + license = lib.meta.getLicenseFromSpdxId "BSD-3-Clause"; hydraPlatforms = lib.platforms.none; } ) { }; @@ -504736,7 +504736,7 @@ self: { hspec-discover ]; description = "Combinators for handling errors of many types in a composable way"; - license = lib.licensesSpdx."MIT"; + license = lib.meta.getLicenseFromSpdxId "MIT"; hydraPlatforms = lib.platforms.none; broken = true; } @@ -504765,7 +504765,7 @@ self: { transformers ]; description = "Oops examples"; - license = lib.licensesSpdx."MIT"; + license = lib.meta.getLicenseFromSpdxId "MIT"; hydraPlatforms = lib.platforms.none; } ) { }; @@ -504788,7 +504788,7 @@ self: { doctest ]; description = "Common operators encouraging large-scale easy reading"; - license = lib.licensesSpdx."Apache-2.0"; + license = lib.meta.getLicenseFromSpdxId "Apache-2.0"; hydraPlatforms = lib.platforms.none; broken = true; } @@ -505019,7 +505019,7 @@ self: { ]; testHaskellDepends = [ base ]; description = "Text search utilities for Opaleye"; - license = lib.licensesSpdx."AGPL-3.0-or-later"; + license = lib.meta.getLicenseFromSpdxId "AGPL-3.0-or-later"; hydraPlatforms = lib.platforms.none; broken = true; } @@ -505160,7 +505160,7 @@ self: { xml-parser ]; description = "OPC XML-DA Client"; - license = lib.licensesSpdx."MIT"; + license = lib.meta.getLicenseFromSpdxId "MIT"; hydraPlatforms = lib.platforms.none; } ) { }; @@ -505479,7 +505479,7 @@ self: { witness ]; description = "open witnesses"; - license = lib.licensesSpdx."BSD-2-Clause"; + license = lib.meta.getLicenseFromSpdxId "BSD-2-Clause"; } ) { }; @@ -505553,7 +505553,7 @@ self: { text ]; description = "Servant bindings to OpenAI"; - license = lib.licensesSpdx."BSD-3-Clause"; + license = lib.meta.getLicenseFromSpdxId "BSD-3-Clause"; hydraPlatforms = lib.platforms.none; broken = true; } @@ -505754,7 +505754,7 @@ self: { warp ]; description = "Auto-generated API bindings for openai"; - license = lib.licensesSpdx."MIT"; + license = lib.meta.getLicenseFromSpdxId "MIT"; hydraPlatforms = lib.platforms.none; broken = true; } @@ -506171,7 +506171,7 @@ self: { ]; librarySystemDepends = [ opencascade-occt ]; description = "Thin Wrapper for the OpenCASCADE CAD Kernel"; - license = lib.licensesSpdx."LGPL-2.1-only"; + license = lib.meta.getLicenseFromSpdxId "LGPL-2.1-only"; } ) { inherit (pkgs) opencascade-occt; }; @@ -506205,7 +506205,7 @@ self: { transformers ]; description = "OpenCC bindings"; - license = lib.licensesSpdx."MIT"; + license = lib.meta.getLicenseFromSpdxId "MIT"; hydraPlatforms = lib.platforms.none; broken = true; } @@ -506275,7 +506275,7 @@ self: { text ]; description = "Haskell client library for OpenCode server API"; - license = lib.licensesSpdx."MIT"; + license = lib.meta.getLicenseFromSpdxId "MIT"; } ) { }; @@ -506553,7 +506553,7 @@ self: { libraryPkgconfigDepends = [ opendht-c ]; libraryToolDepends = [ c2hs ]; description = "Haskell bindings for OpenDHT"; - license = lib.licensesSpdx."GPL-3.0-or-later"; + license = lib.meta.getLicenseFromSpdxId "GPL-3.0-or-later"; hydraPlatforms = lib.platforms.none; broken = true; } @@ -506919,7 +506919,7 @@ self: { unordered-containers ]; description = "An OpenID Connect library that does all the heavy lifting for you"; - license = lib.licensesSpdx."BSD-2-Clause"; + license = lib.meta.getLicenseFromSpdxId "BSD-2-Clause"; hydraPlatforms = lib.platforms.none; broken = true; } @@ -507379,7 +507379,7 @@ self: { ghc-trace-events hashable ]; - license = lib.licensesSpdx."Apache-2.0"; + license = lib.meta.getLicenseFromSpdxId "Apache-2.0"; } ) { }; @@ -507495,7 +507495,7 @@ self: { opentelemetry tasty-bench ]; - license = lib.licensesSpdx."Apache-2.0"; + license = lib.meta.getLicenseFromSpdxId "Apache-2.0"; hydraPlatforms = lib.platforms.none; broken = true; } @@ -507521,7 +507521,7 @@ self: { opentelemetry text ]; - license = lib.licensesSpdx."Apache-2.0"; + license = lib.meta.getLicenseFromSpdxId "Apache-2.0"; hydraPlatforms = lib.platforms.none; broken = true; } @@ -507591,7 +507591,7 @@ self: { typed-process unordered-containers ]; - license = lib.licensesSpdx."Apache-2.0"; + license = lib.meta.getLicenseFromSpdxId "Apache-2.0"; hydraPlatforms = lib.platforms.none; mainProgram = "eventlog-to-lightstep"; } @@ -507634,7 +507634,7 @@ self: { unordered-containers ]; description = "GHC plugin for open telemetry"; - license = lib.licensesSpdx."BSD-3-Clause"; + license = lib.meta.getLicenseFromSpdxId "BSD-3-Clause"; } ) { }; @@ -507660,7 +507660,7 @@ self: { text wai ]; - license = lib.licensesSpdx."Apache-2.0"; + license = lib.meta.getLicenseFromSpdxId "Apache-2.0"; } ) { }; @@ -508189,7 +508189,7 @@ self: { vinyl ]; description = "OpenTracing for Haskell"; - license = lib.licensesSpdx."Apache-2.0"; + license = lib.meta.getLicenseFromSpdxId "Apache-2.0"; hydraPlatforms = lib.platforms.none; } ) { }; @@ -508217,7 +508217,7 @@ self: { text ]; description = "OpenTracing instrumentation of http-client"; - license = lib.licensesSpdx."Apache-2.0"; + license = lib.meta.getLicenseFromSpdxId "Apache-2.0"; hydraPlatforms = lib.platforms.none; } ) { }; @@ -508267,7 +508267,7 @@ self: { vector-instances ]; description = "Jaeger backend for OpenTracing"; - license = lib.licensesSpdx."Apache-2.0"; + license = lib.meta.getLicenseFromSpdxId "Apache-2.0"; hydraPlatforms = lib.platforms.none; } ) { }; @@ -508293,7 +508293,7 @@ self: { wai ]; description = "Middleware adding OpenTracing tracing for WAI applications"; - license = lib.licensesSpdx."Apache-2.0"; + license = lib.meta.getLicenseFromSpdxId "Apache-2.0"; hydraPlatforms = lib.platforms.none; } ) { }; @@ -508317,7 +508317,7 @@ self: { text ]; description = "Zipkin OpenTracing Backend Commons"; - license = lib.licensesSpdx."Apache-2.0"; + license = lib.meta.getLicenseFromSpdxId "Apache-2.0"; hydraPlatforms = lib.platforms.none; } ) { }; @@ -508365,7 +508365,7 @@ self: { vector-instances ]; description = "Zipkin V1 backend for OpenTracing"; - license = lib.licensesSpdx."Apache-2.0"; + license = lib.meta.getLicenseFromSpdxId "Apache-2.0"; hydraPlatforms = lib.platforms.none; } ) { }; @@ -508403,7 +508403,7 @@ self: { text ]; description = "Zipkin V2 backend for OpenTracing"; - license = lib.licensesSpdx."Apache-2.0"; + license = lib.meta.getLicenseFromSpdxId "Apache-2.0"; hydraPlatforms = lib.platforms.none; } ) { }; @@ -508675,7 +508675,7 @@ self: { text-builder-linear ]; description = "Stack-based esoteric programming language"; - license = lib.licensesSpdx."GPL-3.0-only"; + license = lib.meta.getLicenseFromSpdxId "GPL-3.0-only"; hydraPlatforms = lib.platforms.none; mainProgram = "oplang"; broken = true; @@ -509058,7 +509058,7 @@ self: { vector ]; description = "Optics as an abstract interface"; - license = lib.licensesSpdx."BSD-3-Clause"; + license = lib.meta.getLicenseFromSpdxId "BSD-3-Clause"; maintainers = [ lib.maintainers.maralorn ]; } ) { }; @@ -509086,7 +509086,7 @@ self: { transformers ]; description = "Optics as an abstract interface: core definitions"; - license = lib.licensesSpdx."BSD-3-Clause"; + license = lib.meta.getLicenseFromSpdxId "BSD-3-Clause"; } ) { }; @@ -509129,7 +509129,7 @@ self: { vector ]; description = "Extra utilities and instances for optics-core"; - license = lib.licensesSpdx."BSD-3-Clause"; + license = lib.meta.getLicenseFromSpdxId "BSD-3-Clause"; } ) { }; @@ -509202,7 +509202,7 @@ self: { tagged ]; description = "Optics construction using TemplateHaskell"; - license = lib.licensesSpdx."BSD-3-Clause"; + license = lib.meta.getLicenseFromSpdxId "BSD-3-Clause"; } ) { }; @@ -509259,7 +509259,7 @@ self: { rerebase ]; description = "Simple command line interface arguments parser"; - license = lib.licensesSpdx."MIT"; + license = lib.meta.getLicenseFromSpdxId "MIT"; } ) { }; @@ -509288,7 +509288,7 @@ self: { time ]; description = "Command-line arguments parsing for Hasql"; - license = lib.licensesSpdx."MIT"; + license = lib.meta.getLicenseFromSpdxId "MIT"; hydraPlatforms = lib.platforms.none; broken = true; } @@ -509503,7 +509503,7 @@ self: { ]; doHaddock = false; description = "Powerful and easy command-line option parser"; - license = lib.licensesSpdx."MIT"; + license = lib.meta.getLicenseFromSpdxId "MIT"; } ) { }; @@ -509649,7 +509649,7 @@ self: { text ]; description = "Extra functions for working with optparse-applicative"; - license = lib.licensesSpdx."ISC"; + license = lib.meta.getLicenseFromSpdxId "ISC"; } ) { }; @@ -509702,7 +509702,7 @@ self: { mtl ]; description = "Declarative command line option parser"; - license = lib.licensesSpdx."MIT"; + license = lib.meta.getLicenseFromSpdxId "MIT"; } ) { }; @@ -509930,7 +509930,7 @@ self: { text ]; description = "Like `optparse-generic`, but with `TemplateHaskell` for faster builds"; - license = lib.licensesSpdx."BSD-3-Clause"; + license = lib.meta.getLicenseFromSpdxId "BSD-3-Clause"; } ) { }; @@ -510016,7 +510016,7 @@ self: { microlens ]; description = "Bindings to libopus for the Opus audio codec"; - license = lib.licensesSpdx."BSD-3-Clause"; + license = lib.meta.getLicenseFromSpdxId "BSD-3-Clause"; hydraPlatforms = lib.platforms.none; broken = true; } @@ -510330,7 +510330,7 @@ self: { sha256 = "1fgzxlz2rynscnic1jawvrymhp70wxq04lpvp0ls84ky90zyzak8"; libraryHaskellDepends = [ base ]; description = "Axiomata & lemmata for easier use of Data.Type.Ord"; - license = lib.licensesSpdx."BSD-3-Clause"; + license = lib.meta.getLicenseFromSpdxId "BSD-3-Clause"; } ) { }; @@ -510503,7 +510503,7 @@ self: { sha256 = "1na61sq78r190lcn4lw437mj5wcdq9p53zn3vbz16w3b1vwdwfii"; libraryHaskellDepends = [ base ]; description = "Utilities for Orderings"; - license = lib.licensesSpdx."MIT"; + license = lib.meta.getLicenseFromSpdxId "MIT"; } ) { }; @@ -510709,7 +510709,7 @@ self: { time ]; description = "Parser for Emacs org-mode files"; - license = lib.licensesSpdx."BSD-3-Clause"; + license = lib.meta.getLicenseFromSpdxId "BSD-3-Clause"; hydraPlatforms = lib.platforms.none; broken = true; } @@ -510738,7 +510738,7 @@ self: { text ]; description = "Lucid integration for org-mode"; - license = lib.licensesSpdx."BSD-3-Clause"; + license = lib.meta.getLicenseFromSpdxId "BSD-3-Clause"; hydraPlatforms = lib.platforms.none; } ) { }; @@ -510795,7 +510795,7 @@ self: { time ]; description = "Parser for Org Mode documents"; - license = lib.licensesSpdx."GPL-3.0-only"; + license = lib.meta.getLicenseFromSpdxId "GPL-3.0-only"; hydraPlatforms = lib.platforms.none; broken = true; } @@ -511314,7 +511314,7 @@ self: { ]; testToolDepends = [ hspec-discover ]; description = "A formatter for Haskell source code"; - license = lib.licensesSpdx."BSD-3-Clause"; + license = lib.meta.getLicenseFromSpdxId "BSD-3-Clause"; hydraPlatforms = lib.platforms.none; mainProgram = "ormolu"; } @@ -511408,7 +511408,7 @@ self: { ]; testToolDepends = [ hspec-discover ]; description = "A formatter for Haskell source code"; - license = lib.licensesSpdx."BSD-3-Clause"; + license = lib.meta.getLicenseFromSpdxId "BSD-3-Clause"; hydraPlatforms = lib.platforms.none; mainProgram = "ormolu"; } @@ -511505,7 +511505,7 @@ self: { ]; testToolDepends = [ hspec-discover ]; description = "A formatter for Haskell source code"; - license = lib.licensesSpdx."BSD-3-Clause"; + license = lib.meta.getLicenseFromSpdxId "BSD-3-Clause"; mainProgram = "ormolu"; } ) { }; @@ -511774,7 +511774,7 @@ self: { warp ]; description = "API bindings for Ory Kratos"; - license = lib.licensesSpdx."Apache-2.0"; + license = lib.meta.getLicenseFromSpdxId "Apache-2.0"; hydraPlatforms = lib.platforms.none; broken = true; } @@ -511824,7 +511824,7 @@ self: { text ]; description = "/etc/os-release helpers"; - license = lib.licensesSpdx."BSD-3-Clause"; + license = lib.meta.getLicenseFromSpdxId "BSD-3-Clause"; } ) { }; @@ -511867,7 +511867,7 @@ self: { tasty-bench ]; description = "Library for manipulating Operating system strings"; - license = lib.licensesSpdx."BSD-3-Clause"; + license = lib.meta.getLicenseFromSpdxId "BSD-3-Clause"; hydraPlatforms = lib.platforms.none; } ) { }; @@ -511918,7 +511918,7 @@ self: { tasty-bench ]; description = "Compatibility layer for os-string"; - license = lib.licensesSpdx."BSD-3-Clause"; + license = lib.meta.getLicenseFromSpdxId "BSD-3-Clause"; } ) { }; @@ -512253,7 +512253,7 @@ self: { tasty-hunit ]; description = "Open Source Vulnerability format"; - license = lib.licensesSpdx."BSD-3-Clause"; + license = lib.meta.getLicenseFromSpdxId "BSD-3-Clause"; } ) { }; @@ -512476,7 +512476,7 @@ self: { text ]; description = "A library to test programs that output text"; - license = lib.licensesSpdx."BSD-3-Clause"; + license = lib.meta.getLicenseFromSpdxId "BSD-3-Clause"; } ) { }; @@ -512737,7 +512737,7 @@ self: { ]; doHaddock = false; description = "Overloaded pragmas as a plugin"; - license = lib.licensesSpdx."BSD-3-Clause"; + license = lib.meta.getLicenseFromSpdxId "BSD-3-Clause"; hydraPlatforms = lib.platforms.none; broken = true; } @@ -512894,7 +512894,7 @@ self: { ]; doHaddock = false; description = "An efficient CPU-based multidimensional array (tensor) library"; - license = lib.licensesSpdx."BSD-3-Clause"; + license = lib.meta.getLicenseFromSpdxId "BSD-3-Clause"; hydraPlatforms = lib.platforms.none; broken = true; } @@ -512917,7 +512917,7 @@ self: { pa-prelude ]; description = "Collect a tree of errors and pretty-print"; - license = lib.licensesSpdx."BSD-3-Clause"; + license = lib.meta.getLicenseFromSpdxId "BSD-3-Clause"; } ) { }; @@ -512958,7 +512958,7 @@ self: { time ]; description = "“Vertical” parsing of values"; - license = lib.licensesSpdx."BSD-3-Clause"; + license = lib.meta.getLicenseFromSpdxId "BSD-3-Clause"; hydraPlatforms = lib.platforms.none; broken = true; } @@ -513007,7 +513007,7 @@ self: { vector ]; description = "Our JSON parsers/encoders"; - license = lib.licensesSpdx."BSD-3-Clause"; + license = lib.meta.getLicenseFromSpdxId "BSD-3-Clause"; hydraPlatforms = lib.platforms.none; } ) { }; @@ -513020,7 +513020,7 @@ self: { sha256 = "03y2cn6yy06xcpnjs5zc8hd8iba4k44wrrncl7ksplg8j3iank1x"; libraryHaskellDepends = [ base ]; description = "Labels, and labelled tuples and enums (GHC >9.2)"; - license = lib.licensesSpdx."BSD-3-Clause"; + license = lib.meta.getLicenseFromSpdxId "BSD-3-Clause"; } ) { }; @@ -513069,7 +513069,7 @@ self: { vector ]; description = "The Possehl Analytics Prelude"; - license = lib.licensesSpdx."BSD-3-Clause"; + license = lib.meta.getLicenseFromSpdxId "BSD-3-Clause"; } ) { }; @@ -513100,7 +513100,7 @@ self: { text ]; description = "Some pretty-printing helpers"; - license = lib.licensesSpdx."BSD-3-Clause"; + license = lib.meta.getLicenseFromSpdxId "BSD-3-Clause"; } ) { }; @@ -513127,7 +513127,7 @@ self: { typed-process ]; description = "Helper functions for spawning subprocesses"; - license = lib.licensesSpdx."BSD-3-Clause"; + license = lib.meta.getLicenseFromSpdxId "BSD-3-Clause"; } ) { }; @@ -513264,7 +513264,7 @@ self: { text ]; description = "A package for retrieving a package's version number"; - license = lib.licensesSpdx."BSD-3-Clause"; + license = lib.meta.getLicenseFromSpdxId "BSD-3-Clause"; } ) { }; @@ -513470,7 +513470,7 @@ self: { split vector ]; - license = lib.licensesSpdx."BSD-3-Clause"; + license = lib.meta.getLicenseFromSpdxId "BSD-3-Clause"; hydraPlatforms = lib.platforms.none; mainProgram = "examples"; broken = true; @@ -513908,7 +513908,7 @@ self: { ]; doHaddock = false; description = "Time Library for Pact"; - license = lib.licensesSpdx."BSD-3-Clause"; + license = lib.meta.getLicenseFromSpdxId "BSD-3-Clause"; } ) { }; @@ -513977,7 +513977,7 @@ self: { time ]; description = "API to the Paddle payment processor"; - license = lib.licensesSpdx."MIT"; + license = lib.meta.getLicenseFromSpdxId "MIT"; } ) { }; @@ -514594,7 +514594,7 @@ self: { strict ]; description = "Finding palindromes in strings"; - license = lib.licensesSpdx."BSD-3-Clause"; + license = lib.meta.getLicenseFromSpdxId "BSD-3-Clause"; mainProgram = "palindromes"; } ) { }; @@ -514616,7 +514616,7 @@ self: { librarySystemDepends = [ pam ]; libraryToolDepends = [ c2hs ]; description = "Haskell binding for C PAM API"; - license = lib.licensesSpdx."BSD-3-Clause"; + license = lib.meta.getLicenseFromSpdxId "BSD-3-Clause"; badPlatforms = lib.platforms.darwin; } ) { inherit (pkgs) pam; }; @@ -514699,7 +514699,7 @@ self: { primitive ]; description = "Parse syslog traffic from PAN-OS"; - license = lib.licensesSpdx."BSD-3-Clause"; + license = lib.meta.getLicenseFromSpdxId "BSD-3-Clause"; hydraPlatforms = lib.platforms.none; mainProgram = "pan-os-syslog-to-avro"; broken = true; @@ -514963,7 +514963,7 @@ self: { ]; doHaddock = false; description = "Conversion between markup formats"; - license = lib.licensesSpdx."GPL-2.0-or-later"; + license = lib.meta.getLicenseFromSpdxId "GPL-2.0-or-later"; maintainers = [ lib.maintainers.maralorn lib.maintainers.sternenseemann @@ -515171,7 +515171,7 @@ self: { ]; doHaddock = false; description = "Conversion between markup formats"; - license = lib.licensesSpdx."GPL-2.0-or-later"; + license = lib.meta.getLicenseFromSpdxId "GPL-2.0-or-later"; hydraPlatforms = lib.platforms.none; maintainers = [ lib.maintainers.maralorn @@ -515201,7 +515201,7 @@ self: { text ]; description = "A monadic DSL for building pandoc documents"; - license = lib.licensesSpdx."BSD-3-Clause"; + license = lib.meta.getLicenseFromSpdxId "BSD-3-Clause"; } ) { }; @@ -515384,7 +515384,7 @@ self: { warp ]; description = "Conversion between documentation formats"; - license = lib.licensesSpdx."GPL-2.0-or-later"; + license = lib.meta.getLicenseFromSpdxId "GPL-2.0-or-later"; mainProgram = "pandoc"; maintainers = [ lib.maintainers.maralorn ]; } @@ -515423,7 +515423,7 @@ self: { warp ]; description = "Conversion between documentation formats"; - license = lib.licensesSpdx."GPL-2.0-or-later"; + license = lib.meta.getLicenseFromSpdxId "GPL-2.0-or-later"; hydraPlatforms = lib.platforms.none; mainProgram = "pandoc"; maintainers = [ lib.maintainers.maralorn ]; @@ -515453,7 +515453,7 @@ self: { pandoc-types ]; description = "A pandoc filter that provides a Markdown extension for columns"; - license = lib.licensesSpdx."BSD-3-Clause"; + license = lib.meta.getLicenseFromSpdxId "BSD-3-Clause"; hydraPlatforms = lib.platforms.none; mainProgram = "pandoc-columns"; broken = true; @@ -516048,7 +516048,7 @@ self: { pandoc-types ]; description = "Pandoc filter to include files, with image path and heading level adjustment"; - license = lib.licensesSpdx."BSD-3-Clause"; + license = lib.meta.getLicenseFromSpdxId "BSD-3-Clause"; hydraPlatforms = lib.platforms.none; mainProgram = "pandoc-include-plus"; broken = true; @@ -516149,7 +516149,7 @@ self: { pandoc-types ]; description = "A pandoc filter that provides a Markdown extension to wrap text in table cells"; - license = lib.licensesSpdx."BSD-3-Clause"; + license = lib.meta.getLicenseFromSpdxId "BSD-3-Clause"; hydraPlatforms = lib.platforms.none; mainProgram = "pandoc-linear-table"; broken = true; @@ -516177,7 +516177,7 @@ self: { text ]; description = "Extract \"contextual links\" from Pandoc"; - license = lib.licensesSpdx."BSD-3-Clause"; + license = lib.meta.getLicenseFromSpdxId "BSD-3-Clause"; } ) { }; @@ -516206,7 +516206,7 @@ self: { pandoc-types ]; description = "A pandoc filter that provides a Markdown extension for logic proofs"; - license = lib.licensesSpdx."BSD-3-Clause"; + license = lib.meta.getLicenseFromSpdxId "BSD-3-Clause"; hydraPlatforms = lib.platforms.none; mainProgram = "pandoc-logic-proof"; broken = true; @@ -516298,7 +516298,7 @@ self: { text ]; description = "Lua engine to power custom pandoc conversions"; - license = lib.licensesSpdx."GPL-2.0-or-later"; + license = lib.meta.getLicenseFromSpdxId "GPL-2.0-or-later"; } ) { }; @@ -516385,7 +516385,7 @@ self: { text ]; description = "Lua engine to power custom pandoc conversions"; - license = lib.licensesSpdx."GPL-2.0-or-later"; + license = lib.meta.getLicenseFromSpdxId "GPL-2.0-or-later"; hydraPlatforms = lib.platforms.none; } ) { }; @@ -516446,7 +516446,7 @@ self: { text ]; description = "Use pandoc types in Lua"; - license = lib.licensesSpdx."MIT"; + license = lib.meta.getLicenseFromSpdxId "MIT"; } ) { }; @@ -516692,7 +516692,7 @@ self: { text ]; description = "A Pandoc filter to include figures generated from code blocks using your plotting toolkit of choice"; - license = lib.licensesSpdx."GPL-2.0-or-later"; + license = lib.meta.getLicenseFromSpdxId "GPL-2.0-or-later"; mainProgram = "pandoc-plot"; } ) { }; @@ -516802,7 +516802,7 @@ self: { text ]; description = "Pandoc filter to extract only the links"; - license = lib.licensesSpdx."GPL-3.0-only"; + license = lib.meta.getLicenseFromSpdxId "GPL-3.0-only"; hydraPlatforms = lib.platforms.none; broken = true; } @@ -516827,7 +516827,7 @@ self: { pandoc-types ]; description = "Pandoc filter to extract only the code blocks"; - license = lib.licensesSpdx."BSD-3-Clause"; + license = lib.meta.getLicenseFromSpdxId "BSD-3-Clause"; hydraPlatforms = lib.platforms.none; mainProgram = "pandoc-select-code"; broken = true; @@ -516875,7 +516875,7 @@ self: { wai-cors ]; description = "Pandoc document conversion as an HTTP servant-server"; - license = lib.licensesSpdx."GPL-2.0-or-later"; + license = lib.meta.getLicenseFromSpdxId "GPL-2.0-or-later"; } ) { }; @@ -516920,7 +516920,7 @@ self: { wai-cors ]; description = "Pandoc document conversion as an HTTP servant-server"; - license = lib.licensesSpdx."GPL-2.0-or-later"; + license = lib.meta.getLicenseFromSpdxId "GPL-2.0-or-later"; hydraPlatforms = lib.platforms.none; } ) { }; @@ -517130,7 +517130,7 @@ self: { text ]; description = "Types for representing a structured document"; - license = lib.licensesSpdx."BSD-3-Clause"; + license = lib.meta.getLicenseFromSpdxId "BSD-3-Clause"; } ) { }; @@ -517155,7 +517155,7 @@ self: { text ]; description = "TypeScript type generation for Pandoc AST types"; - license = lib.licensesSpdx."MIT"; + license = lib.meta.getLicenseFromSpdxId "MIT"; hydraPlatforms = lib.platforms.none; broken = true; } @@ -517368,7 +517368,7 @@ self: { base ]; description = "Merge environment variables and command line options generically"; - license = lib.licensesSpdx."Apache-2.0"; + license = lib.meta.getLicenseFromSpdxId "Apache-2.0"; hydraPlatforms = lib.platforms.none; } ) { }; @@ -517457,7 +517457,7 @@ self: { ]; libraryPkgconfigDepends = [ pango ]; description = "Binding to the Pango text rendering engine"; - license = lib.licensesSpdx."LGPL-2.1-only"; + license = lib.meta.getLicenseFromSpdxId "LGPL-2.1-only"; } ) { inherit (pkgs) pango; }; @@ -519089,7 +519089,7 @@ self: { validators ]; description = "ParDual class for Parallel <-> Sequential"; - license = lib.licensesSpdx."Apache-2.0"; + license = lib.meta.getLicenseFromSpdxId "Apache-2.0"; hydraPlatforms = lib.platforms.none; } ) { }; @@ -519450,7 +519450,7 @@ self: { tasty-hunit ]; description = "Classes and data structures for working with data-kind indexed types"; - license = lib.licensesSpdx."BSD-3-Clause"; + license = lib.meta.getLicenseFromSpdxId "BSD-3-Clause"; } ) { }; @@ -519513,7 +519513,7 @@ self: { tasty-hunit ]; description = "Classes and data structures for working with data-kind indexed types"; - license = lib.licensesSpdx."BSD-3-Clause"; + license = lib.meta.getLicenseFromSpdxId "BSD-3-Clause"; hydraPlatforms = lib.platforms.none; } ) { }; @@ -519533,7 +519533,7 @@ self: { transformers ]; description = "A known-parametric Functor typeclass"; - license = lib.licensesSpdx."Apache-2.0"; + license = lib.meta.getLicenseFromSpdxId "Apache-2.0"; } ) { }; @@ -519810,7 +519810,7 @@ self: { happy ]; description = "Examples to accompany the book \"Parallel and Concurrent Programming in Haskell\""; - license = lib.licensesSpdx."BSD-3-Clause"; + license = lib.meta.getLicenseFromSpdxId "BSD-3-Clause"; hydraPlatforms = lib.platforms.none; } ) { }; @@ -519910,7 +519910,7 @@ self: { text ]; description = "A quick-and-dirty, low-friction benchmark tool with immediate feedback"; - license = lib.licensesSpdx."BSD-3-Clause"; + license = lib.meta.getLicenseFromSpdxId "BSD-3-Clause"; } ) { }; @@ -519961,7 +519961,7 @@ self: { protolude ]; description = "Help Manage project specific documentation"; - license = lib.licensesSpdx."AGPL-3.0-only"; + license = lib.meta.getLicenseFromSpdxId "AGPL-3.0-only"; hydraPlatforms = lib.platforms.none; mainProgram = "parochial"; broken = true; @@ -520170,7 +520170,7 @@ self: { transformers ]; description = "Parsable and Printable classes"; - license = lib.licensesSpdx."AGPL-3.0-only"; + license = lib.meta.getLicenseFromSpdxId "AGPL-3.0-only"; } ) { }; @@ -520201,7 +520201,7 @@ self: { tasty-quickcheck ]; description = "Test functions for the parsable package"; - license = lib.licensesSpdx."AGPL-3.0-only"; + license = lib.meta.getLicenseFromSpdxId "AGPL-3.0-only"; } ) { }; @@ -520292,7 +520292,7 @@ self: { text ]; description = "Parse machine-readable GHC GC stats"; - license = lib.licensesSpdx."BSD-3-Clause"; + license = lib.meta.getLicenseFromSpdxId "BSD-3-Clause"; hydraPlatforms = lib.platforms.none; broken = true; } @@ -520851,7 +520851,7 @@ self: { sha256 = "1gs0yz7qw5j4w06pfpaiaingr6873znkkrs2m4izrw4xiz1nql4w"; libraryHaskellDepends = [ base ]; description = "Lightweight package providing commonly useful parser combinators"; - license = lib.licensesSpdx."BSD-3-Clause"; + license = lib.meta.getLicenseFromSpdxId "BSD-3-Clause"; } ) { }; @@ -520884,7 +520884,7 @@ self: { ]; testToolDepends = [ hspec-discover ]; description = "Test suite of parser-combinators"; - license = lib.licensesSpdx."BSD-3-Clause"; + license = lib.meta.getLicenseFromSpdxId "BSD-3-Clause"; hydraPlatforms = lib.platforms.none; broken = true; } @@ -520961,7 +520961,7 @@ self: { text ]; description = "Regex based parsers"; - license = lib.licensesSpdx."BSD-3-Clause"; + license = lib.meta.getLicenseFromSpdxId "BSD-3-Clause"; } ) { }; @@ -520993,7 +520993,7 @@ self: { regex-applicative ]; description = "Parsing library with unbiased choice and support for embedding arbitrary monad"; - license = lib.licensesSpdx."BSD-3-Clause"; + license = lib.meta.getLicenseFromSpdxId "BSD-3-Clause"; hydraPlatforms = lib.platforms.none; broken = true; } @@ -521322,7 +521322,7 @@ self: { ]; testToolDepends = [ cpphs ]; description = "A fast parser combinator library backed by Typed Template Haskell"; - license = lib.licensesSpdx."BSD-3-Clause"; + license = lib.meta.getLicenseFromSpdxId "BSD-3-Clause"; hydraPlatforms = lib.platforms.none; } ) { }; @@ -521385,7 +521385,7 @@ self: { th-test-utils ]; description = "A fast parser combinator library backed by Typed Template Haskell"; - license = lib.licensesSpdx."BSD-3-Clause"; + license = lib.meta.getLicenseFromSpdxId "BSD-3-Clause"; hydraPlatforms = lib.platforms.none; broken = true; } @@ -521644,7 +521644,7 @@ self: { hedgehog ]; description = "A partial binary associative operator"; - license = lib.licensesSpdx."Apache-2.0"; + license = lib.meta.getLicenseFromSpdxId "Apache-2.0"; hydraPlatforms = lib.platforms.none; broken = true; } @@ -521667,7 +521667,7 @@ self: { partial-semigroup ]; description = "Property testing for partial semigroups using Hedgehog"; - license = lib.licensesSpdx."Apache-2.0"; + license = lib.meta.getLicenseFromSpdxId "Apache-2.0"; hydraPlatforms = lib.platforms.none; broken = true; } @@ -521727,7 +521727,7 @@ self: { hspec ]; description = "Data structure supporting partial orders"; - license = lib.licensesSpdx."BSD-3-Clause"; + license = lib.meta.getLicenseFromSpdxId "BSD-3-Clause"; } ) { }; @@ -521840,7 +521840,7 @@ self: { transformers-except ]; description = "Platform-Agnostic Security Tokens"; - license = lib.licensesSpdx."MIT"; + license = lib.meta.getLicenseFromSpdxId "MIT"; hydraPlatforms = lib.platforms.none; broken = true; } @@ -521949,7 +521949,7 @@ self: { random ]; description = "a simple password manager"; - license = lib.licensesSpdx."LGPL-3.0-or-later"; + license = lib.meta.getLicenseFromSpdxId "LGPL-3.0-or-later"; hydraPlatforms = lib.platforms.none; mainProgram = "passman"; broken = true; @@ -522158,7 +522158,7 @@ self: { text ]; description = "use password from your CLI"; - license = lib.licensesSpdx."BSD-3-Clause"; + license = lib.meta.getLicenseFromSpdxId "BSD-3-Clause"; mainProgram = "password-cli"; } ) { }; @@ -522394,7 +522394,7 @@ self: { utf8-string ]; description = "Provides the Pasta curves: Pallas, Vesta and their field elements Fp and Fq"; - license = lib.licensesSpdx."MIT"; + license = lib.meta.getLicenseFromSpdxId "MIT"; hydraPlatforms = lib.platforms.none; mainProgram = "pasta-curves"; broken = true; @@ -522828,7 +522828,7 @@ self: { ]; doHaddock = false; description = "Support for well-typed paths"; - license = lib.licensesSpdx."BSD-3-Clause"; + license = lib.meta.getLicenseFromSpdxId "BSD-3-Clause"; } ) { }; @@ -523002,7 +523002,7 @@ self: { unix-compat ]; description = "Interface to ‘directory’ package for users of ‘path’"; - license = lib.licensesSpdx."BSD-3-Clause"; + license = lib.meta.getLicenseFromSpdxId "BSD-3-Clause"; } ) { }; @@ -523076,7 +523076,7 @@ self: { path ]; description = "A singleton wrapper for the `path` library"; - license = lib.licensesSpdx."MPL-2.0"; + license = lib.meta.getLicenseFromSpdxId "MPL-2.0"; hydraPlatforms = lib.platforms.none; broken = true; } @@ -523120,7 +523120,7 @@ self: { ]; testToolDepends = [ tasty-discover ]; description = "A wrapper around the @path@ library, tagged with semantic name"; - license = lib.licensesSpdx."BSD-3-Clause"; + license = lib.meta.getLicenseFromSpdxId "BSD-3-Clause"; } ) { }; @@ -523149,7 +523149,7 @@ self: { text ]; description = "Read and write UTF-8 text files"; - license = lib.licensesSpdx."Apache-2.0"; + license = lib.meta.getLicenseFromSpdxId "Apache-2.0"; hydraPlatforms = lib.platforms.none; broken = true; } @@ -523174,7 +523174,7 @@ self: { relude ]; description = "`Data.Tree` for file paths"; - license = lib.licensesSpdx."MIT"; + license = lib.meta.getLicenseFromSpdxId "MIT"; } ) { }; @@ -523354,7 +523354,7 @@ self: { QuickCheck ]; description = "Type-safe replacement for System.FilePath etc"; - license = lib.licensesSpdx."BSD-3-Clause"; + license = lib.meta.getLicenseFromSpdxId "BSD-3-Clause"; maintainers = [ lib.maintainers.thielema ]; } ) { }; @@ -523457,7 +523457,7 @@ self: { uuid ]; description = "Sentry SDK"; - license = lib.licensesSpdx."MIT"; + license = lib.meta.getLicenseFromSpdxId "MIT"; } ) { }; @@ -523514,7 +523514,7 @@ self: { uuid ]; description = "Sentry SDK"; - license = lib.licensesSpdx."MIT"; + license = lib.meta.getLicenseFromSpdxId "MIT"; hydraPlatforms = lib.platforms.none; } ) { }; @@ -523716,7 +523716,7 @@ self: { vector ]; description = "Greatest convex majorants and least concave minorants"; - license = lib.licensesSpdx."GPL-3.0-or-later"; + license = lib.meta.getLicenseFromSpdxId "GPL-3.0-or-later"; maintainers = [ lib.maintainers.dschrempf ]; } ) { }; @@ -524734,7 +524734,7 @@ self: { tasty-hunit ]; description = "Integration over convex polytopes"; - license = lib.licensesSpdx."GPL-3.0-only"; + license = lib.meta.getLicenseFromSpdxId "GPL-3.0-only"; hydraPlatforms = lib.platforms.none; broken = true; } @@ -525438,7 +525438,7 @@ self: { ]; testToolDepends = [ markdown-unlit ]; description = "Pear Trees: An indexed type using type-level binary numbers"; - license = lib.licensesSpdx."MIT"; + license = lib.meta.getLicenseFromSpdxId "MIT"; } ) { }; @@ -526454,7 +526454,7 @@ self: { transformers ]; description = "Database migration support for use in other libraries"; - license = lib.licensesSpdx."MIT"; + license = lib.meta.getLicenseFromSpdxId "MIT"; hydraPlatforms = lib.platforms.none; broken = true; } @@ -526519,7 +526519,7 @@ self: { ]; benchmarkHaskellDepends = [ base ]; description = "Performance methods and monad"; - license = lib.licensesSpdx."BSD-3-Clause"; + license = lib.meta.getLicenseFromSpdxId "BSD-3-Clause"; mainProgram = "perf-explore"; } ) { }; @@ -526579,7 +526579,7 @@ self: { ]; benchmarkHaskellDepends = [ base ]; description = "Performance tools"; - license = lib.licensesSpdx."BSD-3-Clause"; + license = lib.meta.getLicenseFromSpdxId "BSD-3-Clause"; hydraPlatforms = lib.platforms.none; mainProgram = "perf-explore"; } @@ -526629,7 +526629,7 @@ self: { vector ]; description = "analysis example using perf"; - license = lib.licensesSpdx."BSD-3-Clause"; + license = lib.meta.getLicenseFromSpdxId "BSD-3-Clause"; hydraPlatforms = lib.platforms.none; mainProgram = "perf-examples"; } @@ -526754,7 +526754,7 @@ self: { vector ]; description = "Library for performing vector shuffles"; - license = lib.licensesSpdx."BSD-3-Clause"; + license = lib.meta.getLicenseFromSpdxId "BSD-3-Clause"; hydraPlatforms = lib.platforms.none; mainProgram = "example"; broken = true; @@ -527347,7 +527347,7 @@ self: { text ]; description = "Minimal serialization library with focus on performance"; - license = lib.licensesSpdx."BSD-3-Clause"; + license = lib.meta.getLicenseFromSpdxId "BSD-3-Clause"; hydraPlatforms = lib.platforms.none; broken = true; } @@ -528874,7 +528874,7 @@ self: { unliftio-core ]; description = "A pure haskell backend for the persistent library using MySQL database server"; - license = lib.licensesSpdx."MIT"; + license = lib.meta.getLicenseFromSpdxId "MIT"; hydraPlatforms = lib.platforms.none; mainProgram = "persistent-mysql-pure-example"; broken = true; @@ -529707,7 +529707,7 @@ self: { temporary ]; description = "STM transactions involving persistent storage"; - license = lib.licensesSpdx."BSD-3-Clause"; + license = lib.meta.getLicenseFromSpdxId "BSD-3-Clause"; hydraPlatforms = lib.platforms.none; broken = true; } @@ -530371,7 +530371,7 @@ self: { unordered-containers ]; description = "CLI program for profiles management"; - license = lib.licensesSpdx."BSD-3-Clause"; + license = lib.meta.getLicenseFromSpdxId "BSD-3-Clause"; mainProgram = "pfile"; } ) { }; @@ -530444,7 +530444,7 @@ self: { vector ]; description = "A pleasant PostgreSQL layer"; - license = lib.licensesSpdx."MIT"; + license = lib.meta.getLicenseFromSpdxId "MIT"; hydraPlatforms = lib.platforms.none; } ) { }; @@ -530478,7 +530478,7 @@ self: { text ]; description = "PostgreSQL database performance insights"; - license = lib.licensesSpdx."MIT"; + license = lib.meta.getLicenseFromSpdxId "MIT"; hydraPlatforms = lib.platforms.none; broken = true; } @@ -530640,7 +530640,7 @@ self: { proto-lens-protoc ]; description = "Parse PostgreSQL DDL and DML: Haskell bindings for libpg_query"; - license = lib.licensesSpdx."BSD-3-Clause"; + license = lib.meta.getLicenseFromSpdxId "BSD-3-Clause"; hydraPlatforms = lib.platforms.none; broken = true; } @@ -530783,7 +530783,7 @@ self: { vector ]; description = "Type-level definition of database schema and safe DML for PostgreSQL"; - license = lib.licensesSpdx."BSD-3-Clause"; + license = lib.meta.getLicenseFromSpdxId "BSD-3-Clause"; mainProgram = "test-gen"; } ) { }; @@ -531082,7 +531082,7 @@ self: { text ]; description = "Declarative queue configuration for PGMQ (PostgreSQL Message Queue)"; - license = lib.licensesSpdx."MIT"; + license = lib.meta.getLicenseFromSpdxId "MIT"; hydraPlatforms = lib.platforms.none; } ) { }; @@ -531108,7 +531108,7 @@ self: { time ]; description = "Core types for pgmq-hs, a Haskell client for PGMQ"; - license = lib.licensesSpdx."MIT"; + license = lib.meta.getLicenseFromSpdxId "MIT"; hydraPlatforms = lib.platforms.none; broken = true; } @@ -531153,7 +531153,7 @@ self: { vector ]; description = "Effectful effects for PGMQ (PostgreSQL Message Queue)"; - license = lib.licensesSpdx."MIT"; + license = lib.meta.getLicenseFromSpdxId "MIT"; hydraPlatforms = lib.platforms.none; } ) { }; @@ -531218,7 +531218,7 @@ self: { vector ]; description = "Hasql-based client for PGMQ (PostgreSQL Message Queue)"; - license = lib.licensesSpdx."MIT"; + license = lib.meta.getLicenseFromSpdxId "MIT"; hydraPlatforms = lib.platforms.none; } ) { }; @@ -531262,7 +531262,7 @@ self: { tasty-hunit ]; description = "PGMQ schema migrations without PostgreSQL extension"; - license = lib.licensesSpdx."MIT"; + license = lib.meta.getLicenseFromSpdxId "MIT"; hydraPlatforms = lib.platforms.none; } ) { }; @@ -531356,7 +531356,7 @@ self: { scrappy-core ]; description = "grep-like CLI using Parsec parsers instead of regex"; - license = lib.licensesSpdx."BSD-3-Clause"; + license = lib.meta.getLicenseFromSpdxId "BSD-3-Clause"; mainProgram = "pgrep"; } ) { }; @@ -531500,7 +531500,7 @@ self: { postgresql-simple ]; description = "pgvector support for Haskell"; - license = lib.licensesSpdx."MIT"; + license = lib.meta.getLicenseFromSpdxId "MIT"; hydraPlatforms = lib.platforms.none; broken = true; } @@ -531760,7 +531760,7 @@ self: { ]; testToolDepends = [ hspec-discover ]; description = "Command-Line Manipulator of 𝜑-Calculus Expressions"; - license = lib.licensesSpdx."MIT"; + license = lib.meta.getLicenseFromSpdxId "MIT"; hydraPlatforms = lib.platforms.none; mainProgram = "phino"; broken = true; @@ -531886,7 +531886,7 @@ self: { phonetic-languages-phonetics-basics ]; description = "A shared by different general implementations of the PhLADiPreLiO functionality"; - license = lib.licensesSpdx."MIT"; + license = lib.meta.getLicenseFromSpdxId "MIT"; hydraPlatforms = lib.platforms.none; } ) { }; @@ -531936,7 +531936,7 @@ self: { rhythmic-sequences ]; description = "A generalized functionality of PhLADiPreLiO for different languages that uses hash algorithms"; - license = lib.licensesSpdx."MIT"; + license = lib.meta.getLicenseFromSpdxId "MIT"; hydraPlatforms = lib.platforms.none; } ) { }; @@ -531949,7 +531949,7 @@ self: { sha256 = "1ymsxi750bwah3x1cvq1qvjlgibnbvgkrfv1vkjxs4lb8xa20b3g"; libraryHaskellDepends = [ base ]; description = "Allows to estimate some kind of the rhythmicity properties for the text"; - license = lib.licensesSpdx."MIT"; + license = lib.meta.getLicenseFromSpdxId "MIT"; } ) { }; @@ -531986,7 +531986,7 @@ self: { ukrainian-phonetics-basic-array ]; description = "A shared by different Ukrainian implementations of the PhLADiPreLiO functionality"; - license = lib.licensesSpdx."MIT"; + license = lib.meta.getLicenseFromSpdxId "MIT"; hydraPlatforms = lib.platforms.none; } ) { }; @@ -532063,7 +532063,7 @@ self: { ukrainian-phonetics-basic-array ]; description = "A PhLADiPreLiO implementation for Ukrainian that uses hashes and asynchronous concurrency"; - license = lib.licensesSpdx."MIT"; + license = lib.meta.getLicenseFromSpdxId "MIT"; hydraPlatforms = lib.platforms.none; mainProgram = "phladiprelioUkr"; } @@ -533353,7 +533353,7 @@ self: { unix ]; description = "Rename photo image files based on EXIF shoot date"; - license = lib.licensesSpdx."ISC"; + license = lib.meta.getLicenseFromSpdxId "ISC"; hydraPlatforms = lib.platforms.none; mainProgram = "photoname"; broken = true; @@ -533882,7 +533882,7 @@ self: { text ]; description = "Instant StatsD in Haskell"; - license = lib.licensesSpdx."MIT"; + license = lib.meta.getLicenseFromSpdxId "MIT"; hydraPlatforms = lib.platforms.none; broken = true; } @@ -534659,7 +534659,7 @@ self: { text ]; description = "Functional 2D Game Framework"; - license = lib.licensesSpdx."Zlib"; + license = lib.meta.getLicenseFromSpdxId "Zlib"; hydraPlatforms = lib.platforms.none; } ) { }; @@ -534716,7 +534716,7 @@ self: { vector ]; description = "Servant bindings to Pinecone"; - license = lib.licensesSpdx."BSD-3-Clause"; + license = lib.meta.getLicenseFromSpdxId "BSD-3-Clause"; mainProgram = "pinecone-example"; } ) { }; @@ -534754,7 +534754,7 @@ self: { transformers ]; description = "icmp echo requests"; - license = lib.licensesSpdx."BSD-3-Clause"; + license = lib.meta.getLicenseFromSpdxId "BSD-3-Clause"; hydraPlatforms = lib.platforms.none; } ) { }; @@ -534875,7 +534875,7 @@ self: { tasty-hunit ]; description = "Preserve warnings in a GHCi session"; - license = lib.licensesSpdx."BSD-3-Clause"; + license = lib.meta.getLicenseFromSpdxId "BSD-3-Clause"; } ) { }; @@ -535191,7 +535191,7 @@ self: { transformers ]; description = "Encode and decode JSON streams using Aeson and Pipes"; - license = lib.licensesSpdx."BSD-3-Clause"; + license = lib.meta.getLicenseFromSpdxId "BSD-3-Clause"; } ) { }; @@ -535281,7 +535281,7 @@ self: { transformers ]; description = "Attoparsec and Pipes integration"; - license = lib.licensesSpdx."BSD-3-Clause"; + license = lib.meta.getLicenseFromSpdxId "BSD-3-Clause"; } ) { }; @@ -537035,7 +537035,7 @@ self: { pulse-simple ]; description = "Pipes for pulse-simple audio"; - license = lib.licensesSpdx."Apache-2.0"; + license = lib.meta.getLicenseFromSpdxId "Apache-2.0"; hydraPlatforms = lib.platforms.none; broken = true; } @@ -537303,7 +537303,7 @@ self: { transformers ]; description = "properly streaming text"; - license = lib.licensesSpdx."BSD-3-Clause"; + license = lib.meta.getLicenseFromSpdxId "BSD-3-Clause"; } ) { }; @@ -537748,7 +537748,7 @@ self: { ]; testHaskellDepends = [ base ]; description = "A program for turning pixel art into 3D prints"; - license = lib.licensesSpdx."GPL-3.0-only"; + license = lib.meta.getLicenseFromSpdxId "GPL-3.0-only"; hydraPlatforms = lib.platforms.none; mainProgram = "pixel-printer-exe"; broken = true; @@ -537927,7 +537927,7 @@ self: { http-client-tls ]; description = "Pixiv API binding based on servant-client"; - license = lib.licensesSpdx."BSD-3-Clause"; + license = lib.meta.getLicenseFromSpdxId "BSD-3-Clause"; hydraPlatforms = lib.platforms.none; broken = true; } @@ -538219,7 +538219,7 @@ self: { directory ]; description = "Bindings and wrappers for PL_SYNTH - no-deps sound effects synthesizer and tracker"; - license = lib.licensesSpdx."BSD-3-Clause"; + license = lib.meta.getLicenseFromSpdxId "BSD-3-Clause"; hydraPlatforms = lib.platforms.none; broken = true; } @@ -539027,7 +539027,7 @@ self: { word8 ]; description = "Library and executable for working with playlist files"; - license = lib.licensesSpdx."BSD-3-Clause"; + license = lib.meta.getLicenseFromSpdxId "BSD-3-Clause"; mainProgram = "playlist"; } ) { }; @@ -539077,7 +539077,7 @@ self: { sha256 = "1j7jblcmnvg2f5pdsakr9afqyssaspffbr4rdrixzayywbbrgbic"; libraryHaskellDepends = [ base ]; description = "A semi-cross-platform interface for pledge(2) and unveil(2)"; - license = lib.licensesSpdx."Unlicense"; + license = lib.meta.getLicenseFromSpdxId "Unlicense"; hydraPlatforms = lib.platforms.none; broken = true; } @@ -539160,7 +539160,7 @@ self: { websockets ]; description = "Plexus RPC protocol types and client"; - license = lib.licensesSpdx."MIT"; + license = lib.meta.getLicenseFromSpdxId "MIT"; hydraPlatforms = lib.platforms.none; broken = true; } @@ -539260,7 +539260,7 @@ self: { vector ]; description = "Schema-driven CLI for Plexus RPC servers"; - license = lib.licensesSpdx."MIT"; + license = lib.meta.getLicenseFromSpdxId "MIT"; hydraPlatforms = lib.platforms.none; mainProgram = "synapse"; } @@ -540349,7 +540349,7 @@ self: { ]; testToolDepends = [ hspec-discover ]; description = "pms-application-service"; - license = lib.licensesSpdx."Apache-2.0"; + license = lib.meta.getLicenseFromSpdxId "Apache-2.0"; hydraPlatforms = lib.platforms.none; } ) { }; @@ -540411,7 +540411,7 @@ self: { ]; testToolDepends = [ hspec-discover ]; description = "pms-domain-model"; - license = lib.licensesSpdx."Apache-2.0"; + license = lib.meta.getLicenseFromSpdxId "Apache-2.0"; hydraPlatforms = lib.platforms.none; broken = true; } @@ -540485,7 +540485,7 @@ self: { ]; testToolDepends = [ hspec-discover ]; description = "pms-domain-service"; - license = lib.licensesSpdx."Apache-2.0"; + license = lib.meta.getLicenseFromSpdxId "Apache-2.0"; hydraPlatforms = lib.platforms.none; } ) { }; @@ -540553,7 +540553,7 @@ self: { ]; testToolDepends = [ hspec-discover ]; description = "pms-infra-cmdrun"; - license = lib.licensesSpdx."Apache-2.0"; + license = lib.meta.getLicenseFromSpdxId "Apache-2.0"; hydraPlatforms = lib.platforms.none; } ) { }; @@ -540623,7 +540623,7 @@ self: { ]; testToolDepends = [ hspec-discover ]; description = "pms-infra-filesystem"; - license = lib.licensesSpdx."Apache-2.0"; + license = lib.meta.getLicenseFromSpdxId "Apache-2.0"; hydraPlatforms = lib.platforms.none; } ) { }; @@ -540691,7 +540691,7 @@ self: { ]; testToolDepends = [ hspec-discover ]; description = "pms-infra-procspawn"; - license = lib.licensesSpdx."Apache-2.0"; + license = lib.meta.getLicenseFromSpdxId "Apache-2.0"; hydraPlatforms = lib.platforms.none; } ) { }; @@ -540765,7 +540765,7 @@ self: { ]; testToolDepends = [ hspec-discover ]; description = "pms-infra-serial"; - license = lib.licensesSpdx."Apache-2.0"; + license = lib.meta.getLicenseFromSpdxId "Apache-2.0"; hydraPlatforms = lib.platforms.none; } ) { }; @@ -540837,7 +540837,7 @@ self: { ]; testToolDepends = [ hspec-discover ]; description = "pms-infra-socket"; - license = lib.licensesSpdx."Apache-2.0"; + license = lib.meta.getLicenseFromSpdxId "Apache-2.0"; hydraPlatforms = lib.platforms.none; } ) { }; @@ -540907,7 +540907,7 @@ self: { ]; testToolDepends = [ hspec-discover ]; description = "pms-infra-watch"; - license = lib.licensesSpdx."Apache-2.0"; + license = lib.meta.getLicenseFromSpdxId "Apache-2.0"; hydraPlatforms = lib.platforms.none; } ) { }; @@ -540981,7 +540981,7 @@ self: { ]; testToolDepends = [ hspec-discover ]; description = "pms-infrastructure"; - license = lib.licensesSpdx."Apache-2.0"; + license = lib.meta.getLicenseFromSpdxId "Apache-2.0"; hydraPlatforms = lib.platforms.none; } ) { }; @@ -541042,7 +541042,7 @@ self: { ]; testToolDepends = [ hspec-discover ]; description = "pms-ui-notification"; - license = lib.licensesSpdx."Apache-2.0"; + license = lib.meta.getLicenseFromSpdxId "Apache-2.0"; hydraPlatforms = lib.platforms.none; } ) { }; @@ -541103,7 +541103,7 @@ self: { ]; testToolDepends = [ hspec-discover ]; description = "pms-ui-request"; - license = lib.licensesSpdx."Apache-2.0"; + license = lib.meta.getLicenseFromSpdxId "Apache-2.0"; hydraPlatforms = lib.platforms.none; } ) { }; @@ -541164,7 +541164,7 @@ self: { ]; testToolDepends = [ hspec-discover ]; description = "pms-ui-response"; - license = lib.licensesSpdx."Apache-2.0"; + license = lib.meta.getLicenseFromSpdxId "Apache-2.0"; hydraPlatforms = lib.platforms.none; } ) { }; @@ -541221,7 +541221,7 @@ self: { yaftee-conduit-mono-traversable ]; description = "PNG's chunk codec on Yaftee"; - license = lib.licensesSpdx."BSD-3-Clause"; + license = lib.meta.getLicenseFromSpdxId "BSD-3-Clause"; } ) { }; @@ -541516,7 +541516,7 @@ self: { text ]; description = "A container wrapper"; - license = lib.licensesSpdx."Apache-2.0"; + license = lib.meta.getLicenseFromSpdxId "Apache-2.0"; hydraPlatforms = lib.platforms.none; mainProgram = "podenv"; broken = true; @@ -541775,7 +541775,7 @@ self: { sha256 = "1lrwv6pwnagay3yx36kxhz7j866wqjah7a557l9137kqx7n1hp8v"; libraryHaskellDepends = [ base ]; description = "Some common point-free combinators"; - license = lib.licensesSpdx."BSD-3-Clause"; + license = lib.meta.getLicenseFromSpdxId "BSD-3-Clause"; } ) { }; @@ -542026,7 +542026,7 @@ self: { gauge ]; description = "Texas holdem hand evaluation and simulation"; - license = lib.licensesSpdx."MIT"; + license = lib.meta.getLicenseFromSpdxId "MIT"; hydraPlatforms = lib.platforms.none; mainProgram = "poker-exe"; } @@ -542336,7 +542336,7 @@ self: { text ]; description = "Haskell PVP version adviser"; - license = lib.licensesSpdx."MPL-2.0"; + license = lib.meta.getLicenseFromSpdxId "MPL-2.0"; hydraPlatforms = lib.platforms.none; mainProgram = "policeman"; broken = true; @@ -542385,7 +542385,7 @@ self: { utility-ht ]; description = "Bindings to poll.h"; - license = lib.licensesSpdx."BSD-3-Clause"; + license = lib.meta.getLicenseFromSpdxId "BSD-3-Clause"; } ) { }; @@ -542456,7 +542456,7 @@ self: { text ]; description = "Functionality to help examine Haddock information of a module"; - license = lib.licensesSpdx."MIT"; + license = lib.meta.getLicenseFromSpdxId "MIT"; } ) { }; @@ -542857,7 +542857,7 @@ self: { containers ]; description = "Multivariate polynomial rings"; - license = lib.licensesSpdx."BSD-3-Clause"; + license = lib.meta.getLicenseFromSpdxId "BSD-3-Clause"; hydraPlatforms = lib.platforms.none; } ) { }; @@ -543058,7 +543058,7 @@ self: { sqel ]; description = "Account management with Servant and Polysemy"; - license = lib.licensesSpdx."BSD-2-Clause-Patent"; + license = lib.meta.getLicenseFromSpdxId "BSD-2-Clause-Patent"; hydraPlatforms = lib.platforms.none; } ) { }; @@ -543148,7 +543148,7 @@ self: { zeugma ]; description = "Account management with Servant and Polysemy"; - license = lib.licensesSpdx."BSD-2-Clause-Patent"; + license = lib.meta.getLicenseFromSpdxId "BSD-2-Clause-Patent"; hydraPlatforms = lib.platforms.none; } ) { }; @@ -543187,7 +543187,7 @@ self: { ]; testToolDepends = [ tasty-discover ]; description = "Polysemy wrapper around the Blockfrost client"; - license = lib.licensesSpdx."Apache-2.0"; + license = lib.meta.getLicenseFromSpdxId "Apache-2.0"; hydraPlatforms = lib.platforms.none; broken = true; } @@ -543263,7 +543263,7 @@ self: { tasty ]; description = "A Polysemy effect for Chronos"; - license = lib.licensesSpdx."BSD-2-Clause-Patent"; + license = lib.meta.getLicenseFromSpdxId "BSD-2-Clause-Patent"; } ) { }; @@ -543318,7 +543318,7 @@ self: { torsor ]; description = "Polysemy effects for concurrency"; - license = lib.licensesSpdx."BSD-2-Clause-Patent"; + license = lib.meta.getLicenseFromSpdxId "BSD-2-Clause-Patent"; } ) { }; @@ -543349,7 +543349,7 @@ self: { uuid ]; description = "Polysemy effects for databases"; - license = lib.licensesSpdx."BSD-2-Clause-Patent"; + license = lib.meta.getLicenseFromSpdxId "BSD-2-Clause-Patent"; hydraPlatforms = lib.platforms.none; } ) { }; @@ -543508,7 +543508,7 @@ self: { zeugma ]; description = "Polysemy effects for databases"; - license = lib.licensesSpdx."BSD-2-Clause-Patent"; + license = lib.meta.getLicenseFromSpdxId "BSD-2-Clause-Patent"; hydraPlatforms = lib.platforms.none; } ) { }; @@ -543572,7 +543572,7 @@ self: { tasty ]; description = "Test utilities for polysemy-hasql"; - license = lib.licensesSpdx."BSD-2-Clause-Patent"; + license = lib.meta.getLicenseFromSpdxId "BSD-2-Clause-Patent"; hydraPlatforms = lib.platforms.none; } ) { }; @@ -543635,7 +543635,7 @@ self: { warp ]; description = "Polysemy effects for HTTP clients"; - license = lib.licensesSpdx."BSD-2-Clause-Patent"; + license = lib.meta.getLicenseFromSpdxId "BSD-2-Clause-Patent"; hydraPlatforms = lib.platforms.none; broken = true; } @@ -543794,7 +543794,7 @@ self: { polysemy-plugin ]; description = "Polysemy effects for logging"; - license = lib.licensesSpdx."BSD-2-Clause-Patent"; + license = lib.meta.getLicenseFromSpdxId "BSD-2-Clause-Patent"; } ) { }; @@ -543844,7 +543844,7 @@ self: { tasty ]; description = "Colog adapters for polysemy-log"; - license = lib.licensesSpdx."BSD-2-Clause-Patent"; + license = lib.meta.getLicenseFromSpdxId "BSD-2-Clause-Patent"; hydraPlatforms = lib.platforms.none; broken = true; } @@ -543888,7 +543888,7 @@ self: { tasty ]; description = "Di adapters for polysemy-log"; - license = lib.licensesSpdx."BSD-2-Clause-Patent"; + license = lib.meta.getLicenseFromSpdxId "BSD-2-Clause-Patent"; } ) { }; @@ -543931,7 +543931,7 @@ self: { ]; testToolDepends = [ hspec-discover ]; description = "Primitive functions and data types"; - license = lib.licensesSpdx."BSD-3-Clause"; + license = lib.meta.getLicenseFromSpdxId "BSD-3-Clause"; hydraPlatforms = lib.platforms.none; broken = true; } @@ -544221,7 +544221,7 @@ self: { unix ]; description = "Polysemy effects for system processes"; - license = lib.licensesSpdx."BSD-2-Clause-Patent"; + license = lib.meta.getLicenseFromSpdxId "BSD-2-Clause-Patent"; } ) { }; @@ -544262,7 +544262,7 @@ self: { polysemy-plugin ]; description = "Readline effect for polysemy"; - license = lib.licensesSpdx."BSD-2-Clause"; + license = lib.meta.getLicenseFromSpdxId "BSD-2-Clause"; mainProgram = "echo-repl"; } ) { }; @@ -544286,7 +544286,7 @@ self: { req ]; description = "Polysemy effect for req"; - license = lib.licensesSpdx."BSD-3-Clause"; + license = lib.meta.getLicenseFromSpdxId "BSD-3-Clause"; hydraPlatforms = lib.platforms.none; broken = true; } @@ -544324,7 +544324,7 @@ self: { tasty ]; description = "Polysemy error tracking"; - license = lib.licensesSpdx."BSD-2-Clause-Patent"; + license = lib.meta.getLicenseFromSpdxId "BSD-2-Clause-Patent"; } ) { }; @@ -544374,7 +544374,7 @@ self: { text ]; description = "Well-typed filesystem operation effects"; - license = lib.licensesSpdx."AGPL-3.0-or-later"; + license = lib.meta.getLicenseFromSpdxId "AGPL-3.0-or-later"; hydraPlatforms = lib.platforms.none; } ) { }; @@ -544465,7 +544465,7 @@ self: { tasty ]; description = "Polysemy effects for testing"; - license = lib.licensesSpdx."BSD-2-Clause-Patent"; + license = lib.meta.getLicenseFromSpdxId "BSD-2-Clause-Patent"; } ) { }; @@ -544501,7 +544501,7 @@ self: { time ]; description = "A Polysemy effect for time"; - license = lib.licensesSpdx."BSD-2-Clause-Patent"; + license = lib.meta.getLicenseFromSpdxId "BSD-2-Clause-Patent"; } ) { }; @@ -544880,7 +544880,7 @@ self: { tasty-quickcheck ]; description = "Alternative to `Dynamic` with type guarantees"; - license = lib.licensesSpdx."BSD-3-Clause"; + license = lib.meta.getLicenseFromSpdxId "BSD-3-Clause"; } ) { }; @@ -545348,7 +545348,7 @@ self: { xml-types ]; description = "An XMPP client library"; - license = lib.licensesSpdx."BSD-3-Clause"; + license = lib.meta.getLicenseFromSpdxId "BSD-3-Clause"; } ) { }; @@ -545503,7 +545503,7 @@ self: { timeit ]; description = "Simple work queue for bounded concurrency"; - license = lib.licensesSpdx."ISC"; + license = lib.meta.getLicenseFromSpdxId "ISC"; } ) { }; @@ -545536,7 +545536,7 @@ self: { utility-ht ]; description = "Run jobs on a limited number of threads and support data dependencies"; - license = lib.licensesSpdx."BSD-3-Clause"; + license = lib.meta.getLicenseFromSpdxId "BSD-3-Clause"; maintainers = [ lib.maintainers.thielema ]; } ) { }; @@ -545636,7 +545636,7 @@ self: { ]; testToolDepends = [ hspec-discover ]; description = "Static key-value storage backed by poppy"; - license = lib.licensesSpdx."MIT"; + license = lib.meta.getLicenseFromSpdxId "MIT"; hydraPlatforms = lib.platforms.none; broken = true; } @@ -546082,7 +546082,7 @@ self: { warp ]; description = "A minimalist HTTP server framework written on top of wai"; - license = lib.licensesSpdx."MIT"; + license = lib.meta.getLicenseFromSpdxId "MIT"; hydraPlatforms = lib.platforms.none; mainProgram = "porpoise-example"; broken = true; @@ -546213,7 +546213,7 @@ self: { ]; doHaddock = false; description = "Data structures and functions for interacting with the Portage package manager"; - license = lib.licensesSpdx."AGPL-3.0-only"; + license = lib.meta.getLicenseFromSpdxId "AGPL-3.0-only"; } ) { }; @@ -546344,7 +546344,7 @@ self: { PortMidi ]; description = "PortMidi utilities"; - license = lib.licensesSpdx."BSD-3-Clause"; + license = lib.meta.getLicenseFromSpdxId "BSD-3-Clause"; badPlatforms = lib.platforms.darwin; mainProgram = "portmidi-list-devices"; } @@ -546667,7 +546667,7 @@ self: { template-haskell ]; description = "A product-of-sums generics library"; - license = lib.licensesSpdx."BSD-3-Clause"; + license = lib.meta.getLicenseFromSpdxId "BSD-3-Clause"; hydraPlatforms = lib.platforms.none; broken = true; } @@ -546727,7 +546727,7 @@ self: { uuid ]; description = "Simple extensible library to run SQL file against PostgreSQL database"; - license = lib.licensesSpdx."BSD-3-Clause"; + license = lib.meta.getLicenseFromSpdxId "BSD-3-Clause"; hydraPlatforms = lib.platforms.none; } ) { }; @@ -546960,7 +546960,7 @@ self: { tasty-hunit ]; description = "posix bindings"; - license = lib.licensesSpdx."BSD-3-Clause"; + license = lib.meta.getLicenseFromSpdxId "BSD-3-Clause"; badPlatforms = lib.platforms.darwin; } ) { }; @@ -547519,7 +547519,7 @@ self: { websockets ]; description = "Middleware to map LISTEN/NOTIFY messages to Websockets"; - license = lib.licensesSpdx."BSD-3-Clause"; + license = lib.meta.getLicenseFromSpdxId "BSD-3-Clause"; mainProgram = "postgres-websockets"; maintainers = [ lib.maintainers.wolfgangwalther ]; } @@ -547587,7 +547587,7 @@ self: { rerebase ]; description = "Encoders and decoders for the PostgreSQL's binary format"; - license = lib.licensesSpdx."MIT"; + license = lib.meta.getLicenseFromSpdxId "MIT"; hydraPlatforms = lib.platforms.none; } ) { }; @@ -547654,7 +547654,7 @@ self: { rerebase ]; description = "Encoders and decoders for the PostgreSQL's binary format"; - license = lib.licensesSpdx."MIT"; + license = lib.meta.getLicenseFromSpdxId "MIT"; } ) { }; @@ -547722,7 +547722,7 @@ self: { rerebase ]; description = "Encoders and decoders for the PostgreSQL's binary format"; - license = lib.licensesSpdx."MIT"; + license = lib.meta.getLicenseFromSpdxId "MIT"; hydraPlatforms = lib.platforms.none; } ) { }; @@ -547863,7 +547863,7 @@ self: { text ]; description = "PostgreSQL connection string type, parser and builder"; - license = lib.licensesSpdx."MIT"; + license = lib.meta.getLicenseFromSpdxId "MIT"; } ) { }; @@ -547985,7 +547985,7 @@ self: { tasty-hunit ]; description = "low-level binding to libpq"; - license = lib.licensesSpdx."BSD-3-Clause"; + license = lib.meta.getLicenseFromSpdxId "BSD-3-Clause"; } ) { }; @@ -547998,7 +547998,7 @@ self: { libraryHaskellDepends = [ base ]; doHaddock = false; description = "low-level binding to libpq: configure based provider"; - license = lib.licensesSpdx."BSD-3-Clause"; + license = lib.meta.getLicenseFromSpdxId "BSD-3-Clause"; } ) { }; @@ -548051,7 +548051,7 @@ self: { libraryPkgconfigDepends = [ libpq ]; doHaddock = false; description = "low-level binding to libpq: pkg-config based provider"; - license = lib.licensesSpdx."BSD-3-Clause"; + license = lib.meta.getLicenseFromSpdxId "BSD-3-Clause"; } ) { inherit (pkgs) libpq; }; @@ -548171,7 +548171,7 @@ self: { postgresql-simple ]; description = "PostgreSQL Schema Migrations"; - license = lib.licensesSpdx."BSD-3-Clause"; + license = lib.meta.getLicenseFromSpdxId "BSD-3-Clause"; mainProgram = "migrate"; } ) { }; @@ -548203,7 +548203,7 @@ self: { text ]; description = "A PostgreSQL persistent schema migration utility"; - license = lib.licensesSpdx."MIT"; + license = lib.meta.getLicenseFromSpdxId "MIT"; } ) { }; @@ -548266,7 +548266,7 @@ self: { text ]; description = "Track and render a tally of which PostgreSQL operations have been performed"; - license = lib.licensesSpdx."BSD-3-Clause"; + license = lib.meta.getLicenseFromSpdxId "BSD-3-Clause"; } ) { }; @@ -548367,7 +548367,7 @@ self: { ]; testToolDepends = [ hspec-discover ]; description = "Converter for question mark style and dollar sign style of PostgreSQL SQL"; - license = lib.licensesSpdx."BSD-3-Clause"; + license = lib.meta.getLicenseFromSpdxId "BSD-3-Clause"; } ) { }; @@ -548509,7 +548509,7 @@ self: { utf8-string ]; description = "pure Haskell PostgreSQL driver"; - license = lib.licensesSpdx."BSD-3-Clause"; + license = lib.meta.getLicenseFromSpdxId "BSD-3-Clause"; hydraPlatforms = lib.platforms.none; } ) { }; @@ -548691,7 +548691,7 @@ self: { postgresql-simple ]; description = "Automatic re-connection support for PostgreSQL"; - license = lib.licensesSpdx."Apache-2.0"; + license = lib.meta.getLicenseFromSpdxId "Apache-2.0"; hydraPlatforms = lib.platforms.none; broken = true; } @@ -548930,7 +548930,7 @@ self: { time ]; description = "A simple interval type for PostgreSQL"; - license = lib.licensesSpdx."0BSD"; + license = lib.meta.getLicenseFromSpdxId "0BSD"; hydraPlatforms = lib.platforms.none; broken = true; } @@ -549068,7 +549068,7 @@ self: { transformers ]; description = "Implementation of named parameters for `postgresql-simple` library"; - license = lib.licensesSpdx."MPL-2.0"; + license = lib.meta.getLicenseFromSpdxId "MPL-2.0"; hydraPlatforms = lib.platforms.none; broken = true; } @@ -549175,7 +549175,7 @@ self: { text ]; description = "Integration of \"postgresql-simple\" with \"postgresql-types\""; - license = lib.licensesSpdx."MIT"; + license = lib.meta.getLicenseFromSpdxId "MIT"; hydraPlatforms = lib.platforms.none; } ) { }; @@ -549376,7 +549376,7 @@ self: { tasty-hunit ]; description = "PostgreSQL AST parsing and rendering"; - license = lib.licensesSpdx."MIT"; + license = lib.meta.getLicenseFromSpdxId "MIT"; } ) { }; @@ -549776,7 +549776,7 @@ self: { testToolDepends = [ hspec-discover ]; doHaddock = false; description = "Precise PostgreSQL types representation and driver-agnostic codecs"; - license = lib.licensesSpdx."MIT"; + license = lib.meta.getLicenseFromSpdxId "MIT"; hydraPlatforms = lib.platforms.none; } ) { }; @@ -549808,7 +549808,7 @@ self: { text-builder ]; description = "Type classes for PostgreSQL type mappings"; - license = lib.licensesSpdx."MIT"; + license = lib.meta.getLicenseFromSpdxId "MIT"; hydraPlatforms = lib.platforms.none; } ) { }; @@ -550647,7 +550647,7 @@ self: { tasty-hunit ]; description = "PowerDNS API bindings for api/v1"; - license = lib.licensesSpdx."BSD-3-Clause"; + license = lib.meta.getLicenseFromSpdxId "BSD-3-Clause"; hydraPlatforms = lib.platforms.none; broken = true; } @@ -550919,7 +550919,7 @@ self: { ppad-base16 ]; description = "A pure AEAD-ChaCha20-Poly1305 construction"; - license = lib.licensesSpdx."MIT"; + license = lib.meta.getLicenseFromSpdxId "MIT"; hydraPlatforms = lib.platforms.none; broken = true; } @@ -550963,7 +550963,7 @@ self: { weigh ]; description = "Pure base16 encoding and decoding on bytestrings"; - license = lib.licensesSpdx."MIT"; + license = lib.meta.getLicenseFromSpdxId "MIT"; } ) { }; @@ -551008,7 +551008,7 @@ self: { criterion ]; description = "base58 and base58check encoding/decoding"; - license = lib.licensesSpdx."MIT"; + license = lib.meta.getLicenseFromSpdxId "MIT"; hydraPlatforms = lib.platforms.none; } ) { }; @@ -551047,7 +551047,7 @@ self: { deepseq ]; description = "bech32 and bech32m encoding/decoding, per BIPs 173 & 350"; - license = lib.licensesSpdx."MIT"; + license = lib.meta.getLicenseFromSpdxId "MIT"; } ) { }; @@ -551103,7 +551103,7 @@ self: { ppad-secp256k1 ]; description = "BIP32 hierarchical deterministic wallets"; - license = lib.licensesSpdx."MIT"; + license = lib.meta.getLicenseFromSpdxId "MIT"; hydraPlatforms = lib.platforms.none; } ) { }; @@ -551164,7 +551164,7 @@ self: { deepseq ]; description = "BIP39 mnemonic codes"; - license = lib.licensesSpdx."MIT"; + license = lib.meta.getLicenseFromSpdxId "MIT"; hydraPlatforms = lib.platforms.none; } ) { }; @@ -551206,7 +551206,7 @@ self: { ppad-base16 ]; description = "A pure ChaCha20 stream cipher"; - license = lib.licensesSpdx."MIT"; + license = lib.meta.getLicenseFromSpdxId "MIT"; } ) { }; @@ -551242,7 +551242,7 @@ self: { weigh ]; description = "Large fixed-width words and constant-time arithmetic"; - license = lib.licensesSpdx."MIT"; + license = lib.meta.getLicenseFromSpdxId "MIT"; } ) { }; @@ -551287,7 +551287,7 @@ self: { ppad-sha512 ]; description = "A HMAC-based key derivation function"; - license = lib.licensesSpdx."MIT"; + license = lib.meta.getLicenseFromSpdxId "MIT"; hydraPlatforms = lib.platforms.none; } ) { }; @@ -551335,7 +551335,7 @@ self: { weigh ]; description = "HMAC-based deterministic random bit generator"; - license = lib.licensesSpdx."MIT"; + license = lib.meta.getLicenseFromSpdxId "MIT"; hydraPlatforms = lib.platforms.none; } ) { }; @@ -551381,7 +551381,7 @@ self: { ppad-sha512 ]; description = "A password-based key derivation function"; - license = lib.licensesSpdx."MIT"; + license = lib.meta.getLicenseFromSpdxId "MIT"; hydraPlatforms = lib.platforms.none; } ) { }; @@ -551422,7 +551422,7 @@ self: { ppad-base16 ]; description = "A pure Poly1305 MAC"; - license = lib.licensesSpdx."MIT"; + license = lib.meta.getLicenseFromSpdxId "MIT"; } ) { }; @@ -551463,7 +551463,7 @@ self: { SHA ]; description = "The RIPEMD-160 hashing algorithm"; - license = lib.licensesSpdx."MIT"; + license = lib.meta.getLicenseFromSpdxId "MIT"; } ) { }; @@ -551509,7 +551509,7 @@ self: { weigh ]; description = "Primitive Script support"; - license = lib.licensesSpdx."MIT"; + license = lib.meta.getLicenseFromSpdxId "MIT"; } ) { }; @@ -551566,7 +551566,7 @@ self: { weigh ]; description = "Schnorr signatures, ECDSA, and ECDH on the elliptic curve secp256k1"; - license = lib.licensesSpdx."MIT"; + license = lib.meta.getLicenseFromSpdxId "MIT"; hydraPlatforms = lib.platforms.none; } ) { }; @@ -551616,7 +551616,7 @@ self: { weigh ]; description = "The SHA-256 and HMAC-SHA256 algorithms"; - license = lib.licensesSpdx."MIT"; + license = lib.meta.getLicenseFromSpdxId "MIT"; hydraPlatforms = lib.platforms.none; broken = true; } @@ -551667,7 +551667,7 @@ self: { weigh ]; description = "The SHA-512 and HMAC-SHA512 algorithms"; - license = lib.licensesSpdx."MIT"; + license = lib.meta.getLicenseFromSpdxId "MIT"; hydraPlatforms = lib.platforms.none; broken = true; } @@ -551982,7 +551982,7 @@ self: { ]; testToolDepends = [ hspec-discover ]; description = "Decentralized git pull request and code review flows"; - license = lib.licensesSpdx."BSD-3-Clause"; + license = lib.meta.getLicenseFromSpdxId "BSD-3-Clause"; hydraPlatforms = lib.platforms.none; broken = true; } @@ -552459,7 +552459,7 @@ self: { text ]; description = "A library for writing predicates and transformations over predicates in Haskell"; - license = lib.licensesSpdx."BSD-3-Clause"; + license = lib.meta.getLicenseFromSpdxId "BSD-3-Clause"; } ) { }; @@ -552910,7 +552910,7 @@ self: { template-haskell ]; description = "A Prelude"; - license = lib.licensesSpdx."BSD-2-Clause-Patent"; + license = lib.meta.getLicenseFromSpdxId "BSD-2-Clause-Patent"; } ) { }; @@ -553064,7 +553064,7 @@ self: { sha256 = "0c7k9w5bh8hk6hxd3ya4ih7x0vckr1slwfna4nr48q21n0svx308"; libraryHaskellDepends = [ base ]; description = "A redefinition of the Prelude's Enum class in order to render it safe"; - license = lib.licensesSpdx."BSD-3-Clause"; + license = lib.meta.getLicenseFromSpdxId "BSD-3-Clause"; } ) { }; @@ -553603,7 +553603,7 @@ self: { wl-pprint ]; description = "Pretty-printing library"; - license = lib.licensesSpdx."LGPL-3.0-only"; + license = lib.meta.getLicenseFromSpdxId "LGPL-3.0-only"; hydraPlatforms = lib.platforms.none; broken = true; } @@ -553794,7 +553794,7 @@ self: { ]; doHaddock = false; description = "Produce nice human-readable HTML"; - license = lib.licensesSpdx."MIT"; + license = lib.meta.getLicenseFromSpdxId "MIT"; hydraPlatforms = lib.platforms.none; broken = true; } @@ -554161,7 +554161,7 @@ self: { web-rep ]; description = "Pretty print charts from ghci"; - license = lib.licensesSpdx."BSD-3-Clause"; + license = lib.meta.getLicenseFromSpdxId "BSD-3-Clause"; mainProgram = "prettychart-watch"; } ) { }; @@ -554210,7 +554210,7 @@ self: { ]; testToolDepends = [ hspec-discover ]; description = "API for prettyprinting custom syntax trees (extracted from elm-format)"; - license = lib.licensesSpdx."BSD-3-Clause"; + license = lib.meta.getLicenseFromSpdxId "BSD-3-Clause"; hydraPlatforms = lib.platforms.none; broken = true; } @@ -554358,7 +554358,7 @@ self: { vector ]; description = "Some useful combinators for the prettyprinter package"; - license = lib.licensesSpdx."Apache-2.0"; + license = lib.meta.getLicenseFromSpdxId "Apache-2.0"; } ) { }; @@ -554490,7 +554490,7 @@ self: { text ]; description = "Configurable pretty-printing"; - license = lib.licensesSpdx."Apache-2.0"; + license = lib.meta.getLicenseFromSpdxId "Apache-2.0"; } ) { }; @@ -554551,7 +554551,7 @@ self: { text ]; description = "A prettyprinter backend for graphviz"; - license = lib.licensesSpdx."BSD-3-Clause"; + license = lib.meta.getLicenseFromSpdxId "BSD-3-Clause"; } ) { }; @@ -554588,7 +554588,7 @@ self: { text ]; description = "Efficient interpolation for Prettyprinter"; - license = lib.licensesSpdx."BSD-2-Clause"; + license = lib.meta.getLicenseFromSpdxId "BSD-2-Clause"; } ) { }; @@ -554613,7 +554613,7 @@ self: { text ]; description = "A prettyprinter backend for lucid"; - license = lib.licensesSpdx."BSD-3-Clause"; + license = lib.meta.getLicenseFromSpdxId "BSD-3-Clause"; } ) { }; @@ -554678,7 +554678,7 @@ self: { sha256 = "15igqxb77ycl9lfs1bl1l9x3cynsg4kqzkr54q46ly4l315bsrq4"; libraryHaskellDepends = [ ghc-prim ]; description = "An ergonomic but conservative interface to ghc-prim"; - license = lib.licensesSpdx."MIT"; + license = lib.meta.getLicenseFromSpdxId "MIT"; hydraPlatforms = lib.platforms.none; broken = true; } @@ -554733,7 +554733,7 @@ self: { quickcheck-classes ]; description = "Prim typeclass instances"; - license = lib.licensesSpdx."BSD-3-Clause"; + license = lib.meta.getLicenseFromSpdxId "BSD-3-Clause"; hydraPlatforms = lib.platforms.none; broken = true; } @@ -554989,7 +554989,7 @@ self: { tasty-bench ]; description = "Bindings to the primecount library"; - license = lib.licensesSpdx."BSD-3-Clause"; + license = lib.meta.getLicenseFromSpdxId "BSD-3-Clause"; } ) { inherit (pkgs) primecount; }; @@ -555136,7 +555136,7 @@ self: { primitive ]; description = "Addresses to unmanaged memory"; - license = lib.licensesSpdx."BSD-3-Clause"; + license = lib.meta.getLicenseFromSpdxId "BSD-3-Clause"; } ) { }; @@ -555162,7 +555162,7 @@ self: { primitive-unlifted ]; description = "Wrappers for primops around atomic operations"; - license = lib.licensesSpdx."BSD-3-Clause"; + license = lib.meta.getLicenseFromSpdxId "BSD-3-Clause"; } ) { }; @@ -555181,7 +555181,7 @@ self: { primitive ]; description = "primitive functions with bounds-checking"; - license = lib.licensesSpdx."BSD-3-Clause"; + license = lib.meta.getLicenseFromSpdxId "BSD-3-Clause"; hydraPlatforms = lib.platforms.none; broken = true; } @@ -555261,7 +555261,7 @@ self: { sha256 = "1xnyyw76kh42fy1b1wkc143bg3588gbp48990xdskcad1aj4fyan"; libraryHaskellDepends = [ primitive ]; description = "convenience class for PrimMonad m/PrimState m"; - license = lib.licensesSpdx."BSD-3-Clause"; + license = lib.meta.getLicenseFromSpdxId "BSD-3-Clause"; hydraPlatforms = lib.platforms.none; broken = true; } @@ -555316,7 +555316,7 @@ self: { tasty-quickcheck ]; description = "Extras for the \"primitive\" library"; - license = lib.licensesSpdx."MIT"; + license = lib.meta.getLicenseFromSpdxId "MIT"; } ) { }; @@ -555341,7 +555341,7 @@ self: { QuickCheck ]; description = "using the `Prim` interface for the FFI"; - license = lib.licensesSpdx."BSD-3-Clause"; + license = lib.meta.getLicenseFromSpdxId "BSD-3-Clause"; hydraPlatforms = lib.platforms.none; broken = true; } @@ -555424,7 +555424,7 @@ self: { primitive ]; description = "Types for offsets into unboxed arrays"; - license = lib.licensesSpdx."BSD-3-Clause"; + license = lib.meta.getLicenseFromSpdxId "BSD-3-Clause"; } ) { }; @@ -555443,7 +555443,7 @@ self: { primitive ]; description = "Unboxed variables for `Prim` values"; - license = lib.licensesSpdx."CC0-1.0"; + license = lib.meta.getLicenseFromSpdxId "CC0-1.0"; hydraPlatforms = lib.platforms.none; broken = true; } @@ -555466,7 +555466,7 @@ self: { cpu ]; description = "Serialisation of primitive types"; - license = lib.licensesSpdx."BSD-2-Clause"; + license = lib.meta.getLicenseFromSpdxId "BSD-2-Clause"; } ) { }; @@ -555522,7 +555522,7 @@ self: { primitive-unlifted ]; description = "Slices of primitive arrays"; - license = lib.licensesSpdx."BSD-3-Clause"; + license = lib.meta.getLicenseFromSpdxId "BSD-3-Clause"; hydraPlatforms = lib.platforms.none; broken = true; } @@ -555573,7 +555573,7 @@ self: { random ]; description = "Sort primitive arrays"; - license = lib.licensesSpdx."BSD-3-Clause"; + license = lib.meta.getLicenseFromSpdxId "BSD-3-Clause"; } ) { }; @@ -555592,7 +555592,7 @@ self: { primitive ]; description = "primitive operations on StableNames"; - license = lib.licensesSpdx."BSD-3-Clause"; + license = lib.meta.getLicenseFromSpdxId "BSD-3-Clause"; hydraPlatforms = lib.platforms.none; broken = true; } @@ -555619,7 +555619,7 @@ self: { primitive ]; description = "Unaligned access to primitive arrays"; - license = lib.licensesSpdx."BSD-3-Clause"; + license = lib.meta.getLicenseFromSpdxId "BSD-3-Clause"; } ) { }; @@ -555658,7 +555658,7 @@ self: { tasty-quickcheck ]; description = "Primitive GHC types with unlifted types inside"; - license = lib.licensesSpdx."BSD-3-Clause"; + license = lib.meta.getLicenseFromSpdxId "BSD-3-Clause"; } ) { }; @@ -556220,7 +556220,7 @@ self: { ]; doHaddock = false; description = "Abstract syntax for writing documents"; - license = lib.licensesSpdx."MPL-2.0"; + license = lib.meta.getLicenseFromSpdxId "MPL-2.0"; hydraPlatforms = lib.platforms.none; broken = true; } @@ -556268,7 +556268,7 @@ self: { vector ]; description = "Utilities for tracking source locations"; - license = lib.licensesSpdx."MPL-2.0"; + license = lib.meta.getLicenseFromSpdxId "MPL-2.0"; hydraPlatforms = lib.platforms.none; broken = true; } @@ -556296,7 +556296,7 @@ self: { hspec ]; description = "Discrete probability monad"; - license = lib.licensesSpdx."BSD-3-Clause"; + license = lib.meta.getLicenseFromSpdxId "BSD-3-Clause"; } ) { }; @@ -556358,7 +556358,7 @@ self: { lens ]; description = "A library for modular probabilistic modelling"; - license = lib.licensesSpdx."BSD-3-Clause"; + license = lib.meta.getLicenseFromSpdxId "BSD-3-Clause"; hydraPlatforms = lib.platforms.none; mainProgram = "prob-fx"; broken = true; @@ -556430,7 +556430,7 @@ self: { deepseq ]; description = "Probability distributions via piecewise polynomials"; - license = lib.licensesSpdx."BSD-3-Clause"; + license = lib.meta.getLicenseFromSpdxId "BSD-3-Clause"; } ) { }; @@ -556560,7 +556560,7 @@ self: { unix ]; description = "Process libraries"; - license = lib.licensesSpdx."BSD-3-Clause"; + license = lib.meta.getLicenseFromSpdxId "BSD-3-Clause"; hydraPlatforms = lib.platforms.none; } ) { }; @@ -557040,7 +557040,7 @@ self: { process ]; description = "C bindings for the gnu-extension functions process_vm_readv and process_vm_writev"; - license = lib.licensesSpdx."BSD-3-Clause"; + license = lib.meta.getLicenseFromSpdxId "BSD-3-Clause"; hydraPlatforms = lib.platforms.none; broken = true; } @@ -557110,7 +557110,7 @@ self: { unix ]; description = "Ergonomic process launching with extreme flexibility and speed"; - license = lib.licensesSpdx."MIT"; + license = lib.meta.getLicenseFromSpdxId "MIT"; hydraPlatforms = lib.platforms.none; broken = true; } @@ -557510,7 +557510,7 @@ self: { optparse-applicative ]; description = "Generate flamegraphs from ghc RTS .prof files"; - license = lib.licensesSpdx."MIT"; + license = lib.meta.getLicenseFromSpdxId "MIT"; hydraPlatforms = lib.platforms.none; mainProgram = "prof-flamegraph"; broken = true; @@ -558084,7 +558084,7 @@ self: { tasty-hunit ]; description = "A project initialization library"; - license = lib.licensesSpdx."BSD-3-Clause"; + license = lib.meta.getLicenseFromSpdxId "BSD-3-Clause"; hydraPlatforms = lib.platforms.none; broken = true; } @@ -558443,7 +558443,7 @@ self: { ]; doHaddock = false; description = "Relational Algebra Engine"; - license = lib.licensesSpdx."MIT"; + license = lib.meta.getLicenseFromSpdxId "MIT"; hydraPlatforms = lib.platforms.none; } ) { }; @@ -558614,7 +558614,7 @@ self: { inspection-testing ]; description = "Profunctor-based lightweight implementation of optics"; - license = lib.licensesSpdx."MPL-2.0"; + license = lib.meta.getLicenseFromSpdxId "MPL-2.0"; hydraPlatforms = lib.platforms.none; broken = true; } @@ -559195,7 +559195,7 @@ self: { warp ]; description = "Instrument a wai application with various metrics"; - license = lib.licensesSpdx."BSD-3-Clause"; + license = lib.meta.getLicenseFromSpdxId "BSD-3-Clause"; hydraPlatforms = lib.platforms.none; mainProgram = "prometheus-wai-middleware-example"; broken = true; @@ -559288,7 +559288,7 @@ self: { text ]; description = "A user-friendly, dependently-typed library for asking your users questions"; - license = lib.licensesSpdx."BSD-3-Clause"; + license = lib.meta.getLicenseFromSpdxId "BSD-3-Clause"; } ) { }; @@ -559311,7 +559311,7 @@ self: { text ]; description = "A user-friendly, dependently-typed library for asking your users questions"; - license = lib.licensesSpdx."BSD-3-Clause"; + license = lib.meta.getLicenseFromSpdxId "BSD-3-Clause"; hydraPlatforms = lib.platforms.none; } ) { }; @@ -559394,7 +559394,7 @@ self: { ]; executableHaskellDepends = [ base ]; description = "Telegram bot for proof assistants"; - license = lib.licensesSpdx."MIT"; + license = lib.meta.getLicenseFromSpdxId "MIT"; hydraPlatforms = lib.platforms.none; mainProgram = "proof-assistant-bot"; broken = true; @@ -559499,7 +559499,7 @@ self: { containers ]; description = "A Propagator Library"; - license = lib.licensesSpdx."BSD-3-Clause"; + license = lib.meta.getLicenseFromSpdxId "BSD-3-Clause"; hydraPlatforms = lib.platforms.none; broken = true; } @@ -559688,7 +559688,7 @@ self: { ]; testToolDepends = [ hspec-discover ]; description = "A library for tests, based on transforming and writing properties"; - license = lib.licensesSpdx."BSD-3-Clause"; + license = lib.meta.getLicenseFromSpdxId "BSD-3-Clause"; } ) { }; @@ -559764,7 +559764,7 @@ self: { tasty-quickcheck ]; description = "Proquints: Identifiers that are Readable, Spellable, and Pronounceable"; - license = lib.licensesSpdx."EUPL-1.2"; + license = lib.meta.getLicenseFromSpdxId "EUPL-1.2"; } ) { }; @@ -559837,7 +559837,7 @@ self: { text ]; description = "A simple language for writing documents"; - license = lib.licensesSpdx."MPL-2.0"; + license = lib.meta.getLicenseFromSpdxId "MPL-2.0"; hydraPlatforms = lib.platforms.none; broken = true; } @@ -559874,7 +559874,7 @@ self: { unordered-containers ]; description = "A DSL for processing Prosidy documents"; - license = lib.licensesSpdx."MPL-2.0"; + license = lib.meta.getLicenseFromSpdxId "MPL-2.0"; hydraPlatforms = lib.platforms.none; } ) { }; @@ -559988,7 +559988,7 @@ self: { ]; libraryToolDepends = [ c2hs ]; description = "Simple audio library for Windows, Linux, OSX"; - license = lib.licensesSpdx."BSD-3-Clause"; + license = lib.meta.getLicenseFromSpdxId "BSD-3-Clause"; hydraPlatforms = lib.platforms.none; broken = true; } @@ -560023,7 +560023,7 @@ self: { libraryPkgconfigDepends = [ SDL2 ]; libraryToolDepends = [ c2hs ]; description = "Simple audio library for SDL"; - license = lib.licensesSpdx."BSD-3-Clause"; + license = lib.meta.getLicenseFromSpdxId "BSD-3-Clause"; hydraPlatforms = lib.platforms.none; broken = true; } @@ -560110,7 +560110,7 @@ self: { prelate ]; description = "Neovim Project Manager"; - license = lib.licensesSpdx."BSD-2-Clause-Patent"; + license = lib.meta.getLicenseFromSpdxId "BSD-2-Clause-Patent"; hydraPlatforms = lib.platforms.none; mainProgram = "proteome"; broken = true; @@ -560311,7 +560311,7 @@ self: { ]; libraryToolDepends = [ proto-lens-protoc ]; description = "proto-lens-etcd - protobuffer lenses for etcd provided by protoc-lens-protoc"; - license = lib.licensesSpdx."Apache-2.0"; + license = lib.meta.getLicenseFromSpdxId "Apache-2.0"; hydraPlatforms = lib.platforms.none; broken = true; } @@ -560344,7 +560344,7 @@ self: { vector ]; description = "JSON protobuf encoding for proto-lens"; - license = lib.licensesSpdx."BSD-3-Clause"; + license = lib.meta.getLicenseFromSpdxId "BSD-3-Clause"; hydraPlatforms = lib.platforms.none; broken = true; } @@ -560682,7 +560682,7 @@ self: { vector ]; description = "A higher-level API to the proto3-wire library"; - license = lib.licensesSpdx."Apache-2.0"; + license = lib.meta.getLicenseFromSpdxId "Apache-2.0"; maintainers = [ lib.maintainers.alexfmpe ]; } ) { }; @@ -560852,7 +560852,7 @@ self: { zigzag ]; description = "Slow protobuf implementation"; - license = lib.licensesSpdx."BSD-3-Clause"; + license = lib.meta.getLicenseFromSpdxId "BSD-3-Clause"; } ) { }; @@ -561487,7 +561487,7 @@ self: { vinyl ]; description = "Lightweight dependency injection / namespaced+typed implicit-ish arguments"; - license = lib.licensesSpdx."BSD-3-Clause"; + license = lib.meta.getLicenseFromSpdxId "BSD-3-Clause"; } ) { }; @@ -561639,7 +561639,7 @@ self: { yaml ]; description = "Prune unused Haskell dependencies"; - license = lib.licensesSpdx."MIT"; + license = lib.meta.getLicenseFromSpdxId "MIT"; hydraPlatforms = lib.platforms.none; mainProgram = "prune-juice"; broken = true; @@ -561913,7 +561913,7 @@ self: { vector ]; description = "PostgreSQL client"; - license = lib.licensesSpdx."BSD-3-Clause"; + license = lib.meta.getLicenseFromSpdxId "BSD-3-Clause"; hydraPlatforms = lib.platforms.none; } ) { }; @@ -562061,7 +562061,7 @@ self: { tasty-hunit ]; description = "Integrate libpsx with the GHC RTS"; - license = lib.licensesSpdx."BSD-3-Clause"; + license = lib.meta.getLicenseFromSpdxId "BSD-3-Clause"; hydraPlatforms = lib.platforms.none; broken = true; } @@ -562315,7 +562315,7 @@ self: { rerebase ]; description = "Experimental abstractions for operations on pointers"; - license = lib.licensesSpdx."MIT"; + license = lib.meta.getLicenseFromSpdxId "MIT"; } ) { }; @@ -562365,7 +562365,7 @@ self: { tasty-hunit ]; description = "High-performance composable binary data deserializers"; - license = lib.licensesSpdx."MIT"; + license = lib.meta.getLicenseFromSpdxId "MIT"; } ) { }; @@ -562407,7 +562407,7 @@ self: { rerebase ]; description = "Pointer poking action construction and composition toolkit"; - license = lib.licensesSpdx."MIT"; + license = lib.meta.getLicenseFromSpdxId "MIT"; } ) { }; @@ -562468,7 +562468,7 @@ self: { safe-exceptions ]; description = "pty-mcp-server"; - license = lib.licensesSpdx."Apache-2.0"; + license = lib.meta.getLicenseFromSpdxId "Apache-2.0"; hydraPlatforms = lib.platforms.none; mainProgram = "pty-mcp-server"; } @@ -563476,7 +563476,7 @@ self: { vector ]; description = "High-performance composable noise generation (Perlin, Simplex, Cellular)"; - license = lib.licensesSpdx."BSD-3-Clause"; + license = lib.meta.getLicenseFromSpdxId "BSD-3-Clause"; } ) { }; @@ -563591,7 +563591,7 @@ self: { ]; testToolDepends = [ hspec-discover ]; description = "Derive fromString/toString-like for pure sum types"; - license = lib.licensesSpdx."ISC"; + license = lib.meta.getLicenseFromSpdxId "ISC"; } ) { }; @@ -563627,7 +563627,7 @@ self: { ]; testToolDepends = [ hspec-discover ]; description = "Derive fromString/toString-like for pure sum types (aeson instances)"; - license = lib.licensesSpdx."ISC"; + license = lib.meta.getLicenseFromSpdxId "ISC"; } ) { }; @@ -563808,7 +563808,7 @@ self: { time ]; description = "types and parser for email messages (including MIME)"; - license = lib.licensesSpdx."AGPL-3.0-or-later"; + license = lib.meta.getLicenseFromSpdxId "AGPL-3.0-or-later"; maintainers = [ lib.maintainers.maralorn ]; } ) { }; @@ -563841,7 +563841,7 @@ self: { ]; testToolDepends = [ hspec-discover ]; description = "Bidirectional Haskell/PureScript expression translator"; - license = lib.licensesSpdx."Apache-2.0"; + license = lib.meta.getLicenseFromSpdxId "Apache-2.0"; } ) { }; @@ -563881,7 +563881,7 @@ self: { ]; executableHaskellDepends = [ base ]; description = "Nix backend for PureScript. Transpile PureScript code to Nix."; - license = lib.licensesSpdx."BSD-3-Clause"; + license = lib.meta.getLicenseFromSpdxId "BSD-3-Clause"; mainProgram = "purenix"; } ) { }; @@ -563926,7 +563926,7 @@ self: { ]; doHaddock = false; description = "Pure Haskell SAT-solver"; - license = lib.licensesSpdx."BSD-3-Clause"; + license = lib.meta.getLicenseFromSpdxId "BSD-3-Clause"; } ) { }; @@ -564253,7 +564253,7 @@ self: { ]; doCheck = false; description = "PureScript Programming Language Compiler"; - license = lib.licensesSpdx."BSD-3-Clause"; + license = lib.meta.getLicenseFromSpdxId "BSD-3-Clause"; mainProgram = "purs"; } ) { }; @@ -564297,7 +564297,7 @@ self: { vector ]; description = "PureScript Programming Language Abstract Syntax Tree"; - license = lib.licensesSpdx."BSD-3-Clause"; + license = lib.meta.getLicenseFromSpdxId "BSD-3-Clause"; hydraPlatforms = lib.platforms.none; broken = true; } @@ -564424,7 +564424,7 @@ self: { ]; libraryToolDepends = [ happy ]; description = "PureScript Programming Language Concrete Syntax Tree"; - license = lib.licensesSpdx."BSD-3-Clause"; + license = lib.meta.getLicenseFromSpdxId "BSD-3-Clause"; hydraPlatforms = lib.platforms.none; broken = true; } @@ -564612,7 +564612,7 @@ self: { text ]; description = "Support for purl (mostly universal package url)"; - license = lib.licensesSpdx."BSD-3-Clause"; + license = lib.meta.getLicenseFromSpdxId "BSD-3-Clause"; } ) { }; @@ -565694,7 +565694,7 @@ self: { vector-stream ]; description = "Fast persistent vectors"; - license = lib.licensesSpdx."BSD-3-Clause"; + license = lib.meta.getLicenseFromSpdxId "BSD-3-Clause"; hydraPlatforms = lib.platforms.none; broken = true; } @@ -565994,7 +565994,7 @@ self: { test-framework-hunit ]; description = "Serialization/deserialization using Python Pickle format"; - license = lib.licensesSpdx."BSD-3-Clause"; + license = lib.meta.getLicenseFromSpdxId "BSD-3-Clause"; hydraPlatforms = lib.platforms.none; mainProgram = "pickle"; broken = true; @@ -566083,7 +566083,7 @@ self: { tasty-silver ]; description = "Types and prettyprinter for the IL of the QBE compiler backend"; - license = lib.licensesSpdx."BSD-3-Clause"; + license = lib.meta.getLicenseFromSpdxId "BSD-3-Clause"; hydraPlatforms = lib.platforms.none; broken = true; } @@ -566284,7 +566284,7 @@ self: { ]; doHaddock = false; description = "Command line tool qhs, SQL queries on CSV and TSV files"; - license = lib.licensesSpdx."MIT"; + license = lib.meta.getLicenseFromSpdxId "MIT"; hydraPlatforms = lib.platforms.none; mainProgram = "qhs"; broken = true; @@ -566462,7 +566462,7 @@ self: { template-haskell ]; description = "Typesafe library for linear algebra"; - license = lib.licensesSpdx."BSD-3-Clause"; + license = lib.meta.getLicenseFromSpdxId "BSD-3-Clause"; hydraPlatforms = lib.platforms.none; broken = true; } @@ -566610,7 +566610,7 @@ self: { ]; testToolDepends = [ tasty-discover ]; description = "QuasiQuoter for byte sequence"; - license = lib.licensesSpdx."Apache-2.0"; + license = lib.meta.getLicenseFromSpdxId "Apache-2.0"; } ) { }; @@ -567174,7 +567174,7 @@ self: { editedCabalFile = "0pqi04fvyclnx4lfq8ifax6l4kayay6xbmwp0k0h7yjz14k252gn"; libraryHaskellDepends = [ base ]; description = "Extremely minimal prelude"; - license = lib.licensesSpdx."Apache-2.0"; + license = lib.meta.getLicenseFromSpdxId "Apache-2.0"; } ) { }; @@ -567274,7 +567274,7 @@ self: { text ]; description = "GHC plugin to automatically insert qualified imports"; - license = lib.licensesSpdx."BSD-3-Clause"; + license = lib.meta.getLicenseFromSpdxId "BSD-3-Clause"; hydraPlatforms = lib.platforms.none; broken = true; } @@ -567386,7 +567386,7 @@ self: { unordered-containers ]; description = "Rage against the quantification"; - license = lib.licensesSpdx."BSD-3-Clause"; + license = lib.meta.getLicenseFromSpdxId "BSD-3-Clause"; hydraPlatforms = lib.platforms.none; broken = true; } @@ -567415,7 +567415,7 @@ self: { vector ]; description = "Rage against the quantification - integration with Aeson"; - license = lib.licensesSpdx."BSD-3-Clause"; + license = lib.meta.getLicenseFromSpdxId "BSD-3-Clause"; hydraPlatforms = lib.platforms.none; } ) { }; @@ -568100,7 +568100,7 @@ self: { tasty-hunit ]; description = "queue sheet utility"; - license = lib.licensesSpdx."MIT"; + license = lib.meta.getLicenseFromSpdxId "MIT"; mainProgram = "queue-sheet"; } ) { }; @@ -568157,7 +568157,7 @@ self: { tasty-bench ]; description = "Queue data structures"; - license = lib.licensesSpdx."BSD-3-Clause"; + license = lib.meta.getLicenseFromSpdxId "BSD-3-Clause"; } ) { }; @@ -568201,7 +568201,7 @@ self: { tasty-hunit ]; description = "Convenient SQL query language for Haskell (but only for single tables)"; - license = lib.licensesSpdx."BSD-3-Clause"; + license = lib.meta.getLicenseFromSpdxId "BSD-3-Clause"; hydraPlatforms = lib.platforms.none; broken = true; } @@ -568338,7 +568338,7 @@ self: { text ]; description = "Quick-start wrappers for QUIC"; - license = lib.licensesSpdx."BSD-3-Clause"; + license = lib.meta.getLicenseFromSpdxId "BSD-3-Clause"; hydraPlatforms = lib.platforms.none; } ) { }; @@ -568509,7 +568509,7 @@ self: { testToolDepends = [ tasty-discover ]; doHaddock = false; description = "Run external processes verified at compilation/installation"; - license = lib.licensesSpdx."BSD-3-Clause"; + license = lib.meta.getLicenseFromSpdxId "BSD-3-Clause"; hydraPlatforms = lib.platforms.none; } ) { }; @@ -568798,7 +568798,7 @@ self: { vector ]; description = "QuickCheck common typeclasses"; - license = lib.licensesSpdx."BSD-3-Clause"; + license = lib.meta.getLicenseFromSpdxId "BSD-3-Clause"; } ) { }; @@ -568823,7 +568823,7 @@ self: { transformers ]; description = "QuickCheck common typeclasses from `base`"; - license = lib.licensesSpdx."BSD-3-Clause"; + license = lib.meta.getLicenseFromSpdxId "BSD-3-Clause"; } ) { }; @@ -568885,7 +568885,7 @@ self: { tasty-quickcheck ]; description = "A library for stateful property-based testing"; - license = lib.licensesSpdx."Apache-2.0"; + license = lib.meta.getLicenseFromSpdxId "Apache-2.0"; } ) { }; @@ -568929,7 +568929,7 @@ self: { splitmix ]; description = "Extra utilities for QuickCheck"; - license = lib.licensesSpdx."MIT"; + license = lib.meta.getLicenseFromSpdxId "MIT"; } ) { }; @@ -568967,7 +568967,7 @@ self: { testToolDepends = [ hspec-discover ]; doHaddock = false; description = "Testing group class instances with QuickCheck"; - license = lib.licensesSpdx."Apache-2.0"; + license = lib.meta.getLicenseFromSpdxId "Apache-2.0"; } ) { }; @@ -569075,7 +569075,7 @@ self: { QuickCheck ]; description = "Common quickcheck instances"; - license = lib.licensesSpdx."BSD-3-Clause"; + license = lib.meta.getLicenseFromSpdxId "BSD-3-Clause"; } ) { }; @@ -569146,7 +569146,7 @@ self: { QuickCheck ]; description = "Common quickcheck instances"; - license = lib.licensesSpdx."BSD-3-Clause"; + license = lib.meta.getLicenseFromSpdxId "BSD-3-Clause"; hydraPlatforms = lib.platforms.none; } ) { }; @@ -569217,7 +569217,7 @@ self: { temporary ]; description = "Library for lockstep-style testing with 'quickcheck-dynamic'"; - license = lib.licensesSpdx."BSD-3-Clause"; + license = lib.meta.getLicenseFromSpdxId "BSD-3-Clause"; } ) { }; @@ -569266,7 +569266,7 @@ self: { testToolDepends = [ hspec-discover ]; doHaddock = false; description = "Testing monoid subclass instances with QuickCheck"; - license = lib.licensesSpdx."Apache-2.0"; + license = lib.meta.getLicenseFromSpdxId "Apache-2.0"; } ) { }; @@ -569404,7 +569404,7 @@ self: { testToolDepends = [ hspec-discover ]; doHaddock = false; description = "Quasi-unique identifiers for QuickCheck"; - license = lib.licensesSpdx."Apache-2.0"; + license = lib.meta.getLicenseFromSpdxId "Apache-2.0"; } ) { }; @@ -569714,7 +569714,7 @@ self: { ]; doHaddock = false; description = "Test monadic programs using state machine based models"; - license = lib.licensesSpdx."BSD-3-Clause"; + license = lib.meta.getLicenseFromSpdxId "BSD-3-Clause"; hydraPlatforms = lib.platforms.none; broken = true; } @@ -569863,7 +569863,7 @@ self: { transformers ]; description = "A GenT monad transformer for QuickCheck library"; - license = lib.licensesSpdx."MIT"; + license = lib.meta.getLicenseFromSpdxId "MIT"; maintainers = [ lib.maintainers.thielema ]; } ) { }; @@ -571205,7 +571205,7 @@ self: { th-compat ]; description = "Monad transformer for Quote from template-haskell"; - license = lib.licensesSpdx."CC0-1.0"; + license = lib.meta.getLicenseFromSpdxId "CC0-1.0"; hydraPlatforms = lib.platforms.none; broken = true; } @@ -571319,7 +571319,7 @@ self: { weigh ]; description = "R-/R*-trees"; - license = lib.licensesSpdx."MIT"; + license = lib.meta.getLicenseFromSpdxId "MIT"; } ) { }; @@ -571950,7 +571950,7 @@ self: { validation ]; description = "A railway oriented mini-DSL for unified error handling"; - license = lib.licensesSpdx."BSD-3-Clause"; + license = lib.meta.getLicenseFromSpdxId "BSD-3-Clause"; } ) { }; @@ -572370,7 +572370,7 @@ self: { vector ]; description = "Random access lists"; - license = lib.licensesSpdx."GPL-2.0-or-later"; + license = lib.meta.getLicenseFromSpdxId "GPL-2.0-or-later"; } ) { }; @@ -572397,7 +572397,7 @@ self: { ral ]; description = "Length-indexed random access lists: lens utilities"; - license = lib.licensesSpdx."GPL-2.0-or-later"; + license = lib.meta.getLicenseFromSpdxId "GPL-2.0-or-later"; } ) { }; @@ -572424,7 +572424,7 @@ self: { ral ]; description = "Length-indexed random access lists: optics utilities"; - license = lib.licensesSpdx."GPL-2.0-or-later"; + license = lib.meta.getLicenseFromSpdxId "GPL-2.0-or-later"; } ) { }; @@ -572458,7 +572458,7 @@ self: { deepseq ]; description = "Random access list with a list compatible interface"; - license = lib.licensesSpdx."BSD-3-Clause"; + license = lib.meta.getLicenseFromSpdxId "BSD-3-Clause"; hydraPlatforms = lib.platforms.none; broken = true; } @@ -572512,7 +572512,7 @@ self: { tasty ]; description = "memory and related abstraction stuff"; - license = lib.licensesSpdx."BSD-3-Clause"; + license = lib.meta.getLicenseFromSpdxId "BSD-3-Clause"; } ) { }; @@ -572561,7 +572561,7 @@ self: { hspec ]; description = "Determine how intervals relate to each other"; - license = lib.licensesSpdx."MIT"; + license = lib.meta.getLicenseFromSpdxId "MIT"; } ) { }; @@ -572996,7 +572996,7 @@ self: { vector ]; description = "Uniform draws of partitions and cycle-partitions, with thinning"; - license = lib.licensesSpdx."GPL-3.0-or-later"; + license = lib.meta.getLicenseFromSpdxId "GPL-3.0-or-later"; hydraPlatforms = lib.platforms.none; broken = true; } @@ -573641,7 +573641,7 @@ self: { tasty-quickcheck ]; description = "Memory efficient sets with ranges of elements"; - license = lib.licensesSpdx."MIT"; + license = lib.meta.getLicenseFromSpdxId "MIT"; } ) { }; @@ -573793,7 +573793,7 @@ self: { random-shuffle ]; description = "Efficient sets for semi-contiguous data"; - license = lib.licensesSpdx."BSD-3-Clause"; + license = lib.meta.getLicenseFromSpdxId "BSD-3-Clause"; } ) { }; @@ -573862,7 +573862,7 @@ self: { tasty-hunit ]; description = "Like Data.Dynamic/Data.Typeable but with support for rank-1 polymorphic types"; - license = lib.licensesSpdx."BSD-3-Clause"; + license = lib.meta.getLicenseFromSpdxId "BSD-3-Clause"; } ) { }; @@ -574584,7 +574584,7 @@ self: { hspec ]; description = "Notify Honeybadger about exceptions"; - license = lib.licensesSpdx."MIT"; + license = lib.meta.getLicenseFromSpdxId "MIT"; } ) { }; @@ -574613,7 +574613,7 @@ self: { wai ]; description = "Notify Honeybadger about exceptions via a WAI middleware"; - license = lib.licensesSpdx."MIT"; + license = lib.meta.getLicenseFromSpdxId "MIT"; } ) { }; @@ -574938,7 +574938,7 @@ self: { filepath ]; description = "Parse and generate Rocket League replays"; - license = lib.licensesSpdx."MIT"; + license = lib.meta.getLicenseFromSpdxId "MIT"; hydraPlatforms = lib.platforms.none; mainProgram = "rattletrap"; broken = true; @@ -575157,7 +575157,7 @@ self: { tasty-quickcheck ]; description = "A writer-biased RAW lock"; - license = lib.licensesSpdx."Apache-2.0"; + license = lib.meta.getLicenseFromSpdxId "Apache-2.0"; hydraPlatforms = lib.platforms.none; broken = true; } @@ -575248,7 +575248,7 @@ self: { h-raylib ]; description = "Haskell bindings for rlImGui"; - license = lib.licensesSpdx."Apache-2.0"; + license = lib.meta.getLicenseFromSpdxId "Apache-2.0"; hydraPlatforms = lib.platforms.none; broken = true; } @@ -575290,7 +575290,7 @@ self: { random ]; description = "Ray tracing library"; - license = lib.licensesSpdx."BSD-3-Clause"; + license = lib.meta.getLicenseFromSpdxId "BSD-3-Clause"; hydraPlatforms = lib.platforms.none; broken = true; } @@ -575790,7 +575790,7 @@ self: { text ]; description = "The ActivityStreams 2 RDF vocabulary for rdf4h"; - license = lib.licensesSpdx."BSD-3-Clause"; + license = lib.meta.getLicenseFromSpdxId "BSD-3-Clause"; } ) { }; @@ -575918,7 +575918,7 @@ self: { testToolDepends = [ tasty-discover ]; doHaddock = false; description = "Codecs for use with AWS rds-data"; - license = lib.licensesSpdx."BSD-3-Clause"; + license = lib.meta.getLicenseFromSpdxId "BSD-3-Clause"; hydraPlatforms = lib.platforms.none; broken = true; } @@ -576014,7 +576014,7 @@ self: { tasty-discover ]; description = "Codecs for use with AWS rds-data"; - license = lib.licensesSpdx."BSD-3-Clause"; + license = lib.meta.getLicenseFromSpdxId "BSD-3-Clause"; hydraPlatforms = lib.platforms.none; mainProgram = "rds-data-codecs"; broken = true; @@ -576147,7 +576147,7 @@ self: { testToolDepends = [ tasty-discover ]; doHaddock = false; description = "Codecs for use with AWS rds-data"; - license = lib.licensesSpdx."BSD-3-Clause"; + license = lib.meta.getLicenseFromSpdxId "BSD-3-Clause"; hydraPlatforms = lib.platforms.none; mainProgram = "rds-data"; } @@ -576232,7 +576232,7 @@ self: { text ]; description = "Create React components in Haskell"; - license = lib.licensesSpdx."BSD-3-Clause"; + license = lib.meta.getLicenseFromSpdxId "BSD-3-Clause"; hydraPlatforms = lib.platforms.none; broken = true; } @@ -577091,7 +577091,7 @@ self: { sha256 = "0b2syhxan3fpf9h1zq3izpb8bgsl4qrk975afy3r2ji6dhjq81cl"; libraryHaskellDepends = [ base ]; description = "Class for reading bounded values"; - license = lib.licensesSpdx."BSD-3-Clause"; + license = lib.meta.getLicenseFromSpdxId "BSD-3-Clause"; hydraPlatforms = lib.platforms.none; broken = true; } @@ -577446,7 +577446,7 @@ self: { mtl ]; description = "Readline effect for in-other-words"; - license = lib.licensesSpdx."BSD-2-Clause"; + license = lib.meta.getLicenseFromSpdxId "BSD-2-Clause"; hydraPlatforms = lib.platforms.none; mainProgram = "echo-repl"; } @@ -577520,7 +577520,7 @@ self: { numhask ]; description = "Literate programming support"; - license = lib.licensesSpdx."BSD-3-Clause"; + license = lib.meta.getLicenseFromSpdxId "BSD-3-Clause"; hydraPlatforms = lib.platforms.none; mainProgram = "readme-lhs-example"; broken = true; @@ -577646,7 +577646,7 @@ self: { QuickCheck ]; description = "Random number generation based on physical media touched by humans"; - license = lib.licensesSpdx."MIT"; + license = lib.meta.getLicenseFromSpdxId "MIT"; mainProgram = "real-dice"; } ) { }; @@ -577891,7 +577891,7 @@ self: { vector ]; description = "SVG file loader and serializer"; - license = lib.licensesSpdx."BSD-3-Clause"; + license = lib.meta.getLicenseFromSpdxId "BSD-3-Clause"; maintainers = [ lib.maintainers.Ai-Ya-Ya ]; } ) { }; @@ -578057,7 +578057,7 @@ self: { void ]; description = "A more progressive alternative to the \"base\" package"; - license = lib.licensesSpdx."MIT"; + license = lib.meta.getLicenseFromSpdxId "MIT"; } ) { }; @@ -578126,7 +578126,7 @@ self: { void ]; description = "A more progressive alternative to the \"base\" package"; - license = lib.licensesSpdx."MIT"; + license = lib.meta.getLicenseFromSpdxId "MIT"; hydraPlatforms = lib.platforms.none; } ) { }; @@ -578189,7 +578189,7 @@ self: { tasty-quickcheck ]; description = "A variable binding library based on well-scoped de Bruijn indices"; - license = lib.licensesSpdx."MIT"; + license = lib.meta.getLicenseFromSpdxId "MIT"; hydraPlatforms = lib.platforms.none; broken = true; } @@ -578232,7 +578232,7 @@ self: { template-haskell ]; description = "Recursively defined values"; - license = lib.licensesSpdx."BSD-2-Clause"; + license = lib.meta.getLicenseFromSpdxId "BSD-2-Clause"; maintainers = [ lib.maintainers.nomeata ]; } ) { }; @@ -578332,7 +578332,7 @@ self: { vector ]; description = "Recommendations using alternating least squares algorithm"; - license = lib.licensesSpdx."BSD-3-Clause"; + license = lib.meta.getLicenseFromSpdxId "BSD-3-Clause"; mainProgram = "movielens"; } ) { }; @@ -578842,7 +578842,7 @@ self: { vector ]; description = "Recover run-time type information from the GHC heap"; - license = lib.licensesSpdx."BSD-3-Clause"; + license = lib.meta.getLicenseFromSpdxId "BSD-3-Clause"; } ) { }; @@ -578902,7 +578902,7 @@ self: { vector ]; description = "Recover run-time type information from the GHC heap"; - license = lib.licensesSpdx."BSD-3-Clause"; + license = lib.meta.getLicenseFromSpdxId "BSD-3-Clause"; hydraPlatforms = lib.platforms.none; } ) { }; @@ -579227,7 +579227,7 @@ self: { ]; doHaddock = false; description = "Extensible records and variants indexed by a type-level Red-Black tree"; - license = lib.licensesSpdx."BSD-3-Clause"; + license = lib.meta.getLicenseFromSpdxId "BSD-3-Clause"; } ) { }; @@ -579362,7 +579362,7 @@ self: { unliftio ]; description = "hide secret text on the terminal"; - license = lib.licensesSpdx."MIT"; + license = lib.meta.getLicenseFromSpdxId "MIT"; mainProgram = "redact"; } ) { }; @@ -579540,7 +579540,7 @@ self: { QuickCheck ]; description = "Specify valid redis globs"; - license = lib.licensesSpdx."BSD-3-Clause"; + license = lib.meta.getLicenseFromSpdxId "BSD-3-Clause"; } ) { }; @@ -580043,7 +580043,7 @@ self: { yaml ]; description = "Static analysis tool for Rust embedded systems complexity"; - license = lib.licensesSpdx."BSD-3-Clause"; + license = lib.meta.getLicenseFromSpdxId "BSD-3-Clause"; mainProgram = "reduxwise-exe"; } ) { }; @@ -580382,7 +580382,7 @@ self: { linear-base ]; description = "A reference counting library to alias linear resources"; - license = lib.licensesSpdx."BSD-3-Clause"; + license = lib.meta.getLicenseFromSpdxId "BSD-3-Clause"; hydraPlatforms = lib.platforms.none; broken = true; } @@ -580517,7 +580517,7 @@ self: { QuickCheck ]; description = "Refinement types with static and runtime checking"; - license = lib.licensesSpdx."MIT"; + license = lib.meta.getLicenseFromSpdxId "MIT"; maintainers = [ lib.maintainers.raehik ]; } ) { }; @@ -580557,7 +580557,7 @@ self: { unordered-containers ]; description = "Type-checked proof that a key exists in a container and can be safely indexed"; - license = lib.licensesSpdx."MIT"; + license = lib.meta.getLicenseFromSpdxId "MIT"; } ) { }; @@ -581112,7 +581112,7 @@ self: { text ]; description = "ClasshSS defined element builders for Reflex"; - license = lib.licensesSpdx."MIT"; + license = lib.meta.getLicenseFromSpdxId "MIT"; hydraPlatforms = lib.platforms.none; } ) { }; @@ -581522,7 +581522,7 @@ self: { text ]; description = "Compatible highlevel Wigdets for some Ionic Input Components"; - license = lib.licensesSpdx."BSD-3-Clause"; + license = lib.meta.getLicenseFromSpdxId "BSD-3-Clause"; } ) { }; @@ -581573,7 +581573,7 @@ self: { time ]; description = "Render Pandoc documents to HTML using reflex-dom"; - license = lib.licensesSpdx."BSD-3-Clause"; + license = lib.meta.getLicenseFromSpdxId "BSD-3-Clause"; hydraPlatforms = lib.platforms.none; broken = true; } @@ -581690,7 +581690,7 @@ self: { tasty-hspec ]; description = "reflex-dom-th transpiles HTML templates to haskell code for reflex-dom"; - license = lib.licensesSpdx."BSD-3-Clause"; + license = lib.meta.getLicenseFromSpdxId "BSD-3-Clause"; } ) { }; @@ -581908,7 +581908,7 @@ self: { time ]; description = "Interact with a GADT API in your reflex-dom application"; - license = lib.licensesSpdx."BSD-3-Clause"; + license = lib.meta.getLicenseFromSpdxId "BSD-3-Clause"; hydraPlatforms = lib.platforms.none; mainProgram = "readme"; } @@ -581984,7 +581984,7 @@ self: { temporary ]; description = "A GHCi widget library for use in reflex applications"; - license = lib.licensesSpdx."BSD-3-Clause"; + license = lib.meta.getLicenseFromSpdxId "BSD-3-Clause"; hydraPlatforms = lib.platforms.none; mainProgram = "reflex-ghci"; broken = true; @@ -582213,7 +582213,7 @@ self: { reflex ]; description = "Reflex bindings for libtelnet"; - license = lib.licensesSpdx."GPL-3.0-or-later"; + license = lib.meta.getLicenseFromSpdxId "GPL-3.0-or-later"; platforms = lib.platforms.linux; hydraPlatforms = lib.platforms.none; } @@ -582896,7 +582896,7 @@ self: { transformers ]; description = "See README for more info"; - license = lib.licensesSpdx."MPL-2.0"; + license = lib.meta.getLicenseFromSpdxId "MPL-2.0"; hydraPlatforms = lib.platforms.none; } ) { }; @@ -583125,7 +583125,7 @@ self: { ]; doHaddock = false; description = "Register allocation by graph colorization"; - license = lib.licensesSpdx."MPL-2.0"; + license = lib.meta.getLicenseFromSpdxId "MPL-2.0"; hydraPlatforms = lib.platforms.none; } ) { }; @@ -584298,7 +584298,7 @@ self: { text ]; description = "Types that can only be constructed if they match a regular expression"; - license = lib.licensesSpdx."BSD-3-Clause"; + license = lib.meta.getLicenseFromSpdxId "BSD-3-Clause"; } ) { }; @@ -585103,7 +585103,7 @@ self: { tasty-hunit ]; description = "Simple linear and quadratic regression"; - license = lib.licensesSpdx."BSD-3-Clause"; + license = lib.meta.getLicenseFromSpdxId "BSD-3-Clause"; } ) { }; @@ -585607,7 +585607,7 @@ self: { hspec-discover ]; description = "A data structure representing Relations on Sets"; - license = lib.licensesSpdx."BSD-3-Clause"; + license = lib.meta.getLicenseFromSpdxId "BSD-3-Clause"; hydraPlatforms = lib.platforms.none; broken = true; } @@ -585984,7 +585984,7 @@ self: { ]; executableHaskellDepends = [ base ]; description = "Automation of Haskell package release process"; - license = lib.licensesSpdx."Apache-2.0"; + license = lib.meta.getLicenseFromSpdxId "Apache-2.0"; mainProgram = "releaser"; } ) { }; @@ -586253,7 +586253,7 @@ self: { transformers ]; description = "Equiprobable draw from publicly verifiable random data"; - license = lib.licensesSpdx."AGPL-3.0-or-later"; + license = lib.meta.getLicenseFromSpdxId "AGPL-3.0-or-later"; } ) { }; @@ -586310,7 +586310,7 @@ self: { unordered-containers ]; description = "Safe, performant, user-friendly and lightweight Haskell Standard Library"; - license = lib.licensesSpdx."MIT"; + license = lib.meta.getLicenseFromSpdxId "MIT"; } ) { }; @@ -586889,7 +586889,7 @@ self: { ]; testToolDepends = [ hspec-discover ]; description = "Reorder expressions in a syntax tree according to operator fixities"; - license = lib.licensesSpdx."MIT"; + license = lib.meta.getLicenseFromSpdxId "MIT"; } ) { }; @@ -587526,7 +587526,7 @@ self: { pinned-warnings ]; description = "Currated set of plugins for REPL based development"; - license = lib.licensesSpdx."BSD-3-Clause"; + license = lib.meta.getLicenseFromSpdxId "BSD-3-Clause"; hydraPlatforms = lib.platforms.none; } ) { }; @@ -587644,7 +587644,7 @@ self: { text ]; description = "Find, replace, split string patterns with Megaparsec parsers (instead of regex)"; - license = lib.licensesSpdx."BSD-2-Clause"; + license = lib.meta.getLicenseFromSpdxId "BSD-2-Clause"; maintainers = [ lib.maintainers.maralorn ]; } ) { }; @@ -588206,7 +588206,7 @@ self: { testToolDepends = [ hspec-discover ]; doCheck = false; description = "HTTP client library"; - license = lib.licensesSpdx."BSD-3-Clause"; + license = lib.meta.getLicenseFromSpdxId "BSD-3-Clause"; maintainers = [ lib.maintainers.maralorn ]; } ) { }; @@ -588256,7 +588256,7 @@ self: { weigh ]; description = "Conduit helpers for the req HTTP client library"; - license = lib.licensesSpdx."BSD-3-Clause"; + license = lib.meta.getLicenseFromSpdxId "BSD-3-Clause"; hydraPlatforms = lib.platforms.none; broken = true; } @@ -588557,7 +588557,7 @@ self: { ]; testHaskellDepends = [ base ]; description = "Propagate HasCallStack with constraints"; - license = lib.licensesSpdx."MIT"; + license = lib.meta.getLicenseFromSpdxId "MIT"; } ) { }; @@ -588624,7 +588624,7 @@ self: { parsec ]; description = "Regular-expressions extended with fixpoints for context-free powers"; - license = lib.licensesSpdx."BSD-3-Clause"; + license = lib.meta.getLicenseFromSpdxId "BSD-3-Clause"; } ) { }; @@ -588636,7 +588636,7 @@ self: { sha256 = "047wlwvffmgg70d70dsv6160wq6hfxp4frb0414np270grq0vk3p"; libraryHaskellDepends = [ rebase ]; description = "Reexports from \"base\" with a bunch of other standard libraries"; - license = lib.licensesSpdx."MIT"; + license = lib.meta.getLicenseFromSpdxId "MIT"; } ) { }; @@ -588649,7 +588649,7 @@ self: { libraryHaskellDepends = [ rebase ]; doHaddock = false; description = "Reexports from \"base\" with a bunch of other standard libraries"; - license = lib.licensesSpdx."MIT"; + license = lib.meta.getLicenseFromSpdxId "MIT"; hydraPlatforms = lib.platforms.none; } ) { }; @@ -588949,7 +588949,7 @@ self: { semigroupoids ]; description = "High performance variable binders"; - license = lib.licensesSpdx."BSD-2-Clause"; + license = lib.meta.getLicenseFromSpdxId "BSD-2-Clause"; hydraPlatforms = lib.platforms.none; } ) { }; @@ -589012,7 +589012,7 @@ self: { tasty-hunit ]; description = "Domain Name Service (DNS) lookup via the libresolv standard library routines"; - license = lib.licensesSpdx."GPL-2.0-or-later"; + license = lib.meta.getLicenseFromSpdxId "GPL-2.0-or-later"; } ) { }; @@ -589158,7 +589158,7 @@ self: { stm ]; description = "A region-based resource effect for the effectful ecosystem"; - license = lib.licensesSpdx."BSD-3-Clause"; + license = lib.meta.getLicenseFromSpdxId "BSD-3-Clause"; hydraPlatforms = lib.platforms.none; broken = true; } @@ -589209,7 +589209,7 @@ self: { time ]; description = "A high-performance striped resource pooling implementation"; - license = lib.licensesSpdx."BSD-3-Clause"; + license = lib.meta.getLicenseFromSpdxId "BSD-3-Clause"; } ) { }; @@ -589236,7 +589236,7 @@ self: { time ]; description = "A high-performance striped resource pooling implementation"; - license = lib.licensesSpdx."BSD-3-Clause"; + license = lib.meta.getLicenseFromSpdxId "BSD-3-Clause"; hydraPlatforms = lib.platforms.none; } ) { }; @@ -589374,7 +589374,7 @@ self: { tree-diff ]; description = "Track allocated resources"; - license = lib.licensesSpdx."Apache-2.0"; + license = lib.meta.getLicenseFromSpdxId "Apache-2.0"; hydraPlatforms = lib.platforms.none; broken = true; } @@ -589463,7 +589463,7 @@ self: { resourcet ]; description = "Adaptation of the resourcet library for the effectful ecosystem"; - license = lib.licensesSpdx."BSD-3-Clause"; + license = lib.meta.getLicenseFromSpdxId "BSD-3-Clause"; } ) { }; @@ -589490,7 +589490,7 @@ self: { unliftio-core ]; description = "ResourceT extras"; - license = lib.licensesSpdx."BSD-3-Clause"; + license = lib.meta.getLicenseFromSpdxId "BSD-3-Clause"; } ) { }; @@ -589549,7 +589549,7 @@ self: { utf8-string ]; description = "A fast, non-backtracking parser for the redis RESP3 protocol"; - license = lib.licensesSpdx."BSD-3-Clause"; + license = lib.meta.getLicenseFromSpdxId "BSD-3-Clause"; hydraPlatforms = lib.platforms.none; broken = true; } @@ -590517,7 +590517,7 @@ self: { unix ]; description = "A tool that returns to a landmark parent directory"; - license = lib.licensesSpdx."MIT"; + license = lib.meta.getLicenseFromSpdxId "MIT"; mainProgram = "ret"; } ) { }; @@ -591006,7 +591006,7 @@ self: { tasty-hunit ]; description = "Adaptation of the retry library for the effectful ecosystem"; - license = lib.licensesSpdx."BSD-3-Clause"; + license = lib.meta.getLicenseFromSpdxId "BSD-3-Clause"; } ) { }; @@ -591044,7 +591044,7 @@ self: { sha256 = "110hbw4b8gbkgszc7d77rw9qpiwsz4lvsfbsb4cpw9fwzrcpvwnh"; libraryHaskellDepends = [ base ]; description = "A library to provide special kind of big numbers writing"; - license = lib.licensesSpdx."MIT"; + license = lib.meta.getLicenseFromSpdxId "MIT"; } ) { }; @@ -591166,7 +591166,7 @@ self: { deepseq ]; description = "reversed lists/snoc lists"; - license = lib.licensesSpdx."BSD-3-Clause"; + license = lib.meta.getLicenseFromSpdxId "BSD-3-Clause"; hydraPlatforms = lib.platforms.none; broken = true; } @@ -592043,7 +592043,7 @@ self: { vector-sized ]; description = "Functional Reactive Programming with type-level clocks"; - license = lib.licensesSpdx."BSD-3-Clause"; + license = lib.meta.getLicenseFromSpdxId "BSD-3-Clause"; maintainers = [ lib.maintainers.turion ]; } ) { }; @@ -592133,7 +592133,7 @@ self: { vector-sized ]; description = "Functional Reactive Programming with type-level clocks"; - license = lib.licensesSpdx."BSD-3-Clause"; + license = lib.meta.getLicenseFromSpdxId "BSD-3-Clause"; hydraPlatforms = lib.platforms.none; maintainers = [ lib.maintainers.turion ]; } @@ -592739,7 +592739,7 @@ self: { warp ]; description = "Static site generator based on Shake"; - license = lib.licensesSpdx."BSD-3-Clause"; + license = lib.meta.getLicenseFromSpdxId "BSD-3-Clause"; hydraPlatforms = lib.platforms.none; } ) { }; @@ -592803,7 +592803,7 @@ self: { warp ]; description = "Static site generator based on Shake"; - license = lib.licensesSpdx."BSD-3-Clause"; + license = lib.meta.getLicenseFromSpdxId "BSD-3-Clause"; hydraPlatforms = lib.platforms.none; broken = true; } @@ -592893,7 +592893,7 @@ self: { tasty ]; description = "Neovim plugin framework for Polysemy"; - license = lib.licensesSpdx."BSD-2-Clause-Patent"; + license = lib.meta.getLicenseFromSpdxId "BSD-2-Clause-Patent"; hydraPlatforms = lib.platforms.none; } ) { }; @@ -592952,7 +592952,7 @@ self: { tasty ]; description = "CLI for Ribosome"; - license = lib.licensesSpdx."BSD-2-Clause-Patent"; + license = lib.meta.getLicenseFromSpdxId "BSD-2-Clause-Patent"; hydraPlatforms = lib.platforms.none; mainProgram = "ribosome"; } @@ -593035,7 +593035,7 @@ self: { tasty ]; description = "Neovim plugin host for Polysemy"; - license = lib.licensesSpdx."BSD-2-Clause-Patent"; + license = lib.meta.getLicenseFromSpdxId "BSD-2-Clause-Patent"; hydraPlatforms = lib.platforms.none; } ) { }; @@ -593069,7 +593069,7 @@ self: { ribosome-host ]; description = "Test tools for Ribosome"; - license = lib.licensesSpdx."BSD-2-Clause-Patent"; + license = lib.meta.getLicenseFromSpdxId "BSD-2-Clause-Patent"; hydraPlatforms = lib.platforms.none; } ) { }; @@ -593238,7 +593238,7 @@ self: { tasty ]; description = "Test tools for Ribosome"; - license = lib.licensesSpdx."BSD-2-Clause-Patent"; + license = lib.meta.getLicenseFromSpdxId "BSD-2-Clause-Patent"; hydraPlatforms = lib.platforms.none; } ) { }; @@ -593282,7 +593282,7 @@ self: { ]; testToolDepends = [ hspec-discover ]; description = "Rich environment variable setup for Haskell"; - license = lib.licensesSpdx."MIT"; + license = lib.meta.getLicenseFromSpdxId "MIT"; } ) { }; @@ -593652,7 +593652,7 @@ self: { QuickCheck ]; description = "mutable ring buffers with atomic updates in GHC Haskell"; - license = lib.licensesSpdx."BSD-3-Clause"; + license = lib.meta.getLicenseFromSpdxId "BSD-3-Clause"; hydraPlatforms = lib.platforms.none; broken = true; } @@ -593979,7 +593979,7 @@ self: { unliftio-messagebox ]; description = "A library for process pools coupled with asynchronous message queues"; - license = lib.licensesSpdx."BSD-2-Clause"; + license = lib.meta.getLicenseFromSpdxId "BSD-2-Clause"; hydraPlatforms = lib.platforms.none; mainProgram = "rio-process-pool-memleak-test"; } @@ -594286,7 +594286,7 @@ self: { ]; testHaskellDepends = [ base ]; description = "A DSL for Risk-oriented Object Detection Requirements"; - license = lib.licensesSpdx."MIT"; + license = lib.meta.getLicenseFromSpdxId "MIT"; hydraPlatforms = lib.platforms.none; broken = true; } @@ -594759,7 +594759,7 @@ self: { vector ]; description = "Reed-Muller Expansion normal form for Boolean Formulas"; - license = lib.licensesSpdx."BSD-3-Clause"; + license = lib.meta.getLicenseFromSpdxId "BSD-3-Clause"; } ) { }; @@ -594788,7 +594788,7 @@ self: { what4 ]; description = "What4 adapter for the RME solver"; - license = lib.licensesSpdx."BSD-3-Clause"; + license = lib.meta.getLicenseFromSpdxId "BSD-3-Clause"; hydraPlatforms = lib.platforms.none; broken = true; } @@ -595103,7 +595103,7 @@ self: { ]; testToolDepends = [ tasty-discover ]; description = "Calculate per instrument profit from Robin-Hood activity report"; - license = lib.licensesSpdx."BSD-3-Clause"; + license = lib.meta.getLicenseFromSpdxId "BSD-3-Clause"; hydraPlatforms = lib.platforms.none; mainProgram = "rhprofit"; broken = true; @@ -595368,7 +595368,7 @@ self: { vector-sized ]; description = "Implementation of the ROC (Taiwan) National ID standard"; - license = lib.licensesSpdx."BSD-3-Clause"; + license = lib.meta.getLicenseFromSpdxId "BSD-3-Clause"; } ) { }; @@ -595417,7 +595417,7 @@ self: { text ]; description = "Implementation of the ROC (Taiwan) Uniform ID Number format"; - license = lib.licensesSpdx."BSD-3-Clause"; + license = lib.meta.getLicenseFromSpdxId "BSD-3-Clause"; hydraPlatforms = lib.platforms.none; } ) { }; @@ -596284,7 +596284,7 @@ self: { deepseq ]; description = "RON"; - license = lib.licensesSpdx."BSD-3-Clause"; + license = lib.meta.getLicenseFromSpdxId "BSD-3-Clause"; hydraPlatforms = lib.platforms.none; broken = true; } @@ -596405,7 +596405,7 @@ self: { unordered-containers ]; description = "Replicated Data Types (RON-RDT)"; - license = lib.licensesSpdx."BSD-3-Clause"; + license = lib.meta.getLicenseFromSpdxId "BSD-3-Clause"; hydraPlatforms = lib.platforms.none; } ) { }; @@ -596445,7 +596445,7 @@ self: { transformers ]; description = "RON-Schema"; - license = lib.licensesSpdx."BSD-3-Clause"; + license = lib.meta.getLicenseFromSpdxId "BSD-3-Clause"; hydraPlatforms = lib.platforms.none; } ) { }; @@ -596491,7 +596491,7 @@ self: { transformers ]; description = "RON Storage"; - license = lib.licensesSpdx."BSD-3-Clause"; + license = lib.meta.getLicenseFromSpdxId "BSD-3-Clause"; hydraPlatforms = lib.platforms.none; } ) { }; @@ -596763,7 +596763,7 @@ self: { quickcheck-classes ]; description = "rose trees"; - license = lib.licensesSpdx."BSD-3-Clause"; + license = lib.meta.getLicenseFromSpdxId "BSD-3-Clause"; hydraPlatforms = lib.platforms.none; broken = true; } @@ -597372,7 +597372,7 @@ self: { vector ]; description = "Directed rounding for built-in floating types"; - license = lib.licensesSpdx."BSD-3-Clause"; + license = lib.meta.getLicenseFromSpdxId "BSD-3-Clause"; } ) { }; @@ -598432,7 +598432,7 @@ self: { ]; testHaskellDepends = [ base ]; description = "Let your mind know that your hands need a rest!"; - license = lib.licensesSpdx."BSD-2-Clause"; + license = lib.meta.getLicenseFromSpdxId "BSD-2-Clause"; hydraPlatforms = lib.platforms.none; broken = true; } @@ -598565,7 +598565,7 @@ self: { xml-types ]; description = "Streaming parser/renderer for the RSS standard"; - license = lib.licensesSpdx."CC0-1.0"; + license = lib.meta.getLicenseFromSpdxId "CC0-1.0"; hydraPlatforms = lib.platforms.none; broken = true; } @@ -598656,7 +598656,7 @@ self: { ghc-prim ]; description = "stream-fusion framework from vector"; - license = lib.licensesSpdx."BSD-3-Clause"; + license = lib.meta.getLicenseFromSpdxId "BSD-3-Clause"; hydraPlatforms = lib.platforms.none; broken = true; } @@ -598670,7 +598670,7 @@ self: { sha256 = "18kpashzq6wnf1yc2xvz7l6c53v45yimzsahaavdf60pvw4zfhrx"; libraryHaskellDepends = [ base ]; description = "A more fine-grained version of state threads (ST)"; - license = lib.licensesSpdx."BSD-3-Clause"; + license = lib.meta.getLicenseFromSpdxId "BSD-3-Clause"; } ) { }; @@ -599285,7 +599285,7 @@ self: { primitive-unlifted ]; description = "runST without boxing penalty"; - license = lib.licensesSpdx."BSD-3-Clause"; + license = lib.meta.getLicenseFromSpdxId "BSD-3-Clause"; } ) { }; @@ -599422,7 +599422,7 @@ self: { process ]; description = "Stack wrapper for single-file Haskell programs"; - license = lib.licensesSpdx."BSD-3-Clause"; + license = lib.meta.getLicenseFromSpdxId "BSD-3-Clause"; hydraPlatforms = lib.platforms.none; mainProgram = "runhs"; broken = true; @@ -599537,7 +599537,7 @@ self: { type-reflection ]; description = "Look up class instances at runtime"; - license = lib.licensesSpdx."MIT"; + license = lib.meta.getLicenseFromSpdxId "MIT"; hydraPlatforms = lib.platforms.none; broken = true; } @@ -599602,7 +599602,7 @@ self: { transformers ]; description = "TLS bindings for Rustls"; - license = lib.licensesSpdx."CC0-1.0"; + license = lib.meta.getLicenseFromSpdxId "CC0-1.0"; hydraPlatforms = lib.platforms.none; broken = true; } @@ -600519,7 +600519,7 @@ self: { QuickCheck ]; description = "Recursive Arbitrary instances without headaches"; - license = lib.licensesSpdx."BSD-3-Clause"; + license = lib.meta.getLicenseFromSpdxId "BSD-3-Clause"; } ) { }; @@ -600922,7 +600922,7 @@ self: { doctest ]; description = "Safe arithmetic operations"; - license = lib.licensesSpdx."Apache-2.0"; + license = lib.meta.getLicenseFromSpdxId "Apache-2.0"; } ) { }; @@ -601042,7 +601042,7 @@ self: { ]; testHaskellDepends = [ base ]; description = "Use RecordWildCards safely"; - license = lib.licensesSpdx."BSD-3-Clause"; + license = lib.meta.getLicenseFromSpdxId "BSD-3-Clause"; } ) { }; @@ -601896,7 +601896,7 @@ self: { HUnit ]; description = "Semantic version numbers and constraints"; - license = lib.licensesSpdx."MIT"; + license = lib.meta.getLicenseFromSpdxId "MIT"; } ) { }; @@ -602196,7 +602196,7 @@ self: { storable-record ]; description = "Handling of samples in an (audio) signal"; - license = lib.licensesSpdx."BSD-3-Clause"; + license = lib.meta.getLicenseFromSpdxId "BSD-3-Clause"; maintainers = [ lib.maintainers.thielema ]; } ) { }; @@ -602218,7 +602218,7 @@ self: { sample-frame ]; description = "Orphan instances for types from sample-frame and numericprelude"; - license = lib.licensesSpdx."BSD-3-Clause"; + license = lib.meta.getLicenseFromSpdxId "BSD-3-Clause"; maintainers = [ lib.maintainers.thielema ]; } ) { }; @@ -602278,7 +602278,7 @@ self: { tasty-quickcheck ]; description = "A stable adaptive mergesort implementation"; - license = lib.licensesSpdx."BSD-3-Clause"; + license = lib.meta.getLicenseFromSpdxId "BSD-3-Clause"; } ) { }; @@ -603559,7 +603559,7 @@ self: { ]; testToolDepends = [ alex ]; description = "A staged lexer generator"; - license = lib.licensesSpdx."BSD-3-Clause"; + license = lib.meta.getLicenseFromSpdxId "BSD-3-Clause"; hydraPlatforms = lib.platforms.none; broken = true; } @@ -603665,7 +603665,7 @@ self: { containers ]; description = "A high-level wrapper over minisat"; - license = lib.licensesSpdx."BSD-3-Clause"; + license = lib.meta.getLicenseFromSpdxId "BSD-3-Clause"; hydraPlatforms = lib.platforms.none; broken = true; } @@ -603716,7 +603716,7 @@ self: { base ]; description = "SAT encoding monad"; - license = lib.licensesSpdx."GPL-2.0-only"; + license = lib.meta.getLicenseFromSpdxId "GPL-2.0-only"; } ) { }; @@ -603892,7 +603892,7 @@ self: { ]; doHaddock = false; description = "Handle POSIX cron schedules"; - license = lib.licensesSpdx."MIT"; + license = lib.meta.getLicenseFromSpdxId "MIT"; } ) { }; @@ -603930,7 +603930,7 @@ self: { hspec-core ]; description = "Handle POSIX cron schedules"; - license = lib.licensesSpdx."MIT"; + license = lib.meta.getLicenseFromSpdxId "MIT"; hydraPlatforms = lib.platforms.none; } ) { }; @@ -604033,7 +604033,7 @@ self: { time ]; description = "The eye that watches everything you did on Twitter"; - license = lib.licensesSpdx."MPL-2.0"; + license = lib.meta.getLicenseFromSpdxId "MPL-2.0"; hydraPlatforms = lib.platforms.none; mainProgram = "sauron"; } @@ -604221,7 +604221,7 @@ self: { text ]; description = "Construction of context-adjusted pretty output"; - license = lib.licensesSpdx."ISC"; + license = lib.meta.getLicenseFromSpdxId "ISC"; } ) { }; @@ -604509,7 +604509,7 @@ self: { time ]; description = "SMT Based Verification: Symbolic Haskell theorem prover using SMT solving"; - license = lib.licensesSpdx."BSD-3-Clause"; + license = lib.meta.getLicenseFromSpdxId "BSD-3-Clause"; } ) { inherit (pkgs) z3; }; @@ -604614,7 +604614,7 @@ self: { time ]; description = "SMT Based Verification: Symbolic Haskell theorem prover using SMT solving"; - license = lib.licensesSpdx."BSD-3-Clause"; + license = lib.meta.getLicenseFromSpdxId "BSD-3-Clause"; hydraPlatforms = lib.platforms.none; } ) { inherit (pkgs) z3; }; @@ -604688,7 +604688,7 @@ self: { tasty-golden ]; description = "Formally prove properties of Haskell programs using SBV/SMT"; - license = lib.licensesSpdx."BSD-3-Clause"; + license = lib.meta.getLicenseFromSpdxId "BSD-3-Clause"; hydraPlatforms = lib.platforms.none; broken = true; } @@ -605332,7 +605332,7 @@ self: { unliftio-core ]; description = "Metadata types for Albedo Scanners"; - license = lib.licensesSpdx."MIT"; + license = lib.meta.getLicenseFromSpdxId "MIT"; hydraPlatforms = lib.platforms.none; } ) { }; @@ -605643,7 +605643,7 @@ self: { text ]; description = "SCFG parser for Haskell"; - license = lib.licensesSpdx."MIT"; + license = lib.meta.getLicenseFromSpdxId "MIT"; } ) { }; @@ -605755,7 +605755,7 @@ self: { transformers ]; description = "Pure deterministic scheduled computations"; - license = lib.licensesSpdx."GPL-3.0-or-later"; + license = lib.meta.getLicenseFromSpdxId "GPL-3.0-or-later"; } ) { }; @@ -606602,7 +606602,7 @@ self: { x509-store ]; description = "Haskell query for SciDB via shim"; - license = lib.licensesSpdx."GPL-3.0-only"; + license = lib.meta.getLicenseFromSpdxId "GPL-3.0-only"; hydraPlatforms = lib.platforms.none; mainProgram = "hquery"; broken = true; @@ -606760,7 +606760,7 @@ self: { scientific ]; description = "Scientific notation intended for tokenization"; - license = lib.licensesSpdx."BSD-3-Clause"; + license = lib.meta.getLicenseFromSpdxId "BSD-3-Clause"; } ) { }; @@ -607140,7 +607140,7 @@ self: { unliftio ]; description = "CPS resource allocation but as a Monad and completely safe"; - license = lib.licensesSpdx."AGPL-3.0-or-later"; + license = lib.meta.getLicenseFromSpdxId "AGPL-3.0-or-later"; maintainers = [ lib.maintainers.mangoiv ]; } ) { }; @@ -607785,7 +607785,7 @@ self: { wai ]; description = "A Better way of modeling web resources"; - license = lib.licensesSpdx."Apache-2.0"; + license = lib.meta.getLicenseFromSpdxId "Apache-2.0"; } ) { }; @@ -608291,7 +608291,7 @@ self: { transformers ]; description = "html pattern matching library and high-level interface concurrent requests lib for webscraping"; - license = lib.licensesSpdx."BSD-3-Clause"; + license = lib.meta.getLicenseFromSpdxId "BSD-3-Clause"; } ) { }; @@ -608346,7 +608346,7 @@ self: { transformers ]; description = "html pattern matching library and high-level interface concurrent requests lib for webscraping"; - license = lib.licensesSpdx."BSD-3-Clause"; + license = lib.meta.getLicenseFromSpdxId "BSD-3-Clause"; } ) { }; @@ -608387,7 +608387,7 @@ self: { transformers ]; description = "html pattern matching library and high-level interface concurrent requests lib for webscraping"; - license = lib.licensesSpdx."BSD-3-Clause"; + license = lib.meta.getLicenseFromSpdxId "BSD-3-Clause"; } ) { }; @@ -608429,7 +608429,7 @@ self: { ]; executableHaskellDepends = [ base ]; description = "Take screenshot and copy it to the system clipboard"; - license = lib.licensesSpdx."BSD-3-Clause"; + license = lib.meta.getLicenseFromSpdxId "BSD-3-Clause"; hydraPlatforms = lib.platforms.none; mainProgram = "screenshot-to-clipboard"; broken = true; @@ -608481,7 +608481,7 @@ self: { scrappy-core ]; description = "grep-like CLI using Parsec parsers instead of regex"; - license = lib.licensesSpdx."BSD-3-Clause"; + license = lib.meta.getLicenseFromSpdxId "BSD-3-Clause"; } ) { }; @@ -608589,7 +608589,7 @@ self: { text ]; description = "GHCi scripts for standalone execution and Markdown documentation"; - license = lib.licensesSpdx."MIT"; + license = lib.meta.getLicenseFromSpdxId "MIT"; mainProgram = "scripths"; } ) { }; @@ -608697,7 +608697,7 @@ self: { tasty-bench ]; description = "Worse Haskell documentation"; - license = lib.licensesSpdx."0BSD"; + license = lib.meta.getLicenseFromSpdxId "0BSD"; hydraPlatforms = lib.platforms.none; mainProgram = "scrod"; broken = true; @@ -609571,7 +609571,7 @@ self: { executableSystemDepends = [ SDL2_mixer ]; executablePkgconfigDepends = [ SDL2_mixer ]; description = "Haskell bindings to SDL2_mixer"; - license = lib.licensesSpdx."BSD-3-Clause"; + license = lib.meta.getLicenseFromSpdxId "BSD-3-Clause"; badPlatforms = lib.platforms.darwin; hydraPlatforms = lib.platforms.none; broken = true; @@ -611048,7 +611048,7 @@ self: { text-display ]; description = "Cryptography for the casual user"; - license = lib.licensesSpdx."BSD-3-Clause"; + license = lib.meta.getLicenseFromSpdxId "BSD-3-Clause"; maintainers = [ lib.maintainers.mangoiv ]; } ) { }; @@ -611222,7 +611222,7 @@ self: { simple-prompt ]; description = "Select a subset of RPM packages"; - license = lib.licensesSpdx."MIT"; + license = lib.meta.getLicenseFromSpdxId "MIT"; } ) { }; @@ -611471,7 +611471,7 @@ self: { sha256 = "17vfwyjr3pxzjf35lhqqxid5bds52vk0gdqmnq4hvbjin3l07l98"; libraryHaskellDepends = [ base ]; description = "Framework and service for analyzing and diffing untrusted code"; - license = lib.licensesSpdx."MIT"; + license = lib.meta.getLicenseFromSpdxId "MIT"; } ) { }; @@ -611516,7 +611516,7 @@ self: { text ]; description = "Types and functionality for working with source code"; - license = lib.licensesSpdx."MIT"; + license = lib.meta.getLicenseFromSpdxId "MIT"; hydraPlatforms = lib.platforms.none; } ) { }; @@ -611568,7 +611568,7 @@ self: { unix ]; description = "Cross-platform abstraction for system semaphores"; - license = lib.licensesSpdx."BSD-3-Clause"; + license = lib.meta.getLicenseFromSpdxId "BSD-3-Clause"; hydraPlatforms = lib.platforms.none; } ) { }; @@ -611889,7 +611889,7 @@ self: { semigroupoids ]; description = "Support for QualifiedDo with semigroupoids classes"; - license = lib.licensesSpdx."Apache-2.0"; + license = lib.meta.getLicenseFromSpdxId "Apache-2.0"; hydraPlatforms = lib.platforms.none; broken = true; } @@ -612002,7 +612002,7 @@ self: { quickcheck-instances ]; description = "Semilattices"; - license = lib.licensesSpdx."BSD-3-Clause"; + license = lib.meta.getLicenseFromSpdxId "BSD-3-Clause"; } ) { }; @@ -612546,7 +612546,7 @@ self: { wreq ]; description = "A tool to send command execution results to Sensu"; - license = lib.licensesSpdx."BSD-3-Clause"; + license = lib.meta.getLicenseFromSpdxId "BSD-3-Clause"; hydraPlatforms = lib.platforms.none; mainProgram = "sensu-run"; broken = true; @@ -613210,7 +613210,7 @@ self: { transformers ]; description = "Sequences and measured sequences"; - license = lib.licensesSpdx."BSD-3-Clause"; + license = lib.meta.getLicenseFromSpdxId "BSD-3-Clause"; } ) { }; @@ -613467,7 +613467,7 @@ self: { QuickCheck ]; description = "Grammar-based compression algorithms SEQUITUR"; - license = lib.licensesSpdx."BSD-3-Clause"; + license = lib.meta.getLicenseFromSpdxId "BSD-3-Clause"; hydraPlatforms = lib.platforms.none; broken = true; } @@ -613556,7 +613556,7 @@ self: { tasty-quickcheck ]; description = "`binary` backend for `serdoc`"; - license = lib.licensesSpdx."Apache-2.0"; + license = lib.meta.getLicenseFromSpdxId "Apache-2.0"; } ) { }; @@ -613593,7 +613593,7 @@ self: { tasty-quickcheck ]; description = "Generated documentation of serialization formats"; - license = lib.licensesSpdx."Apache-2.0"; + license = lib.meta.getLicenseFromSpdxId "Apache-2.0"; } ) { }; @@ -613839,7 +613839,7 @@ self: { uuid-types ]; description = "Encode and decode UUID values in CBOR using uuid-types, cborg and serialise"; - license = lib.licensesSpdx."BSD-3-Clause"; + license = lib.meta.getLicenseFromSpdxId "BSD-3-Clause"; } ) { }; @@ -614207,7 +614207,7 @@ self: { ]; testToolDepends = [ hspec-discover ]; description = "A family of combinators for defining webservices APIs"; - license = lib.licensesSpdx."BSD-3-Clause"; + license = lib.meta.getLicenseFromSpdxId "BSD-3-Clause"; } ) { }; @@ -614284,7 +614284,7 @@ self: { text ]; description = "Servant endpoints compatible with Rails's ActiveResource"; - license = lib.licensesSpdx."BSD-3-Clause"; + license = lib.meta.getLicenseFromSpdxId "BSD-3-Clause"; } ) { }; @@ -614365,7 +614365,7 @@ self: { webdriver ]; description = "Generates a TypeScript client for Servant APIs"; - license = lib.licensesSpdx."BSD-3-Clause"; + license = lib.meta.getLicenseFromSpdxId "BSD-3-Clause"; hydraPlatforms = lib.platforms.none; mainProgram = "tests"; } @@ -614469,7 +614469,7 @@ self: { unordered-containers ]; description = "Authentication combinators for servant"; - license = lib.licensesSpdx."BSD-3-Clause"; + license = lib.meta.getLicenseFromSpdxId "BSD-3-Clause"; } ) { }; @@ -614530,7 +614530,7 @@ self: { ]; testToolDepends = [ hspec-discover ]; description = "servant-client/servant-auth compatibility"; - license = lib.licensesSpdx."BSD-3-Clause"; + license = lib.meta.getLicenseFromSpdxId "BSD-3-Clause"; } ) { }; @@ -614672,7 +614672,7 @@ self: { ]; testToolDepends = [ hspec-discover ]; description = "servant-docs/servant-auth compatibility"; - license = lib.licensesSpdx."BSD-3-Clause"; + license = lib.meta.getLicenseFromSpdxId "BSD-3-Clause"; } ) { }; @@ -614884,7 +614884,7 @@ self: { markdown-unlit ]; description = "servant-server/servant-auth compatibility"; - license = lib.licensesSpdx."BSD-3-Clause"; + license = lib.meta.getLicenseFromSpdxId "BSD-3-Clause"; } ) { }; @@ -614930,7 +614930,7 @@ self: { ]; testToolDepends = [ hspec-discover ]; description = "servant-swagger/servant-auth compatibility"; - license = lib.licensesSpdx."BSD-3-Clause"; + license = lib.meta.getLicenseFromSpdxId "BSD-3-Clause"; } ) { }; @@ -615726,7 +615726,7 @@ self: { markdown-unlit ]; description = "Automatic derivation of querying functions for servant"; - license = lib.licensesSpdx."BSD-3-Clause"; + license = lib.meta.getLicenseFromSpdxId "BSD-3-Clause"; } ) { }; @@ -615796,7 +615796,7 @@ self: { ]; testToolDepends = [ hspec-discover ]; description = "Core functionality and class for client function generation for servant APIs"; - license = lib.licensesSpdx."BSD-3-Clause"; + license = lib.meta.getLicenseFromSpdxId "BSD-3-Clause"; } ) { }; @@ -615845,7 +615845,7 @@ self: { transformers-base ]; description = "A servant client for frontend JavaScript"; - license = lib.licensesSpdx."BSD-3-Clause"; + license = lib.meta.getLicenseFromSpdxId "BSD-3-Clause"; hydraPlatforms = lib.platforms.none; broken = true; } @@ -616023,7 +616023,7 @@ self: { warp ]; description = "Servant Stream support for conduit"; - license = lib.licensesSpdx."BSD-3-Clause"; + license = lib.meta.getLicenseFromSpdxId "BSD-3-Clause"; } ) { }; @@ -616279,7 +616279,7 @@ self: { transformers ]; description = "generate API docs for your servant webservice"; - license = lib.licensesSpdx."BSD-3-Clause"; + license = lib.meta.getLicenseFromSpdxId "BSD-3-Clause"; mainProgram = "greet-docs"; } ) { }; @@ -616320,7 +616320,7 @@ self: { servant ]; description = "Generate endpoints overview for Servant API"; - license = lib.licensesSpdx."MIT"; + license = lib.meta.getLicenseFromSpdxId "MIT"; hydraPlatforms = lib.platforms.none; broken = true; } @@ -616559,7 +616559,7 @@ self: { ]; testToolDepends = [ markdown-unlit ]; description = "Servant Errors wai-middlware"; - license = lib.licensesSpdx."MIT"; + license = lib.meta.getLicenseFromSpdxId "MIT"; hydraPlatforms = lib.platforms.none; broken = true; } @@ -616811,7 +616811,7 @@ self: { ]; testToolDepends = [ hspec-discover ]; description = "Helpers for generating clients for servant APIs in any programming language"; - license = lib.licensesSpdx."BSD-3-Clause"; + license = lib.meta.getLicenseFromSpdxId "BSD-3-Clause"; } ) { }; @@ -617059,7 +617059,7 @@ self: { ]; testHaskellDepends = [ base ]; description = "HATEOAS extension for servant"; - license = lib.licensesSpdx."BSD-3-Clause"; + license = lib.meta.getLicenseFromSpdxId "BSD-3-Clause"; } ) { }; @@ -617212,7 +617212,7 @@ self: { ]; testToolDepends = [ hspec-discover ]; description = "Servant authentication with HMAC"; - license = lib.licensesSpdx."MIT"; + license = lib.meta.getLicenseFromSpdxId "MIT"; } ) { }; @@ -617355,7 +617355,7 @@ self: { markdown-unlit ]; description = "Automatic derivation of querying functions for servant"; - license = lib.licensesSpdx."BSD-3-Clause"; + license = lib.meta.getLicenseFromSpdxId "BSD-3-Clause"; hydraPlatforms = lib.platforms.none; broken = true; } @@ -617573,7 +617573,7 @@ self: { text ]; description = "JSON-RPC messages and endpoints"; - license = lib.licensesSpdx."BSD-3-Clause"; + license = lib.meta.getLicenseFromSpdxId "BSD-3-Clause"; } ) { }; @@ -617598,7 +617598,7 @@ self: { servant-jsonrpc ]; description = "Generate JSON-RPC servant clients"; - license = lib.licensesSpdx."BSD-3-Clause"; + license = lib.meta.getLicenseFromSpdxId "BSD-3-Clause"; } ) { }; @@ -617625,7 +617625,7 @@ self: { servant-server ]; description = "JSON-RPC servant servers"; - license = lib.licensesSpdx."BSD-3-Clause"; + license = lib.meta.getLicenseFromSpdxId "BSD-3-Clause"; } ) { }; @@ -617739,7 +617739,7 @@ self: { text ]; description = "Lint Servant Routes"; - license = lib.licensesSpdx."BSD-3-Clause"; + license = lib.meta.getLicenseFromSpdxId "BSD-3-Clause"; hydraPlatforms = lib.platforms.none; broken = true; } @@ -617823,7 +617823,7 @@ self: { warp ]; description = "Servant Stream support for machines"; - license = lib.licensesSpdx."BSD-3-Clause"; + license = lib.meta.getLicenseFromSpdxId "BSD-3-Clause"; } ) { }; @@ -618611,7 +618611,7 @@ self: { warp ]; description = "Servant Stream support for pipes"; - license = lib.licensesSpdx."BSD-3-Clause"; + license = lib.meta.getLicenseFromSpdxId "BSD-3-Clause"; } ) { }; @@ -618678,7 +618678,7 @@ self: { warp ]; description = "Utilities for using servant in a polysemy stack"; - license = lib.licensesSpdx."BSD-3-Clause"; + license = lib.meta.getLicenseFromSpdxId "BSD-3-Clause"; hydraPlatforms = lib.platforms.none; broken = true; } @@ -618803,7 +618803,7 @@ self: { warp ]; description = "Helpers for using prometheus with servant"; - license = lib.licensesSpdx."BSD-3-Clause"; + license = lib.meta.getLicenseFromSpdxId "BSD-3-Clause"; } ) { }; @@ -619032,7 +619032,7 @@ self: { servant-queryparam-core ]; description = "Client support for servant-queryparam-core"; - license = lib.licensesSpdx."BSD-3-Clause"; + license = lib.meta.getLicenseFromSpdxId "BSD-3-Clause"; } ) { }; @@ -619053,7 +619053,7 @@ self: { servant ]; description = "Use records for query parameters in servant APIs"; - license = lib.licensesSpdx."BSD-3-Clause"; + license = lib.meta.getLicenseFromSpdxId "BSD-3-Clause"; } ) { }; @@ -619078,7 +619078,7 @@ self: { servant-queryparam-core ]; description = "Instances of classes from openapi3 for servant-queryparam-core"; - license = lib.licensesSpdx."BSD-3-Clause"; + license = lib.meta.getLicenseFromSpdxId "BSD-3-Clause"; } ) { }; @@ -619103,7 +619103,7 @@ self: { text ]; description = "Server support for servant-queryparam-core"; - license = lib.licensesSpdx."BSD-3-Clause"; + license = lib.meta.getLicenseFromSpdxId "BSD-3-Clause"; } ) { }; @@ -619192,7 +619192,7 @@ self: { ]; testToolDepends = [ hspec-discover ]; description = "QuickCheck entire APIs"; - license = lib.licensesSpdx."BSD-3-Clause"; + license = lib.meta.getLicenseFromSpdxId "BSD-3-Clause"; hydraPlatforms = lib.platforms.none; broken = true; } @@ -619586,7 +619586,7 @@ self: { ]; testToolDepends = [ hspec-discover ]; description = "Generate route descriptions from Servant APIs"; - license = lib.licensesSpdx."BSD-3-Clause"; + license = lib.meta.getLicenseFromSpdxId "BSD-3-Clause"; hydraPlatforms = lib.platforms.none; broken = true; } @@ -619634,7 +619634,7 @@ self: { ]; testToolDepends = [ hspec-discover ]; description = "Golden test your Servant APIs using `servant-routes`"; - license = lib.licensesSpdx."BSD-3-Clause"; + license = lib.meta.getLicenseFromSpdxId "BSD-3-Clause"; hydraPlatforms = lib.platforms.none; } ) { }; @@ -619980,7 +619980,7 @@ self: { ]; testToolDepends = [ hspec-discover ]; description = "A family of combinators for defining webservices APIs and serving them"; - license = lib.licensesSpdx."BSD-3-Clause"; + license = lib.meta.getLicenseFromSpdxId "BSD-3-Clause"; mainProgram = "greet"; } ) { }; @@ -620732,7 +620732,7 @@ self: { ]; testToolDepends = [ hspec-discover ]; description = "Generate a Swagger/OpenAPI/OAS 2.0 specification for your servant API."; - license = lib.licensesSpdx."BSD-3-Clause"; + license = lib.meta.getLicenseFromSpdxId "BSD-3-Clause"; } ) { }; @@ -621597,7 +621597,7 @@ self: { xmlbf-xeno ]; description = "Servant support for the XML Content-Type"; - license = lib.licensesSpdx."BSD-3-Clause"; + license = lib.meta.getLicenseFromSpdxId "BSD-3-Clause"; } ) { }; @@ -621626,7 +621626,7 @@ self: { xml-types ]; description = "Servant XML content-type with support for xml-conduit"; - license = lib.licensesSpdx."AGPL-3.0-or-later"; + license = lib.meta.getLicenseFromSpdxId "AGPL-3.0-or-later"; hydraPlatforms = lib.platforms.none; broken = true; } @@ -622701,7 +622701,7 @@ self: { utility-ht ]; description = "Solve exact set cover problems like Sudoku, 8 Queens, Soma Cube, Tetris Cube"; - license = lib.licensesSpdx."BSD-3-Clause"; + license = lib.meta.getLicenseFromSpdxId "BSD-3-Clause"; maintainers = [ lib.maintainers.thielema ]; } ) { }; @@ -623834,7 +623834,7 @@ self: { vector ]; description = "Validation SHA Implementations"; - license = lib.licensesSpdx."MIT"; + license = lib.meta.getLicenseFromSpdxId "MIT"; } ) { }; @@ -623867,7 +623867,7 @@ self: { primitive ]; description = "SHA-1 Hash"; - license = lib.licensesSpdx."BSD-3-Clause"; + license = lib.meta.getLicenseFromSpdxId "BSD-3-Clause"; hydraPlatforms = lib.platforms.none; broken = true; } @@ -624381,7 +624381,7 @@ self: { text ]; description = "Build rules for historical benchmarking"; - license = lib.licensesSpdx."Apache-2.0"; + license = lib.meta.getLicenseFromSpdxId "Apache-2.0"; maintainers = [ lib.maintainers.maralorn ]; } ) { }; @@ -625571,7 +625571,7 @@ self: { vector ]; description = "“Shuffle and merge overlapping chunks” lossless compression"; - license = lib.licensesSpdx."BSD-3-Clause"; + license = lib.meta.getLicenseFromSpdxId "BSD-3-Clause"; } ) { }; @@ -625628,7 +625628,7 @@ self: { QuickCheck ]; description = "Shannon-fano compression algorithm in Haskell"; - license = lib.licensesSpdx."MIT"; + license = lib.meta.getLicenseFromSpdxId "MIT"; mainProgram = "shannon-fano"; } ) { }; @@ -626120,7 +626120,7 @@ self: { template-haskell ]; description = "Transform a shell script into a series of scripts with only shebang lines"; - license = lib.licensesSpdx."BSD-3-Clause"; + license = lib.meta.getLicenseFromSpdxId "BSD-3-Clause"; mainProgram = "shebanger"; } ) { }; @@ -626463,7 +626463,7 @@ self: { text ]; description = "A tool for generating shell.nix files"; - license = lib.licensesSpdx."Apache-2.0"; + license = lib.meta.getLicenseFromSpdxId "Apache-2.0"; mainProgram = "nix-shellify"; maintainers = [ lib.maintainers.danielrolls ]; } @@ -626607,7 +626607,7 @@ self: { Glob ]; description = "Out of the shell solution for scripting in Haskell"; - license = lib.licensesSpdx."MPL-2.0"; + license = lib.meta.getLicenseFromSpdxId "MPL-2.0"; mainProgram = "readme"; } ) { }; @@ -626750,7 +626750,7 @@ self: { utf8-string ]; description = "Easy, repeatable testing of CLI programs/commands"; - license = lib.licensesSpdx."GPL-3.0-or-later"; + license = lib.meta.getLicenseFromSpdxId "GPL-3.0-or-later"; hydraPlatforms = lib.platforms.none; mainProgram = "shelltest"; } @@ -627114,7 +627114,7 @@ self: { unliftio ]; description = "Supervised queue processing framework for Haskell"; - license = lib.licensesSpdx."MIT"; + license = lib.meta.getLicenseFromSpdxId "MIT"; hydraPlatforms = lib.platforms.none; broken = true; } @@ -627163,7 +627163,7 @@ self: { websockets ]; description = "Metrics web server for Shibuya queue processing framework"; - license = lib.licensesSpdx."MIT"; + license = lib.meta.getLicenseFromSpdxId "MIT"; hydraPlatforms = lib.platforms.none; } ) { }; @@ -627241,7 +627241,7 @@ self: { vector ]; description = "PGMQ adapter for the Shibuya queue processing framework"; - license = lib.licensesSpdx."MIT"; + license = lib.meta.getLicenseFromSpdxId "MIT"; hydraPlatforms = lib.platforms.none; } ) { }; @@ -627410,7 +627410,7 @@ self: { isLibrary = false; isExecutable = true; description = "Examples for the shine package"; - license = lib.licensesSpdx."MIT"; + license = lib.meta.getLicenseFromSpdxId "MIT"; hydraPlatforms = lib.platforms.none; broken = true; } @@ -627722,7 +627722,7 @@ self: { tasty-bench ]; description = "Additional ShortByteString API"; - license = lib.licensesSpdx."MIT"; + license = lib.meta.getLicenseFromSpdxId "MIT"; hydraPlatforms = lib.platforms.none; broken = true; } @@ -627773,7 +627773,7 @@ self: { doctest ]; description = "Link shortcuts for use in text markup"; - license = lib.licensesSpdx."MPL-2.0"; + license = lib.meta.getLicenseFromSpdxId "MPL-2.0"; } ) { }; @@ -628223,7 +628223,7 @@ self: { vector ]; description = "Generate swift types from haskell types"; - license = lib.licensesSpdx."MIT"; + license = lib.meta.getLicenseFromSpdxId "MIT"; hydraPlatforms = lib.platforms.none; broken = true; } @@ -628291,7 +628291,7 @@ self: { tasty-quickcheck ]; description = "timers using SI units (seconds)"; - license = lib.licensesSpdx."Apache-2.0"; + license = lib.meta.getLicenseFromSpdxId "Apache-2.0"; hydraPlatforms = lib.platforms.none; broken = true; } @@ -628938,7 +628938,7 @@ self: { transformers ]; description = "Standard Webhooks"; - license = lib.licensesSpdx."0BSD"; + license = lib.meta.getLicenseFromSpdxId "0BSD"; } ) { }; @@ -628984,7 +628984,7 @@ self: { text ]; description = "Calculate expressions involving significant figures"; - license = lib.licensesSpdx."GPL-3.0-or-later"; + license = lib.meta.getLicenseFromSpdxId "GPL-3.0-or-later"; hydraPlatforms = lib.platforms.none; mainProgram = "significant-figures-cli"; broken = true; @@ -629125,7 +629125,7 @@ self: { prettyprinter ]; description = "Prettyprinting transformers"; - license = lib.licensesSpdx."BSD-3-Clause"; + license = lib.meta.getLicenseFromSpdxId "BSD-3-Clause"; } ) { }; @@ -629216,7 +629216,7 @@ self: { ]; testToolDepends = [ hspec-discover ]; description = "A Haskell interface to simdutf"; - license = lib.licensesSpdx."MIT"; + license = lib.meta.getLicenseFromSpdxId "MIT"; } ) { }; @@ -629281,7 +629281,7 @@ self: { text ]; description = "A library to fetch and parse financial data from the SimFin(+) API"; - license = lib.licensesSpdx."MIT"; + license = lib.meta.getLicenseFromSpdxId "MIT"; hydraPlatforms = lib.platforms.none; broken = true; } @@ -631289,7 +631289,7 @@ self: { text ]; description = "A parser for SQL"; - license = lib.licensesSpdx."BSD-3-Clause"; + license = lib.meta.getLicenseFromSpdxId "BSD-3-Clause"; } ) { }; @@ -632279,7 +632279,7 @@ self: { hspec ]; description = "Simple pool"; - license = lib.licensesSpdx."BSD-3-Clause"; + license = lib.meta.getLicenseFromSpdxId "BSD-3-Clause"; } ) { }; @@ -632430,7 +632430,7 @@ self: { xext ]; description = "A programming language for simple GUIs"; - license = lib.licensesSpdx."BSD-3-Clause"; + license = lib.meta.getLicenseFromSpdxId "BSD-3-Clause"; hydraPlatforms = lib.platforms.none; mainProgram = "sindre"; broken = true; @@ -632472,7 +632472,7 @@ self: { ]; testToolDepends = [ hspec-discover ]; description = "a class for single tuple implementations"; - license = lib.licensesSpdx."Apache-2.0"; + license = lib.meta.getLicenseFromSpdxId "Apache-2.0"; hydraPlatforms = lib.platforms.none; broken = true; } @@ -632506,7 +632506,7 @@ self: { ]; testHaskellDepends = [ base ]; description = "Like singletons, but much smaller"; - license = lib.licensesSpdx."BSD-3-Clause"; + license = lib.meta.getLicenseFromSpdxId "BSD-3-Clause"; hydraPlatforms = lib.platforms.none; broken = true; } @@ -632535,7 +632535,7 @@ self: { some ]; description = "Type level booleans"; - license = lib.licensesSpdx."BSD-3-Clause"; + license = lib.meta.getLicenseFromSpdxId "BSD-3-Clause"; } ) { }; @@ -632723,7 +632723,7 @@ self: { ]; testToolDepends = [ singletons-base-code-generator ]; description = "A promoted and singled version of the base library"; - license = lib.licensesSpdx."BSD-3-Clause"; + license = lib.meta.getLicenseFromSpdxId "BSD-3-Clause"; hydraPlatforms = lib.platforms.none; } ) { }; @@ -632749,7 +632749,7 @@ self: { filepath ]; description = "Code generator for the singletons-base test suite"; - license = lib.licensesSpdx."BSD-3-Clause"; + license = lib.meta.getLicenseFromSpdxId "BSD-3-Clause"; hydraPlatforms = lib.platforms.none; mainProgram = "singletons-base-code-generator"; broken = true; @@ -632775,7 +632775,7 @@ self: { singletons-base ]; description = "An optional type with type level default"; - license = lib.licensesSpdx."BSD-3-Clause"; + license = lib.meta.getLicenseFromSpdxId "BSD-3-Clause"; } ) { }; @@ -632808,7 +632808,7 @@ self: { transformers ]; description = "Presburger Arithmetic Solver for GHC Type-level natural numbers with Singletons package"; - license = lib.licensesSpdx."BSD-3-Clause"; + license = lib.meta.getLicenseFromSpdxId "BSD-3-Clause"; hydraPlatforms = lib.platforms.none; } ) { }; @@ -633077,7 +633077,7 @@ self: { vector ]; description = "Encode and decode CSV files"; - license = lib.licensesSpdx."BSD-3-Clause"; + license = lib.meta.getLicenseFromSpdxId "BSD-3-Clause"; hydraPlatforms = lib.platforms.none; } ) { }; @@ -633497,7 +633497,7 @@ self: { vector ]; description = "Sized sequence data-types"; - license = lib.licensesSpdx."BSD-3-Clause"; + license = lib.meta.getLicenseFromSpdxId "BSD-3-Clause"; hydraPlatforms = lib.platforms.none; } ) { }; @@ -633656,7 +633656,7 @@ self: { ]; testToolDepends = [ hspec-discover ]; description = "Create a Sized version of any container"; - license = lib.licensesSpdx."ISC"; + license = lib.meta.getLicenseFromSpdxId "ISC"; } ) { }; @@ -633691,7 +633691,7 @@ self: { ]; testToolDepends = [ hspec-discover ]; description = "aeson instances for 'Sized'"; - license = lib.licensesSpdx."ISC"; + license = lib.meta.getLicenseFromSpdxId "ISC"; } ) { }; @@ -633712,7 +633712,7 @@ self: { sized-wrapper ]; description = "QuickCheck instance for 'Sized'"; - license = lib.licensesSpdx."ISC"; + license = lib.meta.getLicenseFromSpdxId "ISC"; } ) { }; @@ -633735,7 +633735,7 @@ self: { text ]; description = "'Sized' wrappers for text"; - license = lib.licensesSpdx."ISC"; + license = lib.meta.getLicenseFromSpdxId "ISC"; } ) { }; @@ -633976,7 +633976,7 @@ self: { unliftio ]; description = "Batteries-included, opinionated test framework"; - license = lib.licensesSpdx."BSD-3-Clause"; + license = lib.meta.getLicenseFromSpdxId "BSD-3-Clause"; mainProgram = "skeletest-preprocessor"; } ) { }; @@ -634055,7 +634055,7 @@ self: { unliftio ]; description = "Batteries-included, opinionated test framework"; - license = lib.licensesSpdx."BSD-3-Clause"; + license = lib.meta.getLicenseFromSpdxId "BSD-3-Clause"; hydraPlatforms = lib.platforms.none; mainProgram = "skeletest-preprocessor"; } @@ -634284,7 +634284,7 @@ self: { vector ]; description = "Random access lists: skew binary"; - license = lib.licensesSpdx."BSD-3-Clause"; + license = lib.meta.getLicenseFromSpdxId "BSD-3-Clause"; } ) { }; @@ -634996,7 +634996,7 @@ self: { text ]; description = "A programmable markup language to generate HTML"; - license = lib.licensesSpdx."BSD-2-Clause"; + license = lib.meta.getLicenseFromSpdxId "BSD-2-Clause"; mainProgram = "slab"; } ) { }; @@ -635352,7 +635352,7 @@ self: { ]; testToolDepends = [ hspec-discover ]; description = "Bindings for the Slack web API"; - license = lib.licensesSpdx."MIT"; + license = lib.meta.getLicenseFromSpdxId "MIT"; } ) { }; @@ -635747,7 +635747,7 @@ self: { text ]; description = "SLIP-0032: Extended serialization format for BIP-32 wallets"; - license = lib.licensesSpdx."Apache-2.0"; + license = lib.meta.getLicenseFromSpdxId "Apache-2.0"; hydraPlatforms = lib.platforms.none; } ) { }; @@ -635782,7 +635782,7 @@ self: { hspec-hedgehog ]; description = "Sized list"; - license = lib.licensesSpdx."MPL-2.0"; + license = lib.meta.getLicenseFromSpdxId "MPL-2.0"; } ) { }; @@ -635814,7 +635814,7 @@ self: { hspec-hedgehog ]; description = "Sized list"; - license = lib.licensesSpdx."MPL-2.0"; + license = lib.meta.getLicenseFromSpdxId "MPL-2.0"; hydraPlatforms = lib.platforms.none; } ) { }; @@ -636069,7 +636069,7 @@ self: { text-icu ]; description = "Clean URI slugs for Haskell"; - license = lib.licensesSpdx."BSD-3-Clause"; + license = lib.meta.getLicenseFromSpdxId "BSD-3-Clause"; mainProgram = "slugger"; } ) { }; @@ -636155,7 +636155,7 @@ self: { ]; executableHaskellDepends = [ base ]; description = "Handle molecular sequences"; - license = lib.licensesSpdx."GPL-3.0-or-later"; + license = lib.meta.getLicenseFromSpdxId "GPL-3.0-or-later"; mainProgram = "slynx"; maintainers = [ lib.maintainers.dschrempf ]; } @@ -636209,7 +636209,7 @@ self: { ]; executableHaskellDepends = [ base ]; description = "Handle molecular sequences"; - license = lib.licensesSpdx."GPL-3.0-or-later"; + license = lib.meta.getLicenseFromSpdxId "GPL-3.0-or-later"; hydraPlatforms = lib.platforms.none; mainProgram = "slynx"; maintainers = [ lib.maintainers.dschrempf ]; @@ -636234,7 +636234,7 @@ self: { ]; doHaddock = false; description = "Serialize to bytes"; - license = lib.licensesSpdx."BSD-3-Clause"; + license = lib.meta.getLicenseFromSpdxId "BSD-3-Clause"; } ) { }; @@ -636362,7 +636362,7 @@ self: { gauge ]; description = "See README for more info"; - license = lib.licensesSpdx."BSD-3-Clause"; + license = lib.meta.getLicenseFromSpdxId "BSD-3-Clause"; hydraPlatforms = lib.platforms.none; broken = true; } @@ -637162,7 +637162,7 @@ self: { ]; doHaddock = false; description = "String manipulation tool written in haskell"; - license = lib.licensesSpdx."MIT"; + license = lib.meta.getLicenseFromSpdxId "MIT"; hydraPlatforms = lib.platforms.none; mainProgram = "smh"; broken = true; @@ -637219,7 +637219,7 @@ self: { primitive ]; description = "Parse arrays of tokens"; - license = lib.licensesSpdx."BSD-3-Clause"; + license = lib.meta.getLicenseFromSpdxId "BSD-3-Clause"; } ) { }; @@ -638155,7 +638155,7 @@ self: { typed-process ]; description = "GHC Source Plugin that helps to minimise imports and generate explicit exports"; - license = lib.licensesSpdx."MPL-2.0"; + license = lib.meta.getLicenseFromSpdxId "MPL-2.0"; hydraPlatforms = lib.platforms.none; broken = true; } @@ -638191,7 +638191,7 @@ self: { text ]; description = "Strict ByteString Parser Combinator"; - license = lib.licensesSpdx."CC0-1.0"; + license = lib.meta.getLicenseFromSpdxId "CC0-1.0"; hydraPlatforms = lib.platforms.none; broken = true; } @@ -638430,7 +638430,7 @@ self: { xmlhtml ]; description = "Top-level package for the Snap Web Framework"; - license = lib.licensesSpdx."BSD-3-Clause"; + license = lib.meta.getLicenseFromSpdxId "BSD-3-Clause"; maintainers = [ lib.maintainers.maralorn ]; } ) { }; @@ -638698,7 +638698,7 @@ self: { zlib ]; description = "Snap: A Haskell Web Framework (core interfaces and types)"; - license = lib.licensesSpdx."BSD-3-Clause"; + license = lib.meta.getLicenseFromSpdxId "BSD-3-Clause"; } ) { }; @@ -641294,7 +641294,7 @@ self: { test-framework-quickcheck2 ]; description = "Fast Haskell bindings to Google’s Snappy compression library"; - license = lib.licensesSpdx."Apache-2.0"; + license = lib.meta.getLicenseFromSpdxId "Apache-2.0"; } ) { inherit (pkgs) snappy; }; @@ -641356,7 +641356,7 @@ self: { zlib ]; description = "Bindings to Google's Snappy: A fast compression library"; - license = lib.licensesSpdx."BSD-3-Clause"; + license = lib.meta.getLicenseFromSpdxId "BSD-3-Clause"; mainProgram = "snappy-cli"; } ) { inherit (pkgs) snappy; }; @@ -641438,7 +641438,7 @@ self: { bytestring ]; description = "Snappy compression library"; - license = lib.licensesSpdx."MIT"; + license = lib.meta.getLicenseFromSpdxId "MIT"; } ) { }; @@ -641664,7 +641664,7 @@ self: { yesod-form ]; description = "Import to snelstart"; - license = lib.licensesSpdx."MIT"; + license = lib.meta.getLicenseFromSpdxId "MIT"; hydraPlatforms = lib.platforms.none; mainProgram = "snelstart-import"; broken = true; @@ -641800,7 +641800,7 @@ self: { vector ]; description = "SNMP protocol library"; - license = lib.licensesSpdx."BSD-3-Clause"; + license = lib.meta.getLicenseFromSpdxId "BSD-3-Clause"; hydraPlatforms = lib.platforms.none; } ) { }; @@ -642507,7 +642507,7 @@ self: { unix ]; description = "Unix domain sockets"; - license = lib.licensesSpdx."MIT"; + license = lib.meta.getLicenseFromSpdxId "MIT"; } ) { }; @@ -642737,7 +642737,7 @@ self: { ]; doHaddock = false; description = "High-level network sockets"; - license = lib.licensesSpdx."BSD-3-Clause"; + license = lib.meta.getLicenseFromSpdxId "BSD-3-Clause"; badPlatforms = lib.platforms.darwin; hydraPlatforms = lib.platforms.none; broken = true; @@ -642802,7 +642802,7 @@ self: { ]; doHaddock = false; description = "Support for the Sockets and Pipes book"; - license = lib.licensesSpdx."Apache-2.0"; + license = lib.meta.getLicenseFromSpdxId "Apache-2.0"; hydraPlatforms = lib.platforms.none; } ) { }; @@ -642957,7 +642957,7 @@ self: { tls ]; description = "A SOCKS5 (RFC 1928) implementation"; - license = lib.licensesSpdx."BSD-3-Clause"; + license = lib.meta.getLicenseFromSpdxId "BSD-3-Clause"; hydraPlatforms = lib.platforms.none; broken = true; } @@ -643064,7 +643064,7 @@ self: { unordered-containers ]; description = "A low-boilerplate Haxl-like data fetching library"; - license = lib.licensesSpdx."BSD-3-Clause"; + license = lib.meta.getLicenseFromSpdxId "BSD-3-Clause"; } ) { }; @@ -643093,7 +643093,7 @@ self: { sofetch unordered-containers ]; - license = lib.licensesSpdx."BSD-3-Clause"; + license = lib.meta.getLicenseFromSpdxId "BSD-3-Clause"; } ) { }; @@ -643484,7 +643484,7 @@ self: { test-framework-quickcheck2 ]; description = "Self-Organising Maps"; - license = lib.licensesSpdx."BSD-3-Clause"; + license = lib.meta.getLicenseFromSpdxId "BSD-3-Clause"; hydraPlatforms = lib.platforms.none; broken = true; } @@ -643629,7 +643629,7 @@ self: { tasty-hunit ]; description = "Check satisfiability of expressions on natural numbers"; - license = lib.licensesSpdx."BSD-2-Clause"; + license = lib.meta.getLicenseFromSpdxId "BSD-2-Clause"; hydraPlatforms = lib.platforms.none; broken = true; } @@ -643947,7 +643947,7 @@ self: { type-errors-pretty ]; description = "Haskell EDSL for Souffle"; - license = lib.licensesSpdx."MIT"; + license = lib.meta.getLicenseFromSpdxId "MIT"; hydraPlatforms = lib.platforms.none; } ) { }; @@ -644010,7 +644010,7 @@ self: { vector ]; description = "Souffle Datalog bindings for Haskell"; - license = lib.licensesSpdx."MIT"; + license = lib.meta.getLicenseFromSpdxId "MIT"; hydraPlatforms = lib.platforms.none; broken = true; } @@ -644049,7 +644049,7 @@ self: { ]; testToolDepends = [ hspec-discover ]; description = "Apply sound changes to words"; - license = lib.licensesSpdx."MIT"; + license = lib.meta.getLicenseFromSpdxId "MIT"; hydraPlatforms = lib.platforms.none; broken = true; } @@ -644102,7 +644102,7 @@ self: { utility-ht ]; description = "Approximate a song from other pieces of sound"; - license = lib.licensesSpdx."BSD-3-Clause"; + license = lib.meta.getLicenseFromSpdxId "BSD-3-Clause"; mainProgram = "sound-collage"; maintainers = [ lib.maintainers.thielema ]; } @@ -644394,7 +644394,7 @@ self: { utility-ht ]; description = "Play, write, read, convert audio signals using Sox"; - license = lib.licensesSpdx."GPL-3.0-only"; + license = lib.meta.getLicenseFromSpdxId "GPL-3.0-only"; maintainers = [ lib.maintainers.thielema ]; } ) { }; @@ -644626,7 +644626,7 @@ self: { tasty-hunit ]; description = "Gopher server library and daemon"; - license = lib.licensesSpdx."GPL-3.0-only"; + license = lib.meta.getLicenseFromSpdxId "GPL-3.0-only"; mainProgram = "spacecookie"; maintainers = [ lib.maintainers.sternenseemann ]; } @@ -644907,7 +644907,7 @@ self: { ]; testToolDepends = [ hspec-discover ]; description = "A simple programming and debugging environment"; - license = lib.licensesSpdx."GPL-3.0-only"; + license = lib.meta.getLicenseFromSpdxId "GPL-3.0-only"; badPlatforms = lib.platforms.darwin; hydraPlatforms = lib.platforms.none; mainProgram = "spade"; @@ -645220,7 +645220,7 @@ self: { containers ]; description = "A sparse set-based parsing library for Haskell"; - license = lib.licensesSpdx."MIT"; + license = lib.meta.getLicenseFromSpdxId "MIT"; hydraPlatforms = lib.platforms.none; broken = true; } @@ -645479,7 +645479,7 @@ self: { vector ]; description = "Sparse set data structure"; - license = lib.licensesSpdx."BSD-3-Clause"; + license = lib.meta.getLicenseFromSpdxId "BSD-3-Clause"; mainProgram = "sparse-set"; } ) { }; @@ -645569,7 +645569,7 @@ self: { hspec ]; description = "Sparse vector data structures"; - license = lib.licensesSpdx."BSD-3-Clause"; + license = lib.meta.getLicenseFromSpdxId "BSD-3-Clause"; mainProgram = "sparse-vector"; } ) { }; @@ -645675,7 +645675,7 @@ self: { X11 ]; description = "A unix-style (read from stdin, write to stdout) global hotkey daemon"; - license = lib.licensesSpdx."BSD-3-Clause"; + license = lib.meta.getLicenseFromSpdxId "BSD-3-Clause"; hydraPlatforms = lib.platforms.none; mainProgram = "spartacon"; } @@ -645836,7 +645836,7 @@ self: { tasty-quickcheck ]; description = "SPDX license expression language, Extras"; - license = lib.licensesSpdx."BSD-3-Clause"; + license = lib.meta.getLicenseFromSpdxId "BSD-3-Clause"; } ) { }; @@ -645872,7 +645872,7 @@ self: { text ]; description = "SPDX license templates"; - license = lib.licensesSpdx."BSD-3-Clause"; + license = lib.meta.getLicenseFromSpdxId "BSD-3-Clause"; } ) { }; @@ -646125,7 +646125,7 @@ self: { tasty-hedgehog ]; description = "Embedded specification language & model checker in Haskell"; - license = lib.licensesSpdx."Apache-2.0"; + license = lib.meta.getLicenseFromSpdxId "Apache-2.0"; hydraPlatforms = lib.platforms.none; broken = true; } @@ -646284,7 +646284,7 @@ self: { text ]; description = "Manage the application of templates to custom yaml"; - license = lib.licensesSpdx."GPL-2.0-only"; + license = lib.meta.getLicenseFromSpdxId "GPL-2.0-only"; mainProgram = "specup"; maintainers = [ lib.maintainers.danielrolls ]; } @@ -646762,7 +646762,7 @@ self: { doctest ]; description = "Spiros Boosalis's Custom Prelude"; - license = lib.licensesSpdx."Apache-2.0"; + license = lib.meta.getLicenseFromSpdxId "Apache-2.0"; hydraPlatforms = lib.platforms.none; broken = true; } @@ -646776,7 +646776,7 @@ self: { sha256 = "0sr39lxh4jrzinins8i0lv0y715sc11grp2yq47sa1jpzvaf246v"; libraryHaskellDepends = [ base ]; description = "SPIR-V enumerations generated from Khronos JSON"; - license = lib.licensesSpdx."BSD-3-Clause"; + license = lib.meta.getLicenseFromSpdxId "BSD-3-Clause"; } ) { }; @@ -646801,7 +646801,7 @@ self: { text ]; description = "Types and generator for SPIR-V JSON spec"; - license = lib.licensesSpdx."BSD-3-Clause"; + license = lib.meta.getLicenseFromSpdxId "BSD-3-Clause"; } ) { }; @@ -646967,7 +646967,7 @@ self: { isExecutable = true; executableHaskellDepends = [ base ]; description = "Parallel implementation of the Sorokina/Zeilfelder spline scheme"; - license = lib.licensesSpdx."AGPL-3.0-or-later"; + license = lib.meta.getLicenseFromSpdxId "AGPL-3.0-or-later"; mainProgram = "spline3"; } ) { }; @@ -647037,7 +647037,7 @@ self: { stm ]; description = "HLint as a GHC source plugin"; - license = lib.licensesSpdx."ISC"; + license = lib.meta.getLicenseFromSpdxId "ISC"; hydraPlatforms = lib.platforms.none; broken = true; } @@ -647134,7 +647134,7 @@ self: { utility-ht ]; description = "Split a big audio file into pieces at positions of silence"; - license = lib.licensesSpdx."BSD-3-Clause"; + license = lib.meta.getLicenseFromSpdxId "BSD-3-Clause"; mainProgram = "split-record"; maintainers = [ lib.maintainers.thielema ]; } @@ -647181,7 +647181,7 @@ self: { template-haskell ]; description = "Fast Splittable PRNG"; - license = lib.licensesSpdx."BSD-3-Clause"; + license = lib.meta.getLicenseFromSpdxId "BSD-3-Clause"; } ) { }; @@ -647338,7 +647338,7 @@ self: { editedCabalFile = "0j9jsbn4f73fb1a5rp1qzw4jdh6n3mmlky16pvxw2gnz8kcficng"; libraryHaskellDepends = [ base ]; description = "Unified API for phantom typed newtypes and type aliases"; - license = lib.licensesSpdx."BSD-3-Clause"; + license = lib.meta.getLicenseFromSpdxId "BSD-3-Clause"; } ) { }; @@ -647537,7 +647537,7 @@ self: { ]; doHaddock = false; description = "Spotify Web API"; - license = lib.licensesSpdx."BSD-3-Clause"; + license = lib.meta.getLicenseFromSpdxId "BSD-3-Clause"; hydraPlatforms = lib.platforms.none; mainProgram = "examples"; broken = true; @@ -647612,7 +647612,7 @@ self: { QuickCheck ]; description = "Read and write spreadsheets from and to CSV files in a lazy way"; - license = lib.licensesSpdx."BSD-3-Clause"; + license = lib.meta.getLicenseFromSpdxId "BSD-3-Clause"; maintainers = [ lib.maintainers.thielema ]; } ) { }; @@ -648278,7 +648278,7 @@ self: { stm ]; description = "High-level SQLite client"; - license = lib.licensesSpdx."Apache-2.0"; + license = lib.meta.getLicenseFromSpdxId "Apache-2.0"; } ) { }; @@ -648362,7 +648362,7 @@ self: { tasty-hedgehog ]; description = "Guided derivation for Hasql statements"; - license = lib.licensesSpdx."BSD-2-Clause-Patent"; + license = lib.meta.getLicenseFromSpdxId "BSD-2-Clause-Patent"; hydraPlatforms = lib.platforms.none; broken = true; } @@ -648628,7 +648628,7 @@ self: { testToolDepends = [ tasty-discover ]; doHaddock = false; description = "Generate type-safe Haskell code from SQL via https://github.com/sqlc-dev/sqlc."; - license = lib.licensesSpdx."Apache-2.0"; + license = lib.meta.getLicenseFromSpdxId "Apache-2.0"; hydraPlatforms = lib.platforms.none; mainProgram = "sqlc-hs"; } @@ -648687,7 +648687,7 @@ self: { logging, text, transformers, - unixODBC, + unixodbc, }: mkDerivation { pname = "sqlcli"; @@ -648699,13 +648699,13 @@ self: { text transformers ]; - librarySystemDepends = [ unixODBC ]; + librarySystemDepends = [ unixodbc ]; description = "Bindings for SQL/CLI (ODBC) C API"; license = lib.licenses.bsd3; hydraPlatforms = lib.platforms.none; broken = true; } - ) { unixODBC = null; }; + ) { inherit (pkgs) unixodbc; }; sqlcli-odbc = callPackage ( { @@ -648809,7 +648809,7 @@ self: { deepseq ]; description = "A primitive yet easy to use sqlite library"; - license = lib.licensesSpdx."BSD-3-Clause"; + license = lib.meta.getLicenseFromSpdxId "BSD-3-Clause"; hydraPlatforms = lib.platforms.none; broken = true; } @@ -648922,7 +648922,7 @@ self: { sqlite-simple ]; description = "Interpolated SQLite queries via quasiquotation"; - license = lib.licensesSpdx."BSD-3-Clause"; + license = lib.meta.getLicenseFromSpdxId "BSD-3-Clause"; hydraPlatforms = lib.platforms.none; } ) { }; @@ -649176,7 +649176,7 @@ self: { with-utf8 ]; description = "Squeal PostgreSQL Library"; - license = lib.licensesSpdx."BSD-3-Clause"; + license = lib.meta.getLicenseFromSpdxId "BSD-3-Clause"; mainProgram = "example"; } ) { }; @@ -649208,7 +649208,7 @@ self: { text ]; description = "LTree extension for Squeal"; - license = lib.licensesSpdx."BSD-3-Clause"; + license = lib.meta.getLicenseFromSpdxId "BSD-3-Clause"; } ) { }; @@ -649260,7 +649260,7 @@ self: { uuid ]; description = "QuasiQuoter transforming raw sql into Squeal expressions"; - license = lib.licensesSpdx."MIT"; + license = lib.meta.getLicenseFromSpdxId "MIT"; } ) { }; @@ -649279,7 +649279,7 @@ self: { squeal-postgresql ]; description = "UUID OSSP extension for Squeal"; - license = lib.licensesSpdx."BSD-3-Clause"; + license = lib.meta.getLicenseFromSpdxId "BSD-3-Clause"; } ) { }; @@ -650424,7 +650424,7 @@ self: { primitive ]; description = "shared heap regions between local mutable state threads"; - license = lib.licensesSpdx."BSD-3-Clause"; + license = lib.meta.getLicenseFromSpdxId "BSD-3-Clause"; hydraPlatforms = lib.platforms.none; broken = true; } @@ -650465,7 +650465,7 @@ self: { pqueue ]; description = "Purely functional stable heaps (fair priority queues)"; - license = lib.licensesSpdx."MIT"; + license = lib.meta.getLicenseFromSpdxId "MIT"; hydraPlatforms = lib.platforms.none; broken = true; } @@ -650513,7 +650513,7 @@ self: { ghc-prim ]; description = "algorithms around stable marriage"; - license = lib.licensesSpdx."BSD-3-Clause"; + license = lib.meta.getLicenseFromSpdxId "BSD-3-Clause"; hydraPlatforms = lib.platforms.none; broken = true; } @@ -650682,7 +650682,7 @@ self: { text ]; description = "Mustache templates for Haskell"; - license = lib.licensesSpdx."MIT"; + license = lib.meta.getLicenseFromSpdxId "MIT"; mainProgram = "stache"; } ) { }; @@ -650993,7 +650993,7 @@ self: { $exe --bash-completion-script $exe >$out/share/bash-completion/completions/stack ''; description = "A program for developing Haskell projects"; - license = lib.licensesSpdx."BSD-3-Clause"; + license = lib.meta.getLicenseFromSpdxId "BSD-3-Clause"; mainProgram = "stack"; maintainers = [ lib.maintainers.cdepillabout ]; } @@ -651165,7 +651165,7 @@ self: { turtle ]; description = "Console program used to fix Stack build errors automatically"; - license = lib.licensesSpdx."AGPL-3.0-only"; + license = lib.meta.getLicenseFromSpdxId "AGPL-3.0-only"; hydraPlatforms = lib.platforms.none; mainProgram = "stack-fix"; broken = true; @@ -651798,7 +651798,7 @@ self: { text ]; description = "Convert stack projects to cabal.project + cabal.project.freeze"; - license = lib.licensesSpdx."GPL-3.0-only"; + license = lib.meta.getLicenseFromSpdxId "GPL-3.0-only"; hydraPlatforms = lib.platforms.none; mainProgram = "stack2cabal"; broken = true; @@ -652556,7 +652556,7 @@ self: { text ]; description = "Convert stack.yaml to cabal.project + cabal.project.freeze"; - license = lib.licensesSpdx."GPL-3.0-or-later"; + license = lib.meta.getLicenseFromSpdxId "GPL-3.0-or-later"; hydraPlatforms = lib.platforms.none; mainProgram = "stackage-to-hackage"; broken = true; @@ -652817,7 +652817,7 @@ self: { utf8-string ]; description = "Program to fold GHC prof files into flamegraph input"; - license = lib.licensesSpdx."GPL-3.0-only"; + license = lib.meta.getLicenseFromSpdxId "GPL-3.0-only"; hydraPlatforms = lib.platforms.none; mainProgram = "stackcollapse-ghc"; broken = true; @@ -653053,7 +653053,7 @@ self: { th-lift ]; description = "GHC.Generics style staged generics"; - license = lib.licensesSpdx."BSD-3-Clause"; + license = lib.meta.getLicenseFromSpdxId "BSD-3-Clause"; hydraPlatforms = lib.platforms.none; broken = true; } @@ -653164,7 +653164,7 @@ self: { vector ]; description = "A Haskell PGMQ client"; - license = lib.licensesSpdx."BSD-3-Clause"; + license = lib.meta.getLicenseFromSpdxId "BSD-3-Clause"; } ) { }; @@ -653209,7 +653209,7 @@ self: { time ]; description = "Retries for humans"; - license = lib.licensesSpdx."Apache-2.0"; + license = lib.meta.getLicenseFromSpdxId "Apache-2.0"; mainProgram = "readme"; } ) { }; @@ -653309,7 +653309,7 @@ self: { ]; doHaddock = false; description = "Haskell STatic ANalyser"; - license = lib.licensesSpdx."MPL-2.0"; + license = lib.meta.getLicenseFromSpdxId "MPL-2.0"; mainProgram = "stan"; } ) { }; @@ -653943,7 +653943,7 @@ self: { transformers ]; description = "Type-safe and interoperable static values and closures"; - license = lib.licensesSpdx."GPL-3.0-or-later"; + license = lib.meta.getLicenseFromSpdxId "GPL-3.0-or-later"; hydraPlatforms = lib.platforms.none; broken = true; } @@ -654434,7 +654434,7 @@ self: { vector ]; description = "A library of statistical types, data, and functions"; - license = lib.licensesSpdx."BSD-2-Clause"; + license = lib.meta.getLicenseFromSpdxId "BSD-2-Clause"; } ) { }; @@ -654643,7 +654643,7 @@ self: { sha256 = "1cg0db7malqm75rlxxcmp2w00pvlf1kki4fz5p7lc86qy7241vzb"; libraryHaskellDepends = [ base ]; description = "A discrete probability monad with statistics"; - license = lib.licensesSpdx."BSD-3-Clause"; + license = lib.meta.getLicenseFromSpdxId "BSD-3-Clause"; } ) { }; @@ -655174,7 +655174,7 @@ self: { sha256 = "0ldn5yxpj99yhhp5x7zlxjmd9qgqyjg68avr19k7argwcf3nr9y9"; doHaddock = false; description = "TBA"; - license = lib.licensesSpdx."BSD-3-Clause"; + license = lib.meta.getLicenseFromSpdxId "BSD-3-Clause"; } ) { }; @@ -655220,7 +655220,7 @@ self: { template-haskell ]; description = "Binding to Standard Template Library C++"; - license = lib.licensesSpdx."BSD-2-Clause"; + license = lib.meta.getLicenseFromSpdxId "BSD-2-Clause"; } ) { }; @@ -655567,7 +655567,7 @@ self: { QuickCheck ]; description = "Staircase functions or piecewise constant functions"; - license = lib.licensesSpdx."BSD-3-Clause"; + license = lib.meta.getLicenseFromSpdxId "BSD-3-Clause"; } ) { }; @@ -655812,7 +655812,7 @@ self: { stm-queue ]; description = "A simplistic actor model based on STM"; - license = lib.licensesSpdx."MIT"; + license = lib.meta.getLicenseFromSpdxId "MIT"; hydraPlatforms = lib.platforms.none; broken = true; } @@ -655852,7 +655852,7 @@ self: { stm ]; description = "Additional types of channels for STM"; - license = lib.licensesSpdx."BSD-3-Clause"; + license = lib.meta.getLicenseFromSpdxId "BSD-3-Clause"; } ) { }; @@ -656001,7 +656001,7 @@ self: { tasty-quickcheck ]; description = "Containers for STM"; - license = lib.licensesSpdx."MIT"; + license = lib.meta.getLicenseFromSpdxId "MIT"; maintainers = [ lib.maintainers.maralorn ]; } ) { }; @@ -656157,7 +656157,7 @@ self: { rebase ]; description = "STM-specialised Hash Array Mapped Trie"; - license = lib.licensesSpdx."MIT"; + license = lib.meta.getLicenseFromSpdxId "MIT"; } ) { }; @@ -656182,7 +656182,7 @@ self: { stm ]; description = "A library for constructing incremental computations"; - license = lib.licensesSpdx."MIT"; + license = lib.meta.getLicenseFromSpdxId "MIT"; } ) { }; @@ -656338,7 +656338,7 @@ self: { time ]; description = "An implementation of a real-time concurrent queue"; - license = lib.licensesSpdx."MIT"; + license = lib.meta.getLicenseFromSpdxId "MIT"; } ) { }; @@ -656969,7 +656969,7 @@ self: { utility-ht ]; description = "Elegant definition of Storable instances for records"; - license = lib.licensesSpdx."BSD-3-Clause"; + license = lib.meta.getLicenseFromSpdxId "BSD-3-Clause"; maintainers = [ lib.maintainers.thielema ]; } ) { }; @@ -657018,7 +657018,7 @@ self: { utility-ht ]; description = "Storable instance for pairs and triples"; - license = lib.licensesSpdx."BSD-3-Clause"; + license = lib.meta.getLicenseFromSpdxId "BSD-3-Clause"; maintainers = [ lib.maintainers.thielema ]; } ) { }; @@ -657071,7 +657071,7 @@ self: { utility-ht ]; description = "Fast, packed, strict storable arrays with a list interface like ByteString"; - license = lib.licensesSpdx."BSD-3-Clause"; + license = lib.meta.getLicenseFromSpdxId "BSD-3-Clause"; maintainers = [ lib.maintainers.thielema ]; } ) { }; @@ -664039,7 +664039,7 @@ self: { tasty-hunit ]; description = "Attoparsec integration for the streaming ecosystem"; - license = lib.licensesSpdx."BSD-3-Clause"; + license = lib.meta.getLicenseFromSpdxId "BSD-3-Clause"; } ) { }; @@ -664133,7 +664133,7 @@ self: { vector ]; description = "Measures and compares the performance of streaming libraries"; - license = lib.licensesSpdx."MIT"; + license = lib.meta.getLicenseFromSpdxId "MIT"; hydraPlatforms = lib.platforms.none; broken = true; } @@ -664536,7 +664536,7 @@ self: { wai-extra ]; description = "Client-side consumption of a ServerEvent"; - license = lib.licensesSpdx."BSD-3-Clause"; + license = lib.meta.getLicenseFromSpdxId "BSD-3-Clause"; hydraPlatforms = lib.platforms.none; broken = true; } @@ -664765,7 +664765,7 @@ self: { zlib ]; description = "A hand-written streaming byte parser for OpenStreetMap Protobuf data"; - license = lib.licensesSpdx."BSD-3-Clause"; + license = lib.meta.getLicenseFromSpdxId "BSD-3-Clause"; hydraPlatforms = lib.platforms.none; broken = true; } @@ -664812,7 +664812,7 @@ self: { tasty-hunit ]; description = "Stream packets via libpcap"; - license = lib.licensesSpdx."BSD-3-Clause"; + license = lib.meta.getLicenseFromSpdxId "BSD-3-Clause"; hydraPlatforms = lib.platforms.none; broken = true; } @@ -665160,7 +665160,7 @@ self: { unordered-containers ]; description = "Streaming, dataflow programming and declarative concurrency"; - license = lib.licensesSpdx."BSD-3-Clause"; + license = lib.meta.getLicenseFromSpdxId "BSD-3-Clause"; maintainers = [ lib.maintainers.maralorn ]; } ) { }; @@ -665214,7 +665214,7 @@ self: { unordered-containers ]; description = "Streaming data pipelines with declarative concurrency"; - license = lib.licensesSpdx."BSD-3-Clause"; + license = lib.meta.getLicenseFromSpdxId "BSD-3-Clause"; hydraPlatforms = lib.platforms.none; maintainers = [ lib.maintainers.maralorn ]; } @@ -665276,7 +665276,7 @@ self: { ]; testSystemDepends = [ archive ]; description = "Stream data from archives using the streamly library"; - license = lib.licensesSpdx."BSD-3-Clause"; + license = lib.meta.getLicenseFromSpdxId "BSD-3-Clause"; hydraPlatforms = lib.platforms.none; maintainers = [ lib.maintainers.shlok ]; broken = true; @@ -665477,7 +665477,7 @@ self: { unix ]; description = "Streaming, parsers, arrays, serialization and more"; - license = lib.licensesSpdx."BSD-3-Clause"; + license = lib.meta.getLicenseFromSpdxId "BSD-3-Clause"; } ) { }; @@ -665514,7 +665514,7 @@ self: { transformers ]; description = "Streaming, parsers, arrays, serialization and more"; - license = lib.licensesSpdx."BSD-3-Clause"; + license = lib.meta.getLicenseFromSpdxId "BSD-3-Clause"; hydraPlatforms = lib.platforms.none; } ) { }; @@ -665568,7 +665568,7 @@ self: { vector ]; description = "Examples for Streamly"; - license = lib.licensesSpdx."Apache-2.0"; + license = lib.meta.getLicenseFromSpdxId "Apache-2.0"; hydraPlatforms = lib.platforms.none; broken = true; } @@ -665595,7 +665595,7 @@ self: { streamly-core ]; description = "Streamly compatibility with filepath package"; - license = lib.licensesSpdx."Apache-2.0"; + license = lib.meta.getLicenseFromSpdxId "Apache-2.0"; hydraPlatforms = lib.platforms.none; broken = true; } @@ -665633,7 +665633,7 @@ self: { temporary ]; description = "File system event notification API"; - license = lib.licensesSpdx."BSD-3-Clause"; + license = lib.meta.getLicenseFromSpdxId "BSD-3-Clause"; hydraPlatforms = lib.platforms.none; broken = true; } @@ -665670,7 +665670,7 @@ self: { time ]; description = "Folder watching as a Streamly stream"; - license = lib.licensesSpdx."BSD-3-Clause"; + license = lib.meta.getLicenseFromSpdxId "BSD-3-Clause"; } ) { }; @@ -665738,7 +665738,7 @@ self: { ]; testSystemDepends = [ lmdb ]; description = "Stream data to or from LMDB databases using the streamly library"; - license = lib.licensesSpdx."BSD-3-Clause"; + license = lib.meta.getLicenseFromSpdxId "BSD-3-Clause"; hydraPlatforms = lib.platforms.none; maintainers = [ lib.maintainers.shlok ]; broken = true; @@ -665782,7 +665782,7 @@ self: { streamly ]; description = "Streamly combinators for LZ4 compression"; - license = lib.licensesSpdx."Apache-2.0"; + license = lib.meta.getLicenseFromSpdxId "Apache-2.0"; hydraPlatforms = lib.platforms.none; broken = true; } @@ -665878,7 +665878,7 @@ self: { tasty-bench ]; description = "Use OS processes as stream transformation functions"; - license = lib.licensesSpdx."Apache-2.0"; + license = lib.meta.getLicenseFromSpdxId "Apache-2.0"; hydraPlatforms = lib.platforms.none; broken = true; } @@ -665923,7 +665923,7 @@ self: { tasty-bench ]; description = "Use OS processes as stream transformation functions"; - license = lib.licensesSpdx."Apache-2.0"; + license = lib.meta.getLicenseFromSpdxId "Apache-2.0"; hydraPlatforms = lib.platforms.none; broken = true; } @@ -665981,7 +665981,7 @@ self: { tasty-bench ]; description = "Statistical measures for finite or infinite data streams"; - license = lib.licensesSpdx."Apache-2.0"; + license = lib.meta.getLicenseFromSpdxId "Apache-2.0"; hydraPlatforms = lib.platforms.none; broken = true; } @@ -666017,7 +666017,7 @@ self: { text ]; description = "Library for streamly and text interoperation"; - license = lib.licensesSpdx."BSD-3-Clause"; + license = lib.meta.getLicenseFromSpdxId "BSD-3-Clause"; hydraPlatforms = lib.platforms.none; broken = true; } @@ -666077,7 +666077,7 @@ self: { ]; testSystemDepends = [ zip ]; description = "Stream data from zip archives using the streamly library"; - license = lib.licensesSpdx."BSD-3-Clause"; + license = lib.meta.getLicenseFromSpdxId "BSD-3-Clause"; hydraPlatforms = lib.platforms.none; broken = true; } @@ -666397,7 +666397,7 @@ self: { tasty-quickcheck ]; description = "Strict MVars and TVars with invariant checking for IO and IOSim"; - license = lib.licensesSpdx."Apache-2.0"; + license = lib.meta.getLicenseFromSpdxId "Apache-2.0"; hydraPlatforms = lib.platforms.none; broken = true; } @@ -666490,7 +666490,7 @@ self: { vector ]; description = "Strict containers"; - license = lib.licensesSpdx."BSD-3-Clause"; + license = lib.meta.getLicenseFromSpdxId "BSD-3-Clause"; hydraPlatforms = lib.platforms.none; broken = true; } @@ -666748,7 +666748,7 @@ self: { tasty-quickcheck ]; description = "Strict linked list"; - license = lib.licensesSpdx."MIT"; + license = lib.meta.getLicenseFromSpdxId "MIT"; } ) { }; @@ -666767,7 +666767,7 @@ self: { deepseq ]; description = "Strict variants of mutable data types from base"; - license = lib.licensesSpdx."BSD-3-Clause"; + license = lib.meta.getLicenseFromSpdxId "BSD-3-Clause"; } ) { }; @@ -666801,7 +666801,7 @@ self: { tasty-quickcheck ]; description = "Strict MVars for IO and IOSim"; - license = lib.licensesSpdx."Apache-2.0"; + license = lib.meta.getLicenseFromSpdxId "Apache-2.0"; hydraPlatforms = lib.platforms.none; broken = true; } @@ -666849,7 +666849,7 @@ self: { stm ]; description = "Strict STM interface polymorphic over stm implementation"; - license = lib.licensesSpdx."Apache-2.0"; + license = lib.meta.getLicenseFromSpdxId "Apache-2.0"; hydraPlatforms = lib.platforms.none; broken = true; } @@ -666877,7 +666877,7 @@ self: { ]; testHaskellDepends = [ base ]; description = "Strict tuples"; - license = lib.licensesSpdx."BSD-3-Clause"; + license = lib.meta.getLicenseFromSpdxId "BSD-3-Clause"; } ) { }; @@ -666898,7 +666898,7 @@ self: { strict-tuple ]; description = "Optics for the `strict-tuple` library"; - license = lib.licensesSpdx."BSD-3-Clause"; + license = lib.meta.getLicenseFromSpdxId "BSD-3-Clause"; hydraPlatforms = lib.platforms.none; broken = true; } @@ -666946,7 +666946,7 @@ self: { libraryHaskellDepends = [ base ]; testHaskellDepends = [ base ]; description = "Lightweight strict types"; - license = lib.licensesSpdx."MIT"; + license = lib.meta.getLicenseFromSpdxId "MIT"; } ) { }; @@ -667969,7 +667969,7 @@ self: { text ]; description = "Types for the Stripe API"; - license = lib.licensesSpdx."MIT"; + license = lib.meta.getLicenseFromSpdxId "MIT"; maintainers = [ lib.maintainers.mpscholten ]; } ) { }; @@ -668220,7 +668220,7 @@ self: { text ]; description = "Listen for Stripe webhook events with Scotty"; - license = lib.licensesSpdx."MIT"; + license = lib.meta.getLicenseFromSpdxId "MIT"; hydraPlatforms = lib.platforms.none; broken = true; } @@ -668290,7 +668290,7 @@ self: { text ]; description = "Verification of Stripe webhook signatures"; - license = lib.licensesSpdx."MIT"; + license = lib.meta.getLicenseFromSpdxId "MIT"; maintainers = [ lib.maintainers.mpscholten ]; } ) { }; @@ -668362,7 +668362,7 @@ self: { wreq ]; description = "Use the Stripe API via Wreq"; - license = lib.licensesSpdx."MIT"; + license = lib.meta.getLicenseFromSpdxId "MIT"; } ) { }; @@ -668475,7 +668475,7 @@ self: { transformers ]; description = "A client for the Strava V3 API"; - license = lib.licensesSpdx."MIT"; + license = lib.meta.getLicenseFromSpdxId "MIT"; } ) { }; @@ -668512,7 +668512,7 @@ self: { transformers ]; description = "A client for the Strava V3 API"; - license = lib.licensesSpdx."MIT"; + license = lib.meta.getLicenseFromSpdxId "MIT"; hydraPlatforms = lib.platforms.none; } ) { }; @@ -668756,7 +668756,7 @@ self: { utf8-string ]; description = "Inspect the padding and size of C data declarations and their fields"; - license = lib.licensesSpdx."BSD-3-Clause"; + license = lib.meta.getLicenseFromSpdxId "BSD-3-Clause"; hydraPlatforms = lib.platforms.none; mainProgram = "struct-inspector"; broken = true; @@ -668914,7 +668914,7 @@ self: { vector ]; description = "Structure (hash) of your data types"; - license = lib.licensesSpdx."BSD-3-Clause"; + license = lib.meta.getLicenseFromSpdxId "BSD-3-Clause"; hydraPlatforms = lib.platforms.none; broken = true; } @@ -669487,7 +669487,7 @@ self: { text ]; description = "Haskell code prettifier"; - license = lib.licensesSpdx."BSD-3-Clause"; + license = lib.meta.getLicenseFromSpdxId "BSD-3-Clause"; hydraPlatforms = lib.platforms.none; mainProgram = "stylish-haskell"; } @@ -669586,7 +669586,7 @@ self: { text ]; description = "Haskell code prettifier"; - license = lib.licensesSpdx."BSD-3-Clause"; + license = lib.meta.getLicenseFromSpdxId "BSD-3-Clause"; hydraPlatforms = lib.platforms.none; mainProgram = "stylish-haskell"; } @@ -669685,7 +669685,7 @@ self: { text ]; description = "Haskell code prettifier"; - license = lib.licensesSpdx."BSD-3-Clause"; + license = lib.meta.getLicenseFromSpdxId "BSD-3-Clause"; hydraPlatforms = lib.platforms.none; mainProgram = "stylish-haskell"; } @@ -669784,7 +669784,7 @@ self: { text ]; description = "Haskell code prettifier"; - license = lib.licensesSpdx."BSD-3-Clause"; + license = lib.meta.getLicenseFromSpdxId "BSD-3-Clause"; mainProgram = "stylish-haskell"; } ) { }; @@ -670142,7 +670142,7 @@ self: { ]; testToolDepends = [ tasty-discover ]; description = "Subcategories induced by class constraints"; - license = lib.licensesSpdx."BSD-3-Clause"; + license = lib.meta.getLicenseFromSpdxId "BSD-3-Clause"; } ) { }; @@ -670431,7 +670431,7 @@ self: { websockets ]; description = "Plexus protocol types and client for Substrate"; - license = lib.licensesSpdx."MIT"; + license = lib.meta.getLicenseFromSpdxId "MIT"; hydraPlatforms = lib.platforms.none; broken = true; } @@ -670515,7 +670515,7 @@ self: { text ]; description = "Algebraic CLI for Plexus - coalgebraic schema navigation"; - license = lib.licensesSpdx."MIT"; + license = lib.meta.getLicenseFromSpdxId "MIT"; hydraPlatforms = lib.platforms.none; mainProgram = "synapse"; } @@ -670873,7 +670873,7 @@ self: { ]; doHaddock = false; description = "Memory efficient JSON parser"; - license = lib.licensesSpdx."BSD-3-Clause"; + license = lib.meta.getLicenseFromSpdxId "BSD-3-Clause"; hydraPlatforms = lib.platforms.none; broken = true; } @@ -670911,7 +670911,7 @@ self: { tasty-quickcheck ]; description = "Suffix arrays and friends"; - license = lib.licensesSpdx."BSD-3-Clause"; + license = lib.meta.getLicenseFromSpdxId "BSD-3-Clause"; } ) { }; @@ -671337,7 +671337,7 @@ self: { generics-sop ]; description = "An implementation of extensible products and sums"; - license = lib.licensesSpdx."MIT"; + license = lib.meta.getLicenseFromSpdxId "MIT"; hydraPlatforms = lib.platforms.none; broken = true; } @@ -671404,7 +671404,7 @@ self: { validation-selective ]; description = "Tool for scaffolding fully configured batteries-included production-level Haskell projects"; - license = lib.licensesSpdx."MPL-2.0"; + license = lib.meta.getLicenseFromSpdxId "MPL-2.0"; hydraPlatforms = lib.platforms.none; broken = true; } @@ -671449,7 +671449,7 @@ self: { relude ]; description = "Tool for scaffolding fully configured batteries-included production-level Haskell projects using TUI"; - license = lib.licensesSpdx."MPL-2.0"; + license = lib.meta.getLicenseFromSpdxId "MPL-2.0"; hydraPlatforms = lib.platforms.none; mainProgram = "summon-tui"; } @@ -672167,7 +672167,7 @@ self: { text ]; description = "Apache Pulsar client for Haskell"; - license = lib.licensesSpdx."Apache-2.0"; + license = lib.meta.getLicenseFromSpdxId "Apache-2.0"; hydraPlatforms = lib.platforms.none; } ) { }; @@ -672320,7 +672320,7 @@ self: { hspec ]; description = "Monitor groups of threads with non-hierarchical lifetimes"; - license = lib.licensesSpdx."MIT"; + license = lib.meta.getLicenseFromSpdxId "MIT"; hydraPlatforms = lib.platforms.none; broken = true; } @@ -672380,7 +672380,7 @@ self: { supply-chain-core ]; description = "Composable request-response pipelines"; - license = lib.licensesSpdx."Apache-2.0"; + license = lib.meta.getLicenseFromSpdxId "Apache-2.0"; hydraPlatforms = lib.platforms.none; } ) { }; @@ -672401,7 +672401,7 @@ self: { hspec ]; description = "Composable request-response pipelines"; - license = lib.licensesSpdx."Apache-2.0"; + license = lib.meta.getLicenseFromSpdxId "Apache-2.0"; hydraPlatforms = lib.platforms.none; broken = true; } @@ -672444,7 +672444,7 @@ self: { transformers ]; description = "Supply-chain interface for basic streaming"; - license = lib.licensesSpdx."Apache-2.0"; + license = lib.meta.getLicenseFromSpdxId "Apache-2.0"; hydraPlatforms = lib.platforms.none; } ) { }; @@ -672774,7 +672774,7 @@ self: { happy ]; description = "SystemVerilog to Verilog conversion"; - license = lib.licensesSpdx."BSD-3-Clause"; + license = lib.meta.getLicenseFromSpdxId "BSD-3-Clause"; mainProgram = "sv2v"; } ) { }; @@ -672937,7 +672937,7 @@ self: { text ]; description = "Svg Icons and more"; - license = lib.licensesSpdx."BSD-3-Clause"; + license = lib.meta.getLicenseFromSpdxId "BSD-3-Clause"; mainProgram = "svg-icons-exe"; } ) { }; @@ -673116,7 +673116,7 @@ self: { text ]; description = "Optimise SVGs"; - license = lib.licensesSpdx."BSD-3-Clause"; + license = lib.meta.getLicenseFromSpdxId "BSD-3-Clause"; mainProgram = "svgone"; } ) { }; @@ -673156,7 +673156,7 @@ self: { xml ]; description = "A tool to prune unused symbols from icon SVG files"; - license = lib.licensesSpdx."GPL-3.0-or-later"; + license = lib.meta.getLicenseFromSpdxId "GPL-3.0-or-later"; hydraPlatforms = lib.platforms.none; mainProgram = "svgsym"; broken = true; @@ -673928,7 +673928,7 @@ self: { ]; doHaddock = false; description = "2D resource gathering game with programmable robots"; - license = lib.licensesSpdx."BSD-3-Clause"; + license = lib.meta.getLicenseFromSpdxId "BSD-3-Clause"; hydraPlatforms = lib.platforms.none; broken = true; } @@ -674134,7 +674134,7 @@ self: { time ]; description = "A semantic web toolkit"; - license = lib.licensesSpdx."LGPL-2.1-or-later"; + license = lib.meta.getLicenseFromSpdxId "LGPL-2.1-or-later"; mainProgram = "Swish"; } ) { }; @@ -674311,7 +674311,7 @@ self: { template-haskell ]; description = "Swizzle functions"; - license = lib.licensesSpdx."BSD-3-Clause"; + license = lib.meta.getLicenseFromSpdxId "BSD-3-Clause"; } ) { }; @@ -674340,7 +674340,7 @@ self: { template-haskell ]; description = "Swizzle lens functions"; - license = lib.licensesSpdx."BSD-3-Clause"; + license = lib.meta.getLicenseFromSpdxId "BSD-3-Clause"; } ) { }; @@ -674369,7 +674369,7 @@ self: { template-haskell ]; description = "Swizzle modify functions"; - license = lib.licensesSpdx."BSD-3-Clause"; + license = lib.meta.getLicenseFromSpdxId "BSD-3-Clause"; } ) { }; @@ -674392,7 +674392,7 @@ self: { template-haskell ]; description = "Swizzle set functions"; - license = lib.licensesSpdx."BSD-3-Clause"; + license = lib.meta.getLicenseFromSpdxId "BSD-3-Clause"; } ) { }; @@ -675898,7 +675898,7 @@ self: { unordered-containers ]; description = "Basic symantic combinators for Embedded Domain-Specific Languages (EDSL)"; - license = lib.licensesSpdx."AGPL-3.0-or-later"; + license = lib.meta.getLicenseFromSpdxId "AGPL-3.0-or-later"; } ) { }; @@ -675963,7 +675963,7 @@ self: { transformers ]; description = "Symantics combinators for generating documents"; - license = lib.licensesSpdx."AGPL-3.0-or-later"; + license = lib.meta.getLicenseFromSpdxId "AGPL-3.0-or-later"; } ) { }; @@ -676482,7 +676482,7 @@ self: { ]; doHaddock = false; description = "Parser combinators statically optimized and staged via typed meta-programming"; - license = lib.licensesSpdx."AGPL-3.0-or-later"; + license = lib.meta.getLicenseFromSpdxId "AGPL-3.0-or-later"; hydraPlatforms = lib.platforms.none; broken = true; } @@ -676719,7 +676719,7 @@ self: { unix ]; description = "Symlink functions"; - license = lib.licensesSpdx."BSD-3-Clause"; + license = lib.meta.getLicenseFromSpdxId "BSD-3-Clause"; hydraPlatforms = lib.platforms.none; broken = true; } @@ -676799,7 +676799,7 @@ self: { ]; testHaskellDepends = [ base ]; description = "Symbolic Regression in Haskell"; - license = lib.licensesSpdx."MIT"; + license = lib.meta.getLicenseFromSpdxId "MIT"; hydraPlatforms = lib.platforms.none; broken = true; } @@ -676820,7 +676820,7 @@ self: { youProbablyWantSymbolizeWithAZ ]; description = "You want Symbolize with a Z"; - license = lib.licensesSpdx."BSD-3-Clause"; + license = lib.meta.getLicenseFromSpdxId "BSD-3-Clause"; hydraPlatforms = lib.platforms.none; broken = true; } @@ -676899,7 +676899,7 @@ self: { vector-hashtables ]; description = "Efficient global Symbol table, with Garbage Collection"; - license = lib.licensesSpdx."BSD-3-Clause"; + license = lib.meta.getLicenseFromSpdxId "BSD-3-Clause"; } ) { }; @@ -677222,7 +677222,7 @@ self: { random ]; description = "Synapse is a machine learning library written in pure Haskell"; - license = lib.licensesSpdx."MIT"; + license = lib.meta.getLicenseFromSpdxId "MIT"; hydraPlatforms = lib.platforms.none; } ) { }; @@ -677306,7 +677306,7 @@ self: { text ]; description = "Unified compiler toolchain for Plexus backends"; - license = lib.licensesSpdx."MIT"; + license = lib.meta.getLicenseFromSpdxId "MIT"; hydraPlatforms = lib.platforms.none; mainProgram = "synapse-cc"; } @@ -678102,7 +678102,7 @@ self: { utility-ht ]; description = "Control synthesizer effects via ALSA/MIDI"; - license = lib.licensesSpdx."GPL-3.0-only"; + license = lib.meta.getLicenseFromSpdxId "GPL-3.0-only"; badPlatforms = lib.platforms.darwin; maintainers = [ lib.maintainers.thielema ]; } @@ -678397,7 +678397,7 @@ self: { ]; doHaddock = false; description = "Efficient signal processing using runtime compilation"; - license = lib.licensesSpdx."GPL-3.0-only"; + license = lib.meta.getLicenseFromSpdxId "GPL-3.0-only"; hydraPlatforms = lib.platforms.none; broken = true; } @@ -678597,7 +678597,7 @@ self: { primitive ]; description = "Decode RFC 3164 and RFC 5424 syslog message formats"; - license = lib.licensesSpdx."BSD-3-Clause"; + license = lib.meta.getLicenseFromSpdxId "BSD-3-Clause"; } ) { }; @@ -679258,7 +679258,7 @@ self: { ]; librarySystemDepends = [ systemd ]; description = "systemd bindings"; - license = lib.licensesSpdx."BSD-3-Clause"; + license = lib.meta.getLicenseFromSpdxId "BSD-3-Clause"; platforms = lib.platforms.linux; } ) { inherit (pkgs) systemd; }; @@ -679292,7 +679292,7 @@ self: { wreq ]; description = "Send notifications for systemd units to ntfy.sh"; - license = lib.licensesSpdx."GPL-3.0-only"; + license = lib.meta.getLicenseFromSpdxId "GPL-3.0-only"; hydraPlatforms = lib.platforms.none; mainProgram = "systemd-ntfy"; broken = true; @@ -679324,7 +679324,7 @@ self: { unix ]; description = "Let systemd bind the server's socket for you"; - license = lib.licensesSpdx."MIT"; + license = lib.meta.getLicenseFromSpdxId "MIT"; hydraPlatforms = lib.platforms.none; broken = true; } @@ -679424,7 +679424,7 @@ self: { ]; testToolDepends = [ tasty-autocollect ]; description = "Let you put anything in the system tray"; - license = lib.licensesSpdx."MIT"; + license = lib.meta.getLicenseFromSpdxId "MIT"; mainProgram = "systranything"; } ) { }; @@ -680257,7 +680257,7 @@ self: { testToolDepends = [ hspec-discover ]; doHaddock = false; description = "A desktop bar similar to xmobar, but with more GUI"; - license = lib.licensesSpdx."BSD-3-Clause"; + license = lib.meta.getLicenseFromSpdxId "BSD-3-Clause"; badPlatforms = lib.platforms.darwin; maintainers = [ lib.maintainers.rvl ]; } @@ -680485,7 +680485,7 @@ self: { transformers ]; description = "Trivial monad transformer that allows identical monad stacks to have different types"; - license = lib.licensesSpdx."BSD-3-Clause"; + license = lib.meta.getLicenseFromSpdxId "BSD-3-Clause"; } ) { }; @@ -681067,7 +681067,7 @@ self: { utf8-string ]; description = "Black magic tagsoup"; - license = lib.licensesSpdx."BSD-3-Clause"; + license = lib.meta.getLicenseFromSpdxId "BSD-3-Clause"; mainProgram = "tagstew"; } ) { }; @@ -681155,7 +681155,7 @@ self: { text ]; description = "Hierarchical Tags & Tag Trees"; - license = lib.licensesSpdx."BSD-3-Clause"; + license = lib.meta.getLicenseFromSpdxId "BSD-3-Clause"; } ) { }; @@ -681175,7 +681175,7 @@ self: { ]; testHaskellDepends = [ base ]; description = "Abstractions related to Tahoe-LAFS \"capabilities\""; - license = lib.licensesSpdx."LGPL-3.0-or-later"; + license = lib.meta.getLicenseFromSpdxId "LGPL-3.0-or-later"; hydraPlatforms = lib.platforms.none; broken = true; } @@ -681333,7 +681333,7 @@ self: { text ]; description = "Tahoe-LAFS directory-like abstraction for collections of data objects"; - license = lib.licensesSpdx."BSD-3-Clause"; + license = lib.meta.getLicenseFromSpdxId "BSD-3-Clause"; hydraPlatforms = lib.platforms.none; } ) { }; @@ -681542,7 +681542,7 @@ self: { yaml ]; description = "An implementation of the \"Great Black Swamp\" LAFS protocol"; - license = lib.licensesSpdx."BSD-3-Clause"; + license = lib.meta.getLicenseFromSpdxId "BSD-3-Clause"; hydraPlatforms = lib.platforms.none; } ) { }; @@ -681588,7 +681588,7 @@ self: { utility-ht ]; description = "An HSpec for Great Black Swamp storage backends"; - license = lib.licensesSpdx."Apache-2.0"; + license = lib.meta.getLicenseFromSpdxId "Apache-2.0"; hydraPlatforms = lib.platforms.none; } ) { }; @@ -681622,7 +681622,7 @@ self: { text ]; description = "Types related to implementation of a Tahoe-LAFS Great Black Swamp server"; - license = lib.licensesSpdx."Apache-2.0"; + license = lib.meta.getLicenseFromSpdxId "Apache-2.0"; hydraPlatforms = lib.platforms.none; broken = true; } @@ -681706,7 +681706,7 @@ self: { x509 ]; description = "An implementation of the Tahoe-LAFS SSK cryptographic protocols"; - license = lib.licensesSpdx."BSD-3-Clause"; + license = lib.meta.getLicenseFromSpdxId "BSD-3-Clause"; hydraPlatforms = lib.platforms.none; } ) { }; @@ -681977,7 +681977,7 @@ self: { with-utf8 ]; description = "Tailwind wrapped in Haskell"; - license = lib.licensesSpdx."MIT"; + license = lib.meta.getLicenseFromSpdxId "MIT"; hydraPlatforms = lib.platforms.none; mainProgram = "tailwind-run"; broken = true; @@ -682044,7 +682044,7 @@ self: { ]; doHaddock = false; description = "Library and CLI for working with ID numbers issued in Taiwan"; - license = lib.licensesSpdx."BSD-3-Clause"; + license = lib.meta.getLicenseFromSpdxId "BSD-3-Clause"; hydraPlatforms = lib.platforms.none; mainProgram = "taiwan-id"; broken = true; @@ -682323,7 +682323,7 @@ self: { ]; executableHaskellDepends = [ base ]; description = "Line oriented fast enough text search"; - license = lib.licensesSpdx."GPL-3.0-only"; + license = lib.meta.getLicenseFromSpdxId "GPL-3.0-only"; hydraPlatforms = lib.platforms.none; mainProgram = "talash"; broken = true; @@ -682650,7 +682650,7 @@ self: { transformers ]; description = "Heterogenous memoisation monad"; - license = lib.licensesSpdx."BSD-3-Clause"; + license = lib.meta.getLicenseFromSpdxId "BSD-3-Clause"; } ) { }; @@ -682720,7 +682720,7 @@ self: { vector ]; description = "A tasty enhancement to cassava for easy csv exporting"; - license = lib.licensesSpdx."BSD-3-Clause"; + license = lib.meta.getLicenseFromSpdxId "BSD-3-Clause"; hydraPlatforms = lib.platforms.none; broken = true; } @@ -682793,7 +682793,7 @@ self: { ]; doHaddock = false; description = "Reading, writing and manipulating \".tar\" archive files."; - license = lib.licensesSpdx."BSD-3-Clause"; + license = lib.meta.getLicenseFromSpdxId "BSD-3-Clause"; hydraPlatforms = lib.platforms.none; } ) { }; @@ -682870,7 +682870,7 @@ self: { ]; doHaddock = false; description = "Reading, writing and manipulating \".tar\" archive files."; - license = lib.licensesSpdx."BSD-3-Clause"; + license = lib.meta.getLicenseFromSpdxId "BSD-3-Clause"; } ) { }; @@ -682941,7 +682941,7 @@ self: { ]; doHaddock = false; description = "Reading, writing and manipulating \".tar\" archive files."; - license = lib.licensesSpdx."BSD-3-Clause"; + license = lib.meta.getLicenseFromSpdxId "BSD-3-Clause"; hydraPlatforms = lib.platforms.none; } ) { }; @@ -683267,7 +683267,7 @@ self: { QuickCheck ]; description = "Targeted generators for QuickCheck"; - license = lib.licensesSpdx."MIT"; + license = lib.meta.getLicenseFromSpdxId "MIT"; hydraPlatforms = lib.platforms.none; broken = true; } @@ -683622,7 +683622,7 @@ self: { temporary ]; description = "CLI task / todo list manager with SQLite backend"; - license = lib.licensesSpdx."AGPL-3.0-or-later"; + license = lib.meta.getLicenseFromSpdxId "AGPL-3.0-or-later"; hydraPlatforms = lib.platforms.none; mainProgram = "tasklite"; } @@ -683760,7 +683760,7 @@ self: { protolude ]; description = "CLI task / todo list manager with SQLite backend"; - license = lib.licensesSpdx."AGPL-3.0-or-later"; + license = lib.meta.getLicenseFromSpdxId "AGPL-3.0-or-later"; hydraPlatforms = lib.platforms.none; } ) { }; @@ -683847,7 +683847,7 @@ self: { ]; testToolDepends = [ hspec-discover ]; description = "Types and aeson instances for taskwarrior tasks"; - license = lib.licensesSpdx."AGPL-3.0-or-later"; + license = lib.meta.getLicenseFromSpdxId "AGPL-3.0-or-later"; maintainers = [ lib.maintainers.maralorn ]; } ) { }; @@ -684238,7 +684238,7 @@ self: { text ]; description = "Check multiple items during a tasty test"; - license = lib.licensesSpdx."ISC"; + license = lib.meta.getLicenseFromSpdxId "ISC"; } ) { }; @@ -684265,7 +684265,7 @@ self: { tasty ]; description = "Ingredient for tasty which generates per-test coverage reports"; - license = lib.licensesSpdx."BSD-3-Clause"; + license = lib.meta.getLicenseFromSpdxId "BSD-3-Clause"; } ) { }; @@ -684346,7 +684346,7 @@ self: { tasty-smallcheck ]; description = "Test discovery for the tasty framework"; - license = lib.licensesSpdx."MIT"; + license = lib.meta.getLicenseFromSpdxId "MIT"; mainProgram = "tasty-discover"; } ) { }; @@ -684416,7 +684416,7 @@ self: { temporary ]; description = "Test discovery for the tasty framework"; - license = lib.licensesSpdx."MIT"; + license = lib.meta.getLicenseFromSpdxId "MIT"; hydraPlatforms = lib.platforms.none; mainProgram = "tasty-discover"; } @@ -684522,7 +684522,7 @@ self: { tasty-hunit ]; description = "Handle flaky Tasty-based tests"; - license = lib.licensesSpdx."BSD-3-Clause"; + license = lib.meta.getLicenseFromSpdxId "BSD-3-Clause"; } ) { }; @@ -684551,7 +684551,7 @@ self: { tasty-hunit ]; description = "Simple focus mechanism for tasty"; - license = lib.licensesSpdx."BSD-3-Clause"; + license = lib.meta.getLicenseFromSpdxId "BSD-3-Clause"; } ) { }; @@ -684641,7 +684641,7 @@ self: { yaml ]; description = "Additional golden test helpers for the tasty-golden package"; - license = lib.licensesSpdx."BSD-3-Clause"; + license = lib.meta.getLicenseFromSpdxId "BSD-3-Clause"; } ) { }; @@ -684678,7 +684678,7 @@ self: { text ]; description = "Grade your tasty-testsuite"; - license = lib.licensesSpdx."BSD-3-Clause"; + license = lib.meta.getLicenseFromSpdxId "BSD-3-Clause"; hydraPlatforms = lib.platforms.none; broken = true; } @@ -684823,7 +684823,7 @@ self: { tasty-hunit ]; description = "Tasty helpers to test HsLua"; - license = lib.licensesSpdx."MIT"; + license = lib.meta.getLicenseFromSpdxId "MIT"; } ) { }; @@ -684856,7 +684856,7 @@ self: { tasty-smallcheck ]; description = "Hspec support for the Tasty test framework"; - license = lib.licensesSpdx."BSD-3-Clause"; + license = lib.meta.getLicenseFromSpdxId "BSD-3-Clause"; } ) { }; @@ -685161,7 +685161,7 @@ self: { text ]; description = "JSON reporter for the tasty testing framework"; - license = lib.licensesSpdx."MIT"; + license = lib.meta.getLicenseFromSpdxId "MIT"; } ) { }; @@ -685331,7 +685331,7 @@ self: { tasty-hunit ]; description = "Write tests in Lua, integrate into tasty"; - license = lib.licensesSpdx."MIT"; + license = lib.meta.getLicenseFromSpdxId "MIT"; } ) { }; @@ -685446,7 +685446,7 @@ self: { tasty-focus ]; description = "Unopinionated top-level entry point to tasty ecosystem"; - license = lib.licensesSpdx."MPL-2.0"; + license = lib.meta.getLicenseFromSpdxId "MPL-2.0"; } ) { }; @@ -685643,7 +685643,7 @@ self: { transformers ]; description = "Rerun only tests which failed in a previous test run"; - license = lib.licensesSpdx."BSD-3-Clause"; + license = lib.meta.getLicenseFromSpdxId "BSD-3-Clause"; } ) { }; @@ -685937,7 +685937,7 @@ self: { tasty ]; description = "Test vector support for tasty"; - license = lib.licensesSpdx."BSD-3-Clause"; + license = lib.meta.getLicenseFromSpdxId "BSD-3-Clause"; hydraPlatforms = lib.platforms.none; broken = true; } @@ -686128,7 +686128,7 @@ self: { profunctors ]; description = "Types and combinators for taxes"; - license = lib.licensesSpdx."AGPL-3.0-or-later"; + license = lib.meta.getLicenseFromSpdxId "AGPL-3.0-or-later"; } ) { }; @@ -686153,7 +686153,7 @@ self: { time ]; description = "Tax types and computations for Australia"; - license = lib.licensesSpdx."AGPL-3.0-or-later"; + license = lib.meta.getLicenseFromSpdxId "AGPL-3.0-or-later"; } ) { }; @@ -686570,7 +686570,7 @@ self: { vector-algorithms ]; description = "On-line accumulation of rank-based statistics"; - license = lib.licensesSpdx."BSD-3-Clause"; + license = lib.meta.getLicenseFromSpdxId "BSD-3-Clause"; } ) { }; @@ -687214,7 +687214,7 @@ self: { webgear-core ]; description = "Easily define multiple interrelated data types"; - license = lib.licensesSpdx."BSD-3-Clause"; + license = lib.meta.getLicenseFromSpdxId "BSD-3-Clause"; hydraPlatforms = lib.platforms.none; mainProgram = "tedious-web-exe"; broken = true; @@ -687256,7 +687256,7 @@ self: { prettyprinter-ansi-terminal ]; description = "Prettier error"; - license = lib.licensesSpdx."BSD-3-Clause"; + license = lib.meta.getLicenseFromSpdxId "BSD-3-Clause"; hydraPlatforms = lib.platforms.none; broken = true; } @@ -687737,7 +687737,7 @@ self: { in-other-words ]; description = "Binding to the telegraph API"; - license = lib.licensesSpdx."BSD-3-Clause"; + license = lib.meta.getLicenseFromSpdxId "BSD-3-Clause"; hydraPlatforms = lib.platforms.none; broken = true; } @@ -687927,7 +687927,7 @@ self: { transformers ]; description = "The MonadTell class and related monad transformers"; - license = lib.licensesSpdx."BSD-3-Clause"; + license = lib.meta.getLicenseFromSpdxId "BSD-3-Clause"; hydraPlatforms = lib.platforms.none; broken = true; } @@ -688147,7 +688147,7 @@ self: { template-haskell ]; description = "Backward-compatibility layer for Template Haskell newer than 2.8"; - license = lib.licensesSpdx."MIT"; + license = lib.meta.getLicenseFromSpdxId "MIT"; } ) { }; @@ -688168,7 +688168,7 @@ self: { template-haskell ]; description = "The 'Lift' typeclass"; - license = lib.licensesSpdx."BSD-2-Clause"; + license = lib.meta.getLicenseFromSpdxId "BSD-2-Clause"; } ) { }; @@ -688216,7 +688216,7 @@ self: { template-haskell ]; description = "The 'QuasiQuoter' interface"; - license = lib.licensesSpdx."BSD-2-Clause"; + license = lib.meta.getLicenseFromSpdxId "BSD-2-Clause"; } ) { }; @@ -688567,7 +688567,7 @@ self: { ]; doHaddock = false; description = "You can use template.hs to create a new Haskell GitHub repository."; - license = lib.licensesSpdx."Unlicense"; + license = lib.meta.getLicenseFromSpdxId "Unlicense"; hydraPlatforms = lib.platforms.none; mainProgram = "initialise"; broken = true; @@ -688686,7 +688686,7 @@ self: { proto-lens-protobuf-types proto-lens-runtime ]; - license = lib.licensesSpdx."BSD-3-Clause"; + license = lib.meta.getLicenseFromSpdxId "BSD-3-Clause"; } ) { }; @@ -688959,7 +688959,7 @@ self: { zlib ]; testToolDepends = [ hspec-discover ]; - license = lib.licensesSpdx."BSD-3-Clause"; + license = lib.meta.getLicenseFromSpdxId "BSD-3-Clause"; hydraPlatforms = lib.platforms.none; } ) { }; @@ -689022,7 +689022,7 @@ self: { vector ]; librarySystemDepends = [ temporal_bridge ]; - license = lib.licensesSpdx."BSD-3-Clause"; + license = lib.meta.getLicenseFromSpdxId "BSD-3-Clause"; hydraPlatforms = lib.platforms.none; broken = true; } @@ -689108,7 +689108,7 @@ self: { unix ]; description = "Portable temporary file and directory support"; - license = lib.licensesSpdx."BSD-3-Clause"; + license = lib.meta.getLicenseFromSpdxId "BSD-3-Clause"; } ) { }; @@ -690073,7 +690073,7 @@ self: { QuickCheck ]; description = "Tunable sorting for responsive robustness and beyond"; - license = lib.licensesSpdx."MIT"; + license = lib.meta.getLicenseFromSpdxId "MIT"; mainProgram = "tensort"; } ) { }; @@ -690134,7 +690134,7 @@ self: { termbox-bindings-hs ]; description = "termbox"; - license = lib.licensesSpdx."BSD-3-Clause"; + license = lib.meta.getLicenseFromSpdxId "BSD-3-Clause"; } ) { }; @@ -690157,7 +690157,7 @@ self: { termbox ]; description = "termbox + reactive-banana"; - license = lib.licensesSpdx."BSD-3-Clause"; + license = lib.meta.getLicenseFromSpdxId "BSD-3-Clause"; } ) { }; @@ -690192,7 +690192,7 @@ self: { sha256 = "0da1jq7x2bp92k6ffn4v1mv9c13lm73rj0sjpqkjcrpgygajrqxm"; libraryHaskellDepends = [ base ]; description = "termbox bindings"; - license = lib.licensesSpdx."BSD-3-Clause"; + license = lib.meta.getLicenseFromSpdxId "BSD-3-Clause"; } ) { }; @@ -690211,7 +690211,7 @@ self: { termbox-bindings-c ]; description = "termbox bindings"; - license = lib.licensesSpdx."BSD-3-Clause"; + license = lib.meta.getLicenseFromSpdxId "BSD-3-Clause"; } ) { }; @@ -690234,7 +690234,7 @@ self: { termbox ]; description = "termbox + The Elm Architecture"; - license = lib.licensesSpdx."BSD-3-Clause"; + license = lib.meta.getLicenseFromSpdxId "BSD-3-Clause"; } ) { }; @@ -690944,7 +690944,7 @@ self: { tls ]; description = "create temporary SSL certificates in tests"; - license = lib.licensesSpdx."BSD-3-Clause"; + license = lib.meta.getLicenseFromSpdxId "BSD-3-Clause"; } ) { }; @@ -691557,7 +691557,7 @@ self: { simple-get-opt ]; description = "A library to make a quick test-runner script"; - license = lib.licensesSpdx."ISC"; + license = lib.meta.getLicenseFromSpdxId "ISC"; hydraPlatforms = lib.platforms.none; mainProgram = "test-runner"; broken = true; @@ -692111,7 +692111,7 @@ self: { text ]; description = "Testcontainers integration for PostgreSQL"; - license = lib.licensesSpdx."MIT"; + license = lib.meta.getLicenseFromSpdxId "MIT"; } ) { }; @@ -692194,7 +692194,7 @@ self: { vec ]; description = "Pure implementation of tensors, for use in tests"; - license = lib.licensesSpdx."BSD-3-Clause"; + license = lib.meta.getLicenseFromSpdxId "BSD-3-Clause"; } ) { }; @@ -692713,7 +692713,7 @@ self: { ]; doCheck = false; description = "An efficient packed Unicode text type"; - license = lib.licensesSpdx."BSD-2-Clause"; + license = lib.meta.getLicenseFromSpdxId "BSD-2-Clause"; hydraPlatforms = lib.platforms.none; } ) { }; @@ -692795,7 +692795,7 @@ self: { text-builder-linear ]; description = "Text styling for ANSI terminals"; - license = lib.licensesSpdx."BSD-3-Clause"; + license = lib.meta.getLicenseFromSpdxId "BSD-3-Clause"; } ) { }; @@ -692832,7 +692832,7 @@ self: { text ]; description = "ASCII string and character processing"; - license = lib.licensesSpdx."Apache-2.0"; + license = lib.meta.getLicenseFromSpdxId "Apache-2.0"; hydraPlatforms = lib.platforms.none; broken = true; } @@ -692893,7 +692893,7 @@ self: { rerebase ]; description = "Efficient strict text builder"; - license = lib.licensesSpdx."MIT"; + license = lib.meta.getLicenseFromSpdxId "MIT"; hydraPlatforms = lib.platforms.none; } ) { }; @@ -692944,7 +692944,7 @@ self: { text-builder-linear ]; description = "Efficient and flexible strict text builder"; - license = lib.licensesSpdx."MIT"; + license = lib.meta.getLicenseFromSpdxId "MIT"; } ) { }; @@ -692994,7 +692994,7 @@ self: { text-builder-linear ]; description = "Efficient and flexible strict text builder"; - license = lib.licensesSpdx."MIT"; + license = lib.meta.getLicenseFromSpdxId "MIT"; hydraPlatforms = lib.platforms.none; } ) { }; @@ -693037,7 +693037,7 @@ self: { text-builder-linear ]; description = "Internals of \"text-builder\""; - license = lib.licensesSpdx."MIT"; + license = lib.meta.getLicenseFromSpdxId "MIT"; } ) { }; @@ -693079,7 +693079,7 @@ self: { text-builder-linear ]; description = "Internals of \"text-builder\""; - license = lib.licensesSpdx."MIT"; + license = lib.meta.getLicenseFromSpdxId "MIT"; hydraPlatforms = lib.platforms.none; } ) { }; @@ -693138,7 +693138,7 @@ self: { rerebase ]; description = "Edge of developments for \"text-builder\""; - license = lib.licensesSpdx."MIT"; + license = lib.meta.getLicenseFromSpdxId "MIT"; hydraPlatforms = lib.platforms.none; } ) { }; @@ -693185,7 +693185,7 @@ self: { time ]; description = "Edge of developments for \"text-builder\""; - license = lib.licensesSpdx."MIT"; + license = lib.meta.getLicenseFromSpdxId "MIT"; } ) { }; @@ -693222,7 +693222,7 @@ self: { text-builder ]; description = "Orphan instances of \"lawful-conversions\" for \"text-builder\""; - license = lib.licensesSpdx."MIT"; + license = lib.meta.getLicenseFromSpdxId "MIT"; hydraPlatforms = lib.platforms.none; broken = true; } @@ -693265,7 +693265,7 @@ self: { text ]; description = "Builder for Text and ByteString based on linear types"; - license = lib.licensesSpdx."BSD-3-Clause"; + license = lib.meta.getLicenseFromSpdxId "BSD-3-Clause"; } ) { }; @@ -693286,7 +693286,7 @@ self: { time ]; description = "Various formats for \"time\" in terms of \"text-builder\""; - license = lib.licensesSpdx."MIT"; + license = lib.meta.getLicenseFromSpdxId "MIT"; } ) { }; @@ -693313,7 +693313,7 @@ self: { text ]; description = "A text compression library"; - license = lib.licensesSpdx."BSD-3-Clause"; + license = lib.meta.getLicenseFromSpdxId "BSD-3-Clause"; hydraPlatforms = lib.platforms.none; broken = true; } @@ -693400,7 +693400,7 @@ self: { ]; testToolDepends = [ hspec-discover ]; description = "Safe conversions between textual types"; - license = lib.licensesSpdx."ISC"; + license = lib.meta.getLicenseFromSpdxId "ISC"; } ) { }; @@ -693430,7 +693430,7 @@ self: { text ]; description = "Convert between various textual representations"; - license = lib.licensesSpdx."BSD-3-Clause"; + license = lib.meta.getLicenseFromSpdxId "BSD-3-Clause"; } ) { }; @@ -693498,7 +693498,7 @@ self: { text-builder-linear ]; description = "A typeclass for user-facing output"; - license = lib.licensesSpdx."MIT"; + license = lib.meta.getLicenseFromSpdxId "MIT"; maintainers = [ lib.maintainers.mangoiv ]; } ) { }; @@ -693553,7 +693553,7 @@ self: { ]; doHaddock = false; description = "Classes and newtypes for deriving uniform textual encodings"; - license = lib.licensesSpdx."BSD-3-Clause"; + license = lib.meta.getLicenseFromSpdxId "BSD-3-Clause"; } ) { }; @@ -694147,7 +694147,7 @@ self: { text ]; description = "Case conversion, word boundary manipulation, and textual subjugation"; - license = lib.licensesSpdx."MPL-2.0"; + license = lib.meta.getLicenseFromSpdxId "MPL-2.0"; } ) { }; @@ -694228,7 +694228,7 @@ self: { weigh ]; description = "Calculate various string metrics efficiently"; - license = lib.licensesSpdx."BSD-3-Clause"; + license = lib.meta.getLicenseFromSpdxId "BSD-3-Clause"; } ) { }; @@ -694622,7 +694622,7 @@ self: { text ]; description = "Simple text replacements from a list of search/replace pairs"; - license = lib.licensesSpdx."Apache-2.0"; + license = lib.meta.getLicenseFromSpdxId "Apache-2.0"; hydraPlatforms = lib.platforms.none; mainProgram = "text-replace"; broken = true; @@ -694698,7 +694698,7 @@ self: { text-rope ]; description = "2D text zipper based on text-rope"; - license = lib.licensesSpdx."Apache-2.0"; + license = lib.meta.getLicenseFromSpdxId "Apache-2.0"; } ) { }; @@ -695788,7 +695788,7 @@ self: { template-haskell ]; description = "Compile-time CAS(Computer Algebra System)"; - license = lib.licensesSpdx."MIT"; + license = lib.meta.getLicenseFromSpdxId "MIT"; } ) { }; @@ -695972,7 +695972,7 @@ self: { unordered-containers ]; description = "Check that datatypes are deep strict using Template Haskell"; - license = lib.licensesSpdx."BSD-3-Clause"; + license = lib.meta.getLicenseFromSpdxId "BSD-3-Clause"; } ) { }; @@ -696435,7 +696435,7 @@ self: { template-haskell ]; description = "Template Haskell construction utilities"; - license = lib.licensesSpdx."MIT"; + license = lib.meta.getLicenseFromSpdxId "MIT"; } ) { }; @@ -696464,7 +696464,7 @@ self: { transformers ]; description = "Implicit (recursive) let insertion"; - license = lib.licensesSpdx."BSD-3-Clause"; + license = lib.meta.getLicenseFromSpdxId "BSD-3-Clause"; } ) { }; @@ -696562,7 +696562,7 @@ self: { ]; testToolDepends = [ tasty-discover ]; description = "Serialize compilation of modules with TH code modifing shared state"; - license = lib.licensesSpdx."BSD-3-Clause"; + license = lib.meta.getLicenseFromSpdxId "BSD-3-Clause"; } ) { }; @@ -697126,7 +697126,7 @@ self: { ]; testToolDepends = [ hspec-discover ]; description = "Give your dependencies stars on GitHub!"; - license = lib.licensesSpdx."BSD-3-Clause"; + license = lib.meta.getLicenseFromSpdxId "BSD-3-Clause"; hydraPlatforms = lib.platforms.none; mainProgram = "thank-you-stars"; broken = true; @@ -697202,7 +697202,7 @@ self: { unagi-chan ]; description = "Minimalistic actor library"; - license = lib.licensesSpdx."MIT"; + license = lib.meta.getLicenseFromSpdxId "MIT"; hydraPlatforms = lib.platforms.none; broken = true; } @@ -697239,7 +697239,7 @@ self: { rerebase ]; description = "Minimalistic actor library experiments"; - license = lib.licensesSpdx."MIT"; + license = lib.meta.getLicenseFromSpdxId "MIT"; } ) { }; @@ -697300,7 +697300,7 @@ self: { time ]; description = "Haskell API bindings for http://themoviedb.org"; - license = lib.licensesSpdx."MIT"; + license = lib.meta.getLicenseFromSpdxId "MIT"; hydraPlatforms = lib.platforms.none; mainProgram = "tmdb"; broken = true; @@ -698545,7 +698545,7 @@ self: { text ]; description = "A compiler from the Thrift Interface Definition Language (IDL) to Haskell"; - license = lib.licensesSpdx."BSD-3-Clause"; + license = lib.meta.getLicenseFromSpdxId "BSD-3-Clause"; hydraPlatforms = lib.platforms.none; mainProgram = "thrift-compiler"; } @@ -698580,7 +698580,7 @@ self: { unordered-containers ]; description = "Support for using Haxl with Thrift services"; - license = lib.licensesSpdx."BSD-3-Clause"; + license = lib.meta.getLicenseFromSpdxId "BSD-3-Clause"; hydraPlatforms = lib.platforms.none; } ) { }; @@ -698673,7 +698673,7 @@ self: { ]; doHaddock = false; description = "Support for Thrift-over-HTTP server and client"; - license = lib.licensesSpdx."BSD-3-Clause"; + license = lib.meta.getLicenseFromSpdxId "BSD-3-Clause"; hydraPlatforms = lib.platforms.none; } ) { }; @@ -698775,7 +698775,7 @@ self: { testToolDepends = [ thrift-compiler ]; doHaddock = false; description = "Libraries for Haskell Thrift"; - license = lib.licensesSpdx."BSD-3-Clause"; + license = lib.meta.getLicenseFromSpdxId "BSD-3-Clause"; hydraPlatforms = lib.platforms.none; } ) { }; @@ -699078,7 +699078,7 @@ self: { text ]; description = "Image thumbnail creation"; - license = lib.licensesSpdx."BSD-3-Clause"; + license = lib.meta.getLicenseFromSpdxId "BSD-3-Clause"; hydraPlatforms = lib.platforms.none; } ) { }; @@ -699435,7 +699435,7 @@ self: { text ]; description = "A basic implementation of a personal ticket management system"; - license = lib.licensesSpdx."MIT"; + license = lib.meta.getLicenseFromSpdxId "MIT"; hydraPlatforms = lib.platforms.none; mainProgram = "ticket-manager"; broken = true; @@ -699642,7 +699642,7 @@ self: { ]; executableHaskellDepends = [ base ]; description = "Ableton Link integration for Tidal"; - license = lib.licensesSpdx."GPL-3.0-only"; + license = lib.meta.getLicenseFromSpdxId "GPL-3.0-only"; mainProgram = "tidal-linktest"; } ) { }; @@ -699925,7 +699925,7 @@ self: { ]; testSystemDepends = [ tb_client ]; description = "A Haskell client library for Tigerbeetle database"; - license = lib.licensesSpdx."BSD-3-Clause"; + license = lib.meta.getLicenseFromSpdxId "BSD-3-Clause"; hydraPlatforms = lib.platforms.none; mainProgram = "tigerbeetle-hs"; broken = true; @@ -700074,7 +700074,7 @@ self: { tasty-bench ]; description = "Haskell implementation of tiktoken"; - license = lib.licensesSpdx."BSD-3-Clause"; + license = lib.meta.getLicenseFromSpdxId "BSD-3-Clause"; } ) { }; @@ -700231,7 +700231,7 @@ self: { deepseq ]; description = "A time library"; - license = lib.licensesSpdx."BSD-2-Clause"; + license = lib.meta.getLicenseFromSpdxId "BSD-2-Clause"; hydraPlatforms = lib.platforms.none; } ) { }; @@ -700323,7 +700323,7 @@ self: { time ]; description = "A library for time domains and durations"; - license = lib.licensesSpdx."MIT"; + license = lib.meta.getLicenseFromSpdxId "MIT"; maintainers = [ lib.maintainers.turion ]; } ) { }; @@ -700343,7 +700343,7 @@ self: { time ]; description = "A library for time domains and durations"; - license = lib.licensesSpdx."MIT"; + license = lib.meta.getLicenseFromSpdxId "MIT"; hydraPlatforms = lib.platforms.none; maintainers = [ lib.maintainers.turion ]; } @@ -701405,7 +701405,7 @@ self: { ]; testToolDepends = [ tasty-discover ]; description = "Data type representing a piecewise-constant function over time"; - license = lib.licensesSpdx."BSD-3-Clause"; + license = lib.meta.getLicenseFromSpdxId "BSD-3-Clause"; } ) { }; @@ -701566,7 +701566,7 @@ self: { unliftio ]; description = "Efficient timeout with reset"; - license = lib.licensesSpdx."BSD-3-Clause"; + license = lib.meta.getLicenseFromSpdxId "BSD-3-Clause"; } ) { }; @@ -701732,7 +701732,7 @@ self: { tasty-bench ]; description = "A timer wheel"; - license = lib.licensesSpdx."BSD-3-Clause"; + license = lib.meta.getLicenseFromSpdxId "BSD-3-Clause"; } ) { }; @@ -702020,7 +702020,7 @@ self: { text ]; description = "A library for profiling time in Haskell applications"; - license = lib.licensesSpdx."BSD-3-Clause"; + license = lib.meta.getLicenseFromSpdxId "BSD-3-Clause"; } ) { }; @@ -702509,7 +702509,7 @@ self: { ]; testHaskellDepends = [ base ]; description = "Library to build tiny apps in Haskell"; - license = lib.licensesSpdx."MIT"; + license = lib.meta.getLicenseFromSpdxId "MIT"; hydraPlatforms = lib.platforms.none; broken = true; } @@ -702553,7 +702553,7 @@ self: { entropy ]; description = "A secure URL-friendly string ID generator"; - license = lib.licensesSpdx."MIT"; + license = lib.meta.getLicenseFromSpdxId "MIT"; hydraPlatforms = lib.platforms.none; broken = true; } @@ -703985,7 +703985,7 @@ self: { tls ]; description = "SSLKEYLOGFILE support for Haskell"; - license = lib.licensesSpdx."MIT"; + license = lib.meta.getLicenseFromSpdxId "MIT"; } ) { }; @@ -704039,7 +704039,7 @@ self: { ]; executableHaskellDepends = [ base ]; description = "Handle phylogenetic trees"; - license = lib.licensesSpdx."GPL-3.0-or-later"; + license = lib.meta.getLicenseFromSpdxId "GPL-3.0-or-later"; mainProgram = "tlynx"; maintainers = [ lib.maintainers.dschrempf ]; } @@ -704095,7 +704095,7 @@ self: { ]; executableHaskellDepends = [ base ]; description = "Handle phylogenetic trees"; - license = lib.licensesSpdx."GPL-3.0-or-later"; + license = lib.meta.getLicenseFromSpdxId "GPL-3.0-or-later"; hydraPlatforms = lib.platforms.none; mainProgram = "tlynx"; maintainers = [ lib.maintainers.dschrempf ]; @@ -704338,7 +704338,7 @@ self: { warp-tls ]; description = "Run 'tmp' processes in integration tests"; - license = lib.licensesSpdx."BSD-3-Clause"; + license = lib.meta.getLicenseFromSpdxId "BSD-3-Clause"; } ) { }; @@ -704411,7 +704411,7 @@ self: { hspec ]; description = "Test a simple service with backends running on docker using tmp-proc"; - license = lib.licensesSpdx."BSD-3-Clause"; + license = lib.meta.getLicenseFromSpdxId "BSD-3-Clause"; hydraPlatforms = lib.platforms.none; broken = true; } @@ -704449,7 +704449,7 @@ self: { tmp-proc ]; description = "Launch a PostgreSQL database in docker using tmp-proc"; - license = lib.licensesSpdx."BSD-3-Clause"; + license = lib.meta.getLicenseFromSpdxId "BSD-3-Clause"; } ) { }; @@ -704485,7 +704485,7 @@ self: { tmp-proc ]; description = "Launch RabbitMQ in docker using tmp-proc"; - license = lib.licensesSpdx."BSD-3-Clause"; + license = lib.meta.getLicenseFromSpdxId "BSD-3-Clause"; } ) { }; @@ -704521,7 +704521,7 @@ self: { tmp-proc ]; description = "Launch Redis in docker using tmp-proc"; - license = lib.licensesSpdx."BSD-3-Clause"; + license = lib.meta.getLicenseFromSpdxId "BSD-3-Clause"; } ) { }; @@ -704558,7 +704558,7 @@ self: { tmp-proc ]; description = "Launch ZipKin in docker using tmp-proc"; - license = lib.licensesSpdx."BSD-3-Clause"; + license = lib.meta.getLicenseFromSpdxId "BSD-3-Clause"; hydraPlatforms = lib.platforms.none; broken = true; } @@ -704855,7 +704855,7 @@ self: { testToolDepends = [ hspec-discover ]; doHaddock = false; description = "Unofficial Haskell SDK for the Todoist REST API"; - license = lib.licensesSpdx."MIT"; + license = lib.meta.getLicenseFromSpdxId "MIT"; } ) { }; @@ -705064,7 +705064,7 @@ self: { text ]; description = "Fast rate limiting using the token bucket algorithm (BSD)"; - license = lib.licensesSpdx."BSD-2-Clause"; + license = lib.meta.getLicenseFromSpdxId "BSD-2-Clause"; hydraPlatforms = lib.platforms.none; mainProgram = "token-limiter-extended-tests"; broken = true; @@ -705247,7 +705247,7 @@ self: { transformers ]; description = "Check uniqueness and tokenize safely"; - license = lib.licensesSpdx."MIT"; + license = lib.meta.getLicenseFromSpdxId "MIT"; hydraPlatforms = lib.platforms.none; broken = true; } @@ -705584,7 +705584,7 @@ self: { markdown-unlit ]; description = "TOML 1.1.0 parser"; - license = lib.licensesSpdx."ISC"; + license = lib.meta.getLicenseFromSpdxId "ISC"; } ) { }; @@ -705682,7 +705682,7 @@ self: { toml-reader ]; description = "Alternative parser for TOML values produced by the toml-reader package"; - license = lib.licensesSpdx."Apache-2.0"; + license = lib.meta.getLicenseFromSpdxId "Apache-2.0"; } ) { }; @@ -705715,7 +705715,7 @@ self: { toml-parser ]; description = "toml-parser test drivers"; - license = lib.licensesSpdx."ISC"; + license = lib.meta.getLicenseFromSpdxId "ISC"; hydraPlatforms = lib.platforms.none; broken = true; } @@ -705780,7 +705780,7 @@ self: { unordered-containers ]; description = "Bidirectional TOML serialization"; - license = lib.licensesSpdx."MPL-2.0"; + license = lib.meta.getLicenseFromSpdxId "MPL-2.0"; } ) { }; @@ -706499,7 +706499,7 @@ self: { template-haskell time ]; - license = lib.licensesSpdx."BSD-3-Clause"; + license = lib.meta.getLicenseFromSpdxId "BSD-3-Clause"; hydraPlatforms = lib.platforms.none; broken = true; } @@ -706542,7 +706542,7 @@ self: { text ]; description = "Tribial tools"; - license = lib.licensesSpdx."BSD-3-Clause"; + license = lib.meta.getLicenseFromSpdxId "BSD-3-Clause"; } ) { }; @@ -706680,7 +706680,7 @@ self: { vector ]; description = "Extensible records library"; - license = lib.licensesSpdx."BSD-3-Clause"; + license = lib.meta.getLicenseFromSpdxId "BSD-3-Clause"; hydraPlatforms = lib.platforms.none; } ) { }; @@ -706782,7 +706782,7 @@ self: { vector ]; description = "Directed acyclic graphs"; - license = lib.licensesSpdx."BSD-3-Clause"; + license = lib.meta.getLicenseFromSpdxId "BSD-3-Clause"; } ) { }; @@ -706848,7 +706848,7 @@ self: { sha256 = "0ljcxlv019qfbs3wvp03j8l261i1p6vv3vycabcd0hpy0dbq80d9"; libraryHaskellDepends = [ base ]; description = "Torsor Typeclass"; - license = lib.licensesSpdx."BSD-3-Clause"; + license = lib.meta.getLicenseFromSpdxId "BSD-3-Clause"; } ) { }; @@ -707440,7 +707440,7 @@ self: { vector ]; description = "Assorted decision procedures for SAT, SMT, Max-SAT, PB, MIP, etc"; - license = lib.licensesSpdx."BSD-3-Clause"; + license = lib.meta.getLicenseFromSpdxId "BSD-3-Clause"; hydraPlatforms = lib.platforms.none; } ) { }; @@ -707677,7 +707677,7 @@ self: { text ]; description = "Data Type for Rewriting Systems"; - license = lib.licensesSpdx."GPL-3.0-only"; + license = lib.meta.getLicenseFromSpdxId "GPL-3.0-only"; } ) { }; @@ -707721,7 +707721,7 @@ self: { text ]; description = "Parser and pretty printer for the TPTP language"; - license = lib.licensesSpdx."GPL-3.0-only"; + license = lib.meta.getLicenseFromSpdxId "GPL-3.0-only"; hydraPlatforms = lib.platforms.none; broken = true; } @@ -707861,7 +707861,7 @@ self: { ]; testToolDepends = [ tasty-discover ]; description = "Smart version of Debug.Trace module"; - license = lib.licensesSpdx."BSD-3-Clause"; + license = lib.meta.getLicenseFromSpdxId "BSD-3-Clause"; hydraPlatforms = lib.platforms.none; } ) { }; @@ -708292,7 +708292,7 @@ self: { unliftio-core ]; description = "Haskell bindings for Tracy frame profiler"; - license = lib.licensesSpdx."BSD-3-Clause"; + license = lib.meta.getLicenseFromSpdxId "BSD-3-Clause"; } ) { }; @@ -709101,7 +709101,7 @@ self: { transformers ]; description = "An Either monad transformer"; - license = lib.licensesSpdx."BSD-3-Clause"; + license = lib.meta.getLicenseFromSpdxId "BSD-3-Clause"; } ) { }; @@ -709126,7 +709126,7 @@ self: { transformers ]; description = "An Except monad transformer with"; - license = lib.licensesSpdx."BSD-3-Clause"; + license = lib.meta.getLicenseFromSpdxId "BSD-3-Clause"; } ) { }; @@ -709193,7 +709193,7 @@ self: { writer-cps-transformers ]; description = "Ad-hoc type classes for lifting"; - license = lib.licensesSpdx."BSD-3-Clause"; + license = lib.meta.getLicenseFromSpdxId "BSD-3-Clause"; hydraPlatforms = lib.platforms.none; broken = true; } @@ -709576,7 +709576,7 @@ self: { doctest ]; description = "Type Safe Web Routing"; - license = lib.licensesSpdx."MIT"; + license = lib.meta.getLicenseFromSpdxId "MIT"; hydraPlatforms = lib.platforms.none; broken = true; } @@ -709613,7 +709613,7 @@ self: { trasa ]; description = "Type safe http requests"; - license = lib.licensesSpdx."MIT"; + license = lib.meta.getLicenseFromSpdxId "MIT"; hydraPlatforms = lib.platforms.none; } ) { }; @@ -709772,7 +709772,7 @@ self: { wai ]; description = "Type safe web server"; - license = lib.licensesSpdx."MIT"; + license = lib.meta.getLicenseFromSpdxId "MIT"; hydraPlatforms = lib.platforms.none; } ) { }; @@ -709802,7 +709802,7 @@ self: { trasa ]; description = "Template Haskell to generate trasa routes"; - license = lib.licensesSpdx."MIT"; + license = lib.meta.getLicenseFromSpdxId "MIT"; hydraPlatforms = lib.platforms.none; } ) { }; @@ -709838,7 +709838,7 @@ self: { util ]; description = "See README for more info"; - license = lib.licensesSpdx."MPL-2.0"; + license = lib.meta.getLicenseFromSpdxId "MPL-2.0"; hydraPlatforms = lib.platforms.none; broken = true; } @@ -709880,7 +709880,7 @@ self: { template-haskell ]; description = "General data structure lifting for Template Haskell"; - license = lib.licensesSpdx."BSD-3-Clause"; + license = lib.meta.getLicenseFromSpdxId "BSD-3-Clause"; hydraPlatforms = lib.platforms.none; broken = true; } @@ -710133,7 +710133,7 @@ self: { hspec-core ]; description = "Efficient implementation of the implicit treap data structure"; - license = lib.licensesSpdx."MPL-2.0"; + license = lib.meta.getLicenseFromSpdxId "MPL-2.0"; hydraPlatforms = lib.platforms.none; broken = true; } @@ -710224,7 +710224,7 @@ self: { Diff ]; description = "Diffing of (expression) trees"; - license = lib.licensesSpdx."GPL-2.0-or-later"; + license = lib.meta.getLicenseFromSpdxId "GPL-2.0-or-later"; } ) { }; @@ -710269,7 +710269,7 @@ self: { vector ]; description = "Tree Edit Distance to determine the similarity between two trees"; - license = lib.licensesSpdx."BSD-3-Clause"; + license = lib.meta.getLicenseFromSpdxId "BSD-3-Clause"; mainProgram = "tree-edit-distance-exe"; } ) { }; @@ -710328,7 +710328,7 @@ self: { mtl ]; description = "Configurable text rendering of trees"; - license = lib.licensesSpdx."BSD-3-Clause"; + license = lib.meta.getLicenseFromSpdxId "BSD-3-Clause"; hydraPlatforms = lib.platforms.none; broken = true; } @@ -710366,7 +710366,7 @@ self: { hedgehog ]; description = "Unstable bindings for the tree-sitter parsing library"; - license = lib.licensesSpdx."BSD-3-Clause"; + license = lib.meta.getLicenseFromSpdxId "BSD-3-Clause"; } ) { }; @@ -710386,7 +710386,7 @@ self: { tree-sitter ]; description = "Tree-sitter grammar/parser for C#"; - license = lib.licensesSpdx."BSD-3-Clause"; + license = lib.meta.getLicenseFromSpdxId "BSD-3-Clause"; } ) { }; @@ -710406,7 +710406,7 @@ self: { tree-sitter ]; description = "Tree-sitter grammar/parser for Go"; - license = lib.licensesSpdx."BSD-3-Clause"; + license = lib.meta.getLicenseFromSpdxId "BSD-3-Clause"; } ) { }; @@ -710427,7 +710427,7 @@ self: { tree-sitter ]; description = "Tree-sitter grammar/parser for Haskell (with GHC extensions)"; - license = lib.licensesSpdx."BSD-3-Clause"; + license = lib.meta.getLicenseFromSpdxId "BSD-3-Clause"; } ) { }; @@ -710447,7 +710447,7 @@ self: { tree-sitter ]; description = "Tree-sitter grammar/parser for Java"; - license = lib.licensesSpdx."BSD-3-Clause"; + license = lib.meta.getLicenseFromSpdxId "BSD-3-Clause"; } ) { }; @@ -710467,7 +710467,7 @@ self: { tree-sitter ]; description = "Tree-sitter grammar/parser for JSON"; - license = lib.licensesSpdx."BSD-3-Clause"; + license = lib.meta.getLicenseFromSpdxId "BSD-3-Clause"; } ) { }; @@ -710487,7 +710487,7 @@ self: { tree-sitter ]; description = "Tree-sitter grammar/parser for OCaml"; - license = lib.licensesSpdx."BSD-3-Clause"; + license = lib.meta.getLicenseFromSpdxId "BSD-3-Clause"; } ) { }; @@ -710507,7 +710507,7 @@ self: { tree-sitter ]; description = "Tree-sitter grammar/parser for PHP"; - license = lib.licensesSpdx."BSD-3-Clause"; + license = lib.meta.getLicenseFromSpdxId "BSD-3-Clause"; } ) { }; @@ -710527,7 +710527,7 @@ self: { tree-sitter ]; description = "Tree-sitter grammar/parser for Python"; - license = lib.licensesSpdx."BSD-3-Clause"; + license = lib.meta.getLicenseFromSpdxId "BSD-3-Clause"; } ) { }; @@ -710547,7 +710547,7 @@ self: { tree-sitter ]; description = "Tree-sitter grammar/parser for QL"; - license = lib.licensesSpdx."BSD-3-Clause"; + license = lib.meta.getLicenseFromSpdxId "BSD-3-Clause"; } ) { }; @@ -710567,7 +710567,7 @@ self: { tree-sitter ]; description = "Tree-sitter grammar/parser for Ruby"; - license = lib.licensesSpdx."BSD-3-Clause"; + license = lib.meta.getLicenseFromSpdxId "BSD-3-Clause"; } ) { }; @@ -710587,7 +710587,7 @@ self: { tree-sitter ]; description = "Tree-sitter grammar/parser for Rust"; - license = lib.licensesSpdx."BSD-3-Clause"; + license = lib.meta.getLicenseFromSpdxId "BSD-3-Clause"; } ) { }; @@ -710607,7 +710607,7 @@ self: { tree-sitter ]; description = "Tree-sitter grammar/parser for TSX"; - license = lib.licensesSpdx."BSD-3-Clause"; + license = lib.meta.getLicenseFromSpdxId "BSD-3-Clause"; } ) { }; @@ -710627,7 +710627,7 @@ self: { tree-sitter ]; description = "Tree-sitter grammar/parser for TypeScript"; - license = lib.licensesSpdx."BSD-3-Clause"; + license = lib.meta.getLicenseFromSpdxId "BSD-3-Clause"; } ) { }; @@ -710654,7 +710654,7 @@ self: { mtl ]; description = "Functions and newtype wrappers for traversing Trees"; - license = lib.licensesSpdx."CC0-1.0"; + license = lib.meta.getLicenseFromSpdxId "CC0-1.0"; hydraPlatforms = lib.platforms.none; broken = true; } @@ -711201,7 +711201,7 @@ self: { ]; doHaddock = false; description = "Bindings to the TREXIO library for wave function data"; - license = lib.licensesSpdx."BSD-3-Clause"; + license = lib.meta.getLicenseFromSpdxId "BSD-3-Clause"; } ) { inherit (pkgs) trexio; }; @@ -711251,7 +711251,7 @@ self: { splitmix ]; description = "Trial Data Structure"; - license = lib.licensesSpdx."MPL-2.0"; + license = lib.meta.getLicenseFromSpdxId "MPL-2.0"; } ) { }; @@ -711274,7 +711274,7 @@ self: { trial ]; description = "Trial helper functions for optparse-applicative"; - license = lib.licensesSpdx."MPL-2.0"; + license = lib.meta.getLicenseFromSpdxId "MPL-2.0"; } ) { }; @@ -711299,7 +711299,7 @@ self: { trial ]; description = "Trial helper functions for tomland"; - license = lib.licensesSpdx."MPL-2.0"; + license = lib.meta.getLicenseFromSpdxId "MPL-2.0"; } ) { }; @@ -711633,7 +711633,7 @@ self: { hspec ]; description = "A command-line tool for trimming whitespace"; - license = lib.licensesSpdx."BSD-3-Clause"; + license = lib.meta.getLicenseFromSpdxId "BSD-3-Clause"; hydraPlatforms = lib.platforms.none; mainProgram = "trim"; broken = true; @@ -711904,7 +711904,7 @@ self: { time ]; description = "Template Haskell hack to violate module abstractions"; - license = lib.licensesSpdx."BSD-3-Clause"; + license = lib.meta.getLicenseFromSpdxId "BSD-3-Clause"; hydraPlatforms = lib.platforms.none; broken = true; } @@ -712029,7 +712029,7 @@ self: { text ]; description = "An implementation of a trust chain"; - license = lib.licensesSpdx."MIT"; + license = lib.meta.getLicenseFromSpdxId "MIT"; hydraPlatforms = lib.platforms.none; broken = true; } @@ -712055,7 +712055,7 @@ self: { sha256 = "164jxd8cyjb4qkmwqchzcpvd5fh7d124gbpryi26y8cbabmhfm8z"; libraryHaskellDepends = [ base ]; description = "Generalized booleans and truthy values"; - license = lib.licensesSpdx."MIT"; + license = lib.meta.getLicenseFromSpdxId "MIT"; } ) { }; @@ -712618,7 +712618,7 @@ self: { text-short ]; description = "Textual Type Classes"; - license = lib.licensesSpdx."MIT"; + license = lib.meta.getLicenseFromSpdxId "MIT"; } ) { }; @@ -713000,7 +713000,7 @@ self: { vty-crossplatform ]; description = "Small Brick-based terminal launcher"; - license = lib.licensesSpdx."MIT"; + license = lib.meta.getLicenseFromSpdxId "MIT"; hydraPlatforms = lib.platforms.none; mainProgram = "tui-launcher"; } @@ -713067,7 +713067,7 @@ self: { text ]; description = "Playwright-like black-box testing for terminal UIs over PTY"; - license = lib.licensesSpdx."MIT"; + license = lib.meta.getLicenseFromSpdxId "MIT"; hydraPlatforms = lib.platforms.none; mainProgram = "tuispec"; broken = true; @@ -713249,7 +713249,7 @@ self: { tasty-hunit ]; description = "Access tuple fields using record dot syntax"; - license = lib.licensesSpdx."BSD-3-Clause"; + license = lib.meta.getLicenseFromSpdxId "BSD-3-Clause"; hydraPlatforms = lib.platforms.none; mainProgram = "gen-source"; broken = true; @@ -713504,7 +713504,7 @@ self: { tasty-quickcheck ]; description = "Small monomorphic tuples"; - license = lib.licensesSpdx."BSD-3-Clause"; + license = lib.meta.getLicenseFromSpdxId "BSD-3-Clause"; } ) { }; @@ -713986,7 +713986,7 @@ self: { ]; testToolDepends = [ hspec-discover ]; description = "Tiny web application framework for WAI"; - license = lib.licensesSpdx."BSD-3-Clause"; + license = lib.meta.getLicenseFromSpdxId "BSD-3-Clause"; } ) { }; @@ -714931,7 +714931,7 @@ self: { vector ]; description = "Simple 2D Game Engine"; - license = lib.licensesSpdx."Zlib"; + license = lib.meta.getLicenseFromSpdxId "Zlib"; badPlatforms = lib.platforms.darwin; hydraPlatforms = lib.platforms.none; mainProgram = "example"; @@ -714984,7 +714984,7 @@ self: { wai ]; description = "Haskell twirp foundations"; - license = lib.licensesSpdx."BSD-3-Clause"; + license = lib.meta.getLicenseFromSpdxId "BSD-3-Clause"; hydraPlatforms = lib.platforms.none; broken = true; } @@ -715985,7 +715985,7 @@ self: { Glob ]; description = "Combinators for writing pretty type errors easily"; - license = lib.licensesSpdx."MPL-2.0"; + license = lib.meta.getLicenseFromSpdxId "MPL-2.0"; hydraPlatforms = lib.platforms.none; broken = true; } @@ -716013,7 +716013,7 @@ self: { sha256 = "06k6a9p0pvrn31dcqidfpzg1ighrc657hcxblg01awgcwrqdxv14"; libraryHaskellDepends = [ base ]; description = "A library for folding types to a value"; - license = lib.licensesSpdx."MIT"; + license = lib.meta.getLicenseFromSpdxId "MIT"; hydraPlatforms = lib.platforms.none; broken = true; } @@ -716574,7 +716574,7 @@ self: { template-haskell ]; description = "Type-level functions for record types"; - license = lib.licensesSpdx."BSD-3-Clause"; + license = lib.meta.getLicenseFromSpdxId "BSD-3-Clause"; mainProgram = "vector-example"; } ) { }; @@ -716659,7 +716659,7 @@ self: { ]; testToolDepends = [ tasty-discover ]; description = "Type-level natural and proofs of their properties"; - license = lib.licensesSpdx."BSD-3-Clause"; + license = lib.meta.getLicenseFromSpdxId "BSD-3-Clause"; hydraPlatforms = lib.platforms.none; } ) { }; @@ -716865,7 +716865,7 @@ self: { tasty-hunit ]; description = "Support functions to work with type representations"; - license = lib.licensesSpdx."MIT"; + license = lib.meta.getLicenseFromSpdxId "MIT"; hydraPlatforms = lib.platforms.none; broken = true; } @@ -716886,7 +716886,7 @@ self: { invariant ]; description = "Classes for the rig (sums and products) of types"; - license = lib.licensesSpdx."BSD-2-Clause"; + license = lib.meta.getLicenseFromSpdxId "BSD-2-Clause"; } ) { }; @@ -716900,7 +716900,7 @@ self: { editedCabalFile = "0xcamv7cy7saywzx2vj7d0l1hpjqkz8jzkdy8hdabz7q9zlynshg"; libraryHaskellDepends = [ base ]; description = "Type safe BST and AVL trees"; - license = lib.licensesSpdx."GPL-3.0-only"; + license = lib.meta.getLicenseFromSpdxId "GPL-3.0-only"; hydraPlatforms = lib.platforms.none; broken = true; } @@ -716928,7 +716928,7 @@ self: { template-haskell ]; description = "Type set"; - license = lib.licensesSpdx."BSD-3-Clause"; + license = lib.meta.getLicenseFromSpdxId "BSD-3-Clause"; } ) { }; @@ -717337,7 +717337,7 @@ self: { unordered-containers ]; description = "An implementation of LangChain in Haskell"; - license = lib.licensesSpdx."GPL-3.0-or-later"; + license = lib.meta.getLicenseFromSpdxId "GPL-3.0-or-later"; hydraPlatforms = lib.platforms.none; mainProgram = "typechain-exe"; broken = true; @@ -717655,7 +717655,7 @@ self: { singletons-base ]; description = "A framework for strongly typed FSM"; - license = lib.licensesSpdx."MIT"; + license = lib.meta.getLicenseFromSpdxId "MIT"; } ) { }; @@ -717683,7 +717683,7 @@ self: { ]; testHaskellDepends = [ base ]; description = "GUI framework based on typed-fsm"; - license = lib.licensesSpdx."MIT"; + license = lib.meta.getLicenseFromSpdxId "MIT"; hydraPlatforms = lib.platforms.none; broken = true; } @@ -717765,7 +717765,7 @@ self: { tasty-hunit ]; description = "A binding of the typed-process library for the effectful effect system"; - license = lib.licensesSpdx."BSD-3-Clause"; + license = lib.meta.getLicenseFromSpdxId "BSD-3-Clause"; hydraPlatforms = lib.platforms.none; broken = true; } @@ -717821,7 +717821,7 @@ self: { ]; doHaddock = false; description = "A framework for strongly typed protocols"; - license = lib.licensesSpdx."Apache-2.0"; + license = lib.meta.getLicenseFromSpdxId "Apache-2.0"; hydraPlatforms = lib.platforms.none; broken = true; } @@ -717900,7 +717900,7 @@ self: { typed-protocols ]; description = "Derive documentation from typed-protocols source code"; - license = lib.licensesSpdx."Apache-2.0"; + license = lib.meta.getLicenseFromSpdxId "Apache-2.0"; hydraPlatforms = lib.platforms.none; mainProgram = "typed-protocols-doc-demo"; broken = true; @@ -717942,7 +717942,7 @@ self: { test-framework-quickcheck2 ]; description = "An efficient and versatile typed range library"; - license = lib.licensesSpdx."MIT"; + license = lib.meta.getLicenseFromSpdxId "MIT"; } ) { }; @@ -717981,7 +717981,7 @@ self: { template-haskell ]; description = "typed session framework"; - license = lib.licensesSpdx."MIT"; + license = lib.meta.getLicenseFromSpdxId "MIT"; hydraPlatforms = lib.platforms.none; broken = true; } @@ -718015,7 +718015,7 @@ self: { raw-strings-qq ]; description = "Automatically generate status for typed-session"; - license = lib.licensesSpdx."MIT"; + license = lib.meta.getLicenseFromSpdxId "MIT"; hydraPlatforms = lib.platforms.none; broken = true; } @@ -718387,7 +718387,7 @@ self: { tasty-quickcheck ]; description = "Plugin to faciliate type-level let"; - license = lib.licensesSpdx."BSD-3-Clause"; + license = lib.meta.getLicenseFromSpdxId "BSD-3-Clause"; hydraPlatforms = lib.platforms.none; broken = true; } @@ -718695,7 +718695,7 @@ self: { ]; doHaddock = false; description = "Efficient implementation of a dependent map with types as keys"; - license = lib.licensesSpdx."MPL-2.0"; + license = lib.meta.getLicenseFromSpdxId "MPL-2.0"; maintainers = [ lib.maintainers.mpscholten ]; } ) { }; @@ -718771,7 +718771,7 @@ self: { ]; testToolDepends = [ hspec-discover ]; description = "Type-safe transformations and purifications of PreCures (Japanese Battle Heroine)"; - license = lib.licensesSpdx."BSD-3-Clause"; + license = lib.meta.getLicenseFromSpdxId "BSD-3-Clause"; } ) { }; @@ -718863,7 +718863,7 @@ self: { text-show ]; description = "Typelevel printf"; - license = lib.licensesSpdx."MIT"; + license = lib.meta.getLicenseFromSpdxId "MIT"; hydraPlatforms = lib.platforms.none; broken = true; } @@ -719219,7 +719219,7 @@ self: { time ]; description = "Parsing and evaluating typst syntax"; - license = lib.licensesSpdx."BSD-3-Clause"; + license = lib.meta.getLicenseFromSpdxId "BSD-3-Clause"; } ) { }; @@ -719292,7 +719292,7 @@ self: { time ]; description = "Parsing and evaluating typst syntax"; - license = lib.licensesSpdx."BSD-3-Clause"; + license = lib.meta.getLicenseFromSpdxId "BSD-3-Clause"; hydraPlatforms = lib.platforms.none; } ) { }; @@ -719312,7 +719312,7 @@ self: { text ]; description = "Symbol and emoji lookup for typst language"; - license = lib.licensesSpdx."MIT"; + license = lib.meta.getLicenseFromSpdxId "MIT"; } ) { }; @@ -719331,7 +719331,7 @@ self: { text ]; description = "Symbol and emoji lookup for typst language"; - license = lib.licensesSpdx."MIT"; + license = lib.meta.getLicenseFromSpdxId "MIT"; hydraPlatforms = lib.platforms.none; } ) { }; @@ -719986,7 +719986,7 @@ self: { gauge ]; description = "Unicode Character Database — Predicates on characters specified by Unicode"; - license = lib.licensesSpdx."BSD-3-Clause"; + license = lib.meta.getLicenseFromSpdxId "BSD-3-Clause"; hydraPlatforms = lib.platforms.none; broken = true; } @@ -720019,7 +720019,7 @@ self: { containers ]; description = "Datatype and parser for the Universal Configuration Language (UCL) using libucl"; - license = lib.licensesSpdx."BSD-3-Clause"; + license = lib.meta.getLicenseFromSpdxId "BSD-3-Clause"; hydraPlatforms = lib.platforms.none; broken = true; } @@ -720428,7 +720428,7 @@ self: { vector ]; description = "Interface with Ettus USRP SDRs"; - license = lib.licensesSpdx."MIT"; + license = lib.meta.getLicenseFromSpdxId "MIT"; hydraPlatforms = lib.platforms.none; broken = true; } @@ -720525,7 +720525,7 @@ self: { ]; executableHaskellDepends = [ base ]; description = "Minimalistic console UI (getLine), arrow key support (edit, browse cmd history)"; - license = lib.licensesSpdx."MIT"; + license = lib.meta.getLicenseFromSpdxId "MIT"; mainProgram = "example"; } ) { }; @@ -720775,7 +720775,7 @@ self: { time ]; description = "Implementation of ULID - Universally Unique Lexicographically Sortable Identifier"; - license = lib.licensesSpdx."BSD-3-Clause"; + license = lib.meta.getLicenseFromSpdxId "BSD-3-Clause"; mainProgram = "ulid-exe"; } ) { }; @@ -720823,7 +720823,7 @@ self: { ]; testToolDepends = [ hspec-discover ]; description = "Another ULID implementation with tight memory representation"; - license = lib.licensesSpdx."MIT"; + license = lib.meta.getLicenseFromSpdxId "MIT"; hydraPlatforms = lib.platforms.none; broken = true; } @@ -720879,7 +720879,7 @@ self: { hspec ]; description = "Bindings for libunac(3)"; - license = lib.licensesSpdx."Unlicense"; + license = lib.meta.getLicenseFromSpdxId "Unlicense"; hydraPlatforms = lib.platforms.none; broken = true; } @@ -721191,7 +721191,7 @@ self: { unbound-generics ]; description = "Unification based on unbound-generics"; - license = lib.licensesSpdx."BSD-3-Clause"; + license = lib.meta.getLicenseFromSpdxId "BSD-3-Clause"; } ) { }; @@ -721348,7 +721348,7 @@ self: { vector ]; description = "A library for reference cells backed by unboxed-vectors"; - license = lib.licensesSpdx."BSD-3-Clause"; + license = lib.meta.getLicenseFromSpdxId "BSD-3-Clause"; hydraPlatforms = lib.platforms.none; mainProgram = "example"; broken = true; @@ -721457,7 +721457,7 @@ self: { libraryHaskellDepends = [ base ]; executableHaskellDepends = [ base ]; description = "Customize uncaught exception handling"; - license = lib.licensesSpdx."MPL-2.0"; + license = lib.meta.getLicenseFromSpdxId "MPL-2.0"; mainProgram = "uncaught-exception-demo"; } ) { }; @@ -721544,7 +721544,7 @@ self: { unliftio ]; description = "a library which implements easy, concurrent and pretty logging"; - license = lib.licensesSpdx."AGPL-3.0-or-later"; + license = lib.meta.getLicenseFromSpdxId "AGPL-3.0-or-later"; mainProgram = "unclogging"; maintainers = [ lib.maintainers.mangoiv ]; } @@ -721567,7 +721567,7 @@ self: { int-supply ]; description = "Unconditional jumps"; - license = lib.licensesSpdx."BSD-3-Clause"; + license = lib.meta.getLicenseFromSpdxId "BSD-3-Clause"; } ) { }; @@ -721684,7 +721684,7 @@ self: { transformers ]; description = "Class of data structures that can be unfolded"; - license = lib.licensesSpdx."BSD-3-Clause"; + license = lib.meta.getLicenseFromSpdxId "BSD-3-Clause"; } ) { }; @@ -721738,7 +721738,7 @@ self: { stm ]; description = "Make any action thread safe"; - license = lib.licensesSpdx."Apache-2.0"; + license = lib.meta.getLicenseFromSpdxId "Apache-2.0"; hydraPlatforms = lib.platforms.none; broken = true; } @@ -722084,7 +722084,7 @@ self: { text-icu ]; description = "Haskell implementation of the Unicode Collation Algorithm"; - license = lib.licensesSpdx."BSD-2-Clause"; + license = lib.meta.getLicenseFromSpdxId "BSD-2-Clause"; } ) { }; @@ -722115,7 +722115,7 @@ self: { tasty-bench ]; description = "Access Unicode Character Database (UCD)"; - license = lib.licensesSpdx."Apache-2.0"; + license = lib.meta.getLicenseFromSpdxId "Apache-2.0"; } ) { }; @@ -722144,7 +722144,7 @@ self: { tasty-bench ]; description = "Access Unicode Character Database (UCD)"; - license = lib.licensesSpdx."Apache-2.0"; + license = lib.meta.getLicenseFromSpdxId "Apache-2.0"; hydraPlatforms = lib.platforms.none; } ) { }; @@ -722182,7 +722182,7 @@ self: { unicode-data ]; description = "Unicode characters names and aliases"; - license = lib.licensesSpdx."Apache-2.0"; + license = lib.meta.getLicenseFromSpdxId "Apache-2.0"; hydraPlatforms = lib.platforms.none; broken = true; } @@ -722203,7 +722203,7 @@ self: { bytestring ]; description = "Parsers for Unicode Character Database (UCD) files"; - license = lib.licensesSpdx."BSD-3-Clause"; + license = lib.meta.getLicenseFromSpdxId "BSD-3-Clause"; } ) { }; @@ -722232,7 +722232,7 @@ self: { tasty-bench ]; description = "Unicode characters scripts"; - license = lib.licensesSpdx."Apache-2.0"; + license = lib.meta.getLicenseFromSpdxId "Apache-2.0"; } ) { }; @@ -722265,7 +722265,7 @@ self: { tasty-bench ]; description = "Unicode security mechanisms database"; - license = lib.licensesSpdx."Apache-2.0"; + license = lib.meta.getLicenseFromSpdxId "Apache-2.0"; hydraPlatforms = lib.platforms.none; broken = true; } @@ -722494,7 +722494,7 @@ self: { text ]; description = "Unicode normalization"; - license = lib.licensesSpdx."BSD-3-Clause"; + license = lib.meta.getLicenseFromSpdxId "BSD-3-Clause"; } ) { }; @@ -722627,7 +722627,7 @@ self: { mtl ]; description = "Simple generic unification algorithms"; - license = lib.licensesSpdx."BSD-3-Clause"; + license = lib.meta.getLicenseFromSpdxId "BSD-3-Clause"; } ) { }; @@ -722650,7 +722650,7 @@ self: { test-invariant ]; description = "Pointless functions and a simplistic zero and monoid"; - license = lib.licensesSpdx."GPL-2.0-only"; + license = lib.meta.getLicenseFromSpdxId "GPL-2.0-only"; } ) { }; @@ -722707,7 +722707,7 @@ self: { uniform-strings ]; description = "Handling errors in the uniform framework"; - license = lib.licensesSpdx."GPL-2.0-only"; + license = lib.meta.getLicenseFromSpdxId "GPL-2.0-only"; } ) { }; @@ -722787,7 +722787,7 @@ self: { zlib ]; description = "Uniform file handling operations"; - license = lib.licensesSpdx."GPL-2.0-only"; + license = lib.meta.getLicenseFromSpdxId "GPL-2.0-only"; } ) { }; @@ -723087,7 +723087,7 @@ self: { uniform-algebras ]; description = "Manipulate and convert strings of characters uniformly and consistently"; - license = lib.licensesSpdx."GPL-2.0-only"; + license = lib.meta.getLicenseFromSpdxId "GPL-2.0-only"; } ) { }; @@ -723116,7 +723116,7 @@ self: { uniform-strings ]; description = "Time in the uniform framework"; - license = lib.licensesSpdx."GPL-2.0-only"; + license = lib.meta.getLicenseFromSpdxId "GPL-2.0-only"; } ) { }; @@ -723194,7 +723194,7 @@ self: { uniform-time ]; description = "A uniform base to build apps on"; - license = lib.licensesSpdx."GPL-2.0-only"; + license = lib.meta.getLicenseFromSpdxId "GPL-2.0-only"; } ) { }; @@ -723262,7 +723262,7 @@ self: { lens ]; description = "Extensible type-safe unions"; - license = lib.licensesSpdx."BSD-3-Clause"; + license = lib.meta.getLicenseFromSpdxId "BSD-3-Clause"; } ) { }; @@ -723433,7 +723433,7 @@ self: { with-utf8 ]; description = "Union mount filesystem paths into Haskell datastructures"; - license = lib.licensesSpdx."MIT"; + license = lib.meta.getLicenseFromSpdxId "MIT"; } ) { }; @@ -723578,7 +723578,7 @@ self: { transformers ]; description = "Esoteric programming language where each number can only appear once"; - license = lib.licensesSpdx."MIT"; + license = lib.meta.getLicenseFromSpdxId "MIT"; hydraPlatforms = lib.platforms.none; mainProgram = "unique"; broken = true; @@ -723615,7 +723615,7 @@ self: { utility-ht ]; description = "Solve simple simultaneous equations"; - license = lib.licensesSpdx."BSD-3-Clause"; + license = lib.meta.getLicenseFromSpdxId "BSD-3-Clause"; maintainers = [ lib.maintainers.thielema ]; } ) { }; @@ -723653,7 +723653,7 @@ self: { utility-ht ]; description = "Solve simple simultaneous equations"; - license = lib.licensesSpdx."BSD-3-Clause"; + license = lib.meta.getLicenseFromSpdxId "BSD-3-Clause"; maintainers = [ lib.maintainers.thielema ]; } ) { }; @@ -724095,7 +724095,7 @@ self: { ]; testHaskellDepends = [ base ]; description = "Extensible typed Dimensions"; - license = lib.licensesSpdx."BSD-3-Clause"; + license = lib.meta.getLicenseFromSpdxId "BSD-3-Clause"; hydraPlatforms = lib.platforms.none; broken = true; } @@ -724358,7 +724358,7 @@ self: { universe-some ]; description = "A class for finite and recursively enumerable types"; - license = lib.licensesSpdx."BSD-3-Clause"; + license = lib.meta.getLicenseFromSpdxId "BSD-3-Clause"; maintainers = [ lib.maintainers.alexfmpe ]; } ) { }; @@ -724390,7 +724390,7 @@ self: { QuickCheck ]; description = "A class for finite and recursively enumerable types"; - license = lib.licensesSpdx."BSD-3-Clause"; + license = lib.meta.getLicenseFromSpdxId "BSD-3-Clause"; } ) { }; @@ -724411,7 +724411,7 @@ self: { universe-some ]; description = "Universe instances for types from dependent-sum"; - license = lib.licensesSpdx."BSD-3-Clause"; + license = lib.meta.getLicenseFromSpdxId "BSD-3-Clause"; } ) { }; @@ -724461,7 +724461,7 @@ self: { universe-base ]; description = "Universe instances for types from selected extra packages"; - license = lib.licensesSpdx."BSD-3-Clause"; + license = lib.meta.getLicenseFromSpdxId "BSD-3-Clause"; } ) { }; @@ -724507,7 +724507,7 @@ self: { universe-base ]; description = "Instances of standard classes that are made possible by enumerations"; - license = lib.licensesSpdx."BSD-3-Clause"; + license = lib.meta.getLicenseFromSpdxId "BSD-3-Clause"; } ) { }; @@ -724542,7 +724542,7 @@ self: { universe-base ]; description = "Universe instances for Some from some"; - license = lib.licensesSpdx."BSD-3-Clause"; + license = lib.meta.getLicenseFromSpdxId "BSD-3-Clause"; maintainers = [ lib.maintainers.alexfmpe ]; } ) { }; @@ -724655,7 +724655,7 @@ self: { ]; testToolDepends = [ tasty-discover ]; description = "Custom prelude used in Serokell"; - license = lib.licensesSpdx."MIT"; + license = lib.meta.getLicenseFromSpdxId "MIT"; } ) { }; @@ -724709,7 +724709,7 @@ self: { bytestring ]; description = "Unix/Posix-specific functions for ByteStrings"; - license = lib.licensesSpdx."BSD-3-Clause"; + license = lib.meta.getLicenseFromSpdxId "BSD-3-Clause"; } ) { }; @@ -724961,7 +724961,7 @@ self: { zenhack-prelude ]; description = "Straightforward bindings to the posix API"; - license = lib.licensesSpdx."MIT"; + license = lib.meta.getLicenseFromSpdxId "MIT"; hydraPlatforms = lib.platforms.none; broken = true; } @@ -725145,7 +725145,7 @@ self: { unliftio ]; description = "Unleash feature toggle client"; - license = lib.licensesSpdx."MIT"; + license = lib.meta.getLicenseFromSpdxId "MIT"; hydraPlatforms = lib.platforms.none; mainProgram = "example"; } @@ -725193,7 +725193,7 @@ self: { text ]; description = "Unleash feature toggle client core"; - license = lib.licensesSpdx."MIT"; + license = lib.meta.getLicenseFromSpdxId "MIT"; hydraPlatforms = lib.platforms.none; broken = true; } @@ -725218,7 +725218,7 @@ self: { transformers-base ]; description = "Typeclass for monads that can be unlifted to arbitrary base monads"; - license = lib.licensesSpdx."MPL-2.0"; + license = lib.meta.getLicenseFromSpdxId "MPL-2.0"; hydraPlatforms = lib.platforms.none; broken = true; } @@ -725245,7 +725245,7 @@ self: { unliftio-core ]; description = "(un)lifted classes and functions for the STM monad"; - license = lib.licensesSpdx."BSD-2-Clause"; + license = lib.meta.getLicenseFromSpdxId "BSD-2-Clause"; hydraPlatforms = lib.platforms.none; broken = true; } @@ -725268,7 +725268,7 @@ self: { text-short ]; description = "Unlifted and levity-polymorphic types"; - license = lib.licensesSpdx."BSD-3-Clause"; + license = lib.meta.getLicenseFromSpdxId "BSD-3-Clause"; } ) { }; @@ -725476,7 +725476,7 @@ self: { unliftio ]; description = "Fast and robust message queues for concurrent processes"; - license = lib.licensesSpdx."BSD-2-Clause"; + license = lib.meta.getLicenseFromSpdxId "BSD-2-Clause"; hydraPlatforms = lib.platforms.none; mainProgram = "unliftio-messagebox-memleak-test"; broken = true; @@ -725552,7 +725552,7 @@ self: { unliftio-core ]; description = "Use MonadUnliftIO on servant APIs"; - license = lib.licensesSpdx."BSD-3-Clause"; + license = lib.meta.getLicenseFromSpdxId "BSD-3-Clause"; } ) { }; @@ -726023,7 +726023,7 @@ self: { quickcheck-classes ]; description = "maybes of numeric values with fewer indirections"; - license = lib.licensesSpdx."BSD-3-Clause"; + license = lib.meta.getLicenseFromSpdxId "BSD-3-Clause"; } ) { }; @@ -726044,7 +726044,7 @@ self: { text-short ]; description = "optional text that unpacks well"; - license = lib.licensesSpdx."BSD-3-Clause"; + license = lib.meta.getLicenseFromSpdxId "BSD-3-Clause"; hydraPlatforms = lib.platforms.none; broken = true; } @@ -726260,7 +726260,7 @@ self: { ghc ]; description = "Unsatisfiable type class"; - license = lib.licensesSpdx."BSD-3-Clause"; + license = lib.meta.getLicenseFromSpdxId "BSD-3-Clause"; hydraPlatforms = lib.platforms.none; broken = true; } @@ -726462,7 +726462,7 @@ self: { text ]; description = "converts between primitives"; - license = lib.licensesSpdx."MIT"; + license = lib.meta.getLicenseFromSpdxId "MIT"; } ) { }; @@ -726497,7 +726497,7 @@ self: { bifunctors ]; description = "Unzip functions for general Traversable containers"; - license = lib.licensesSpdx."BSD-2-Clause"; + license = lib.meta.getLicenseFromSpdxId "BSD-2-Clause"; } ) { }; @@ -726564,7 +726564,7 @@ self: { split ]; description = "Command-line tool to generate paths for moving upward in a file system"; - license = lib.licensesSpdx."BSD-3-Clause"; + license = lib.meta.getLicenseFromSpdxId "BSD-3-Clause"; hydraPlatforms = lib.platforms.none; mainProgram = "up"; } @@ -727681,7 +727681,7 @@ self: { uri-encode ]; description = "Encoding and decoding of URL slugs"; - license = lib.licensesSpdx."MIT"; + license = lib.meta.getLicenseFromSpdxId "MIT"; } ) { }; @@ -728475,7 +728475,7 @@ self: { gauge ]; description = "UTF-8"; - license = lib.licensesSpdx."BSD-3-Clause"; + license = lib.meta.getLicenseFromSpdxId "BSD-3-Clause"; hydraPlatforms = lib.platforms.none; broken = true; } @@ -728566,7 +728566,7 @@ self: { ]; testToolDepends = [ hspec-discover ]; description = "Unicode"; - license = lib.licensesSpdx."BSD-3-Clause"; + license = lib.meta.getLicenseFromSpdxId "BSD-3-Clause"; } ) { }; @@ -728732,7 +728732,7 @@ self: { logict ]; description = "See README for more info"; - license = lib.licensesSpdx."BSD-3-Clause"; + license = lib.meta.getLicenseFromSpdxId "BSD-3-Clause"; hydraPlatforms = lib.platforms.none; broken = true; } @@ -728886,7 +728886,7 @@ self: { QuickCheck ]; description = "Various small helper functions for Lists, Maybes, Tuples, Functions"; - license = lib.licensesSpdx."BSD-3-Clause"; + license = lib.meta.getLicenseFromSpdxId "BSD-3-Clause"; maintainers = [ lib.maintainers.thielema ]; } ) { }; @@ -728910,7 +728910,7 @@ self: { proto-lens-runtime ]; description = "Generated code for a gRPC interface for UTxO Blockchains"; - license = lib.licensesSpdx."Apache-2.0"; + license = lib.meta.getLicenseFromSpdxId "Apache-2.0"; } ) { }; @@ -728990,7 +728990,7 @@ self: { uuid ]; description = "An SDK for clients of the UTxO RPC specification"; - license = lib.licensesSpdx."Apache-2.0"; + license = lib.meta.getLicenseFromSpdxId "Apache-2.0"; hydraPlatforms = lib.platforms.none; } ) { }; @@ -729071,7 +729071,7 @@ self: { warp-grpc ]; description = "An SDK for UTxO RPC services"; - license = lib.licensesSpdx."Apache-2.0"; + license = lib.meta.getLicenseFromSpdxId "Apache-2.0"; hydraPlatforms = lib.platforms.none; mainProgram = "example"; } @@ -729295,7 +729295,7 @@ self: { text ]; description = "utilities for parse errors"; - license = lib.licensesSpdx."BSD-2-Clause"; + license = lib.meta.getLicenseFromSpdxId "BSD-2-Clause"; } ) { }; @@ -729798,7 +729798,7 @@ self: { text ]; description = "Tweak .cabal files"; - license = lib.licensesSpdx."MIT"; + license = lib.meta.getLicenseFromSpdxId "MIT"; hydraPlatforms = lib.platforms.none; maintainers = [ lib.maintainers.berberman ]; broken = true; @@ -730229,7 +730229,7 @@ self: { text ]; description = "Runs commands on remote machines using ssh"; - license = lib.licensesSpdx."MIT"; + license = lib.meta.getLicenseFromSpdxId "MIT"; hydraPlatforms = lib.platforms.none; broken = true; } @@ -730547,7 +730547,7 @@ self: { text ]; description = "Lighweight pure data validation based on Applicative and Selective functors"; - license = lib.licensesSpdx."MPL-2.0"; + license = lib.meta.getLicenseFromSpdxId "MPL-2.0"; } ) { }; @@ -731081,7 +731081,7 @@ self: { ]; testToolDepends = [ hspec-discover ]; description = "Simple and powerful data validation"; - license = lib.licensesSpdx."MIT"; + license = lib.meta.getLicenseFromSpdxId "MIT"; } ) { }; @@ -731131,7 +731131,7 @@ self: { ]; testToolDepends = [ doctest ]; description = "Valuations"; - license = lib.licensesSpdx."BSD-3-Clause"; + license = lib.meta.getLicenseFromSpdxId "BSD-3-Clause"; } ) { }; @@ -731258,7 +731258,7 @@ self: { stm ]; description = "The VarMonad typeclass, generalizing types of references"; - license = lib.licensesSpdx."Apache-2.0"; + license = lib.meta.getLicenseFromSpdxId "Apache-2.0"; hydraPlatforms = lib.platforms.none; broken = true; } @@ -731308,7 +731308,7 @@ self: { libraryHaskellDepends = [ base ]; testHaskellDepends = [ base ]; description = "Utilities for working with variadic functions using type-level lists"; - license = lib.licensesSpdx."BSD-3-Clause"; + license = lib.meta.getLicenseFromSpdxId "BSD-3-Clause"; } ) { }; @@ -731540,7 +731540,7 @@ self: { QuickCheck ]; description = "Variant and EADT"; - license = lib.licensesSpdx."BSD-3-Clause"; + license = lib.meta.getLicenseFromSpdxId "BSD-3-Clause"; } ) { }; @@ -731597,7 +731597,7 @@ self: { QuickCheck ]; description = "integer arithmetic codes"; - license = lib.licensesSpdx."MIT"; + license = lib.meta.getLicenseFromSpdxId "MIT"; } ) { }; @@ -731722,7 +731722,7 @@ self: { unordered-containers ]; description = "a persistent store for values of arbitrary types"; - license = lib.licensesSpdx."BSD-3-Clause"; + license = lib.meta.getLicenseFromSpdxId "BSD-3-Clause"; } ) { }; @@ -732195,7 +732195,7 @@ self: { ]; testToolDepends = [ hspec-discover ]; description = "Library for handling files ignored by VCS systems"; - license = lib.licensesSpdx."BSD-3-Clause"; + license = lib.meta.getLicenseFromSpdxId "BSD-3-Clause"; mainProgram = "ignore"; } ) { }; @@ -732397,7 +732397,7 @@ self: { vector ]; description = "Vec: length-indexed (sized) list"; - license = lib.licensesSpdx."BSD-3-Clause"; + license = lib.meta.getLicenseFromSpdxId "BSD-3-Clause"; } ) { }; @@ -732422,7 +732422,7 @@ self: { vec ]; description = "Vec: length-indexed (sized) list: lens support"; - license = lib.licensesSpdx."BSD-3-Clause"; + license = lib.meta.getLicenseFromSpdxId "BSD-3-Clause"; } ) { }; @@ -732447,7 +732447,7 @@ self: { vec ]; description = "Vec: length-indexed (sized) list: optics support"; - license = lib.licensesSpdx."BSD-3-Clause"; + license = lib.meta.getLicenseFromSpdxId "BSD-3-Clause"; } ) { }; @@ -732593,7 +732593,7 @@ self: { ]; doHaddock = false; description = "Efficient Arrays"; - license = lib.licensesSpdx."BSD-3-Clause"; + license = lib.meta.getLicenseFromSpdxId "BSD-3-Clause"; } ) { }; @@ -732699,7 +732699,7 @@ self: { vector ]; description = "Instances of Data.Binary for vector"; - license = lib.licensesSpdx."BSD-3-Clause"; + license = lib.meta.getLicenseFromSpdxId "BSD-3-Clause"; } ) { }; @@ -732753,7 +732753,7 @@ self: { tasty-quickcheck ]; description = "Vector builder"; - license = lib.licensesSpdx."MIT"; + license = lib.meta.getLicenseFromSpdxId "MIT"; } ) { }; @@ -732859,7 +732859,7 @@ self: { hedgehog-classes ]; description = "circular vectors"; - license = lib.licensesSpdx."MIT"; + license = lib.meta.getLicenseFromSpdxId "MIT"; hydraPlatforms = lib.platforms.none; broken = true; } @@ -732992,7 +732992,7 @@ self: { ]; doHaddock = false; description = "Storable vectors with cpu-independent representation"; - license = lib.licensesSpdx."MIT"; + license = lib.meta.getLicenseFromSpdxId "MIT"; hydraPlatforms = lib.platforms.none; broken = true; } @@ -733013,7 +733013,7 @@ self: { vector ]; description = "Utilities for the \"vector\" library"; - license = lib.licensesSpdx."MIT"; + license = lib.meta.getLicenseFromSpdxId "MIT"; } ) { }; @@ -733326,7 +733326,7 @@ self: { ]; doHaddock = false; description = "Fast and flexible quicksort implementation for mutable vectors"; - license = lib.licensesSpdx."Apache-2.0"; + license = lib.meta.getLicenseFromSpdxId "Apache-2.0"; } ) { }; @@ -733461,7 +733461,7 @@ self: { vector ]; description = "Size tagged vectors"; - license = lib.licensesSpdx."BSD-3-Clause"; + license = lib.meta.getLicenseFromSpdxId "BSD-3-Clause"; } ) { }; @@ -733793,7 +733793,7 @@ self: { vector ]; description = "GIS Vector Tiles, as defined by Mapbox"; - license = lib.licensesSpdx."BSD-3-Clause"; + license = lib.meta.getLicenseFromSpdxId "BSD-3-Clause"; hydraPlatforms = lib.platforms.none; } ) { }; @@ -733938,7 +733938,7 @@ self: { ]; testToolDepends = [ hspec-discover ]; description = "ASCII platform-adventure game"; - license = lib.licensesSpdx."GPL-3.0-only"; + license = lib.meta.getLicenseFromSpdxId "GPL-3.0-only"; hydraPlatforms = lib.platforms.none; mainProgram = "venzone"; } @@ -734329,7 +734329,7 @@ self: { uuid ]; description = "Small alternative prelude"; - license = lib.licensesSpdx."MIT"; + license = lib.meta.getLicenseFromSpdxId "MIT"; } ) { }; @@ -734489,7 +734489,7 @@ self: { text ]; description = "Types and parsers for software version numbers"; - license = lib.licensesSpdx."BSD-3-Clause"; + license = lib.meta.getLicenseFromSpdxId "BSD-3-Clause"; } ) { }; @@ -734523,7 +734523,7 @@ self: { tasty-hunit ]; description = "Vertex enumeration"; - license = lib.licensesSpdx."GPL-3.0-only"; + license = lib.meta.getLicenseFromSpdxId "GPL-3.0-only"; hydraPlatforms = lib.platforms.none; } ) { }; @@ -734629,7 +734629,7 @@ self: { ]; doHaddock = false; description = "Array library monomorphized with backpack"; - license = lib.licensesSpdx."BSD-3-Clause"; + license = lib.meta.getLicenseFromSpdxId "BSD-3-Clause"; hydraPlatforms = lib.platforms.none; broken = true; } @@ -734675,7 +734675,7 @@ self: { text ]; description = "types for ingesting vflow data with aeson"; - license = lib.licensesSpdx."BSD-3-Clause"; + license = lib.meta.getLicenseFromSpdxId "BSD-3-Clause"; hydraPlatforms = lib.platforms.none; } ) { }; @@ -735418,7 +735418,7 @@ self: { yaml ]; description = "Frontend for video metadata tagging tools"; - license = lib.licensesSpdx."BSD-2-Clause"; + license = lib.meta.getLicenseFromSpdxId "BSD-2-Clause"; hydraPlatforms = lib.platforms.none; mainProgram = "vimeta"; } @@ -735761,7 +735761,7 @@ self: { vinyl ]; description = "Syntax sugar for vinyl records using overloaded labels"; - license = lib.licensesSpdx."MIT"; + license = lib.meta.getLicenseFromSpdxId "MIT"; hydraPlatforms = lib.platforms.none; broken = true; } @@ -736229,7 +736229,7 @@ self: { profunctors ]; description = "Profunctor optics via the profunctor representation theorem"; - license = lib.licensesSpdx."GPL-3.0-or-later"; + license = lib.meta.getLicenseFromSpdxId "GPL-3.0-or-later"; hydraPlatforms = lib.platforms.none; broken = true; } @@ -736899,7 +736899,7 @@ self: { ]; testToolDepends = [ tasty-discover ]; description = "Switch VPN with web interface for LAN"; - license = lib.licensesSpdx."BSD-3-Clause"; + license = lib.meta.getLicenseFromSpdxId "BSD-3-Clause"; hydraPlatforms = lib.platforms.none; mainProgram = "vpn-router"; } @@ -737239,7 +737239,7 @@ self: { vty-unix ]; description = "Cross-platform support for Vty"; - license = lib.licensesSpdx."BSD-3-Clause"; + license = lib.meta.getLicenseFromSpdxId "BSD-3-Clause"; } ) { }; @@ -737262,7 +737262,7 @@ self: { vty-unix ]; description = "Cross-platform support for Vty"; - license = lib.licensesSpdx."BSD-3-Clause"; + license = lib.meta.getLicenseFromSpdxId "BSD-3-Clause"; hydraPlatforms = lib.platforms.none; } ) { }; @@ -737485,7 +737485,7 @@ self: { vty ]; description = "Unix backend for Vty"; - license = lib.licensesSpdx."BSD-3-Clause"; + license = lib.meta.getLicenseFromSpdxId "BSD-3-Clause"; mainProgram = "vty-unix-build-width-table"; } ) { }; @@ -737537,7 +737537,7 @@ self: { Win32 ]; description = "Windows backend for Vty"; - license = lib.licensesSpdx."BSD-3-Clause"; + license = lib.meta.getLicenseFromSpdxId "BSD-3-Clause"; platforms = lib.platforms.windows; } ) { }; @@ -737589,7 +737589,7 @@ self: { Win32 ]; description = "Windows backend for Vty"; - license = lib.licensesSpdx."BSD-3-Clause"; + license = lib.meta.getLicenseFromSpdxId "BSD-3-Clause"; platforms = lib.platforms.windows; hydraPlatforms = lib.platforms.none; } @@ -737631,7 +737631,7 @@ self: { ]; testToolDepends = [ tasty-discover ]; description = "Bindings to the Vulkan graphics API"; - license = lib.licensesSpdx."BSD-3-Clause"; + license = lib.meta.getLicenseFromSpdxId "BSD-3-Clause"; badPlatforms = [ "i686-linux" "armv7l-linux" @@ -738365,7 +738365,7 @@ self: { wai ]; description = "assetPath function for WAI"; - license = lib.licensesSpdx."MIT"; + license = lib.meta.getLicenseFromSpdxId "MIT"; } ) { }; @@ -738580,7 +738580,7 @@ self: { wai-extra ]; description = "Encrypted cookies for WAI"; - license = lib.licensesSpdx."Apache-2.0"; + license = lib.meta.getLicenseFromSpdxId "Apache-2.0"; } ) { }; @@ -738622,7 +738622,7 @@ self: { wai-extra ]; description = "Cross-site request forgery protection for WAI"; - license = lib.licensesSpdx."Apache-2.0"; + license = lib.meta.getLicenseFromSpdxId "Apache-2.0"; } ) { }; @@ -739015,7 +739015,7 @@ self: { wai-session ]; description = "Flash messages for wai apps"; - license = lib.licensesSpdx."MIT"; + license = lib.meta.getLicenseFromSpdxId "MIT"; } ) { }; @@ -739278,7 +739278,7 @@ self: { ]; testToolDepends = [ tasty-discover ]; description = "Wrap WAI applications to run on AWS Lambda"; - license = lib.licensesSpdx."BSD-3-Clause"; + license = lib.meta.getLicenseFromSpdxId "BSD-3-Clause"; hydraPlatforms = lib.platforms.none; } ) { }; @@ -740708,7 +740708,7 @@ self: { warp-tls ]; description = "WAI middleware that delegates handling of requests"; - license = lib.licensesSpdx."BSD-3-Clause"; + license = lib.meta.getLicenseFromSpdxId "BSD-3-Clause"; } ) { }; @@ -741662,7 +741662,7 @@ self: { wai ]; description = "Problem details middleware for WAI"; - license = lib.licensesSpdx."MIT"; + license = lib.meta.getLicenseFromSpdxId "MIT"; hydraPlatforms = lib.platforms.none; broken = true; } @@ -741738,7 +741738,7 @@ self: { warp ]; description = "See README for more info"; - license = lib.licensesSpdx."Apache-2.0"; + license = lib.meta.getLicenseFromSpdxId "Apache-2.0"; hydraPlatforms = lib.platforms.none; broken = true; } @@ -741848,7 +741848,7 @@ self: { wai-extra ]; description = "Generic parameter parsing for WAI requests"; - license = lib.licensesSpdx."MIT"; + license = lib.meta.getLicenseFromSpdxId "MIT"; } ) { }; @@ -742361,7 +742361,7 @@ self: { ]; testToolDepends = [ hspec-discover ]; description = "WAI middleware to automatically encrypt and sign cookies"; - license = lib.licensesSpdx."MIT"; + license = lib.meta.getLicenseFromSpdxId "MIT"; hydraPlatforms = lib.platforms.none; mainProgram = "waicookie-genkey"; broken = true; @@ -742954,7 +742954,7 @@ self: { criterion ]; description = "A request rate limiting middleware using token buckets"; - license = lib.licensesSpdx."Apache-2.0"; + license = lib.meta.getLicenseFromSpdxId "Apache-2.0"; } ) { }; @@ -743483,7 +743483,7 @@ self: { ]; testToolDepends = [ hspec-discover ]; description = "Automatic type-safe conversion between Haskell data types using Template Haskell"; - license = lib.licensesSpdx."BSD-3-Clause"; + license = lib.meta.getLicenseFromSpdxId "BSD-3-Clause"; } ) { }; @@ -743938,7 +743938,7 @@ self: { warp ]; description = "Socket activation and other systemd integration for the Warp web server (WAI)"; - license = lib.licensesSpdx."BSD-3-Clause"; + license = lib.meta.getLicenseFromSpdxId "BSD-3-Clause"; mainProgram = "warp-systemd-example"; maintainers = [ lib.maintainers.mpscholten ]; } @@ -744334,7 +744334,7 @@ self: { text ]; description = "WebAssembly Language Toolkit and Interpreter"; - license = lib.licensesSpdx."MIT"; + license = lib.meta.getLicenseFromSpdxId "MIT"; hydraPlatforms = lib.platforms.none; broken = true; } @@ -744643,7 +744643,7 @@ self: { ]; testToolDepends = [ hspec-discover ]; description = "Work with WAVE and RF64 files"; - license = lib.licensesSpdx."BSD-3-Clause"; + license = lib.meta.getLicenseFromSpdxId "BSD-3-Clause"; } ) { }; @@ -744838,7 +744838,7 @@ self: { uuid-types ]; description = "Bidirectional URL path, URL query string and HTTP headers codecs"; - license = lib.licensesSpdx."Apache-2.0"; + license = lib.meta.getLicenseFromSpdxId "Apache-2.0"; hydraPlatforms = lib.platforms.none; broken = true; } @@ -744884,7 +744884,7 @@ self: { process ]; description = "Run a command on a specified directory"; - license = lib.licensesSpdx."Apache-2.0"; + license = lib.meta.getLicenseFromSpdxId "Apache-2.0"; mainProgram = "wd"; } ) { }; @@ -745010,7 +745010,7 @@ self: { xml ]; description = "Weather and related data info command-line tool"; - license = lib.licensesSpdx."GPL-3.0-or-later"; + license = lib.meta.getLicenseFromSpdxId "GPL-3.0-or-later"; hydraPlatforms = lib.platforms.none; mainProgram = "weatherhs"; } @@ -745040,7 +745040,7 @@ self: { ]; doHaddock = false; description = "Compositional breadth-first walks"; - license = lib.licensesSpdx."BSD-3-Clause"; + license = lib.meta.getLicenseFromSpdxId "BSD-3-Clause"; hydraPlatforms = lib.platforms.none; } ) { }; @@ -745060,7 +745060,7 @@ self: { some ]; description = "Core definitions for weave"; - license = lib.licensesSpdx."BSD-3-Clause"; + license = lib.meta.getLicenseFromSpdxId "BSD-3-Clause"; } ) { }; @@ -745121,7 +745121,7 @@ self: { time ]; description = "Parsing/printing of persistent web cookies"; - license = lib.licensesSpdx."BSD-3-Clause"; + license = lib.meta.getLicenseFromSpdxId "BSD-3-Clause"; } ) { }; @@ -745530,7 +745530,7 @@ self: { optparse-applicative ]; description = "representations of a web page"; - license = lib.licensesSpdx."BSD-3-Clause"; + license = lib.meta.getLicenseFromSpdxId "BSD-3-Clause"; mainProgram = "web-rep-example"; } ) { }; @@ -745594,7 +745594,7 @@ self: { optparse-applicative ]; description = "representations of a web page"; - license = lib.licensesSpdx."BSD-3-Clause"; + license = lib.meta.getLicenseFromSpdxId "BSD-3-Clause"; hydraPlatforms = lib.platforms.none; mainProgram = "web-rep-example"; } @@ -745997,7 +745997,7 @@ self: { text ]; description = "Type-safe HTML and CSS"; - license = lib.licensesSpdx."BSD-3-Clause"; + license = lib.meta.getLicenseFromSpdxId "BSD-3-Clause"; hydraPlatforms = lib.platforms.none; broken = true; } @@ -746048,7 +746048,7 @@ self: { text ]; description = "Type-safe HTML and CSS with intuitive layouts and composable styles"; - license = lib.licensesSpdx."BSD-3-Clause"; + license = lib.meta.getLicenseFromSpdxId "BSD-3-Clause"; hydraPlatforms = lib.platforms.none; broken = true; } @@ -746085,7 +746085,7 @@ self: { web-view ]; description = "Build HTML tables using web-view and colonnade"; - license = lib.licensesSpdx."MIT"; + license = lib.meta.getLicenseFromSpdxId "MIT"; hydraPlatforms = lib.platforms.none; } ) { }; @@ -746862,7 +746862,7 @@ self: { validation ]; description = "Relying party (server) implementation of the WebAuthn 2 specification"; - license = lib.licensesSpdx."Apache-2.0"; + license = lib.meta.getLicenseFromSpdxId "Apache-2.0"; hydraPlatforms = lib.platforms.none; broken = true; } @@ -746934,7 +746934,7 @@ self: { wai ]; description = "A super-simple web server framework"; - license = lib.licensesSpdx."Apache-2.0"; + license = lib.meta.getLicenseFromSpdxId "Apache-2.0"; hydraPlatforms = lib.platforms.none; broken = true; } @@ -746990,7 +746990,7 @@ self: { tasty-hunit ]; description = "Plug-n-play #hex-syntax for your colors"; - license = lib.licensesSpdx."MPL-2.0"; + license = lib.meta.getLicenseFromSpdxId "MPL-2.0"; } ) { }; @@ -747424,7 +747424,7 @@ self: { ]; testToolDepends = [ tasty-discover ]; description = "A typed wrapper for W3C WebDriver protocol. A base for other libraries."; - license = lib.licensesSpdx."BSD-3-Clause"; + license = lib.meta.getLicenseFromSpdxId "BSD-3-Clause"; } ) { }; @@ -747492,7 +747492,7 @@ self: { ]; doHaddock = false; description = "A typed wrapper for W3C WebDriver (HTTP and BiDi) protocols"; - license = lib.licensesSpdx."BSD-3-Clause"; + license = lib.meta.getLicenseFromSpdxId "BSD-3-Clause"; hydraPlatforms = lib.platforms.none; } ) { }; @@ -747742,7 +747742,7 @@ self: { zlib ]; description = "Wrapper around the webdriver package that automatically manages Selenium"; - license = lib.licensesSpdx."BSD-3-Clause"; + license = lib.meta.getLicenseFromSpdxId "BSD-3-Clause"; } ) { }; @@ -748038,7 +748038,7 @@ self: { wai-extra ]; description = "Composable, type-safe library to build HTTP APIs"; - license = lib.licensesSpdx."MPL-2.0"; + license = lib.meta.getLicenseFromSpdxId "MPL-2.0"; } ) { }; @@ -748089,7 +748089,7 @@ self: { wai-extra ]; description = "Composable, type-safe library to build HTTP APIs"; - license = lib.licensesSpdx."MPL-2.0"; + license = lib.meta.getLicenseFromSpdxId "MPL-2.0"; hydraPlatforms = lib.platforms.none; } ) { }; @@ -748125,7 +748125,7 @@ self: { webgear-core ]; description = "Composable, type-safe library to build HTTP API servers"; - license = lib.licensesSpdx."MPL-2.0"; + license = lib.meta.getLicenseFromSpdxId "MPL-2.0"; } ) { }; @@ -748162,7 +748162,7 @@ self: { webgear-core ]; description = "Composable, type-safe library to build HTTP API servers"; - license = lib.licensesSpdx."MPL-2.0"; + license = lib.meta.getLicenseFromSpdxId "MPL-2.0"; hydraPlatforms = lib.platforms.none; } ) { }; @@ -748235,7 +748235,7 @@ self: { webgear-core ]; description = "Composable, type-safe library to build HTTP API servers"; - license = lib.licensesSpdx."MPL-2.0"; + license = lib.meta.getLicenseFromSpdxId "MPL-2.0"; } ) { }; @@ -748309,7 +748309,7 @@ self: { webgear-core ]; description = "Composable, type-safe library to build HTTP API servers"; - license = lib.licensesSpdx."MPL-2.0"; + license = lib.meta.getLicenseFromSpdxId "MPL-2.0"; hydraPlatforms = lib.platforms.none; } ) { }; @@ -748343,7 +748343,7 @@ self: { webgear-core ]; description = "Composable, type-safe library to build HTTP API servers"; - license = lib.licensesSpdx."MPL-2.0"; + license = lib.meta.getLicenseFromSpdxId "MPL-2.0"; } ) { }; @@ -748378,7 +748378,7 @@ self: { webgear-core ]; description = "Composable, type-safe library to build HTTP API servers"; - license = lib.licensesSpdx."MPL-2.0"; + license = lib.meta.getLicenseFromSpdxId "MPL-2.0"; hydraPlatforms = lib.platforms.none; } ) { }; @@ -748408,7 +748408,7 @@ self: { webgear-core ]; description = "Host swagger UI based on WebGear API specifications"; - license = lib.licensesSpdx."MPL-2.0"; + license = lib.meta.getLicenseFromSpdxId "MPL-2.0"; } ) { }; @@ -748439,7 +748439,7 @@ self: { webgear-core ]; description = "Host swagger UI based on WebGear API specifications"; - license = lib.licensesSpdx."MPL-2.0"; + license = lib.meta.getLicenseFromSpdxId "MPL-2.0"; hydraPlatforms = lib.platforms.none; } ) { }; @@ -748512,7 +748512,7 @@ self: { hspec ]; description = "Haskell bindings to WebGPU Dawn for GPU computing and graphics"; - license = lib.licensesSpdx."MIT"; + license = lib.meta.getLicenseFromSpdxId "MIT"; hydraPlatforms = lib.platforms.none; broken = true; } @@ -749522,7 +749522,7 @@ self: { ]; testToolDepends = [ hspec-discover ]; description = "Detect dead code"; - license = lib.licensesSpdx."BSD-3-Clause"; + license = lib.meta.getLicenseFromSpdxId "BSD-3-Clause"; mainProgram = "weeder"; maintainers = [ lib.maintainers.maralorn ]; } @@ -750027,7 +750027,7 @@ self: { ]; doHaddock = false; description = "WGPU"; - license = lib.licensesSpdx."BSD-3-Clause"; + license = lib.meta.getLicenseFromSpdxId "BSD-3-Clause"; hydraPlatforms = lib.platforms.none; } ) { }; @@ -750053,7 +750053,7 @@ self: { ]; libraryPkgconfigDepends = [ SDL2 ]; description = "WGPU Raw"; - license = lib.licensesSpdx."BSD-3-Clause"; + license = lib.meta.getLicenseFromSpdxId "BSD-3-Clause"; hydraPlatforms = lib.platforms.none; broken = true; } @@ -750212,7 +750212,7 @@ self: { versions ]; description = "Solver-agnostic symbolic values support for issuing queries"; - license = lib.licensesSpdx."BSD-3-Clause"; + license = lib.meta.getLicenseFromSpdxId "BSD-3-Clause"; mainProgram = "quickstart"; } ) { }; @@ -750373,7 +750373,7 @@ self: { versions ]; description = "Solver-agnostic symbolic values support for issuing queries"; - license = lib.licensesSpdx."BSD-3-Clause"; + license = lib.meta.getLicenseFromSpdxId "BSD-3-Clause"; hydraPlatforms = lib.platforms.none; } ) { }; @@ -750480,7 +750480,7 @@ self: { tasty-hunit ]; description = "A compatibility layer for GHC's 'wherefrom' function"; - license = lib.licensesSpdx."BSD-2-Clause"; + license = lib.meta.getLicenseFromSpdxId "BSD-2-Clause"; } ) { }; @@ -750508,7 +750508,7 @@ self: { tasty-hunit ]; description = "A compatibility layer for GHC's 'wherefrom' function"; - license = lib.licensesSpdx."BSD-2-Clause"; + license = lib.meta.getLicenseFromSpdxId "BSD-2-Clause"; hydraPlatforms = lib.platforms.none; } ) { }; @@ -750567,7 +750567,7 @@ self: { which ]; description = "which-embed"; - license = lib.licensesSpdx."Apache-2.0"; + license = lib.meta.getLicenseFromSpdxId "Apache-2.0"; } ) { }; @@ -750854,7 +750854,7 @@ self: { wide-word ]; description = "Instances for wide-word"; - license = lib.licensesSpdx."BSD-3-Clause"; + license = lib.meta.getLicenseFromSpdxId "BSD-3-Clause"; hydraPlatforms = lib.platforms.none; broken = true; } @@ -751571,7 +751571,7 @@ self: { unordered-containers ]; description = "An implementation of the web Document Object Model, and its rendering"; - license = lib.licensesSpdx."MPL-2.0"; + license = lib.meta.getLicenseFromSpdxId "MPL-2.0"; hydraPlatforms = lib.platforms.none; broken = true; } @@ -751680,7 +751680,7 @@ self: { X11 ]; description = "OS window icon/name utilities"; - license = lib.licensesSpdx."BSD-3-Clause"; + license = lib.meta.getLicenseFromSpdxId "BSD-3-Clause"; } ) { }; @@ -752102,7 +752102,7 @@ self: { transformers ]; description = "Convert values from one type into another"; - license = lib.licensesSpdx."MIT"; + license = lib.meta.getLicenseFromSpdxId "MIT"; maintainers = [ lib.maintainers.maralorn ]; } ) { }; @@ -752293,7 +752293,7 @@ self: { vector ]; description = "filterable traversable"; - license = lib.licensesSpdx."BSD-3-Clause"; + license = lib.meta.getLicenseFromSpdxId "BSD-3-Clause"; } ) { }; @@ -752312,7 +752312,7 @@ self: { witherable ]; description = "Witherable = Traversable + Filterable"; - license = lib.licensesSpdx."BSD-3-Clause"; + license = lib.meta.getLicenseFromSpdxId "BSD-3-Clause"; hydraPlatforms = lib.platforms.none; broken = true; } @@ -752366,7 +752366,7 @@ self: { countable ]; description = "values that witness types"; - license = lib.licensesSpdx."BSD-2-Clause"; + license = lib.meta.getLicenseFromSpdxId "BSD-2-Clause"; } ) { }; @@ -752575,7 +752575,7 @@ self: { text ]; description = "A library for working with .wkt files."; - license = lib.licensesSpdx."BSD-3-Clause"; + license = lib.meta.getLicenseFromSpdxId "BSD-3-Clause"; } ) { }; @@ -752865,7 +752865,7 @@ self: { ]; testToolDepends = [ hspec-discover ]; description = "Convenient interface for interacting with WLED devices"; - license = lib.licensesSpdx."BSD-3-Clause"; + license = lib.meta.getLicenseFromSpdxId "BSD-3-Clause"; } ) { }; @@ -752916,7 +752916,7 @@ self: { optparse-applicative ]; description = "StatusNotifierItem tray icon for controlling wlsunset"; - license = lib.licensesSpdx."BSD-3-Clause"; + license = lib.meta.getLicenseFromSpdxId "BSD-3-Clause"; mainProgram = "wlsunset-sni"; } ) { }; @@ -753034,7 +753034,7 @@ self: { sha256 = "0f0pa2vlp56j35llhzq1qqkwkfpm7r96av8jw22jngd0kcpc185b"; libraryHaskellDepends = [ base ]; description = "Convenient typeclass for defining arbitrary-index enums"; - license = lib.licensesSpdx."BSD-3-Clause"; + license = lib.meta.getLicenseFromSpdxId "BSD-3-Clause"; hydraPlatforms = lib.platforms.none; broken = true; } @@ -753265,7 +753265,7 @@ self: { weigh ]; description = "treat integral types as arrays of smaller integral types"; - license = lib.licensesSpdx."MIT"; + license = lib.meta.getLicenseFromSpdxId "MIT"; } ) { }; @@ -753285,7 +753285,7 @@ self: { ]; testHaskellDepends = [ base ]; description = "Compatibility shim for the Int/Word internal change in GHC 9.2"; - license = lib.licensesSpdx."BSD-3-Clause"; + license = lib.meta.getLicenseFromSpdxId "BSD-3-Clause"; } ) { }; @@ -753312,7 +753312,7 @@ self: { typed-process ]; description = "SoX for algorithmic composition with groups of notes liken to words"; - license = lib.licensesSpdx."MIT"; + license = lib.meta.getLicenseFromSpdxId "MIT"; } ) { }; @@ -753324,7 +753324,7 @@ self: { sha256 = "0kpw4gmy4yvpmcvz1sk0nfr21f7zvv3fnd2k59zx1amx8n4c5s7n"; libraryHaskellDepends = [ base ]; description = "General datatypes for music creation for one instrument"; - license = lib.licensesSpdx."MIT"; + license = lib.meta.getLicenseFromSpdxId "MIT"; } ) { }; @@ -753618,7 +753618,7 @@ self: { tasty-quickcheck ]; description = "Word8 set"; - license = lib.licensesSpdx."BSD-3-Clause"; + license = lib.meta.getLicenseFromSpdxId "BSD-3-Clause"; } ) { }; @@ -753853,7 +753853,7 @@ self: { vector ]; description = "Command-line tool to get random words"; - license = lib.licensesSpdx."Apache-2.0"; + license = lib.meta.getLicenseFromSpdxId "Apache-2.0"; hydraPlatforms = lib.platforms.none; mainProgram = "wordlist"; broken = true; @@ -754432,7 +754432,7 @@ self: { transformers ]; description = "LOGO-like Turtle graphics with a monadic interface"; - license = lib.licensesSpdx."BSD-3-Clause"; + license = lib.meta.getLicenseFromSpdxId "BSD-3-Clause"; hydraPlatforms = lib.platforms.none; broken = true; } @@ -754576,7 +754576,7 @@ self: { xml-basic ]; description = "Lazy wrapper to HaXML, HXT, TagSoup via custom XML tree structure"; - license = lib.licensesSpdx."GPL-3.0-only"; + license = lib.meta.getLicenseFromSpdxId "GPL-3.0-only"; } ) { }; @@ -754922,7 +754922,7 @@ self: { vector ]; description = "An easy-to-use HTTP client library"; - license = lib.licensesSpdx."BSD-3-Clause"; + license = lib.meta.getLicenseFromSpdxId "BSD-3-Clause"; } ) { }; @@ -754948,7 +754948,7 @@ self: { ]; testHaskellDepends = [ base ]; description = "Adaptation of the wreq library for the effectful ecosystem"; - license = lib.licensesSpdx."MIT"; + license = lib.meta.getLicenseFromSpdxId "MIT"; hydraPlatforms = lib.platforms.none; broken = true; } @@ -756031,7 +756031,7 @@ self: { yaml ]; description = "Unimportant Unix adminstration tool"; - license = lib.licensesSpdx."BSD-3-Clause"; + license = lib.meta.getLicenseFromSpdxId "BSD-3-Clause"; hydraPlatforms = lib.platforms.none; mainProgram = "pao"; } @@ -756229,7 +756229,7 @@ self: { websockets ]; description = "Secure WebSocket (WSS) clients"; - license = lib.licensesSpdx."MIT"; + license = lib.meta.getLicenseFromSpdxId "MIT"; } ) { }; @@ -756685,7 +756685,7 @@ self: { HUnit ]; description = "Simple flowchart diagrams. Inspired by DRAKON."; - license = lib.licensesSpdx."BSD-3-Clause"; + license = lib.meta.getLicenseFromSpdxId "BSD-3-Clause"; hydraPlatforms = lib.platforms.none; mainProgram = "wyvern-diagrams"; broken = true; @@ -756895,7 +756895,7 @@ self: { pem ]; description = "Basic X509 OCSP implementation"; - license = lib.licensesSpdx."BSD-3-Clause"; + license = lib.meta.getLicenseFromSpdxId "BSD-3-Clause"; } ) { }; @@ -756939,7 +756939,7 @@ self: { HUnit ]; description = "Basic X509 OCSP implementation"; - license = lib.licensesSpdx."BSD-3-Clause"; + license = lib.meta.getLicenseFromSpdxId "BSD-3-Clause"; hydraPlatforms = lib.platforms.none; } ) { }; @@ -757317,7 +757317,7 @@ self: { xcb-types ]; description = "A cffi-based python binding for X"; - license = lib.licensesSpdx."Apache-2.0"; + license = lib.meta.getLicenseFromSpdxId "Apache-2.0"; hydraPlatforms = lib.platforms.none; mainProgram = "xcffibgen"; broken = true; @@ -757349,7 +757349,7 @@ self: { temporary ]; description = "Cabal hooks for producing an XCFramework from a Haskell library"; - license = lib.licensesSpdx."BSD-3-Clause"; + license = lib.meta.getLicenseFromSpdxId "BSD-3-Clause"; hydraPlatforms = lib.platforms.none; broken = true; } @@ -757604,7 +757604,7 @@ self: { unix ]; description = "Parse files conforming to the xdg desktop entry spec"; - license = lib.licensesSpdx."BSD-3-Clause"; + license = lib.meta.getLicenseFromSpdxId "BSD-3-Clause"; } ) { }; @@ -758829,7 +758829,7 @@ self: { utility-ht ]; description = "Basics for XML/HTML representation and processing"; - license = lib.licensesSpdx."BSD-3-Clause"; + license = lib.meta.getLicenseFromSpdxId "BSD-3-Clause"; maintainers = [ lib.maintainers.thielema ]; } ) { }; @@ -759165,7 +759165,7 @@ self: { text ]; description = "Warm and fuzzy creation of XML documents"; - license = lib.licensesSpdx."MIT"; + license = lib.meta.getLicenseFromSpdxId "MIT"; } ) { }; @@ -759559,7 +759559,7 @@ self: { xml-conduit ]; description = "Lenses, traversals, and prisms for xml-conduit"; - license = lib.licensesSpdx."BSD-3-Clause"; + license = lib.meta.getLicenseFromSpdxId "BSD-3-Clause"; } ) { }; @@ -759610,7 +759610,7 @@ self: { xml-conduit ]; description = "Optics for xml-conduit"; - license = lib.licensesSpdx."BSD-3-Clause"; + license = lib.meta.getLicenseFromSpdxId "BSD-3-Clause"; } ) { }; @@ -759681,7 +759681,7 @@ self: { xml-conduit ]; description = "XML parser with informative error-reporting and simple API"; - license = lib.licensesSpdx."MIT"; + license = lib.meta.getLicenseFromSpdxId "MIT"; hydraPlatforms = lib.platforms.none; broken = true; } @@ -759826,7 +759826,7 @@ self: { protolude ]; description = "XML pretty printer"; - license = lib.licensesSpdx."GPL-2.0-only"; + license = lib.meta.getLicenseFromSpdxId "GPL-2.0-only"; hydraPlatforms = lib.platforms.none; mainProgram = "xml-prettify"; broken = true; @@ -760030,7 +760030,7 @@ self: { tasty-hunit ]; description = "Parse XML from bytes"; - license = lib.licensesSpdx."BSD-3-Clause"; + license = lib.meta.getLicenseFromSpdxId "BSD-3-Clause"; hydraPlatforms = lib.platforms.none; broken = true; } @@ -760244,7 +760244,7 @@ self: { ]; testToolDepends = [ hspec-discover ]; description = "Utilities for dealing with Content-values of \"xml-types\""; - license = lib.licensesSpdx."MIT"; + license = lib.meta.getLicenseFromSpdxId "MIT"; hydraPlatforms = lib.platforms.none; broken = true; } @@ -760277,7 +760277,7 @@ self: { ]; libraryPkgconfigDepends = [ xmlsec1 ]; description = "Verifying XML signatures"; - license = lib.licensesSpdx."BSD-3-Clause"; + license = lib.meta.getLicenseFromSpdxId "BSD-3-Clause"; hydraPlatforms = lib.platforms.none; broken = true; } @@ -760654,7 +760654,7 @@ self: { unordered-containers ]; description = "XML parser and renderer with HTML 5 quirks mode"; - license = lib.licensesSpdx."BSD-3-Clause"; + license = lib.meta.getLicenseFromSpdxId "BSD-3-Clause"; } ) { }; @@ -761625,7 +761625,7 @@ self: { ]; doHaddock = false; description = "Text-based notification server for XMobar"; - license = lib.licensesSpdx."BSD-3-Clause"; + license = lib.meta.getLicenseFromSpdxId "BSD-3-Clause"; badPlatforms = lib.platforms.darwin; hydraPlatforms = lib.platforms.none; mainProgram = "echo"; @@ -761666,7 +761666,7 @@ self: { criterion ]; description = "Efficient XOR masking"; - license = lib.licensesSpdx."GPL-2.0-or-later"; + license = lib.meta.getLicenseFromSpdxId "GPL-2.0-or-later"; } ) { }; @@ -761728,7 +761728,7 @@ self: { Xorshift128Plus ]; description = "Simple implementation of xorshift+ PRNG"; - license = lib.licensesSpdx."BSD-3-Clause"; + license = lib.meta.getLicenseFromSpdxId "BSD-3-Clause"; hydraPlatforms = lib.platforms.none; broken = true; } @@ -762384,7 +762384,7 @@ self: { hedgehog ]; description = "XTEA (eXtended Tiny Encryption Algorithm)"; - license = lib.licensesSpdx."MIT"; + license = lib.meta.getLicenseFromSpdxId "MIT"; hydraPlatforms = lib.platforms.none; broken = true; } @@ -762505,7 +762505,7 @@ self: { tasty-bench, tasty-quickcheck, text, - xxHash, + xxhash, }: mkDerivation { pname = "xxhash-ffi"; @@ -762517,7 +762517,7 @@ self: { hashable text ]; - libraryPkgconfigDepends = [ xxHash ]; + libraryPkgconfigDepends = [ xxhash ]; testHaskellDepends = [ base bytestring @@ -762535,9 +762535,9 @@ self: { tasty-bench ]; description = "Bindings and high-level helpers for xxHash"; - license = lib.licensesSpdx."BSD-3-Clause"; + license = lib.meta.getLicenseFromSpdxId "BSD-3-Clause"; } - ) { inherit (pkgs) xxHash; }; + ) { xxhash = null; }; xz = callPackage ( { @@ -762572,7 +762572,7 @@ self: { tasty-quickcheck ]; description = "LZMA/XZ compression and decompression"; - license = lib.licensesSpdx."BSD-3-Clause"; + license = lib.meta.getLicenseFromSpdxId "BSD-3-Clause"; } ) { inherit (pkgs) xz; }; @@ -762584,7 +762584,7 @@ self: { sha256 = "0q9cwdbqvc8i337gp9wmxbb79v8i2lasi39i92r42202m7mzsa79"; doHaddock = false; description = "LZMA/XZ clibs"; - license = lib.licensesSpdx."0BSD"; + license = lib.meta.getLicenseFromSpdxId "0BSD"; } ) { }; @@ -762786,7 +762786,7 @@ self: { higher-order-open-union ]; description = "Yet Another heFTy-inspired Extensible Effect"; - license = lib.licensesSpdx."BSD-3-Clause"; + license = lib.meta.getLicenseFromSpdxId "BSD-3-Clause"; } ) { }; @@ -762818,7 +762818,7 @@ self: { yaftee ]; description = "Basic monads implemented on Yaftee"; - license = lib.licensesSpdx."BSD-3-Clause"; + license = lib.meta.getLicenseFromSpdxId "BSD-3-Clause"; } ) { }; @@ -762853,7 +762853,7 @@ self: { yaftee-basic-monads ]; description = "Conduit implemented on Yaftee"; - license = lib.licensesSpdx."BSD-3-Clause"; + license = lib.meta.getLicenseFromSpdxId "BSD-3-Clause"; } ) { }; @@ -762903,7 +762903,7 @@ self: { yaftee-conduit ]; description = "Yaftee Conduit tools for ByteString"; - license = lib.licensesSpdx."BSD-3-Clause"; + license = lib.meta.getLicenseFromSpdxId "BSD-3-Clause"; } ) { }; @@ -762944,7 +762944,7 @@ self: { yaftee-conduit ]; description = "Finger tree-based byte string tools for Yaftee Conduit"; - license = lib.licensesSpdx."BSD-3-Clause"; + license = lib.meta.getLicenseFromSpdxId "BSD-3-Clause"; } ) { }; @@ -762982,7 +762982,7 @@ self: { yaftee-conduit ]; description = "Mono traversable tools for Yaftee Conduit"; - license = lib.licensesSpdx."BSD-3-Clause"; + license = lib.meta.getLicenseFromSpdxId "BSD-3-Clause"; } ) { }; @@ -764407,7 +764407,7 @@ self: { versions ]; description = "Support for parsing and rendering YAML documents"; - license = lib.licensesSpdx."BSD-3-Clause"; + license = lib.meta.getLicenseFromSpdxId "BSD-3-Clause"; } ) { }; @@ -764544,7 +764544,7 @@ self: { tasty-hunit ]; description = "Flexible declarative YAML parsing toolkit"; - license = lib.licensesSpdx."MIT"; + license = lib.meta.getLicenseFromSpdxId "MIT"; } ) { }; @@ -764710,7 +764710,7 @@ self: { vector ]; description = "Haskell bindings for YAMLScript"; - license = lib.licensesSpdx."MIT"; + license = lib.meta.getLicenseFromSpdxId "MIT"; hydraPlatforms = lib.platforms.none; mainProgram = "yamlscript-test"; broken = true; @@ -765148,7 +765148,7 @@ self: { deepseq ]; description = "Yet another records libraries"; - license = lib.licensesSpdx."ISC"; + license = lib.meta.getLicenseFromSpdxId "ISC"; } ) { }; @@ -765414,7 +765414,7 @@ self: { ]; testToolDepends = [ tasty-discover ]; description = "Yet another string interpolator"; - license = lib.licensesSpdx."CC0-1.0"; + license = lib.meta.getLicenseFromSpdxId "CC0-1.0"; } ) { }; @@ -765546,7 +765546,7 @@ self: { doctest ]; description = "Total recursion schemes"; - license = lib.licensesSpdx."AGPL-3.0-or-later"; + license = lib.meta.getLicenseFromSpdxId "AGPL-3.0-or-later"; maintainers = [ lib.maintainers.sellout ]; } ) { }; @@ -765631,7 +765631,7 @@ self: { doctest ]; description = "Pattern functors and instances for types in the containers package"; - license = lib.licensesSpdx."AGPL-3.0-or-later"; + license = lib.meta.getLicenseFromSpdxId "AGPL-3.0-or-later"; maintainers = [ lib.maintainers.sellout ]; } ) { }; @@ -765705,7 +765705,7 @@ self: { yaya ]; description = "Hedgehog testing support for the Yaya recursion scheme library"; - license = lib.licensesSpdx."AGPL-3.0-or-later"; + license = lib.meta.getLicenseFromSpdxId "AGPL-3.0-or-later"; maintainers = [ lib.maintainers.sellout ]; } ) { }; @@ -765779,7 +765779,7 @@ self: { doctest ]; description = "QuickCheck testing support for the Yaya recursion scheme library"; - license = lib.licensesSpdx."AGPL-3.0-or-later"; + license = lib.meta.getLicenseFromSpdxId "AGPL-3.0-or-later"; maintainers = [ lib.maintainers.sellout ]; } ) { }; @@ -765842,7 +765842,7 @@ self: { yaya-hedgehog ]; description = "Test suites for `yaya`"; - license = lib.licensesSpdx."AGPL-3.0-or-later"; + license = lib.meta.getLicenseFromSpdxId "AGPL-3.0-or-later"; hydraPlatforms = lib.platforms.none; broken = true; } @@ -765886,7 +765886,7 @@ self: { yaya-hedgehog ]; description = "Non-total extensions to the Yaya recursion scheme library"; - license = lib.licensesSpdx."AGPL-3.0-or-later"; + license = lib.meta.getLicenseFromSpdxId "AGPL-3.0-or-later"; maintainers = [ lib.maintainers.sellout ]; } ) { }; @@ -765958,7 +765958,7 @@ self: { yaya-unsafe ]; description = "Test suites for `yaya-unsafe`"; - license = lib.licensesSpdx."AGPL-3.0-or-later"; + license = lib.meta.getLicenseFromSpdxId "AGPL-3.0-or-later"; hydraPlatforms = lib.platforms.none; broken = true; } @@ -767678,7 +767678,7 @@ self: { yesod-form ]; description = "A yesod-auth plugin for multi-tenant SSO via OpenID Connect"; - license = lib.licensesSpdx."BSD-3-Clause"; + license = lib.meta.getLicenseFromSpdxId "BSD-3-Clause"; hydraPlatforms = lib.platforms.none; broken = true; } @@ -767846,7 +767846,7 @@ self: { ]; testToolDepends = [ hspec-discover ]; description = "Traditional email/pass auth for Yesod"; - license = lib.licensesSpdx."BSD-3-Clause"; + license = lib.meta.getLicenseFromSpdxId "BSD-3-Clause"; platforms = lib.platforms.x86; mainProgram = "yesod-auth-simple-test"; } @@ -768115,7 +768115,7 @@ self: { yesod-elements ]; description = "Helper functions for using yesod with colonnade"; - license = lib.licensesSpdx."BSD-3-Clause"; + license = lib.meta.getLicenseFromSpdxId "BSD-3-Clause"; hydraPlatforms = lib.platforms.none; } ) { }; @@ -771409,7 +771409,7 @@ self: { yesod-static ]; description = "A streamly-based library providing performance-focused alternatives for functionality found in yesod-static"; - license = lib.licensesSpdx."BSD-3-Clause"; + license = lib.meta.getLicenseFromSpdxId "BSD-3-Clause"; hydraPlatforms = lib.platforms.none; broken = true; } @@ -772057,7 +772057,7 @@ self: { void ]; description = "Yet Another Logger"; - license = lib.licensesSpdx."Apache-2.0"; + license = lib.meta.getLicenseFromSpdxId "Apache-2.0"; mainProgram = "example"; } ) { }; @@ -773339,7 +773339,7 @@ self: { random text ]; - license = lib.licensesSpdx."GPL-3.0-only"; + license = lib.meta.getLicenseFromSpdxId "GPL-3.0-only"; mainProgram = "yiyd"; } ) { }; @@ -773370,7 +773370,7 @@ self: { template-haskell ]; description = "try hackage"; - license = lib.licensesSpdx."BSD-3-Clause"; + license = lib.meta.getLicenseFromSpdxId "BSD-3-Clause"; mainProgram = "yj-sandbox-exe"; } ) { }; @@ -773569,7 +773569,7 @@ self: { ]; testToolDepends = [ hspec-discover ]; description = "Bindings to Facebook's Yoga layout library"; - license = lib.licensesSpdx."BSD-3-Clause"; + license = lib.meta.getLicenseFromSpdxId "BSD-3-Clause"; } ) { }; @@ -773680,7 +773680,7 @@ self: { text ]; description = "Yosys RTL Intermediate Language"; - license = lib.licensesSpdx."MIT"; + license = lib.meta.getLicenseFromSpdxId "MIT"; hydraPlatforms = lib.platforms.none; broken = true; } @@ -773839,7 +773839,7 @@ self: { yaml ]; description = "Builds a static website from templates and data in YAML or CSV files"; - license = lib.licensesSpdx."GPL-2.0-or-later"; + license = lib.meta.getLicenseFromSpdxId "GPL-2.0-or-later"; mainProgram = "yst"; } ) { }; @@ -774806,7 +774806,7 @@ self: { editedCabalFile = "0sj45k2v33x3312yz1bdbck2bcv5q64mh7v7xy35ghp72ynw1z8z"; libraryHaskellDepends = [ base ]; description = "@zenhack's personal custom prelude"; - license = lib.licensesSpdx."MIT"; + license = lib.meta.getLicenseFromSpdxId "MIT"; } ) { }; @@ -774911,7 +774911,7 @@ self: { ]; doHaddock = false; description = "Zeolite is a statically-typed, general-purpose programming language"; - license = lib.licensesSpdx."Apache-2.0"; + license = lib.meta.getLicenseFromSpdxId "Apache-2.0"; hydraPlatforms = lib.platforms.none; broken = true; } @@ -775556,7 +775556,7 @@ self: { ]; testHaskellDepends = [ base ]; description = "Command-line utility for working with zettelkast files"; - license = lib.licensesSpdx."BSD-3-Clause"; + license = lib.meta.getLicenseFromSpdxId "BSD-3-Clause"; hydraPlatforms = lib.platforms.none; mainProgram = "zettelkast"; broken = true; @@ -775596,7 +775596,7 @@ self: { tasty-hedgehog ]; description = "Polysemy effects for testing"; - license = lib.licensesSpdx."BSD-2-Clause-Patent"; + license = lib.meta.getLicenseFromSpdxId "BSD-2-Clause-Patent"; } ) { }; @@ -775920,7 +775920,7 @@ self: { tasty-quickcheck ]; description = "Zigzag encoding of integers into unsigned integers"; - license = lib.licensesSpdx."BSD-3-Clause"; + license = lib.meta.getLicenseFromSpdxId "BSD-3-Clause"; } ) { }; @@ -776011,7 +776011,7 @@ self: { tasty-quickcheck ]; description = "Typed templates with jinja like syntax"; - license = lib.licensesSpdx."GPL-2.0-or-later"; + license = lib.meta.getLicenseFromSpdxId "GPL-2.0-or-later"; } ) { }; @@ -776129,7 +776129,7 @@ self: { time ]; description = "Operations on zip archives"; - license = lib.licensesSpdx."BSD-3-Clause"; + license = lib.meta.getLicenseFromSpdxId "BSD-3-Clause"; mainProgram = "haskell-zip-app"; maintainers = [ lib.maintainers.mpscholten ]; } @@ -776717,7 +776717,7 @@ self: { tasty-quickcheck ]; description = "zlib compression bindings"; - license = lib.licensesSpdx."BSD-3-Clause"; + license = lib.meta.getLicenseFromSpdxId "BSD-3-Clause"; } ) { }; @@ -776729,7 +776729,7 @@ self: { sha256 = "153aldw8vqy6wzz7knbzyfkxsr3gsv5hjf4y84s12ifx2fi8zfkn"; doHaddock = false; description = "zlib C library bits"; - license = lib.licensesSpdx."Zlib"; + license = lib.meta.getLicenseFromSpdxId "Zlib"; } ) { }; @@ -776786,7 +776786,7 @@ self: { tools-yj ]; description = "Thin wrapper for zlib"; - license = lib.licensesSpdx."BSD-3-Clause"; + license = lib.meta.getLicenseFromSpdxId "BSD-3-Clause"; } ) { inherit (pkgs) zlib; }; @@ -776886,7 +776886,7 @@ self: { zlib-core ]; description = "Zlib wrapper built on Yaftee"; - license = lib.licensesSpdx."BSD-3-Clause"; + license = lib.meta.getLicenseFromSpdxId "BSD-3-Clause"; } ) { }; @@ -777359,7 +777359,7 @@ self: { Z-Data ]; description = "A haskell binding to Apache Zookeeper C library(mt) using Haskell Z project"; - license = lib.licensesSpdx."BSD-3-Clause"; + license = lib.meta.getLicenseFromSpdxId "BSD-3-Clause"; hydraPlatforms = lib.platforms.none; } ) { inherit (pkgs) zookeeper_mt; }; @@ -777883,7 +777883,7 @@ self: { tasty-hunit ]; description = "A zuul client library"; - license = lib.licensesSpdx."Apache-2.0"; + license = lib.meta.getLicenseFromSpdxId "Apache-2.0"; hydraPlatforms = lib.platforms.none; mainProgram = "zuul-cli"; broken = true; @@ -777993,7 +777993,7 @@ self: { ]; doHaddock = false; description = "a live coding language for playing with nested functions of time"; - license = lib.licensesSpdx."GPL-3.0-only"; + license = lib.meta.getLicenseFromSpdxId "GPL-3.0-only"; hydraPlatforms = lib.platforms.none; } ) { }; @@ -778093,7 +778093,7 @@ self: { zxcvbn-hs ]; description = "Password strength estimation based on zxcvbn"; - license = lib.licensesSpdx."MIT"; + license = lib.meta.getLicenseFromSpdxId "MIT"; hydraPlatforms = lib.platforms.none; broken = true; } @@ -778203,7 +778203,7 @@ self: { zlib ]; description = "Password strength estimation based on zxcvbn"; - license = lib.licensesSpdx."MIT"; + license = lib.meta.getLicenseFromSpdxId "MIT"; mainProgram = "zxcvbn-example"; } ) { }; From 53a4565bcea8db9605a07d88b3026303d27b52d2 Mon Sep 17 00:00:00 2001 From: Wolfgang Walther Date: Tue, 7 Apr 2026 11:03:43 +0200 Subject: [PATCH 34/52] git-annex: fix hash for 10.20260316 Still failing the test-suite for me, but the hash needs to be fixed regardless. --- pkgs/development/haskell-modules/configuration-common.nix | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/pkgs/development/haskell-modules/configuration-common.nix b/pkgs/development/haskell-modules/configuration-common.nix index 678187c1b610..15838c5bf0cc 100644 --- a/pkgs/development/haskell-modules/configuration-common.nix +++ b/pkgs/development/haskell-modules/configuration-common.nix @@ -700,7 +700,7 @@ with haskellLib; name = "git-annex-${super.git-annex.version}-src"; url = "git://git-annex.branchable.com/"; tag = super.git-annex.version; - sha256 = "sha256-oh9lrQvj1Ooi3PI5heNXBopX35s1K5Kyn/mH7V4sXB8="; + sha256 = "sha256-/IfPJx3k2U7+vUnQ2IJlT5BxAr+G3yNEQU3w+afQ2aQ="; # 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 From 7f4582ea1acf8cd61ea33242e81a37d90d3927ae Mon Sep 17 00:00:00 2001 From: Wolfgang Walther Date: Tue, 7 Apr 2026 11:02:14 +0200 Subject: [PATCH 35/52] haskellPackages.hpc-codecov: fix tests with tasty 1.5.4 --- pkgs/development/haskell-modules/configuration-common.nix | 6 ++++++ 1 file changed, 6 insertions(+) diff --git a/pkgs/development/haskell-modules/configuration-common.nix b/pkgs/development/haskell-modules/configuration-common.nix index 15838c5bf0cc..558900942a07 100644 --- a/pkgs/development/haskell-modules/configuration-common.nix +++ b/pkgs/development/haskell-modules/configuration-common.nix @@ -1581,6 +1581,12 @@ with haskellLib; sha256 = "056rk58v9h114mjx62f41x971xn9p3nhsazcf9zrcyxh1ymrdm8j"; }) super.hpc-coveralls; + hpc-codecov = overrideCabal (drv: { + # Work around test suite race condition due to tasty >= 1.5.4 + # https://github.com/8c6794b6/hpc-codecov/issues/52 + testFlags = drv.testFlags or [ ] ++ [ "-j1" ]; + }) super.hpc-codecov; + # sexpr is old, broken and has no issue-tracker. Let's fix it the best we can. sexpr = appendPatch ./patches/sexpr-0.2.1.patch ( overrideCabal (drv: { From ea3d4871db266949fedf663a883bf6209d0c4dcb Mon Sep 17 00:00:00 2001 From: Wolfgang Walther Date: Tue, 7 Apr 2026 11:04:27 +0200 Subject: [PATCH 36/52] haskellPackages.hpc-codecov: add wolfgangwalther as maintainer We're using this for PostgREST, so I don't want this to fail. --- .../haskell-modules/configuration-hackage2nix/main.yaml | 1 + pkgs/development/haskell-modules/hackage-packages.nix | 1 + 2 files changed, 2 insertions(+) diff --git a/pkgs/development/haskell-modules/configuration-hackage2nix/main.yaml b/pkgs/development/haskell-modules/configuration-hackage2nix/main.yaml index 5aa084ff5f2c..6794a86fc302 100644 --- a/pkgs/development/haskell-modules/configuration-hackage2nix/main.yaml +++ b/pkgs/development/haskell-modules/configuration-hackage2nix/main.yaml @@ -664,6 +664,7 @@ package-maintainers: utdemir: - nix-tree wolfgangwalther: + - hpc-codecov - postgres-websockets - postgrest zowoq: diff --git a/pkgs/development/haskell-modules/hackage-packages.nix b/pkgs/development/haskell-modules/hackage-packages.nix index f4093355977d..b5ad793304ac 100644 --- a/pkgs/development/haskell-modules/hackage-packages.nix +++ b/pkgs/development/haskell-modules/hackage-packages.nix @@ -350838,6 +350838,7 @@ self: { description = "Generate reports from hpc data"; license = lib.licenses.bsd3; mainProgram = "hpc-codecov"; + maintainers = [ lib.maintainers.wolfgangwalther ]; } ) { }; From ca14dff974907029c02c895e3c8b6186d2f0672b Mon Sep 17 00:00:00 2001 From: Wolfgang Walther Date: Tue, 7 Apr 2026 11:12:23 +0200 Subject: [PATCH 37/52] haskellPackages.snappy-hs: jailbreak --- pkgs/development/haskell-modules/configuration-common.nix | 4 ++++ 1 file changed, 4 insertions(+) diff --git a/pkgs/development/haskell-modules/configuration-common.nix b/pkgs/development/haskell-modules/configuration-common.nix index 558900942a07..bd91bb4c5f9f 100644 --- a/pkgs/development/haskell-modules/configuration-common.nix +++ b/pkgs/development/haskell-modules/configuration-common.nix @@ -1203,6 +1203,10 @@ with haskellLib; # https://github.com/bos/snappy/pull/10 snappy = dontCheck super.snappy; + # 2026-04-07: jailbreak for time 1.15 + # https://github.com/mchav/snappy-hs/issues/2 + snappy-hs = doJailbreak super.snappy-hs; + # https://github.com/vincenthz/hs-crypto-pubkey/issues/20 crypto-pubkey = dontCheck super.crypto-pubkey; From 79ba6be5f8f3be23429e8bfec0ef6069db2f502f Mon Sep 17 00:00:00 2001 From: sternenseemann Date: Tue, 7 Apr 2026 12:03:31 +0200 Subject: [PATCH 38/52] haskell.packages.ghc914.HTTP: 4000.4.1 -> 4000.5.0 --- pkgs/development/haskell-modules/configuration-ghc-9.14.x.nix | 1 + 1 file changed, 1 insertion(+) diff --git a/pkgs/development/haskell-modules/configuration-ghc-9.14.x.nix b/pkgs/development/haskell-modules/configuration-ghc-9.14.x.nix index 812caea9b98b..b7b7452c9e4a 100644 --- a/pkgs/development/haskell-modules/configuration-ghc-9.14.x.nix +++ b/pkgs/development/haskell-modules/configuration-ghc-9.14.x.nix @@ -87,6 +87,7 @@ with haskellLib; parallel = doDistribute self.parallel_3_3_0_0; tagged = doDistribute self.tagged_0_8_10; unordered-containers = doDistribute self.unordered-containers_0_2_21; + HTTP = doDistribute self.HTTP_4000_5_0; # # Jailbreaks From 5ae7e44eedcf541f209a69a6f7764e4acf1d3cf9 Mon Sep 17 00:00:00 2001 From: sternenseemann Date: Tue, 7 Apr 2026 12:02:54 +0200 Subject: [PATCH 39/52] haskell.packages.ghc914.blaze-markup: allow containers 0.8 in tests --- .../development/haskell-modules/configuration-ghc-9.14.x.nix | 5 +++++ 1 file changed, 5 insertions(+) diff --git a/pkgs/development/haskell-modules/configuration-ghc-9.14.x.nix b/pkgs/development/haskell-modules/configuration-ghc-9.14.x.nix index b7b7452c9e4a..b2bd993d5b61 100644 --- a/pkgs/development/haskell-modules/configuration-ghc-9.14.x.nix +++ b/pkgs/development/haskell-modules/configuration-ghc-9.14.x.nix @@ -154,4 +154,9 @@ with haskellLib; # Fails to compile with GHC 9.14 https://github.com/snoyberg/mono-traversable/pull/261 mono-traversable = dontCheck super.mono-traversable; + + # Too strict bound on containers in test suite + # https://github.com/jaspervdj/blaze-markup/issues/69 + blaze-markup = doJailbreak super.blaze-markup; + } From f4b432d29c8b2093edeedb6f62bfe01fce5f0cb0 Mon Sep 17 00:00:00 2001 From: sternenseemann Date: Tue, 7 Apr 2026 12:12:08 +0200 Subject: [PATCH 40/52] haskell.packages.ghc914.blaze-html: allow containers 0.8 in tests --- pkgs/development/haskell-modules/configuration-ghc-9.14.x.nix | 2 ++ 1 file changed, 2 insertions(+) diff --git a/pkgs/development/haskell-modules/configuration-ghc-9.14.x.nix b/pkgs/development/haskell-modules/configuration-ghc-9.14.x.nix index b2bd993d5b61..49bd42ec1fe0 100644 --- a/pkgs/development/haskell-modules/configuration-ghc-9.14.x.nix +++ b/pkgs/development/haskell-modules/configuration-ghc-9.14.x.nix @@ -158,5 +158,7 @@ with haskellLib; # Too strict bound on containers in test suite # https://github.com/jaspervdj/blaze-markup/issues/69 blaze-markup = doJailbreak super.blaze-markup; + # https://github.com/jaspervdj/blaze-html/issues/151 + blaze-html = doJailbreak super.blaze-html; } From 5d07e3806531acba775a79772331af9ba43b6e91 Mon Sep 17 00:00:00 2001 From: sternenseemann Date: Tue, 7 Apr 2026 12:28:49 +0200 Subject: [PATCH 41/52] haskell.packages.ghc914.feed: allow core pkg versions of time, base --- pkgs/development/haskell-modules/configuration-ghc-9.14.x.nix | 3 +++ 1 file changed, 3 insertions(+) diff --git a/pkgs/development/haskell-modules/configuration-ghc-9.14.x.nix b/pkgs/development/haskell-modules/configuration-ghc-9.14.x.nix index 49bd42ec1fe0..833f7091c3de 100644 --- a/pkgs/development/haskell-modules/configuration-ghc-9.14.x.nix +++ b/pkgs/development/haskell-modules/configuration-ghc-9.14.x.nix @@ -116,6 +116,9 @@ with haskellLib; text-iso8601 = doJailbreak super.text-iso8601; aeson = doJailbreak super.aeson; + # https://github.com/haskell-party/feed/issues/76 + feed = doJailbreak super.feed; # time<1.15, base<4.22 + # https://github.com/well-typed/cborg/issues/373 cborg = doJailbreak super.cborg; serialise = doJailbreak ( From cfd032a5477f245b7c5206b60807f97060733384 Mon Sep 17 00:00:00 2001 From: sternenseemann Date: Tue, 7 Apr 2026 12:32:18 +0200 Subject: [PATCH 42/52] haskellPackages.feed: execute main test suite at least --- .../haskell-modules/configuration-common.nix | 10 ++++++++-- 1 file changed, 8 insertions(+), 2 deletions(-) diff --git a/pkgs/development/haskell-modules/configuration-common.nix b/pkgs/development/haskell-modules/configuration-common.nix index bd91bb4c5f9f..13b9925cd503 100644 --- a/pkgs/development/haskell-modules/configuration-common.nix +++ b/pkgs/development/haskell-modules/configuration-common.nix @@ -2090,8 +2090,14 @@ with haskellLib; # Test suite fails, upstream not reachable for simple fix (not responsive on github) vivid-supercollider = dontCheck super.vivid-supercollider; - # Test suite does not compile. - feed = dontCheck super.feed; + # Test suite `readme` does not compile. + # https://github.com/haskell-party/feed/issues/77 + # `readme-doctests` are also broken (can't find a variety of imports) + feed = overrideCabal { + buildTarget = "tests"; + testTargets = [ "tests" ]; + jailbreak = true; + } super.feed; spacecookie = overrideCabal (old: { buildTools = (old.buildTools or [ ]) ++ [ pkgs.buildPackages.installShellFiles ]; From 46823c161a582d84e686964e6152bc50535076ed Mon Sep 17 00:00:00 2001 From: sternenseemann Date: Tue, 7 Apr 2026 12:59:44 +0200 Subject: [PATCH 43/52] haskellPackages.pandoc: patch test suite race condition, enable -j --- .../haskell-modules/configuration-common.nix | 11 +++++++---- 1 file changed, 7 insertions(+), 4 deletions(-) diff --git a/pkgs/development/haskell-modules/configuration-common.nix b/pkgs/development/haskell-modules/configuration-common.nix index bd91bb4c5f9f..1fe11e4b898d 100644 --- a/pkgs/development/haskell-modules/configuration-common.nix +++ b/pkgs/development/haskell-modules/configuration-common.nix @@ -949,10 +949,6 @@ with haskellLib; ]; pandoc = overrideCabal (drv: { - # Work around test suite race condition(s) due to tasty >= 1.5.4 - # https://github.com/jgm/pandoc/issues/11566 - testFlags = drv.testFlags or [ ] ++ [ "-j1" ]; - patches = drv.patches or [ ] ++ [ # Adjust test fixtures for djot >= 0.1.2.3, patch extracted from unrelated change. (pkgs.fetchpatch { @@ -968,6 +964,13 @@ with haskellLib; hash = "sha256-lpddKGa8xs+Lhi62HhBgV04fUq2kkippA1xX2/b2ukM="; includes = [ "test/Tests/Writers/HTML.hs" ]; }) + # Resolve test suite race condition(s) due to tasty >= 1.5.4 and + # inDirectory, https://github.com/jgm/pandoc/issues/11566 krank:ignore-line + (pkgs.fetchpatch { + name = "pandoc-tests-fix-race-condition.patch"; + url = "https://github.com/jgm/pandoc/commit/134296c54145ef8ea7de523774837055239e0b3d.patch"; + hash = "sha256-s3v6ukoVZm8cvh9mAp0U+cQDT3p8QSu1F0oQD4Ks9F8="; + }) ]; }) super.pandoc; From 9fca99b8b28faa36713e969473aad799d52a115f Mon Sep 17 00:00:00 2001 From: sternenseemann Date: Tue, 7 Apr 2026 21:31:59 +0200 Subject: [PATCH 44/52] git-annex: work around test suite race condition w/ tasty-1.5.4 --- pkgs/development/haskell-modules/configuration-common.nix | 7 +++++++ 1 file changed, 7 insertions(+) diff --git a/pkgs/development/haskell-modules/configuration-common.nix b/pkgs/development/haskell-modules/configuration-common.nix index 26f852cfa73e..0f856d32f183 100644 --- a/pkgs/development/haskell-modules/configuration-common.nix +++ b/pkgs/development/haskell-modules/configuration-common.nix @@ -722,6 +722,13 @@ with haskellLib; --replace-fail 'InstallDesktopFile $(PREFIX)/bin/git-annex' \ 'InstallDesktopFile git-annex' ''; + + # Work around race condition in test suite exposed by tasty-1.5.4 + # TODO(@sternenseemann): make testFlags arg usable with git-annex + preCheck = '' + ${drv.preCheck or ""} + appendToVar checkFlags -j1 + ''; })) ]; From aca3442971bf98f0be6c16d4888d6aae6101f3b5 Mon Sep 17 00:00:00 2001 From: Alexandre Esteves Date: Wed, 8 Apr 2026 12:05:54 +0100 Subject: [PATCH 45/52] haskellPackages.iserv-proxy: 9.3-unstable-2026-02-04 -> 9.3-unstable-2026-04-08 --- pkgs/development/tools/haskell/iserv-proxy/default.nix | 6 +++--- 1 file changed, 3 insertions(+), 3 deletions(-) diff --git a/pkgs/development/tools/haskell/iserv-proxy/default.nix b/pkgs/development/tools/haskell/iserv-proxy/default.nix index c31d9e4cba64..a0261b8fb22a 100644 --- a/pkgs/development/tools/haskell/iserv-proxy/default.nix +++ b/pkgs/development/tools/haskell/iserv-proxy/default.nix @@ -15,14 +15,14 @@ }: mkDerivation { pname = "iserv-proxy"; - version = "9.3-unstable-2026-02-04"; + version = "9.3-unstable-2026-04-08"; # https://github.com/stable-haskell/iserv-proxy/pull/1 src = fetchFromGitHub { owner = "stable-haskell"; repo = "iserv-proxy"; - rev = "91ef7ffdeedfb141a4d69dcf9e550abe3e1160c6"; - hash = "sha256-x6QYupvHZM7rRpVO4AIC5gUWFprFQ59A95FPC7/Owjg"; + rev = "3f7b2815307c20a0dfd816bdf4a39ab86af3e0d4"; + hash = "sha256-10x8/G0x3eR/++XRHPx4MBuqlnc6+N+ajIxXyLkG+nU="; }; isLibrary = true; From d2e8530be23b2f54611e5c10312df882cb4f8901 Mon Sep 17 00:00:00 2001 From: Alexandre Esteves Date: Wed, 8 Apr 2026 20:41:47 +0100 Subject: [PATCH 46/52] haskellPackages.iserv-proxy: use in subprocess mode when doing cross --- pkgs/development/haskell-modules/generic-builder.nix | 11 ++--------- 1 file changed, 2 insertions(+), 9 deletions(-) diff --git a/pkgs/development/haskell-modules/generic-builder.nix b/pkgs/development/haskell-modules/generic-builder.nix index e2c875508f01..7e7720dd9f82 100644 --- a/pkgs/development/haskell-modules/generic-builder.nix +++ b/pkgs/development/haskell-modules/generic-builder.nix @@ -46,14 +46,8 @@ let in buildPackages.writeShellScriptBin ("iserv-wrapper" + lib.optionalString enableProfiling "-prof") '' set -euo pipefail - PORT=$((5000 + $RANDOM % 5000)) ${lib.optionalString stdenv.hostPlatform.isWindows "export WINEDEBUG=-all WINEPREFIX=$TMP"} - (>&2 echo "---> Starting interpreter on port $PORT") - ${emulator} ${hostProxy} tmp $PORT & - RISERV_PID="$!" - trap "kill $RISERV_PID" EXIT # Needs cleanup when building without sandbox - ${buildProxy} $@ 127.0.0.1 "$PORT" - (>&2 echo "---> killing interpreter...") + ${buildProxy} $@ --pipe ${emulator} ${hostProxy} tmp --stdio ''; # GHC will add `-prof` to the external interpreter when doing a profiled build. @@ -262,8 +256,7 @@ in __onlyPropagateKnownPkgConfigModules ? false, enableExternalInterpreter ? isCross && crossSupport.canProxyTH && crossSupport.needsExternalInterpreterSetup, - # iserv-proxy needs local network access - __darwinAllowLocalNetworking ? stdenv.hostPlatform.isDarwin && enableExternalInterpreter, + __darwinAllowLocalNetworking ? false, }@args: assert editedCabalFile != null -> revision != null; From ae8e5411434a0ed50970d7bc31d54461c2e39459 Mon Sep 17 00:00:00 2001 From: Wolfgang Walther Date: Thu, 9 Apr 2026 22:37:21 +0200 Subject: [PATCH 47/52] haskellPackages: unbreak Automatically created by maintainers/scripts/haskell/unbreak.nu. --- .../configuration-hackage2nix/broken.yaml | 30 ------ .../transitive-broken.yaml | 35 ------- .../haskell-modules/hackage-packages.nix | 95 ------------------- 3 files changed, 160 deletions(-) diff --git a/pkgs/development/haskell-modules/configuration-hackage2nix/broken.yaml b/pkgs/development/haskell-modules/configuration-hackage2nix/broken.yaml index 973b18aeb357..2d8e0d095cdf 100644 --- a/pkgs/development/haskell-modules/configuration-hackage2nix/broken.yaml +++ b/pkgs/development/haskell-modules/configuration-hackage2nix/broken.yaml @@ -3,7 +3,6 @@ broken-packages: - 2captcha # failure in job https://hydra.nixos.org/build/324105279 at 2026-03-15 - 3d-graphics-examples # failure in job https://hydra.nixos.org/build/234454565 at 2023-09-13 - 3dmodels # failure in job https://hydra.nixos.org/build/233220850 at 2023-09-02 - - A-gent # failure in job https://hydra.nixos.org/build/324105105 at 2026-03-15 - AAI # failure in job https://hydra.nixos.org/build/233258828 at 2023-09-02 - aasam # failure in job https://hydra.nixos.org/build/233216423 at 2023-09-02 - abacate # failure in job https://hydra.nixos.org/build/233201225 at 2023-09-02 @@ -581,7 +580,6 @@ broken-packages: - brick-list-search # failure in job https://hydra.nixos.org/build/233193835 at 2023-09-02 - bricks-internal # failure in job https://hydra.nixos.org/build/233215572 at 2023-09-02 - brillig # failure in job https://hydra.nixos.org/build/233208148 at 2023-09-02 - - brillo-algorithms # failure in job https://hydra.nixos.org/build/307517131 at 2025-09-19 - brittany # failure in job https://hydra.nixos.org/build/233234100 at 2023-09-02 - broadcast-chan-conduit # failure in job https://hydra.nixos.org/build/295092082 at 2025-04-22 - broadcast-chan-tests # failure in job https://hydra.nixos.org/build/233202605 at 2023-09-02 @@ -727,7 +725,6 @@ broken-packages: - caramia # failure in job https://hydra.nixos.org/build/233257225 at 2023-09-02 - carbonara # failure in job https://hydra.nixos.org/build/233201166 at 2023-09-02 - carettah # failure in job https://hydra.nixos.org/build/233230612 at 2023-09-02 - - CarneadesDSL # failure in job https://hydra.nixos.org/build/233236706 at 2023-09-02 - carte # failure in job https://hydra.nixos.org/build/233201806 at 2023-09-02 - Cartesian # failure in job https://hydra.nixos.org/build/233249956 at 2023-09-02 - cas-hashable # failure in job https://hydra.nixos.org/build/233238789 at 2023-09-02 @@ -747,7 +744,6 @@ broken-packages: - catamorphism # failure in job https://hydra.nixos.org/build/233208488 at 2023-09-02 - Catana # failure in job https://hydra.nixos.org/build/233196550 at 2023-09-02 - catch-fd # failure in job https://hydra.nixos.org/build/233223935 at 2023-09-02 - - category-printf # failure in job https://hydra.nixos.org/build/233216355 at 2023-09-02 - category-traced # failure in job https://hydra.nixos.org/build/233193963 at 2023-09-02 - catnplus # failure in job https://hydra.nixos.org/build/233241280 at 2023-09-02 - cautious-file # failure in job https://hydra.nixos.org/build/233218702 at 2023-09-02 @@ -784,7 +780,6 @@ broken-packages: - cg # failure in job https://hydra.nixos.org/build/233212272 at 2023-09-02 - cgen # failure in job https://hydra.nixos.org/build/233198570 at 2023-09-02 - cgi-utils # failure in job https://hydra.nixos.org/build/233251773 at 2023-09-02 - - cgrep # failure in job https://hydra.nixos.org/build/315095274 at 2025-11-29 - cgroup-rts-threads # failure in job https://hydra.nixos.org/build/233207888 at 2023-09-02 - chakra # failure in job https://hydra.nixos.org/build/282936173 at 2024-12-24 - chalkboard # failure in job https://hydra.nixos.org/build/234453414 at 2023-09-13 @@ -849,7 +844,6 @@ broken-packages: - clash-verilog # failure in job https://hydra.nixos.org/build/273466517 at 2024-10-01 - clash-vhdl # failure in job https://hydra.nixos.org/build/273460098 at 2024-10-01 - clashilator # failure in job https://hydra.nixos.org/build/273442437 at 2024-10-01 - - 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 - classy-effects-base # failure in updateAutotoolsGnuConfigScriptsPhase in job https://hydra.nixos.org/build/237233636 at 2023-10-21 - classy-influxdb-simple # failure in job https://hydra.nixos.org/build/233253418 at 2023-09-02 @@ -2012,7 +2006,6 @@ broken-packages: - frown # failure in job https://hydra.nixos.org/build/233208462 at 2023-09-02 - frp-arduino # failure in job https://hydra.nixos.org/build/233192216 at 2023-09-02 - frpnow # failure in job https://hydra.nixos.org/build/233236056 at 2023-09-02 - - fs-api # failure in job https://hydra.nixos.org/build/316127858 at 2025-12-19 - fs-events # failure in job https://hydra.nixos.org/build/233218231 at 2023-09-02 - fsh-csv # failure in job https://hydra.nixos.org/build/233220196 at 2023-09-02 - FSM # failure in job https://hydra.nixos.org/build/233247343 at 2023-09-02 @@ -2062,7 +2055,6 @@ broken-packages: - fvars # failure in job https://hydra.nixos.org/build/234461649 at 2023-09-13 - fwgl # failure in job https://hydra.nixos.org/build/233246210 at 2023-09-02 - fwgl-javascript # broken by fwgl, manually entered here, because it does not appear in transitive-broken.yaml at 2024-07-09 - - fx # failure in job https://hydra.nixos.org/build/295093438 at 2025-04-22 - fxpak # failure in job https://hydra.nixos.org/build/309813706 at 2025-10-15 - g-npm # failure in job https://hydra.nixos.org/build/233215965 at 2023-09-02 - g4ip # failure in job https://hydra.nixos.org/build/233248315 at 2023-09-02 @@ -2244,7 +2236,6 @@ broken-packages: - GLFW-b-demo # failure in job https://hydra.nixos.org/build/233230505 at 2023-09-02 - gli # failure in job https://hydra.nixos.org/build/233210279 at 2023-09-02 - glider-nlp # failure in job https://hydra.nixos.org/build/233229600 at 2023-09-02 - - gll # failure in job https://hydra.nixos.org/build/307518707 at 2025-09-19 - GLMatrix # failure in job https://hydra.nixos.org/build/233202880 at 2023-09-02 - glob-posix # failure in job https://hydra.nixos.org/build/233253059 at 2023-09-02 - global-variables # failure in job https://hydra.nixos.org/build/233204607 at 2023-09-02 @@ -2723,7 +2714,6 @@ broken-packages: - helm # failure in job https://hydra.nixos.org/build/233251620 at 2023-09-02 - help-esb # failure in job https://hydra.nixos.org/build/233202622 at 2023-09-02 - hemkay # failure in job https://hydra.nixos.org/build/233227889 at 2023-09-02 - - henforcer # failure in job https://hydra.nixos.org/build/320783245 at 2026-02-07 - her-lexer-parsec # failure in job https://hydra.nixos.org/build/233237312 at 2023-09-02 - HERA # failure in job https://hydra.nixos.org/build/233204724 at 2023-09-02 - herbalizer # failure in job https://hydra.nixos.org/build/233214866 at 2023-09-02 @@ -2769,7 +2759,6 @@ broken-packages: - hgearman # failure in job https://hydra.nixos.org/build/233231063 at 2023-09-02 - hGelf # failure in job https://hydra.nixos.org/build/233203909 at 2023-09-02 - hgeometric # failure in job https://hydra.nixos.org/build/233197856 at 2023-09-02 - - hgettext # failure in job https://hydra.nixos.org/build/309814473 at 2025-10-15 - hgis # failure in job https://hydra.nixos.org/build/233200418 at 2023-09-02 - hgmp # failure in job https://hydra.nixos.org/build/307519217 at 2025-09-19 - hgom # failure in job https://hydra.nixos.org/build/233255569 at 2023-09-02 @@ -3016,7 +3005,6 @@ broken-packages: - hs-opentelemetry-instrumentation-conduit # failure in job https://hydra.nixos.org/build/311053155 at 2025-11-02 - hs-opentelemetry-instrumentation-hspec # failure in job https://hydra.nixos.org/build/311053154 at 2025-11-02 - hs-opentelemetry-instrumentation-persistent # failure in job https://hydra.nixos.org/build/311053162 at 2025-11-02 - - hs-opentelemetry-instrumentation-postgresql-simple # failure in job https://hydra.nixos.org/build/311053156 at 2025-11-02 - hs-opentelemetry-instrumentation-tasty # failure in job https://hydra.nixos.org/build/311053195 at 2025-11-02 - hs-opentelemetry-instrumentation-wai # failure in job https://hydra.nixos.org/build/311053157 at 2025-11-02 - hs-opentelemetry-utils-exceptions # failure in job https://hydra.nixos.org/build/311053185 at 2025-11-02 @@ -3262,7 +3250,6 @@ broken-packages: - hypertypes # failure in job https://hydra.nixos.org/build/252735804 at 2024-03-16 - hypher # failure in job https://hydra.nixos.org/build/233233236 at 2023-09-02 - hyraxAbif # failure in job https://hydra.nixos.org/build/233195246 at 2023-09-02 - - hzenity # failure in job https://hydra.nixos.org/build/295094627 at 2025-04-22 - hzulip # failure in job https://hydra.nixos.org/build/233191086 at 2023-09-02 - i # failure in job https://hydra.nixos.org/build/295094611 at 2025-04-22 - i18n # failure in job https://hydra.nixos.org/build/233247578 at 2023-09-02 @@ -3503,8 +3490,6 @@ broken-packages: - jsonlogic-aeson # failure in job https://hydra.nixos.org/build/233246828 at 2023-09-02 - jsonnet # failure in job https://hydra.nixos.org/build/233254884 at 2023-09-02 - jsonresume # failure in job https://hydra.nixos.org/build/233202350 at 2023-09-02 - - jsonrpc-tinyclient # failure in job https://hydra.nixos.org/build/233214174 at 2023-09-02 - - jsonschema # failure in job https://hydra.nixos.org/build/311053632 at 2025-11-02 - jsonschema-gen # failure in job https://hydra.nixos.org/build/233225063 at 2023-09-02 - jsonsql # failure in job https://hydra.nixos.org/build/233255704 at 2023-09-02 - jsontsv # failure in job https://hydra.nixos.org/build/233234129 at 2023-09-02 @@ -3876,7 +3861,6 @@ broken-packages: - long-double # failure in job https://hydra.nixos.org/build/307520133 at 2025-09-19 - longboi # failure in job https://hydra.nixos.org/build/233233913 at 2023-09-02 - longshot # bounds issues https://hydra.nixos.org/build/295428416 - - looksee # failure in job https://hydra.nixos.org/build/307520163 at 2025-09-19 - lookup-tables # failure in job https://hydra.nixos.org/build/233196965 at 2023-09-02 - loop-dsl # failure in job https://hydra.nixos.org/build/233198743 at 2023-09-02 - loop-while # failure in job https://hydra.nixos.org/build/233198041 at 2023-09-02 @@ -3993,7 +3977,6 @@ broken-packages: - mcm # failure in job https://hydra.nixos.org/build/233229087 at 2023-09-02 - mcmaster-gloss-examples # failure in job https://hydra.nixos.org/build/234457610 at 2023-09-13 - mcmc-synthesis # failure in job https://hydra.nixos.org/build/233208414 at 2023-09-02 - - mcp # failure in job https://hydra.nixos.org/build/302804588 at 2025-07-27 - mcpi # failure in job https://hydra.nixos.org/build/233231465 at 2023-09-02 - mdapi # failure in job https://hydra.nixos.org/build/233257724 at 2023-09-02 - mdcat # failure in job https://hydra.nixos.org/build/233249429 at 2023-09-02 @@ -4060,7 +4043,6 @@ broken-packages: - midi-util # failure in job https://hydra.nixos.org/build/307520300 at 2025-09-19 - midi-utils # failure in job https://hydra.nixos.org/build/233222257 at 2023-09-02 - midisurface # failure in job https://hydra.nixos.org/build/233224559 at 2023-09-02 - - mig-swagger-ui # failure in job https://hydra.nixos.org/build/295095369 at 2025-04-22 - mikmod # failure in job https://hydra.nixos.org/build/233247364 at 2023-09-02 - mikrokosmos # failure in job https://hydra.nixos.org/build/233232143 at 2023-09-02 - miku # failure in job https://hydra.nixos.org/build/233212186 at 2023-09-02 @@ -4416,7 +4398,6 @@ broken-packages: - normalization-insensitive # failure in job https://hydra.nixos.org/build/233239612 at 2023-09-02 - not-prelude # failure in job https://hydra.nixos.org/build/233248453 at 2023-09-02 - notcpp # failure in job https://hydra.nixos.org/build/233216543 at 2023-09-02 - - notifications-tray-icon # failure in job https://hydra.nixos.org/build/267969113 at 2024-07-31 - notmuch-haskell # failure in job https://hydra.nixos.org/build/233332618 at 2023-09-02 - NoTrace # failure in job https://hydra.nixos.org/build/233229305 at 2023-09-02 - notzero # failure in job https://hydra.nixos.org/build/233216133 at 2023-09-02 @@ -5166,7 +5147,6 @@ broken-packages: - qm-interpolated-string # failure in job https://hydra.nixos.org/build/295096370 at 2025-04-22 - qr-imager # failure in job https://hydra.nixos.org/build/233201973 at 2023-09-02 - qrcode # failure in job https://hydra.nixos.org/build/233225438 at 2023-09-02 - - qrcode-core # failure in job https://hydra.nixos.org/build/295096377 at 2025-04-22 - qsem # failure in job https://hydra.nixos.org/build/295096373 at 2025-04-22 - qt # failure in job https://hydra.nixos.org/build/233248869 at 2023-09-02 - QuadEdge # failure in job https://hydra.nixos.org/build/233249144 at 2023-09-02 @@ -5181,7 +5161,6 @@ broken-packages: - quenya-verb # failure in job https://hydra.nixos.org/build/233209006 at 2023-09-02 - querystring-pickle # failure in job https://hydra.nixos.org/build/233246108 at 2023-09-02 - questioner # failure in job https://hydra.nixos.org/build/233213704 at 2023-09-02 - - quibble-core # failure in job https://hydra.nixos.org/build/233200635 at 2023-09-02 - quic # failure in job https://hydra.nixos.org/build/295457190 at 2025-05-02 - quick-schema # failure in job https://hydra.nixos.org/build/233256519 at 2023-09-02 - QuickAnnotate # failure in job https://hydra.nixos.org/build/233197428 at 2023-09-02 @@ -5220,7 +5199,6 @@ broken-packages: - raft # failure in job https://hydra.nixos.org/build/233248392 at 2023-09-02 - rakhana # failure in job https://hydra.nixos.org/build/233256901 at 2023-09-02 - rakuten # failure in job https://hydra.nixos.org/build/233196803 at 2023-09-02 - - ralist # failure in job https://hydra.nixos.org/build/233195682 at 2023-09-02 - raml # failure in job https://hydra.nixos.org/build/233212517 at 2023-09-02 - rand-vars # failure in job https://hydra.nixos.org/build/233219255 at 2023-09-02 - rando # failure in job https://hydra.nixos.org/build/233257817 at 2023-09-02 @@ -5454,7 +5432,6 @@ broken-packages: - rollbar-hs # failure in job https://hydra.nixos.org/build/233240182 at 2023-09-02 - roller # failure in job https://hydra.nixos.org/build/233198848 at 2023-09-02 - roman-numerals # failure in job https://hydra.nixos.org/build/233214716 at 2023-09-02 - - ron # failure in job https://hydra.nixos.org/build/233197052 at 2023-09-02 - ron-hs # failure in job https://hydra.nixos.org/build/295096708 at 2025-04-22 - rope # failure in job https://hydra.nixos.org/build/233198109 at 2023-09-02 - rose # failure in job https://hydra.nixos.org/build/252717613 at 2024-03-16 @@ -5474,7 +5451,6 @@ broken-packages: - rrule # failure in job https://hydra.nixos.org/build/233259470 at 2023-09-02 - rsi-break # failure in job https://hydra.nixos.org/build/245788743 at 2024-01-07 - rspp # failure in job https://hydra.nixos.org/build/233236691 at 2023-09-02 - - rss-conduit # failure in job https://hydra.nixos.org/build/307611286 at 2025-09-19 - rss2irc # failure in job https://hydra.nixos.org/build/233196081 at 2023-09-02 - rstream # failure in job https://hydra.nixos.org/build/233249587 at 2023-09-02 - RtMidi # failure in job https://hydra.nixos.org/build/233241377 at 2023-09-02 @@ -5536,7 +5512,6 @@ broken-packages: - sbv-program # failure in job https://hydra.nixos.org/build/323973607 at 2026-03-12 - sbvPlugin # 2026-03-12 - sc2-proto # failure in job https://hydra.nixos.org/build/252730301 at 2024-03-16 - - scale # failure in job https://hydra.nixos.org/build/233222189 at 2023-09-02 - scaleimage # failure in job https://hydra.nixos.org/build/233240688 at 2023-09-02 - scalendar # failure in job https://hydra.nixos.org/build/233206581 at 2023-09-02 - scgi # failure in job https://hydra.nixos.org/build/233247314 at 2023-09-02 @@ -5590,7 +5565,6 @@ broken-packages: - seclib # failure in job https://hydra.nixos.org/build/233203235 at 2023-09-02 - second-transfer # failure in job https://hydra.nixos.org/build/233214725 at 2023-09-02 - secp256k1 # failure in job https://hydra.nixos.org/build/233231129 at 2023-09-02 - - secp256k1-haskell # failure in job https://hydra.nixos.org/build/323790174 at 2026-03-11 - secp256k1-legacy # failure in job https://hydra.nixos.org/build/233197038 at 2023-09-02 - secret-santa # failure in job https://hydra.nixos.org/build/233208686 at 2023-09-02 - secure-memory # failure in job https://hydra.nixos.org/build/233226568 at 2023-09-02 @@ -5979,7 +5953,6 @@ broken-packages: - sqlcipher # failure in job https://hydra.nixos.org/build/233259217 at 2023-09-02 - sqlcli # failure in job https://hydra.nixos.org/build/252719841 at 2024-03-16 - sqlite # failure in job https://hydra.nixos.org/build/233215839 at 2023-09-02 - - sqlite-easy # failure in job https://hydra.nixos.org/build/318377025 at 2026-01-10 - sqlite-simple-errors # failure in job https://hydra.nixos.org/build/233232977 at 2023-09-02 - sqlvalue-list # failure in job https://hydra.nixos.org/build/233197313 at 2023-09-02 - sqsd-local # failure in updateAutotoolsGnuConfigScriptsPhase in job https://hydra.nixos.org/build/237237046 at 2023-10-21 @@ -6414,7 +6387,6 @@ broken-packages: - sugarhaskell # failure in job https://hydra.nixos.org/build/233199879 at 2023-09-02 - suitable # failure in job https://hydra.nixos.org/build/233225075 at 2023-09-02 - sum-type-boilerplate # failure in job https://hydra.nixos.org/build/233251040 at 2023-09-02 - - summer # failure in job https://hydra.nixos.org/build/252728622 at 2024-03-16 - summoner # failure in job https://hydra.nixos.org/build/233232530 at 2023-09-02 - sump # failure in job https://hydra.nixos.org/build/265955678 at 2024-07-14 - sunlight # failure in job https://hydra.nixos.org/build/233212375 at 2023-09-02 @@ -6468,7 +6440,6 @@ broken-packages: - symtegration # failure in job https://hydra.nixos.org/build/307522286 at 2025-09-19 - sync # failure in job https://hydra.nixos.org/build/233254114 at 2023-09-02 - sync-mht # failure in job https://hydra.nixos.org/build/233236022 at 2023-09-02 - - syntactic # failure in job https://hydra.nixos.org/build/233210123 at 2023-09-02 - syntax-trees # failure in job https://hydra.nixos.org/build/233209576 at 2023-09-02 - syntax-trees-fork-bairyn # failure in job https://hydra.nixos.org/build/233216989 at 2023-09-02 - SyntaxMacros # failure in job https://hydra.nixos.org/build/309811610 at 2025-10-15 @@ -6775,7 +6746,6 @@ broken-packages: - tracetree # failure in job https://hydra.nixos.org/build/233213937 at 2023-09-02 - tracked-files # failure in job https://hydra.nixos.org/build/233256779 at 2023-09-02 - tracker # failure in job https://hydra.nixos.org/build/233226925 at 2023-09-02 - - trackit # failure in job https://hydra.nixos.org/build/233243891 at 2023-09-02 - traction # failure in job https://hydra.nixos.org/build/233193894 at 2023-09-02 - tracy # failure in job https://hydra.nixos.org/build/233210215 at 2023-09-02 - trade-journal # failure in job https://hydra.nixos.org/build/252737021 at 2024-03-16 diff --git a/pkgs/development/haskell-modules/configuration-hackage2nix/transitive-broken.yaml b/pkgs/development/haskell-modules/configuration-hackage2nix/transitive-broken.yaml index d699e541caf3..3f3436e74086 100644 --- a/pkgs/development/haskell-modules/configuration-hackage2nix/transitive-broken.yaml +++ b/pkgs/development/haskell-modules/configuration-hackage2nix/transitive-broken.yaml @@ -488,7 +488,6 @@ dont-distribute-packages: - cmptype - cmv - cnc-spec-compiler - - co-feldspar - Coadjute - cobot-io - codec @@ -945,7 +944,6 @@ dont-distribute-packages: - fei-modelzoo - fei-nn - feldspar-compiler - - feldspar-language - FermatsLastMargin - festung - ffmpeg-tutorials @@ -1054,7 +1052,6 @@ dont-distribute-packages: - functor-monad - funflow - funflow-nix - - fungll-combinators - funion - funsat - fwgl-glfw @@ -1305,7 +1302,6 @@ dont-distribute-packages: - happstack-state - happybara-webkit - haquil - - hardware-edsl - HaRe - hark - harmony @@ -1383,14 +1379,9 @@ dont-distribute-packages: - haskgame - hasklepias - haskoin-bitcoind - - haskoin-core - haskoin-crypto - - haskoin-node - haskoin-protocol - haskoin-script - - haskoin-store - - haskoin-store-data - - haskoin-wallet - haskoon - haskoon-httpspec - haskoon-salvia @@ -1800,8 +1791,6 @@ dont-distribute-packages: - imj-measure-stdout - immutaball-core - imparse - - imperative-edsl - - imperative-edsl-vhdl - importify - imprevu-happstack - improve @@ -1938,7 +1927,6 @@ dont-distribute-packages: - karakuri - katip-rollbar - keelung - - keera-hails-i18n - keera-hails-mvc-environment-gtk - keera-hails-mvc-model-lightmodel - keera-hails-mvc-model-protectedmodel @@ -2220,7 +2208,6 @@ dont-distribute-packages: - mellon-web - memcache-conduit - memory-cd - - memory-hexstring - merkle-patricia-db - message-db-temp - meta-par-accelerate @@ -2243,8 +2230,6 @@ dont-distribute-packages: - microformats2-types - MicrosoftTranslator - midimory - - mig-rio - - mig-server - mighttpd - minecraft-data - minesweeper @@ -2500,7 +2485,6 @@ dont-distribute-packages: - oops-examples - opc-xml-da-client - open-adt-tutorial - - open-typerep - OpenAFP-Utils - OpenGLCheck - openpgp-Crypto @@ -2706,14 +2690,11 @@ dont-distribute-packages: - postgresql-common-persistent - postgresql-pure - postgresql-simple-ltree - - postgresql-simple-postgresql-types - postgresql-simple-queue - postgresql-simple-typed - postgresql-tx-query - postgresql-tx-squeal - postgresql-tx-squeal-compat-simple - - postgresql-types - - postgresql-types-algebra - postmark - potoki - potoki-cereal @@ -2790,7 +2771,6 @@ dont-distribute-packages: - qhull - qnap-decrypt - qr-repa - - qrcode-juicypixels - qtah-cpp-qt5 - qtah-cpp-qt6 - qtah-examples @@ -2859,7 +2839,6 @@ dont-distribute-packages: - rasa-ext-views - rasa-ext-vim - rascal - - raw-feldspar - razom-text-util - rbr - rc @@ -2886,7 +2865,6 @@ dont-distribute-packages: - refh - reflex-animation - reflex-backend-wai - - reflex-classhss - reflex-gloss-scene - reflex-libtelnet - reflex-localize @@ -2925,7 +2903,6 @@ dont-distribute-packages: - repr - representable-tries - reserve - - resin - resource-pool-catchio - resource-simple - rest-client @@ -2987,9 +2964,6 @@ dont-distribute-packages: - rollbar-wai - rollbar-yesod - RollingDirectory - - ron-rdt - - ron-schema - - ron-storage - rose-trie - roshask - rosmsg-bin @@ -3185,7 +3159,6 @@ dont-distribute-packages: - si-clock - sibe - sigma-ij - - signals - signify-hs - silvi - simgi @@ -3720,14 +3693,6 @@ dont-distribute-packages: - web-routes-regular - web-routing - web-view-colonnade - - web3 - - web3-bignum - - web3-crypto - - web3-ethereum - - web3-polkadot - - web3-provider - - web3-solidity - - web3-tools - WebBits-Html - WebBits-multiplate - WebCont diff --git a/pkgs/development/haskell-modules/hackage-packages.nix b/pkgs/development/haskell-modules/hackage-packages.nix index b5ad793304ac..324c8c68bd29 100644 --- a/pkgs/development/haskell-modules/hackage-packages.nix +++ b/pkgs/development/haskell-modules/hackage-packages.nix @@ -154,8 +154,6 @@ self: { ]; description = "Polite & well educated LLM agent with excellent manners that always behaves well"; license = "(SSPL-1.0 OR AGPL-3.0-only)"; - hydraPlatforms = lib.platforms.none; - broken = true; } ) { }; @@ -6426,8 +6424,6 @@ self: { ]; description = "An implementation and DSL for the Carneades argumentation model"; license = lib.meta.getLicenseFromSpdxId "BSD-3-Clause"; - hydraPlatforms = lib.platforms.none; - broken = true; } ) { }; @@ -7314,8 +7310,6 @@ self: { ]; description = "Typified Tailwind for Rapid Development"; license = lib.meta.getLicenseFromSpdxId "MIT"; - hydraPlatforms = lib.platforms.none; - broken = true; } ) { }; @@ -118311,8 +118305,6 @@ self: { ]; description = "Data structures and algorithms for working with 2D graphics"; license = lib.meta.getLicenseFromSpdxId "MIT"; - hydraPlatforms = lib.platforms.none; - broken = true; } ) { }; @@ -135126,8 +135118,6 @@ self: { ]; description = "Highbrow approach to type-safe printf format specifications"; license = lib.licenses.bsd3; - hydraPlatforms = lib.platforms.none; - broken = true; } ) { }; @@ -137604,9 +137594,7 @@ self: { ]; description = "Command line tool"; license = lib.meta.getLicenseFromSpdxId "GPL-2.0-or-later"; - hydraPlatforms = lib.platforms.none; mainProgram = "cgrep"; - broken = true; } ) { }; @@ -149673,7 +149661,6 @@ self: { ]; description = "Hardware software co-design Feldspar"; license = lib.licenses.bsd3; - hydraPlatforms = lib.platforms.none; } ) { }; @@ -236578,7 +236565,6 @@ self: { ]; description = "A functional embedded language for DSP and parallelism"; license = lib.licenses.bsd3; - hydraPlatforms = lib.platforms.none; } ) { }; @@ -251516,8 +251502,6 @@ self: { ]; description = "Abstract interface for the file system"; license = lib.meta.getLicenseFromSpdxId "Apache-2.0"; - hydraPlatforms = lib.platforms.none; - broken = true; } ) { }; @@ -253563,7 +253547,6 @@ self: { ]; description = "GLL parser with simple combinator interface"; license = lib.meta.getLicenseFromSpdxId "BSD-3-Clause"; - hydraPlatforms = lib.platforms.none; } ) { }; @@ -255223,8 +255206,6 @@ self: { testToolDepends = [ hspec-discover ]; description = "Modular effectful computations with explicit environments and errors"; license = lib.meta.getLicenseFromSpdxId "MIT"; - hydraPlatforms = lib.platforms.none; - broken = true; } ) { }; @@ -279293,8 +279274,6 @@ self: { ]; description = "GLL parser with simple combinator interface"; license = lib.licenses.bsd3; - hydraPlatforms = lib.platforms.none; - broken = true; } ) { }; @@ -304958,7 +304937,6 @@ self: { ]; description = "Deep embedding of hardware descriptions with code generation"; license = lib.licenses.bsd3; - hydraPlatforms = lib.platforms.none; } ) { }; @@ -315592,7 +315570,6 @@ self: { testToolDepends = [ hspec-discover ]; description = "Bitcoin & Bitcoin Cash library for Haskell"; license = lib.licenses.mit; - hydraPlatforms = lib.platforms.none; } ) { }; @@ -315742,7 +315719,6 @@ self: { testToolDepends = [ hspec-discover ]; description = "P2P library for Bitcoin and Bitcoin Cash"; license = lib.licenses.mit; - hydraPlatforms = lib.platforms.none; } ) { }; @@ -316042,7 +316018,6 @@ self: { testToolDepends = [ hspec-discover ]; description = "Storage and index for Bitcoin and Bitcoin Cash"; license = lib.licenses.mit; - hydraPlatforms = lib.platforms.none; mainProgram = "haskoin-store"; } ) { }; @@ -316136,7 +316111,6 @@ self: { testToolDepends = [ hspec-discover ]; description = "Data for Haskoin Store"; license = lib.licenses.mit; - hydraPlatforms = lib.platforms.none; } ) { }; @@ -316363,7 +316337,6 @@ self: { testToolDepends = [ hspec-discover ]; description = "Lightweight CLI wallet for Bitcoin and Bitcoin Cash"; license = lib.licenses.publicDomain; - hydraPlatforms = lib.platforms.none; mainProgram = "hw"; } ) { }; @@ -328477,8 +328450,6 @@ self: { doHaddock = false; description = "GHC plugin to enforce user specified rules on code"; license = lib.meta.getLicenseFromSpdxId "MIT"; - hydraPlatforms = lib.platforms.none; - broken = true; } ) { }; @@ -332993,9 +332964,7 @@ self: { ]; description = "Bindings to libintl.h (gettext, bindtextdomain)"; license = lib.licenses.bsd3; - hydraPlatforms = lib.platforms.none; mainProgram = "hgettext"; - broken = true; } ) { }; @@ -355047,8 +355016,6 @@ self: { unordered-containers ]; license = lib.licenses.bsd3; - hydraPlatforms = lib.platforms.none; - broken = true; } ) { }; @@ -380414,8 +380381,6 @@ self: { ]; description = "Haskell interface to Zenity dialogs"; license = lib.licenses.bsd3; - hydraPlatforms = lib.platforms.none; - broken = true; } ) { }; @@ -386634,7 +386599,6 @@ self: { ]; description = "Deep embedding of imperative programs with code generation"; license = lib.licenses.bsd3; - hydraPlatforms = lib.platforms.none; } ) { }; @@ -386668,7 +386632,6 @@ self: { ]; description = "Deep embedding of VHDL programs with code generation"; license = lib.licenses.bsd3; - hydraPlatforms = lib.platforms.none; } ) { }; @@ -406023,8 +405986,6 @@ self: { ]; description = "Tiny JSON-RPC client for Haskell Web3 library"; license = lib.licenses.asl20; - hydraPlatforms = lib.platforms.none; - broken = true; } ) { }; @@ -406147,8 +406108,6 @@ self: { ]; description = "JSON Schema derivation and validation"; license = lib.meta.getLicenseFromSpdxId "MPL-2.0"; - hydraPlatforms = lib.platforms.none; - broken = true; } ) { }; @@ -410069,7 +410028,6 @@ self: { ]; description = "Rapid Gtk Application Development - I18N"; license = lib.licenses.bsd3; - hydraPlatforms = lib.platforms.none; } ) { }; @@ -441667,8 +441625,6 @@ self: { ]; description = "A simple text parser with decent errors"; license = lib.licenses.bsd3; - hydraPlatforms = lib.platforms.none; - broken = true; } ) { }; @@ -454245,8 +454201,6 @@ self: { ]; description = "A Servant-based Model Context Protocol (MCP) server for Haskell"; license = lib.meta.getLicenseFromSpdxId "MPL-2.0"; - hydraPlatforms = lib.platforms.none; - broken = true; } ) { }; @@ -456914,7 +456868,6 @@ self: { ]; description = "Hex-string type for Haskell Web3 library"; license = lib.licenses.asl20; - hydraPlatforms = lib.platforms.none; } ) { }; @@ -460519,7 +460472,6 @@ self: { ]; description = "Utils to use RIO with mig library"; license = lib.licenses.bsd3; - hydraPlatforms = lib.platforms.none; } ) { }; @@ -460563,7 +460515,6 @@ self: { ]; description = "Build lightweight and composable servers"; license = lib.licenses.bsd3; - hydraPlatforms = lib.platforms.none; } ) { }; @@ -460605,8 +460556,6 @@ self: { ]; description = "Swagger servers for mig library"; license = lib.licenses.bsd3; - hydraPlatforms = lib.platforms.none; - broken = true; } ) { }; @@ -496319,9 +496268,7 @@ self: { ]; license = lib.licenses.bsd3; badPlatforms = lib.platforms.darwin; - hydraPlatforms = lib.platforms.none; mainProgram = "notifications-tray-icon"; - broken = true; } ) { }; @@ -505417,7 +505364,6 @@ self: { ]; description = "Open type representations and dynamic types"; license = lib.licenses.bsd3; - hydraPlatforms = lib.platforms.none; } ) { }; @@ -549177,7 +549123,6 @@ self: { ]; description = "Integration of \"postgresql-simple\" with \"postgresql-types\""; license = lib.meta.getLicenseFromSpdxId "MIT"; - hydraPlatforms = lib.platforms.none; } ) { }; @@ -549778,7 +549723,6 @@ self: { doHaddock = false; description = "Precise PostgreSQL types representation and driver-agnostic codecs"; license = lib.meta.getLicenseFromSpdxId "MIT"; - hydraPlatforms = lib.platforms.none; } ) { }; @@ -549810,7 +549754,6 @@ self: { ]; description = "Type classes for PostgreSQL type mappings"; license = lib.meta.getLicenseFromSpdxId "MIT"; - hydraPlatforms = lib.platforms.none; } ) { }; @@ -566827,8 +566770,6 @@ self: { ]; description = "QR code library in pure Haskell"; license = lib.licenses.mit; - hydraPlatforms = lib.platforms.none; - broken = true; } ) { }; @@ -566858,7 +566799,6 @@ self: { ]; description = "Converts a qrcode-core image to JuicyPixels"; license = lib.licenses.mit; - hydraPlatforms = lib.platforms.none; } ) { }; @@ -568203,8 +568143,6 @@ self: { ]; description = "Convenient SQL query language for Haskell (but only for single tables)"; license = lib.meta.getLicenseFromSpdxId "BSD-3-Clause"; - hydraPlatforms = lib.platforms.none; - broken = true; } ) { }; @@ -572460,8 +572398,6 @@ self: { ]; description = "Random access list with a list compatible interface"; license = lib.meta.getLicenseFromSpdxId "BSD-3-Clause"; - hydraPlatforms = lib.platforms.none; - broken = true; } ) { }; @@ -575072,7 +575008,6 @@ self: { ]; description = "Resource-Aware Feldspar"; license = lib.licenses.bsd3; - hydraPlatforms = lib.platforms.none; } ) { }; @@ -581114,7 +581049,6 @@ self: { ]; description = "ClasshSS defined element builders for Reflex"; license = lib.meta.getLicenseFromSpdxId "MIT"; - hydraPlatforms = lib.platforms.none; } ) { }; @@ -588951,7 +588885,6 @@ self: { ]; description = "High performance variable binders"; license = lib.meta.getLicenseFromSpdxId "BSD-2-Clause"; - hydraPlatforms = lib.platforms.none; } ) { }; @@ -596286,8 +596219,6 @@ self: { ]; description = "RON"; license = lib.meta.getLicenseFromSpdxId "BSD-3-Clause"; - hydraPlatforms = lib.platforms.none; - broken = true; } ) { }; @@ -596407,7 +596338,6 @@ self: { ]; description = "Replicated Data Types (RON-RDT)"; license = lib.meta.getLicenseFromSpdxId "BSD-3-Clause"; - hydraPlatforms = lib.platforms.none; } ) { }; @@ -596447,7 +596377,6 @@ self: { ]; description = "RON-Schema"; license = lib.meta.getLicenseFromSpdxId "BSD-3-Clause"; - hydraPlatforms = lib.platforms.none; } ) { }; @@ -596493,7 +596422,6 @@ self: { ]; description = "RON Storage"; license = lib.meta.getLicenseFromSpdxId "BSD-3-Clause"; - hydraPlatforms = lib.platforms.none; } ) { }; @@ -598567,8 +598495,6 @@ self: { ]; description = "Streaming parser/renderer for the RSS standard"; license = lib.meta.getLicenseFromSpdxId "CC0-1.0"; - hydraPlatforms = lib.platforms.none; - broken = true; } ) { }; @@ -604997,8 +604923,6 @@ self: { testToolDepends = [ hspec-discover ]; description = "SCALE v2.0 codec for Haskell Web3 library."; license = lib.licenses.asl20; - hydraPlatforms = lib.platforms.none; - broken = true; } ) { }; @@ -610631,8 +610555,6 @@ self: { testToolDepends = [ hspec-discover ]; description = "Bindings for secp256k1"; license = lib.licenses.mit; - hydraPlatforms = lib.platforms.none; - broken = true; } ) { inherit (pkgs) secp256k1; }; @@ -628834,7 +628756,6 @@ self: { ]; description = "Synchronous signal processing for DSLs"; license = lib.licenses.bsd3; - hydraPlatforms = lib.platforms.none; } ) { }; @@ -648811,8 +648732,6 @@ self: { ]; description = "A primitive yet easy to use sqlite library"; license = lib.meta.getLicenseFromSpdxId "BSD-3-Clause"; - hydraPlatforms = lib.platforms.none; - broken = true; } ) { }; @@ -671339,8 +671258,6 @@ self: { ]; description = "An implementation of extensible products and sums"; license = lib.meta.getLicenseFromSpdxId "MIT"; - hydraPlatforms = lib.platforms.none; - broken = true; } ) { }; @@ -677666,8 +677583,6 @@ self: { ]; description = "Generic representation and manipulation of abstract syntax"; license = lib.licenses.bsd3; - hydraPlatforms = lib.platforms.none; - broken = true; } ) { }; @@ -708193,9 +708108,7 @@ self: { ]; description = "A command-line tool for live monitoring"; license = lib.licenses.bsd3; - hydraPlatforms = lib.platforms.none; mainProgram = "trackit"; - broken = true; } ) { }; @@ -746111,7 +746024,6 @@ self: { ]; description = "Haskell Web3 library"; license = lib.licenses.asl20; - hydraPlatforms = lib.platforms.none; } ) { }; @@ -746156,7 +746068,6 @@ self: { testToolDepends = [ hspec-discover ]; description = "Fixed size big integers for Haskell Web3 library"; license = lib.licenses.asl20; - hydraPlatforms = lib.platforms.none; } ) { }; @@ -746219,7 +746130,6 @@ self: { testToolDepends = [ hspec-discover ]; description = "Cryptograhical primitives for Haskell Web3 library"; license = lib.licenses.asl20; - hydraPlatforms = lib.platforms.none; } ) { }; @@ -746316,7 +746226,6 @@ self: { testToolDepends = [ hspec-discover ]; description = "Ethereum support for Haskell Web3 library"; license = lib.licenses.asl20; - hydraPlatforms = lib.platforms.none; } ) { }; @@ -746447,7 +746356,6 @@ self: { testToolDepends = [ hspec-discover ]; description = "Polkadot support for Haskell Web3 library"; license = lib.licenses.asl20; - hydraPlatforms = lib.platforms.none; } ) { }; @@ -746485,7 +746393,6 @@ self: { ]; description = "Node connection provider for Haskell Web3 library"; license = lib.licenses.asl20; - hydraPlatforms = lib.platforms.none; } ) { }; @@ -746560,7 +746467,6 @@ self: { testToolDepends = [ hspec-discover ]; description = "Solidity language for Haskell Web3 library"; license = lib.licenses.asl20; - hydraPlatforms = lib.platforms.none; } ) { }; @@ -746602,7 +746508,6 @@ self: { testToolDepends = [ hspec-discover ]; description = "Tools for working with Crypto/Web3"; license = lib.licenses.mit; - hydraPlatforms = lib.platforms.none; } ) { }; From 8618bb50f0f52f4b285055fcf4ff93ae5c9401fb Mon Sep 17 00:00:00 2001 From: Wolfgang Walther Date: Fri, 10 Apr 2026 09:52:55 +0200 Subject: [PATCH 48/52] haskellPackages: stackage LTS 24.35 -> LTS 24.36 all-cabal-hashes: 2026-03-30T06:52:34Z -> 2026-04-09T21:58:58Z (generated by maintainers/scripts/haskell/update-package-set.sh) --- pkgs/data/misc/hackage/pin.json | 8 +- .../haskell-modules/configuration-common.nix | 23 - .../configuration-hackage2nix/stackage.yaml | 12 +- .../haskell-modules/hackage-packages.nix | 2719 ++++++++++++++--- 4 files changed, 2373 insertions(+), 389 deletions(-) diff --git a/pkgs/data/misc/hackage/pin.json b/pkgs/data/misc/hackage/pin.json index 51d7ba78a886..b051caa41ca0 100644 --- a/pkgs/data/misc/hackage/pin.json +++ b/pkgs/data/misc/hackage/pin.json @@ -1,6 +1,6 @@ { - "commit": "7c90adee4a21c129dfe6b4b9d2d63c0d704d11ef", - "url": "https://github.com/commercialhaskell/all-cabal-hashes/archive/7c90adee4a21c129dfe6b4b9d2d63c0d704d11ef.tar.gz", - "sha256": "1l0lk9ifzby749w9wj1v8cp048ndpf6qznlpdjkmmz5f8fvlr53z", - "msg": "Update from Hackage at 2026-03-30T06:52:34Z" + "commit": "fc5584ee196b463b3e36ec8731df48ca0434eb54", + "url": "https://github.com/commercialhaskell/all-cabal-hashes/archive/fc5584ee196b463b3e36ec8731df48ca0434eb54.tar.gz", + "sha256": "1c2a9jvjy72v92h233ya26f50yv302msn95f4jnq7k9774fb1brw", + "msg": "Update from Hackage at 2026-04-09T21:58:58Z" } diff --git a/pkgs/development/haskell-modules/configuration-common.nix b/pkgs/development/haskell-modules/configuration-common.nix index 8451d22a2aab..d697c47aed3f 100644 --- a/pkgs/development/haskell-modules/configuration-common.nix +++ b/pkgs/development/haskell-modules/configuration-common.nix @@ -29,29 +29,6 @@ with haskellLib; # To avoid merge conflicts, consider adding your item at an arbitrary place in the list instead. { - # Hackage's accelerate is from 2020 and incompatible with our GHC. - # The existing derivation also has missing dependencies - # compared to the source from github. - # https://github.com/AccelerateHS/accelerate/issues/553 - accelerate = lib.pipe super.accelerate [ - (warnAfterVersion "1.3.0.0") - (addBuildDepends [ - self.double-conversion - self.formatting - self.microlens - ]) - - (overrideCabal (drv: { - version = "1.3.0.0-unstable-2026-01-30"; - src = pkgs.fetchFromGitHub { - owner = "AccelerateHS"; - repo = "accelerate"; - rev = "c22387ed2e00b00a6c79dcec5d22b53874da91fc"; - sha256 = "sha256-AtKdxeCytRbmOIFe7OPbSMlhFhJnrgMuIqLFIeqnBGU"; - }; - })) - ]; - # Make sure that Cabal_* can be built as-is Cabal_3_10_3_0 = doDistribute ( super.Cabal_3_10_3_0.override { diff --git a/pkgs/development/haskell-modules/configuration-hackage2nix/stackage.yaml b/pkgs/development/haskell-modules/configuration-hackage2nix/stackage.yaml index 13647054de09..e6358c3ae1ef 100644 --- a/pkgs/development/haskell-modules/configuration-hackage2nix/stackage.yaml +++ b/pkgs/development/haskell-modules/configuration-hackage2nix/stackage.yaml @@ -1,4 +1,4 @@ -# Stackage LTS 24.35 +# Stackage LTS 24.36 # This file is auto-generated by # maintainers/scripts/haskell/update-stackage.sh default-package-overrides: @@ -500,7 +500,7 @@ default-package-overrides: - crc32c ==0.2.2 - crdt-event-fold ==1.8.1.2 - criterion ==1.6.4.0 - - criterion-measurement ==0.2.3.0 + - criterion-measurement ==0.2.4.0 - cron ==0.7.2 - crypto-api ==0.13.3 - crypto-api-tests ==0.3 @@ -704,7 +704,7 @@ default-package-overrides: - drifter-postgresql ==0.2.1 - drifter-sqlite ==0.1.0.0 - dsp ==0.2.5.2 - - dual-tree ==0.2.3.2 + - dual-tree ==0.2.3.3 - dublincore-xml-conduit ==0.1.0.3 - dunai ==0.14.1 - duration ==0.2.0.0 @@ -2064,7 +2064,7 @@ default-package-overrides: - options ==1.2.1.2 - optparse-applicative ==0.18.1.0 - optparse-enum ==1.0.0.0 - - optparse-generic ==1.5.2 + - optparse-generic ==1.5.3 - optparse-simple ==0.1.1.4 - optparse-text ==0.1.1.0 - ordered-containers ==0.2.4 @@ -2710,7 +2710,7 @@ default-package-overrides: - statistics ==0.16.5.0 - statistics-linreg ==0.3 - statsd-rupp ==0.5.0.1 - - status-notifier-item ==0.3.2.10 + - status-notifier-item ==0.3.2.13 - step-function ==0.2.1 - stitch ==0.6.0.0 - stm-chans ==3.0.0.11 @@ -3215,7 +3215,7 @@ default-package-overrides: - wave ==0.2.1 - wcwidth ==0.0.2 - web-cookiejar ==0.1.3.1 - - web-rep ==0.14.0.1 + - web-rep ==0.14.1.0 - web-routes ==0.27.16 - web-routes-th ==0.22.8.3 - web-view ==0.7.0 diff --git a/pkgs/development/haskell-modules/hackage-packages.nix b/pkgs/development/haskell-modules/hackage-packages.nix index 324c8c68bd29..704d0418575a 100644 --- a/pkgs/development/haskell-modules/hackage-packages.nix +++ b/pkgs/development/haskell-modules/hackage-packages.nix @@ -144,8 +144,8 @@ self: { }: mkDerivation { pname = "A-gent"; - version = "0.11.0.6"; - sha256 = "0a6ll33b1m35ddg5wmmfxw0rq8vg1pzbpsdiy6a1h3pczkmyhizf"; + version = "0.11.0.7"; + sha256 = "1p6yxa7rbw1bm6hdr2jwaxc8yhlf5m5byff6rqq5w63qsz76kmk4"; libraryHaskellDepends = [ base containers @@ -50186,18 +50186,19 @@ self: { Cabal, cabal-doctest, containers, - cryptonite, deepseq, directory, doctest, + double-conversion, exceptions, filepath, + formatting, ghc-prim, half, hashable, hashtables, hedgehog, - lens, + microlens, mtl, prettyprinter, prettyprinter-ansi-terminal, @@ -50214,12 +50215,16 @@ self: { }: mkDerivation { pname = "accelerate"; - version = "1.3.0.0"; - sha256 = "14md9fbxckgwpbkm7hdj95ny11w5b5cj103r8razg0aw2hgid5sb"; + version = "1.4.0.0"; + sha256 = "055r9dcznm5gic9dn924sxbcywjjjf353aw89ml4fzknfwl5kamr"; + isLibrary = true; + isExecutable = true; setupHaskellDepends = [ base Cabal cabal-doctest + directory + filepath ]; libraryHaskellDepends = [ ansi-terminal @@ -50227,17 +50232,18 @@ self: { base-orphans bytestring containers - cryptonite deepseq directory + double-conversion exceptions filepath + formatting ghc-prim half hashable hashtables hedgehog - lens + microlens mtl prettyprinter prettyprinter-ansi-terminal @@ -50257,7 +50263,7 @@ self: { doctest ]; description = "An embedded language for accelerated array processing"; - license = lib.licenses.bsd3; + license = lib.meta.getLicenseFromSpdxId "BSD-3-Clause"; } ) { }; @@ -51178,18 +51184,27 @@ self: { dlist, exceptions, filepath, - llvm-hs, - llvm-hs-pure, + formatting, + hashable, + microlens, + microlens-th, + monadLib, mtl, + parsec, + pretty, primitive, + process, + syb, template-haskell, + text, + th-abstraction, unordered-containers, vector, }: mkDerivation { pname = "accelerate-llvm"; - version = "1.3.0.0"; - sha256 = "1fjjfjav11s6grwl6ihqdrzx738bwki0l25qlp4zzz2hi2440qbp"; + version = "1.4.0.0"; + sha256 = "0j101nmc1iirx5xrdgf8l6572vjfqnfryy6g3s1rxriy323drz04"; libraryHaskellDepends = [ accelerate base @@ -51202,16 +51217,26 @@ self: { dlist exceptions filepath - llvm-hs - llvm-hs-pure + formatting + hashable + microlens + microlens-th + monadLib mtl + parsec + pretty primitive + process + syb template-haskell + text + th-abstraction unordered-containers vector ]; + doHaddock = false; description = "Accelerate backend component generating LLVM IR"; - license = lib.licenses.bsd3; + license = lib.meta.getLicenseFromSpdxId "BSD-3-Clause"; hydraPlatforms = lib.platforms.none; } ) { }; @@ -51223,63 +51248,73 @@ self: { accelerate-llvm, base, bytestring, - c2hs, - cereal, + Cabal, containers, deepseq, directory, dlist, filepath, + formatting, ghc, - ghc-prim, hashable, libffi, - llvm-hs, - llvm-hs-pure, lockfree-queue, mtl, + pretty, + process, + tasty, + tasty-hunit, template-haskell, + text, + th-lift-instances, unique, unix, + unordered-containers, vector, }: mkDerivation { pname = "accelerate-llvm-native"; - version = "1.3.0.0"; - sha256 = "1x4wfbp83ppzknd98k2ad160a8kdqh96qqmyfzdqyvy44iskxcn6"; - revision = "1"; - editedCabalFile = "1w98zxyg5zr9xbx6wzglh1agc7pf25qlxbblvvvizf9niq84bw56"; + version = "1.4.0.0"; + sha256 = "1bl4br298vn6gl5dfqy0bc0kh3vxbhfmpbds9xcby2qyq6mjk60q"; + setupHaskellDepends = [ + base + Cabal + filepath + ]; libraryHaskellDepends = [ accelerate accelerate-llvm base bytestring - cereal containers deepseq directory dlist filepath + formatting ghc - ghc-prim hashable libffi - llvm-hs - llvm-hs-pure lockfree-queue mtl + pretty + process template-haskell + text + th-lift-instances unique unix + unordered-containers vector ]; - libraryToolDepends = [ c2hs ]; testHaskellDepends = [ accelerate base + tasty + tasty-hunit ]; description = "Accelerate backend for multicore CPUs"; - license = lib.licenses.bsd3; + license = lib.meta.getLicenseFromSpdxId "BSD-3-Clause"; hydraPlatforms = lib.platforms.none; } ) { }; @@ -51298,21 +51333,24 @@ self: { dlist, file-embed, filepath, + formatting, ghc-heap, hashable, - llvm-hs, - llvm-hs-pure, mtl, - nvvm, pretty, + prettyprinter, + primitive, process, + tasty, + tasty-hunit, template-haskell, + text, unordered-containers, }: mkDerivation { pname = "accelerate-llvm-ptx"; - version = "1.3.0.0"; - sha256 = "0bb7p67dv5csbblnaxbm7hkq8y2qknz0yd1f0rav29igsv3a9rfx"; + version = "1.4.0.0"; + sha256 = "0f70p2nnwwaw1h18wg6i9n1alwl4437vsnsw0r5s0b7f2s741bx5"; libraryHaskellDepends = [ accelerate accelerate-llvm @@ -51325,23 +51363,26 @@ self: { dlist file-embed filepath + formatting ghc-heap hashable - llvm-hs - llvm-hs-pure mtl - nvvm pretty + prettyprinter + primitive process template-haskell + text unordered-containers ]; testHaskellDepends = [ accelerate base + tasty + tasty-hunit ]; description = "Accelerate backend for NVIDIA GPUs"; - license = lib.licenses.bsd3; + license = lib.meta.getLicenseFromSpdxId "BSD-3-Clause"; hydraPlatforms = lib.platforms.none; } ) { }; @@ -53436,8 +53477,8 @@ self: { }: mkDerivation { pname = "add-dependent-file"; - version = "0.0.1"; - sha256 = "1rsfvgrlyd76vpdsrq6qcl4zm3g361lj7g4r63r2jwdrv5ayzrg8"; + version = "0.0.2"; + sha256 = "1ri0sf07w8qb6217c8ny5lrv9wmnb1s06z6x4a8cn6qm490n6iky"; libraryHaskellDepends = [ base bytestring @@ -55675,8 +55716,8 @@ self: { }: mkDerivation { pname = "aeson-match-qq"; - version = "1.8.0"; - sha256 = "1jzkxpy7qgln68sz5r9j5n963pnwxnclqav8qfc583yv9zszl0dp"; + version = "1.9.0"; + sha256 = "1naxb6ymg5f8dmj3xbcim5q09g10b7a1n5dmzc4wp6pwjaqxw2vv"; libraryHaskellDepends = [ aeson attoparsec @@ -56742,6 +56783,49 @@ self: { } ) { }; + aeson-value-qq = callPackage ( + { + mkDerivation, + aeson, + attoparsec, + attoparsec-aeson, + base, + bytestring, + ghc-hs-meta, + hspec, + scientific, + template-haskell, + text, + unordered-containers, + vector, + }: + mkDerivation { + pname = "aeson-value-qq"; + version = "1.0.0"; + sha256 = "0gw92qy5ih3z55afz0xkc8jigx1cqaajjcnhkg45bw1q44xsiy4n"; + libraryHaskellDepends = [ + aeson + attoparsec + attoparsec-aeson + base + bytestring + ghc-hs-meta + scientific + template-haskell + text + unordered-containers + vector + ]; + testHaskellDepends = [ + aeson + base + hspec + ]; + description = "QuasiQuoter for Aeson.Value"; + license = lib.licenses.bsd2; + } + ) { }; + aeson-via = callPackage ( { mkDerivation, @@ -79341,23 +79425,34 @@ self: { apecs-physics, base, brillo, + brillo-rendering, containers, linear, }: mkDerivation { pname = "apecs-brillo"; - version = "0.1.0"; - sha256 = "0a0j74m6p6fnzagh5knlg9fn522ahr0ag4pgnssbl0lz4x2kwh13"; + version = "0.1.1"; + sha256 = "1lbkim53ra5jf74l9xglzfh3i5x13ji6vxp85xwl4479vv402k66"; libraryHaskellDepends = [ apecs apecs-physics base brillo + brillo-rendering containers linear ]; - description = "Simple brillo renderer for apecs"; - license = lib.licenses.bsd3; + testHaskellDepends = [ + apecs + apecs-physics + base + brillo + brillo-rendering + containers + linear + ]; + description = "Apecs' gloss package, but adapted for brillo"; + license = lib.meta.getLicenseFromSpdxId "BSD-3-Clause"; hydraPlatforms = lib.platforms.none; broken = true; } @@ -97841,10 +97936,8 @@ self: { }: mkDerivation { pname = "ban-instance"; - version = "0.1.0.1"; - sha256 = "0504qsjbqbrdf9avfrhs290baszc9dickx7wknbyxwrzpzzbpggk"; - revision = "5"; - editedCabalFile = "1a0xh0kfdpqgppaisb0hlm4k40gssbxh5jjz2j2l8xn2bnmv95cb"; + version = "0.1.1.0"; + sha256 = "174srwcxcfvf8h7v2k9pk3a8gqi29h2pwm7c1qx3xpmad6d32b5y"; libraryHaskellDepends = [ base template-haskell @@ -99710,8 +99803,8 @@ self: { }: mkDerivation { pname = "basesystems"; - version = "1.0.0.0"; - sha256 = "1904s9ii1nxpxcg6ah2192k7j193s8i1lnci2d6r4jb15s30b61d"; + version = "1.0.0.1"; + sha256 = "0hh804vpm38z0mwsv6vcihfrhwcwpmlj47pngspclm9m9lvmvwsn"; libraryHaskellDepends = [ array base @@ -111219,21 +111312,21 @@ self: { { mkDerivation, base, - memory, + ram, tasty, tasty-hunit, }: mkDerivation { pname = "blake3"; - version = "0.3"; - sha256 = "12hm7bd4jqxw0gqmczb9vxn99lbwawr09xwp6y7xb0fzrr97ysls"; + version = "0.3.1"; + sha256 = "1fi4dwdj9yzlq0lm3nf1l0y73sqf0vbwfqwhikr3cd3bmgf6d5hl"; libraryHaskellDepends = [ base - memory + ram ]; testHaskellDepends = [ base - memory + ram tasty tasty-hunit ]; @@ -113727,12 +113820,12 @@ self: { } ) { }; - bluefin_0_5_0_0 = callPackage ( + bluefin_0_5_1_0 = callPackage ( { mkDerivation, bluefin-internal }: mkDerivation { pname = "bluefin"; - version = "0.5.0.0"; - sha256 = "0yvqp9mvwpqqqwfa8nzvcscai3ajm04l7frsh0pba43rnbvq1fng"; + version = "0.5.1.0"; + sha256 = "1a9rp4l4sws6miq0hlfw383inka2yj303c96srvnyq1liadxa7yd"; libraryHaskellDepends = [ bluefin-internal ]; description = "The Bluefin effect system"; license = lib.meta.getLicenseFromSpdxId "MIT"; @@ -113829,7 +113922,7 @@ self: { } ) { }; - bluefin-internal_0_5_0_0 = callPackage ( + bluefin-internal_0_5_1_0 = callPackage ( { mkDerivation, async, @@ -113842,8 +113935,8 @@ self: { }: mkDerivation { pname = "bluefin-internal"; - version = "0.5.0.0"; - sha256 = "0asl1y892j69vq57myfl2dipf0ig6dscvcch1pjn3lg0g4w7ynj8"; + version = "0.5.1.0"; + sha256 = "035dw13rw0sjcfb8d88ab66j4kcdj5prhiw9cr1l2p7smjv3rvnx"; libraryHaskellDepends = [ async base @@ -114691,6 +114784,7 @@ self: { mkDerivation, aeson, base, + base64-bytestring, bytestring, crypton-connection, data-default, @@ -114699,6 +114793,7 @@ self: { network, packstream-bolt, persist, + QuickCheck, resource-pool, sandwich, scientific, @@ -114714,11 +114809,12 @@ self: { }: mkDerivation { pname = "bolty"; - version = "0.1.0.2"; - sha256 = "1d5ic68akkjd3w352rdnk1vp3b4dx3mv2w5irar4ykvg0iy87i0v"; + version = "0.1.1.0"; + sha256 = "1gczh6rlfcg1hcyyf26n1jsr559bh412m4c1wrlfd1qa3hsd8fz3"; libraryHaskellDepends = [ aeson base + base64-bytestring bytestring crypton-connection data-default @@ -114740,6 +114836,7 @@ self: { word8 ]; testHaskellDepends = [ + aeson base bytestring crypton-connection @@ -114749,6 +114846,7 @@ self: { network packstream-bolt persist + QuickCheck sandwich split text @@ -114780,8 +114878,8 @@ self: { }: mkDerivation { pname = "bolty-streamly"; - version = "0.1.0.0"; - sha256 = "11wjapwlsi4mc2h0j5fiqyd3nnzd52sagkrlmc3fgl46q4198mx6"; + version = "0.1.0.1"; + sha256 = "0n9njqzjkvxak075x1cjj1q419q8n3hgjj9myhbm0naiqs4s7zfv"; libraryHaskellDepends = [ base bolty @@ -115723,6 +115821,54 @@ self: { } ) { }; + boomwhacker_0_0_2_1 = callPackage ( + { + mkDerivation, + array, + base, + containers, + event-list, + filepath, + HPDF, + midi, + non-empty, + non-negative, + optparse-applicative, + shell-utility, + time, + transformers, + utility-ht, + }: + mkDerivation { + pname = "boomwhacker"; + version = "0.0.2.1"; + sha256 = "16057myaadccm16lbdp8rrrcq9c0qswdj49l5xvs64w705cp7pjw"; + isLibrary = false; + isExecutable = true; + enableSeparateDataOutput = true; + executableHaskellDepends = [ + array + base + containers + event-list + filepath + HPDF + midi + non-empty + non-negative + optparse-applicative + shell-utility + time + transformers + utility-ht + ]; + description = "Convert MIDI file to play-along boomwhacker animation"; + license = lib.licenses.bsd3; + hydraPlatforms = lib.platforms.none; + mainProgram = "boomwhacker"; + } + ) { }; + boop = callPackage ( { mkDerivation, @@ -125881,13 +126027,18 @@ self: { }: mkDerivation { pname = "cabal-detailed-quickcheck"; - version = "0.2.0.1"; - sha256 = "0z82ira6g3mkqj9cw050s4m4nk2n5d4zx6gqlrcgszypd80h03f2"; + version = "0.3.0.0"; + sha256 = "0jbzjqjwzwxdn2fpmlxqh6jjs2j6q82ldmq4ap1x6ffbhqizqmqs"; libraryHaskellDepends = [ base Cabal QuickCheck ]; + testHaskellDepends = [ + base + Cabal + QuickCheck + ]; description = "QuickCheck for Cabal tests"; license = lib.meta.getLicenseFromSpdxId "MIT"; hydraPlatforms = lib.platforms.none; @@ -126448,7 +126599,7 @@ self: { } ) { }; - cabal-gild_1_7_0_2 = callPackage ( + cabal-gild_1_8_4_1 = callPackage ( { mkDerivation, base, @@ -126468,8 +126619,8 @@ self: { }: mkDerivation { pname = "cabal-gild"; - version = "1.7.0.2"; - sha256 = "18a8p7imdsi4yix6qh0qwpi5knw17gj8nj3zzlpd9s88ydl6yq75"; + version = "1.8.4.1"; + sha256 = "07axmqsdm2sgpwbz52y2cy281xxk0fhp3vnsw7fyp7ndn0786h8q"; isLibrary = true; isExecutable = true; libraryHaskellDepends = [ @@ -129728,6 +129879,85 @@ self: { } ) { }; + cadence = callPackage ( + { + mkDerivation, + aeson, + apecs, + base, + bytestring, + containers, + exceptions, + hspec, + hspec-contrib, + HUnit, + linear, + QuickCheck, + random, + random-shuffle, + sdl2, + sdl2-image, + sdl2-ttf, + template-haskell, + text, + vector, + }: + mkDerivation { + pname = "cadence"; + version = "0.1.0.0"; + sha256 = "128qsl0ymmjircxrpyfb7cg02nfv9z7l7y6yrxrbjka4c49lydv6"; + isLibrary = true; + isExecutable = true; + libraryHaskellDepends = [ + apecs + base + containers + linear + sdl2 + sdl2-image + sdl2-ttf + template-haskell + text + vector + ]; + executableHaskellDepends = [ + aeson + apecs + base + bytestring + containers + linear + random + random-shuffle + sdl2 + sdl2-image + sdl2-ttf + template-haskell + text + vector + ]; + testHaskellDepends = [ + apecs + base + containers + exceptions + hspec + hspec-contrib + HUnit + linear + QuickCheck + sdl2 + sdl2-image + sdl2-ttf + template-haskell + text + vector + ]; + description = "An ECS-based 2D game framework"; + license = lib.meta.getLicenseFromSpdxId "BSD-3-Clause"; + } + ) { }; + caerbannog = callPackage ( { mkDerivation, @@ -138181,8 +138411,8 @@ self: { }: mkDerivation { pname = "changeset"; - version = "0.1.1"; - sha256 = "1mp5g0y1rbhfp5js3g2szpr7cfywpqjnh7ps01l1pxrvirxkdbbr"; + version = "0.2"; + sha256 = "010r452dbj4x93g2msdazaahs19q58cnzmskjfdgw7f8b7690ajg"; libraryHaskellDepends = [ base containers @@ -138217,24 +138447,32 @@ self: { base, changeset, containers, + data-default, + falsify, + indexed-traversable, monoid-extras, tasty, tasty-hunit, + transformers, }: mkDerivation { pname = "changeset-containers"; - version = "0.1.1"; - sha256 = "0dyxhpbhwbqpbjmyhdqbdy82fbx76163az6m9lrcq8p5026n0ndc"; + version = "0.2"; + sha256 = "0xk88k3ywrdc1gxnnd07c2rxqln7f6204fkb8365iffnafcw09m5"; libraryHaskellDepends = [ base changeset containers + indexed-traversable monoid-extras + transformers ]; testHaskellDepends = [ base changeset containers + data-default + falsify monoid-extras tasty tasty-hunit @@ -138262,8 +138500,8 @@ self: { }: mkDerivation { pname = "changeset-lens"; - version = "0.1.1"; - sha256 = "0fi3yjb689mvl8scmi3yz29fx4f1z2idclij4jn1mqavaaz4wzgd"; + version = "0.2"; + sha256 = "00wyd04d103g08p1n33qaqx234rpwz81rps2rm1bdaq4axzpl9pk"; libraryHaskellDepends = [ base changeset @@ -138303,8 +138541,8 @@ self: { }: mkDerivation { pname = "changeset-reflex"; - version = "0.1.1"; - sha256 = "0jad77lp542y7kw0dbq4spdkpv38ygg7hlmbik7a5wikf90dfvz7"; + version = "0.2"; + sha256 = "1ilcn0qd5hhsvbv5194z0p04h7fb0bqb9k09fw9xs0v9drxyrnx1"; libraryHaskellDepends = [ base changeset @@ -139610,6 +139848,58 @@ self: { } ) { }; + checked-literals = callPackage ( + { + mkDerivation, + base, + directory, + filepath, + ghc, + ghc-typelits-extra, + ghc-typelits-knownnat, + ghc-typelits-natnormalise, + mtl, + process, + string-interpolate, + syb, + tasty, + tasty-hunit, + template-haskell, + temporary, + }: + mkDerivation { + pname = "checked-literals"; + version = "0.1.0.0"; + sha256 = "1dwiwr92hsw4c3yx1h6n5bb3fsf9zx6k3qq8fgq0in1h7jzkmkrw"; + libraryHaskellDepends = [ + base + ghc + ghc-typelits-extra + ghc-typelits-knownnat + ghc-typelits-natnormalise + mtl + syb + template-haskell + ]; + testHaskellDepends = [ + base + directory + filepath + ghc-typelits-extra + ghc-typelits-knownnat + ghc-typelits-natnormalise + process + string-interpolate + tasty + tasty-hunit + temporary + ]; + doHaddock = false; + description = "GHC plugin for checked numeric literals"; + license = lib.meta.getLicenseFromSpdxId "BSD-2-Clause"; + } + ) { }; + checkers = callPackage ( { mkDerivation, @@ -140246,8 +140536,8 @@ self: { }: mkDerivation { pname = "chiasma"; - version = "0.10.1.0"; - sha256 = "09nsi5lksmbwqxy76h122kzp23632gvfbngs1vilmqhcf6zrbbg5"; + version = "0.12.2.0"; + sha256 = "01srs9xs31f7gi3l0d7k1xwm9lvpldh1p8jq8342n97b2w04whxx"; libraryHaskellDepends = [ attoparsec base @@ -140311,8 +140601,8 @@ self: { }: mkDerivation { pname = "chiasma-test"; - version = "0.10.1.0"; - sha256 = "0gyr4im2f8x335q3svvyr7lrf5z6ypln764spz986qf5ibg4arrb"; + version = "0.12.2.0"; + sha256 = "0zxb9m4q5kx2lz0lvbhl5f396pl324xn1qy4h7iqghvncvsds779"; libraryHaskellDepends = [ base bytestring @@ -140343,6 +140633,7 @@ self: { polysemy polysemy-chronos polysemy-plugin + polysemy-process polysemy-test prelate tasty @@ -150286,6 +150577,35 @@ self: { } ) { RNA = null; }; + coco = callPackage ( + { + mkDerivation, + base, + bytestring, + template-haskell, + text, + utf8-string, + utility-ht, + uuid, + }: + mkDerivation { + pname = "coco"; + version = "0.0.0.0"; + sha256 = "0hxf6i61lhp1mm34mmgbzcz3z9mx3lvl7j6z4vql2v767blav006"; + libraryHaskellDepends = [ + base + bytestring + template-haskell + text + utf8-string + utility-ht + uuid + ]; + description = "compatible conversions"; + license = lib.meta.getLicenseFromSpdxId "MIT"; + } + ) { }; + code-builder = callPackage ( { mkDerivation, @@ -163669,9 +163989,10 @@ self: { { mkDerivation, base }: mkDerivation { pname = "contra-tracer"; - version = "0.2.0.0"; - sha256 = "1rb2fal2rn02qnp28dsvq3r94b72jkqrp2s1lryhmrdj23jc3swy"; + version = "0.2.1.0"; + sha256 = "06c08m3s9r920y4zhrwfld2mxa18m4qyh21rkf80xsk493dq5s5z"; libraryHaskellDepends = [ base ]; + testHaskellDepends = [ base ]; description = "Arrow and contravariant tracers"; license = lib.licenses.asl20; } @@ -170540,7 +170861,7 @@ self: { } ) { }; - criterion_1_6_4_1 = callPackage ( + criterion_1_6_5_0 = callPackage ( { mkDerivation, aeson, @@ -170565,7 +170886,6 @@ self: { mtl, mwc-random, optparse-applicative, - parsec, prettyprinter, prettyprinter-ansi-terminal, QuickCheck, @@ -170574,18 +170894,14 @@ self: { tasty-hunit, tasty-quickcheck, text, - time, transformers, transformers-compat, vector, - vector-algorithms, }: mkDerivation { pname = "criterion"; - version = "1.6.4.1"; - sha256 = "03danwzqimrnw39s91pxmya3jrb4wxvx0ijm3qr5mik8axn6z9af"; - revision = "1"; - editedCabalFile = "02sbckvbz107n369crcpb31jq4x6jw4kqvrkh3m03i8wn9bxbkis"; + version = "1.6.5.0"; + sha256 = "0f7011j1bz9p6b88aj6s4yp3m9vwn95irqby1glmh05lj46dh4yn"; isLibrary = true; isExecutable = true; enableSeparateDataOutput = true; @@ -170610,16 +170926,13 @@ self: { mtl mwc-random optparse-applicative - parsec prettyprinter prettyprinter-ansi-terminal statistics text - time transformers transformers-compat vector - vector-algorithms ]; executableHaskellDepends = [ base @@ -170753,8 +171066,8 @@ self: { }: mkDerivation { pname = "criterion-measurement"; - version = "0.2.3.0"; - sha256 = "1qnzgkmjlv3m6zr8l3dfnc1b5jy2fyjxb7s1qzhdcww4bsixqxfc"; + version = "0.2.4.0"; + sha256 = "18zr0z9fa2x61bynzvhh7g8r7mshsz6l4dd7bl8k9mwy0icy0hm3"; libraryHaskellDepends = [ aeson base @@ -171385,6 +171698,8 @@ self: { pname = "crucible-debug"; version = "0.1.2.0"; sha256 = "0i3bbk28sihyb8nirjcz72mrhz6m08k3iz1jz2rx5jn7nwskxzba"; + revision = "1"; + editedCabalFile = "17x1lwjfwh97lm9r9halx3jx447gvqjfynxfvv6ndy1brp0xq2px"; isLibrary = true; isExecutable = true; libraryHaskellDepends = [ @@ -171605,6 +171920,8 @@ self: { pname = "crucible-syntax"; version = "0.5.0.0"; sha256 = "08b027d6m8c1wsfn21kjywg1gqw4s4nanzj1q4kqp65n4gmaai5b"; + revision = "1"; + editedCabalFile = "141mjylrq9j2k6qpaa01g4ngdidd57cmwy70d016d7wxckb3n3hs"; libraryHaskellDepends = [ base bv-sized @@ -173795,6 +174112,8 @@ self: { pname = "crypton-conduit"; version = "0.2.3"; sha256 = "1kkizzapdv1lnkijmygpr3jdh2wiszcjhbi9byjzjphinpwlaply"; + revision = "1"; + editedCabalFile = "0czvkgb8lr7w23fyz1skajz7dcwh0xylnw4cvgs4ixpz96f109y8"; libraryHaskellDepends = [ base bytestring @@ -173822,6 +174141,55 @@ self: { } ) { }; + crypton-conduit_0_3_0 = callPackage ( + { + mkDerivation, + base, + bytestring, + conduit, + conduit-combinators, + conduit-extra, + crypton, + exceptions, + ram, + resourcet, + tasty, + tasty-hunit, + tasty-quickcheck, + transformers, + }: + mkDerivation { + pname = "crypton-conduit"; + version = "0.3.0"; + sha256 = "0gi70jasy95khp7d133ymipqlyqf37sg0p17w1s6bagjqkpk7qnq"; + libraryHaskellDepends = [ + base + bytestring + conduit + conduit-extra + crypton + exceptions + ram + resourcet + transformers + ]; + testHaskellDepends = [ + base + bytestring + conduit + conduit-combinators + crypton + ram + tasty + tasty-hunit + tasty-quickcheck + ]; + description = "crypton conduit"; + license = lib.licenses.bsd3; + hydraPlatforms = lib.platforms.none; + } + ) { }; + crypton-connection = callPackage ( { mkDerivation, @@ -173874,6 +174242,8 @@ self: { pname = "crypton-connection"; version = "0.4.6"; sha256 = "0d20qp4jim89s6psi0iyjwjzgbi4piw9pxyyr15qrshpb22vg1nn"; + revision = "1"; + editedCabalFile = "0bnjm3rdk4wv9p743fp324wzq08lxaxrw04hyplv2hwzvr24lxm3"; libraryHaskellDepends = [ base bytestring @@ -175258,10 +175628,10 @@ self: { css-class-bindings = callPackage ( { mkDerivation, + add-dependent-file, base, containers, css-syntax, - directory, filepath, QuickCheck, tasty, @@ -175273,13 +175643,13 @@ self: { }: mkDerivation { pname = "css-class-bindings"; - version = "0.0.2"; - sha256 = "1pz2wimhy0f28c9zdkkfws18ayci2d744fd0hnq76s0sxsml6hxf"; + version = "0.0.4"; + sha256 = "00gkpp5vs2dx41aw6pizb4vlkk64yrd4h90glw2har70dhij1k63"; libraryHaskellDepends = [ + add-dependent-file base containers css-syntax - directory filepath template-haskell text @@ -176254,8 +176624,8 @@ self: { }: mkDerivation { pname = "cuda"; - version = "0.12.8.0"; - sha256 = "06sc7jkg24742frz7q8jimw8szvsva20zy4jn35dj585mibnljcr"; + version = "0.13.0.0"; + sha256 = "03xvkzylbfrbhh4ds37cj900w9kh5ikxynscrng3z6avvsg0nc1j"; isLibrary = true; isExecutable = true; setupHaskellDepends = [ @@ -176277,7 +176647,7 @@ self: { base pretty ]; - description = "FFI binding to the CUDA interface for programming NVIDIA GPUs"; + description = "FFI binding to the CUDA driver interface for programming NVIDIA GPUs"; license = lib.licenses.bsd3; hydraPlatforms = lib.platforms.none; mainProgram = "nvidia-device-query"; @@ -176357,8 +176727,8 @@ self: { }: mkDerivation { pname = "cuddle"; - version = "1.2.0.0"; - sha256 = "0638jvj6wkczrxfswlcbzkci20s79s1yf4v22fz5gdmv34l21gvm"; + version = "1.4.0.0"; + sha256 = "0gx7snfndyw6sjn3s2j1kg67y8sf6sz7hv6iankm48i5rivyfn60"; isLibrary = true; isExecutable = true; enableSeparateDataOutput = true; @@ -176374,6 +176744,7 @@ self: { data-default-class foldable1-classes-compat generic-optics + generic-random half hashable megaparsec @@ -176427,6 +176798,7 @@ self: { prettyprinter prettyprinter-ansi-terminal QuickCheck + quickcheck-transformer random string-qq text @@ -191293,6 +191665,40 @@ self: { } ) { }; + deque_0_4_4_4 = callPackage ( + { + mkDerivation, + base, + deepseq, + hashable, + mtl, + rerebase, + strict-list, + tasty, + tasty-quickcheck, + }: + mkDerivation { + pname = "deque"; + version = "0.4.4.4"; + sha256 = "09c3cld56k0frl1kvhrrb1kz8i3w9n3qycr7qvf0ihjw6kg5b0za"; + libraryHaskellDepends = [ + base + deepseq + hashable + mtl + strict-list + ]; + testHaskellDepends = [ + rerebase + tasty + tasty-quickcheck + ]; + description = "Double-ended queues"; + license = lib.meta.getLicenseFromSpdxId "MIT"; + hydraPlatforms = lib.platforms.none; + } + ) { }; + dequeue = callPackage ( { mkDerivation, @@ -191756,6 +192162,64 @@ self: { } ) { }; + derive-topdown_0_1_1_1 = callPackage ( + { + mkDerivation, + base, + binary, + bytestring, + containers, + ghc, + haskell-src, + haskell-src-exts, + HUnit, + mtl, + primitive, + syb, + template-haskell, + th-abstraction, + th-expand-syns, + transformers, + }: + mkDerivation { + pname = "derive-topdown"; + version = "0.1.1.1"; + sha256 = "1diagpj0218ciqhrbf6blvip8pwkbwd9hxb0w6a8dyjpyfjwwllq"; + libraryHaskellDepends = [ + base + containers + mtl + primitive + syb + template-haskell + th-abstraction + th-expand-syns + transformers + ]; + testHaskellDepends = [ + base + binary + bytestring + containers + ghc + haskell-src + haskell-src-exts + HUnit + mtl + primitive + syb + template-haskell + th-abstraction + th-expand-syns + transformers + ]; + description = "Derive type class instances"; + license = lib.licenses.bsd3; + hydraPlatforms = lib.platforms.none; + broken = true; + } + ) { }; + derive-trie = callPackage ( { mkDerivation, @@ -191969,6 +192433,46 @@ self: { } ) { }; + deriving-trans_0_11_0_0 = callPackage ( + { + mkDerivation, + base, + exceptions, + logict, + monad-control, + monad-control-identity, + monad-logger, + mtl, + primitive, + resourcet, + transformers, + transformers-base, + unliftio-core, + }: + mkDerivation { + pname = "deriving-trans"; + version = "0.11.0.0"; + sha256 = "00i7aln2aqlakka49lkfml28s4h56ssw23lzhfb28ngyl52zc5n2"; + libraryHaskellDepends = [ + base + exceptions + logict + monad-control + monad-control-identity + monad-logger + mtl + primitive + resourcet + transformers + transformers-base + unliftio-core + ]; + description = "Derive instances for monad transformer stacks"; + license = lib.meta.getLicenseFromSpdxId "BSD-3-Clause"; + hydraPlatforms = lib.platforms.none; + } + ) { }; + deriving-via-fun = callPackage ( { mkDerivation, base }: mkDerivation { @@ -194718,8 +195222,8 @@ self: { }: mkDerivation { pname = "dhscanner-bitcode"; - version = "1.0.15"; - sha256 = "0pwb89rxm3pfyy1cq4zd5m8wwk5afjpj60zmp7443q7fwpygx8b4"; + version = "1.0.16"; + sha256 = "1khjwdmnih5vn9pxi8mjf5faq0g1kd5pfzk54i3gw2alw2g8266m"; libraryHaskellDepends = [ aeson base @@ -194751,8 +195255,8 @@ self: { }: mkDerivation { pname = "dhscanner-kbgen"; - version = "1.0.25"; - sha256 = "066jr09bhlbaqbg72049wn09464j6vr1jk866pjbwipcl3yk6bzb"; + version = "1.0.31"; + sha256 = "03mgjidx48d3sxxky7v3ws3v990rr24xkjn4q6msbjdkrr1q0mya"; libraryHaskellDepends = [ aeson base @@ -195108,6 +195612,34 @@ self: { } ) { }; + diagnostician = callPackage ( + { + mkDerivation, + base, + containers, + prettyprinter, + text, + vector, + }: + mkDerivation { + pname = "diagnostician"; + version = "0.1.0.0"; + sha256 = "0qk4h48afzv6f8xgm8nyyf4bv9ghc2zdwcrk7lfcqvi5nm7vqxhs"; + libraryHaskellDepends = [ + base + containers + prettyprinter + text + vector + ]; + testHaskellDepends = [ + base + containers + ]; + license = lib.meta.getLicenseFromSpdxId "MPL-2.0"; + } + ) { }; + diagrams = callPackage ( { mkDerivation, @@ -208812,8 +209344,8 @@ self: { }: mkDerivation { pname = "dual-tree"; - version = "0.2.3.2"; - sha256 = "12k22x4264x0g0rvv4bdz22bi10fdim9h512ibi59wzvkbb6pkl5"; + version = "0.2.3.3"; + sha256 = "0hk7qc8i3447bsfb85gwswqrkqp9811wxw6ysf838wdq3k37ccrv"; libraryHaskellDepends = [ base monoid-extras @@ -213887,6 +214419,33 @@ self: { } ) { }; + effectful-plugin_2_1_0_0 = callPackage ( + { + mkDerivation, + base, + containers, + effectful-core, + ghc, + }: + mkDerivation { + pname = "effectful-plugin"; + version = "2.1.0.0"; + sha256 = "11kdrx4axrc6lbgra8r4bvnyphdhqrps9ggrlx3wrrr7csdv0a7s"; + libraryHaskellDepends = [ + base + containers + ghc + ]; + testHaskellDepends = [ + base + effectful-core + ]; + description = "A GHC plugin for improving disambiguation of effects"; + license = lib.meta.getLicenseFromSpdxId "BSD-3-Clause"; + hydraPlatforms = lib.platforms.none; + } + ) { }; + effectful-poolboy = callPackage ( { mkDerivation, @@ -220632,6 +221191,8 @@ self: { pname = "env-guard"; version = "0.2.1"; sha256 = "0xm9638nkikfy62abims10jmmr9y3rm2vb22aqh4qmjcj4r37ibq"; + revision = "1"; + editedCabalFile = "0q1dsk4mc5mqd90ya67yjl2himwkwj24vzc4l3njfs9cwkank69v"; libraryHaskellDepends = [ base ]; description = "Conditionally running IO actions based on environment variables"; license = lib.meta.getLicenseFromSpdxId "MIT"; @@ -244408,6 +244969,54 @@ self: { } ) { }; + fnotation = callPackage ( + { + mkDerivation, + base, + bytestring, + containers, + diagnostician, + filepath, + hashable, + prettyprinter, + tasty, + tasty-golden, + temporary, + text, + vector, + vector-hashtables, + }: + mkDerivation { + pname = "fnotation"; + version = "0.1.0.0"; + sha256 = "18jglwasaly5p0x6y4wkijaxyvcyi6cq0n0lz73f2vyxw1inqp5j"; + libraryHaskellDepends = [ + base + containers + diagnostician + hashable + prettyprinter + text + vector + vector-hashtables + ]; + testHaskellDepends = [ + base + bytestring + containers + diagnostician + filepath + prettyprinter + tasty + tasty-golden + temporary + text + vector + ]; + license = lib.meta.getLicenseFromSpdxId "MPL-2.0"; + } + ) { }; + focus = callPackage ( { mkDerivation, @@ -252632,7 +253241,6 @@ self: { funcons-tools, funcons-values, gll, - iml-tools, mtl, pretty, regex-applicative, @@ -252642,8 +253250,8 @@ self: { }: mkDerivation { pname = "funcons-intgen"; - version = "0.2.0.1"; - sha256 = "12g6lizcxhvk26k3qp1k3v9dz9pz9xx004jpmipqm291r9nyiya9"; + version = "0.2.0.3"; + sha256 = "0rzyislf08ginflq7m7gjri3m5asshyfywn46fcfv4v3gnqhkmv4"; isLibrary = false; isExecutable = true; executableHaskellDepends = [ @@ -252654,7 +253262,6 @@ self: { funcons-tools funcons-values gll - iml-tools mtl pretty regex-applicative @@ -252664,11 +253271,9 @@ self: { ]; description = "Generate Funcons interpreters from CBS description files"; license = lib.licenses.mit; - hydraPlatforms = lib.platforms.none; mainProgram = "cbsc"; - broken = true; } - ) { iml-tools = null; }; + ) { }; funcons-lambda-cbv-mp = callPackage ( { @@ -254182,6 +254787,7 @@ self: { language-c-quote, lens, lsp, + lsp-test, lsp-types, mainland-pretty, megaparsec, @@ -254191,6 +254797,7 @@ self: { parallel, prettyprinter, prettyprinter-ansi-terminal, + process, process-extras, QuickCheck, random, @@ -254213,10 +254820,8 @@ self: { }: mkDerivation { pname = "futhark"; - version = "0.25.36"; - sha256 = "1wyc7pakrd2rrql3bqww9xid5w26y9ll2c35kqnpx8fwv73918j1"; - revision = "1"; - editedCabalFile = "18r45jsyk48g3y37fa7m5a5lv7bym7qrp930brqags4fjnw3ngbv"; + version = "0.25.37"; + sha256 = "0ynbbp66f6xx836zf71qfarnkmnsbm1hyk1pmk3yf4z301vz1xdh"; isLibrary = true; isExecutable = true; libraryHaskellDepends = [ @@ -254254,6 +254859,7 @@ self: { language-c-quote lens lsp + lsp-test lsp-types mainland-pretty megaparsec @@ -254263,6 +254869,7 @@ self: { parallel prettyprinter prettyprinter-ansi-terminal + process process-extras QuickCheck random @@ -254431,7 +255038,7 @@ self: { } ) { }; - futhark-server_1_3_2_0 = callPackage ( + futhark-server_1_3_3_0 = callPackage ( { mkDerivation, base, @@ -254446,10 +255053,8 @@ self: { }: mkDerivation { pname = "futhark-server"; - version = "1.3.2.0"; - sha256 = "1rpvd0z09bgnzj6npgc6ngz8par7zcda9y408yjfv5vawd9srv07"; - revision = "1"; - editedCabalFile = "1jfsv31s90prnh5gipyfa533sdivh8r2mxq0pbvq1vjbiwjqd81q"; + version = "1.3.3.0"; + sha256 = "0j45clfg1mzy06nnzbgn9gdbys0nh7d9h31gyvpa825qm44xjfdj"; libraryHaskellDepends = [ base binary @@ -255189,8 +255794,8 @@ self: { }: mkDerivation { pname = "fx"; - version = "0.11"; - sha256 = "1ibz7hxq6svlfdvmlr0hz8y43rpjs6hf1j08wrbx78vb3irb18cl"; + version = "0.11.1"; + sha256 = "0v418z9bjkh5a4m7p7fkabkdcw0ld0d8491yjxcibghzchsm0a10"; libraryHaskellDepends = [ base monad-parallel @@ -277678,6 +278283,8 @@ self: { pname = "gitrev-typed"; version = "0.1"; sha256 = "17313dgh672zw854zckp9wch7fpkwq3gsragqv7fpj82av0s4js1"; + revision = "1"; + editedCabalFile = "1x6z2ij43kzr94fnxy5gjrs0nd4wdi9i54c41mq7yy1v9qyv6fib"; libraryHaskellDepends = [ base directory @@ -292685,13 +293292,16 @@ self: { gi-gdk3, gi-gdkpixbuf, gi-glib, + gi-gobject, gi-gtk-layer-shell, gi-gtk3, + gtk-scaling-image, gtk-strut, gtk3, haskell-gi, haskell-gi-base, hslogger, + hspec, optparse-applicative, status-notifier-item, text, @@ -292701,8 +293311,8 @@ self: { }: mkDerivation { pname = "gtk-sni-tray"; - version = "0.2.0.0"; - sha256 = "1nhw7nlcghwi9rlrd55951brfi98fz7za9jhn9bnrca6yd8pkh35"; + version = "0.2.1.1"; + sha256 = "0cc7lzn19ipn69i4ggqs308ncn06w772azcgha1biqba0hv1hcsp"; isLibrary = true; isExecutable = true; libraryHaskellDepends = [ @@ -292721,7 +293331,9 @@ self: { gi-gdk3 gi-gdkpixbuf gi-glib + gi-gobject gi-gtk3 + gtk-scaling-image gtk-strut haskell-gi haskell-gi-base @@ -292748,6 +293360,11 @@ self: { text unix ]; + testHaskellDepends = [ + base + containers + hspec + ]; description = "A standalone StatusNotifierItem/AppIndicator tray"; license = lib.licenses.bsd3; badPlatforms = lib.platforms.darwin; @@ -319696,8 +320313,8 @@ self: { }: mkDerivation { pname = "hasql-postgresql-types"; - version = "0.2"; - sha256 = "10yh2mlr97w7s7gz63g5mzgcnrbadkzv59xfs99hf0rs0syckm2l"; + version = "0.2.0.1"; + sha256 = "0g1r4b98y939fkvacy9lyr9sk1mzpz5514rbgiv0g91vy0mr52ch"; libraryHaskellDepends = [ base hasql @@ -321793,6 +322410,64 @@ self: { } ) { }; + haxr_3000_11_6_1 = callPackage ( + { + mkDerivation, + array, + base, + base-compat, + base64-bytestring, + blaze-builder, + bytestring, + HaXml, + HsOpenSSL, + http-streams, + http-types, + io-streams, + mtl, + mtl-compat, + network, + network-uri, + old-locale, + old-time, + template-haskell, + text, + time, + utf8-string, + }: + mkDerivation { + pname = "haxr"; + version = "3000.11.6.1"; + sha256 = "1ldlgp22y8zs84mgp1d3q35r9rbfjrknslw0b9wjnwnzhvxb8g91"; + libraryHaskellDepends = [ + array + base + base-compat + base64-bytestring + blaze-builder + bytestring + HaXml + HsOpenSSL + http-streams + http-types + io-streams + mtl + mtl-compat + network + network-uri + old-locale + old-time + template-haskell + text + time + utf8-string + ]; + description = "XML-RPC client and server library"; + license = lib.licenses.bsd3; + hydraPlatforms = lib.platforms.none; + } + ) { }; + haxr-th = callPackage ( { mkDerivation, @@ -334126,6 +334801,8 @@ self: { pname = "hie-bios"; version = "0.18.0"; sha256 = "0bzav8ppm7mfy01d8vin67ik5jb6zld06716zy0i32c2fys6wack"; + revision = "1"; + editedCabalFile = "0y74bp7ss0z8sbirx161pc40wnl86bkflapgxxkl71m533csxqmf"; isLibrary = true; isExecutable = true; libraryHaskellDepends = [ @@ -339357,8 +340034,8 @@ self: { pname = "hledger-interest"; version = "1.6.7"; sha256 = "1jirygghw82zi8z160j45qzfcj1l89vckqr7hrv78h3f3pim6np4"; - revision = "4"; - editedCabalFile = "1h3jx1jj4spgj34mhxydg24lwv95m39f8ndy222849s5nsh6lg0n"; + revision = "5"; + editedCabalFile = "0nvvya1mrvsi5cj86fq403129isc5pz2a0982y37dk8h8l0jwrgn"; isLibrary = false; isExecutable = true; executableHaskellDepends = [ @@ -361080,6 +361757,45 @@ self: { } ) { }; + hslua-annotations = callPackage ( + { + mkDerivation, + base, + hslua-core, + hslua-marshalling, + hslua-module-path, + hslua-module-version, + hslua-packaging, + tasty, + tasty-golden, + text, + }: + mkDerivation { + pname = "hslua-annotations"; + version = "0.1.0"; + sha256 = "127jnd73f10xy24ri79q8v18v00lp98as5afdchzy1aykrxv95cw"; + libraryHaskellDepends = [ + base + hslua-core + hslua-packaging + text + ]; + testHaskellDepends = [ + base + hslua-core + hslua-marshalling + hslua-module-path + hslua-module-version + hslua-packaging + tasty + tasty-golden + text + ]; + description = "A type annotation generator for HSLua"; + license = "(MIT OR Apache-2.0)"; + } + ) { }; + hslua-classes = callPackage ( { mkDerivation, @@ -371325,6 +372041,99 @@ self: { } ) { }; + http-tower-hs = callPackage ( + { + mkDerivation, + aeson, + async, + base, + bytestring, + containers, + crypton-connection, + crypton-x509-store, + crypton-x509-system, + directory, + hs-opentelemetry-api, + hs-opentelemetry-exporter-in-memory, + hs-opentelemetry-exporter-otlp, + hs-opentelemetry-sdk, + hspec, + hspec-discover, + http-client, + http-client-tls, + http-conduit, + http-types, + process, + QuickCheck, + safe-exceptions, + stm, + testcontainers, + text, + time, + tls, + tower-hs, + unagi-chan, + unordered-containers, + uuid, + vector, + }: + mkDerivation { + pname = "http-tower-hs"; + version = "0.3.1.0"; + sha256 = "1pbi2nqrba0rirlm7nyd5fa79a1119hsnv1hd6kv1c2rarln8wvf"; + libraryHaskellDepends = [ + base + bytestring + containers + crypton-connection + crypton-x509-store + crypton-x509-system + hs-opentelemetry-api + http-client + http-client-tls + http-types + safe-exceptions + text + time + tls + tower-hs + unordered-containers + uuid + ]; + testHaskellDepends = [ + aeson + async + base + bytestring + containers + directory + hs-opentelemetry-api + hs-opentelemetry-exporter-in-memory + hs-opentelemetry-exporter-otlp + hs-opentelemetry-sdk + hspec + hspec-discover + http-client + http-client-tls + http-conduit + http-types + process + QuickCheck + stm + testcontainers + text + time + tower-hs + unagi-chan + uuid + vector + ]; + testToolDepends = [ hspec-discover ]; + description = "Composable HTTP client middleware for Haskell, built on tower-hs"; + license = lib.licenses.mit; + } + ) { }; + http-trace = callPackage ( { mkDerivation, @@ -371864,6 +372673,8 @@ self: { pname = "http2-tls"; version = "0.5.3"; sha256 = "1awhnls36h3i4qbcnjxbjipzq0qfcgzx7brb9nlnmi5p8fbz5458"; + revision = "1"; + editedCabalFile = "1iiisrk3sr97zzbzimfr4b3dcjmvpacfdj72y49hq4m47pc174hk"; isLibrary = true; isExecutable = true; libraryHaskellDepends = [ @@ -371924,8 +372735,8 @@ self: { pname = "http3"; version = "0.1.3"; sha256 = "0agb0cp5lh74vv47ryv38pk46mpiqpv659i9qqmgvigaxkl379sh"; - revision = "1"; - editedCabalFile = "0xhc36rfdcmwcp17ghfgqbv1k4ncanrf4gy9pz2g8w1sj9f2wnbs"; + revision = "2"; + editedCabalFile = "1dahwp4hmzb5khb3v1s5m2ivbm6pqbvv3m24ih44204vhcr4s0lc"; isLibrary = true; isExecutable = true; libraryHaskellDepends = [ @@ -384749,17 +385560,49 @@ self: { ihp-migrate = callPackage ( { mkDerivation, - ihp, + base, + directory, + filepath, + hasql, + hasql-transaction, + hspec, + string-conversions, + temporary, + text, with-utf8, }: mkDerivation { pname = "ihp-migrate"; - version = "1.4.0"; - sha256 = "1l4vapnqnnayfdrbrspsvjjyi2wd7jy3a081dpzyi4pwl4jdwgx8"; - isLibrary = false; + version = "1.5.0"; + sha256 = "1r2jraa85ghvswng06pza3ygnvszq360vbhanqx2707ns2abnccr"; + isLibrary = true; isExecutable = true; + libraryHaskellDepends = [ + base + directory + filepath + hasql + hasql-transaction + string-conversions + text + with-utf8 + ]; executableHaskellDepends = [ - ihp + base + directory + filepath + hasql + hasql-transaction + string-conversions + text + with-utf8 + ]; + testHaskellDepends = [ + base + directory + filepath + hspec + temporary with-utf8 ]; description = "Provides the IHP migrate binary"; @@ -385282,6 +386125,31 @@ self: { } ) { }; + ihp-zip = callPackage ( + { + mkDerivation, + base, + http-types, + ihp, + wai, + zip-archive, + }: + mkDerivation { + pname = "ihp-zip"; + version = "0.1.0"; + sha256 = "0q6qg2kr7lgf2q0rhjpnbpqapwdqni19ldk5lcp1s8q8rb7mmxrz"; + libraryHaskellDepends = [ + base + http-types + ihp + wai + zip-archive + ]; + description = "Support for making ZIP archives with IHP"; + license = lib.meta.getLicenseFromSpdxId "MIT"; + } + ) { }; + ihs = callPackage ( { mkDerivation, @@ -411364,7 +412232,7 @@ self: { } ) { }; - keter_2_3_3 = callPackage ( + keter_2_3_4 = callPackage ( { mkDerivation, aeson, @@ -411426,8 +412294,8 @@ self: { }: mkDerivation { pname = "keter"; - version = "2.3.3"; - sha256 = "1538641m3c74mgz8p2jsypiw258h94rhcdjrzkll4b7af8z3q4yy"; + version = "2.3.4"; + sha256 = "0abz4g3kg718yr68g0m2zl35n7q1ms05sb62gyyhd9rm05v10czz"; isLibrary = true; isExecutable = true; libraryHaskellDepends = [ @@ -423291,19 +424159,24 @@ self: { base, tasty, tasty-hunit, + text, }: mkDerivation { pname = "layoutz"; - version = "0.3.3.0"; - sha256 = "0ra8v9ybpx5i69g0w2r8j2xqnsq90l74ka2x8p221c134g0i7vrp"; + version = "0.3.4.0"; + sha256 = "1wkldb91mlp4sqi04bc1az7a1wpj1i0g5kqhnzycqbr2idzk7n4k"; isLibrary = true; isExecutable = true; - libraryHaskellDepends = [ base ]; + libraryHaskellDepends = [ + base + text + ]; executableHaskellDepends = [ base ]; testHaskellDepends = [ base tasty tasty-hunit + text ]; description = "Simple, beautiful CLI output"; license = lib.meta.getLicenseFromSpdxId "Apache-2.0"; @@ -436776,6 +437649,27 @@ self: { } ) { }; + live-stats = callPackage ( + { + mkDerivation, + base, + relude, + time, + }: + mkDerivation { + pname = "live-stats"; + version = "0.1.0.0"; + sha256 = "1k99vrnvrspmk826dgrhkyb6q2jjqrzsi83jwxbywfzwlfdwyw2q"; + libraryHaskellDepends = [ + base + relude + time + ]; + description = "A reusable run-time stats module"; + license = lib.licenses.bsd3; + } + ) { }; + liveplot = callPackage ( { mkDerivation, @@ -458632,13 +459526,12 @@ self: { bytestring, containers, crypton, - memory, - text, + ram, }: mkDerivation { pname = "mfmts"; - version = "1.0.0.0"; - sha256 = "1h2gr2a03gs1gy3wngq0l25bdph3xfvmhipqmzybaknjiix5mix8"; + version = "1.0.0.1"; + sha256 = "0ff8i8y6khcci1mqfjw75j3aiak9srfp3rr1hyic6w4l4js6x16i"; libraryHaskellDepends = [ array base @@ -458646,10 +459539,8 @@ self: { bytestring containers crypton - memory - text + ram ]; - doHaddock = false; description = "Implements multiformats specification"; license = lib.meta.getLicenseFromSpdxId "AGPL-3.0-or-later"; hydraPlatforms = lib.platforms.none; @@ -463442,6 +464333,36 @@ self: { } ) { }; + miso_1_9_0_0 = callPackage ( + { + mkDerivation, + base, + bytestring, + containers, + mtl, + text, + transformers, + }: + mkDerivation { + pname = "miso"; + version = "1.9.0.0"; + sha256 = "0v45pvrxwf0biywx8icq2qww8gvmy2a9k1iz0n21p14bxm2fjicx"; + revision = "1"; + editedCabalFile = "0pjvyyr7ldggx0ffzrwnrmx7xss407i0sprvpy55n9lxknzvjav0"; + libraryHaskellDepends = [ + base + bytestring + containers + mtl + text + transformers + ]; + description = "A tasty Haskell front-end web framework"; + license = lib.meta.getLicenseFromSpdxId "BSD-3-Clause"; + hydraPlatforms = lib.platforms.none; + } + ) { }; + miso-action-logger = callPackage ( { mkDerivation, @@ -463466,6 +464387,35 @@ self: { } ) { }; + miso-aeson = callPackage ( + { + mkDerivation, + aeson, + base, + containers, + miso, + scientific, + unordered-containers, + vector, + }: + mkDerivation { + pname = "miso-aeson"; + version = "0.1.0.0"; + sha256 = "0h83n38p14sr4si9z4x0ilhdmnhiz8xi7fd9g61ws3b0dcwfb917"; + libraryHaskellDepends = [ + aeson + base + containers + miso + scientific + unordered-containers + vector + ]; + description = "JSON conversion library"; + license = lib.meta.getLicenseFromSpdxId "BSD-3-Clause"; + } + ) { }; + miso-examples = callPackage ( { mkDerivation }: mkDerivation { @@ -463483,30 +464433,61 @@ self: { miso-from-html = callPackage ( { mkDerivation, - attoparsec, base, bytestring, containers, + fourmolu, + html-parse, + miso, + mtl, pretty-simple, text, }: mkDerivation { pname = "miso-from-html"; - version = "0.2.0.0"; - sha256 = "191qszlmgakpjdzg6k54kxg7c8v05jib66sk3w1aqc98j74f4yix"; - isLibrary = false; + version = "0.3.0.0"; + sha256 = "1vv4brss0cg80jxb9s0rjcpm401b2d1qh4v1k3c246x2p2g3zkvc"; + isLibrary = true; isExecutable = true; - executableHaskellDepends = [ - attoparsec + libraryHaskellDepends = [ base bytestring containers + html-parse + miso + mtl pretty-simple text ]; + executableHaskellDepends = [ + base + fourmolu + miso + text + ]; description = "Convert HTML to miso View syntax"; - license = lib.licenses.bsd3; - mainProgram = "miso-from-html"; + license = lib.meta.getLicenseFromSpdxId "BSD-3-Clause"; + } + ) { }; + + miso-optics = callPackage ( + { + mkDerivation, + base, + miso, + optics, + }: + mkDerivation { + pname = "miso-optics"; + version = "0.1.0.0"; + sha256 = "1xai6klyhxlylx6cbg5cjqa9mjx02w4hgb6k8wwpbx4jx0i44l5v"; + libraryHaskellDepends = [ + base + miso + optics + ]; + description = "An adaptor package for using miso with optics"; + license = lib.meta.getLicenseFromSpdxId "BSD-3-Clause"; } ) { }; @@ -474619,15 +475600,13 @@ self: { }: mkDerivation { pname = "mpd-current-json"; - version = "3.0.0.0"; - sha256 = "184466w92jif7266izbpb4l3i6arsg2199c70yfngsw7fvyhy2hr"; + version = "3.1.0.0"; + sha256 = "0z0yc5gy02kpdd22x77pnawlr9fcdspda138gnm1q3sn4ryq9z7a"; isLibrary = true; isExecutable = true; libraryHaskellDepends = [ aeson - aeson-pretty base - bytestring deriving-aeson libmpd text @@ -482451,8 +483430,8 @@ self: { }: mkDerivation { pname = "mysql-haskell"; - version = "1.2.1"; - sha256 = "0liw714g0jp4www7jp3v6ngsazi3fvbi685lgg49w7zm5yvfxlha"; + version = "1.2.2"; + sha256 = "1dx3rn16dbg7klabikq0d9rb3a4q954ch1rddibwk6l3g6vqm6m5"; libraryHaskellDepends = [ base binary @@ -490143,8 +491122,8 @@ self: { pname = "network-transport-quic"; version = "0.1.1"; sha256 = "1grif580mw6kp5hdgmimia8a14ydqcz1q4wj824hs3qwmxgmp44d"; - revision = "2"; - editedCabalFile = "0flm8syhran28h0a66hsrzkqsfdsr9hcjwmbw0wr6x981ldlabn8"; + revision = "3"; + editedCabalFile = "0dg1laqr0bllj41nq2dl2kd8d1icizv8p5pigsarp7jgnni5aarq"; libraryHaskellDepends = [ async base @@ -496300,8 +497279,8 @@ self: { }: mkDerivation { pname = "notion-client"; - version = "0.5.0.0"; - sha256 = "0fzvyzfl44nnm43gqdd7qpfg530ga2yjyqs6v9dqlnwlxd0080m2"; + version = "0.6.1.0"; + sha256 = "1fhdflm2y6py600i4n8na0i0y1azb9wi8c6il9jmccgs572c6gnc"; isLibrary = true; isExecutable = true; libraryHaskellDepends = [ @@ -496339,6 +497318,7 @@ self: { base bytestring containers + http-api-data http-client http-client-tls scientific @@ -509680,47 +510660,6 @@ self: { ) { }; optparse-generic = callPackage ( - { - mkDerivation, - base, - bytestring, - filepath, - Only, - optparse-applicative, - text, - time, - transformers, - transformers-compat, - void, - }: - mkDerivation { - pname = "optparse-generic"; - version = "1.5.2"; - sha256 = "0dca5q57jv4b8l1af4ywimaiw9rfrysambcghfmll4il5prm3d67"; - revision = "3"; - editedCabalFile = "0rmfwb4plak9vymdcf553ml7b5kpx81arjszwk4fsswx3mry6kif"; - isLibrary = true; - isExecutable = true; - libraryHaskellDepends = [ - base - bytestring - filepath - Only - optparse-applicative - text - time - transformers - transformers-compat - void - ]; - executableHaskellDepends = [ base ]; - description = "Auto-generate a command-line parser for your datatype"; - license = lib.licenses.bsd3; - maintainers = [ lib.maintainers.Gabriella439 ]; - } - ) { }; - - optparse-generic_1_5_3 = callPackage ( { mkDerivation, base, @@ -509755,7 +510694,6 @@ self: { executableHaskellDepends = [ base ]; description = "Auto-generate a command-line parser for your datatype"; license = lib.licenses.bsd3; - hydraPlatforms = lib.platforms.none; maintainers = [ lib.maintainers.Gabriella439 ]; } ) { }; @@ -513195,6 +514133,8 @@ self: { pname = "package-version"; version = "0.4.1"; sha256 = "116r62wk0pyp1cqhsfjsp0jchyqf5638by6vl7k3c7ylac6ki45c"; + revision = "1"; + editedCabalFile = "0y8zp2nxjsjq90q5b035g6r5k2p4gynh1wjgx7mz14kgh9qcfskm"; libraryHaskellDepends = [ base bytestring @@ -513717,6 +514657,8 @@ self: { hashable, int-cast, persist, + QuickCheck, + sandwich, text, text-show, time, @@ -513725,8 +514667,8 @@ self: { }: mkDerivation { pname = "packstream-bolt"; - version = "0.1.0.0"; - sha256 = "1ws1k7xcmdq66y5iq2lc53zx1y66r558vy06iinnq2mvsqjhlpcw"; + version = "0.1.0.1"; + sha256 = "0ixbwisx5zkdzmvkzcv951x6c67kn47f6n4f5kl6flkzjb70wpiz"; libraryHaskellDepends = [ base bytestring @@ -513740,6 +514682,15 @@ self: { unordered-containers vector ]; + testHaskellDepends = [ + base + bytestring + QuickCheck + sandwich + text + unordered-containers + vector + ]; description = "PackStream binary serialization format"; license = lib.licenses.asl20; hydraPlatforms = lib.platforms.none; @@ -522080,6 +523031,53 @@ self: { } ) { }; + password-aeson = callPackage ( + { + mkDerivation, + aeson, + base, + base-compat, + Cabal, + cabal-doctest, + doctest, + password, + password-types, + quickcheck-instances, + tasty, + tasty-quickcheck, + text, + }: + mkDerivation { + pname = "password-aeson"; + version = "0.1.0.0"; + sha256 = "18yx6n3iji3sygd4svscf31bz84gvsdsajgcasv2hdyp7v5fwzbz"; + setupHaskellDepends = [ + base + Cabal + cabal-doctest + ]; + libraryHaskellDepends = [ + aeson + base + password-types + ]; + testHaskellDepends = [ + aeson + base + base-compat + doctest + password + password-types + quickcheck-instances + tasty + tasty-quickcheck + text + ]; + description = "aeson typeclass instances for password package"; + license = lib.licenses.bsd3; + } + ) { }; + password-cli = callPackage ( { mkDerivation, @@ -522110,6 +523108,51 @@ self: { } ) { }; + password-http-api-data = callPackage ( + { + mkDerivation, + base, + base-compat, + Cabal, + cabal-doctest, + doctest, + http-api-data, + password, + password-types, + quickcheck-instances, + tasty, + tasty-quickcheck, + }: + mkDerivation { + pname = "password-http-api-data"; + version = "0.1.0.0"; + sha256 = "0gm07c9y6brgfjqcg7mcp4idgw9nzd0v89i85ahd4j9fmk9p0ch0"; + setupHaskellDepends = [ + base + Cabal + cabal-doctest + ]; + libraryHaskellDepends = [ + base + http-api-data + password-types + ]; + testHaskellDepends = [ + base + base-compat + doctest + http-api-data + password + password-types + quickcheck-instances + tasty + tasty-quickcheck + ]; + description = "http-api-data typeclass instances for password package"; + license = lib.licenses.bsd3; + } + ) { }; + password-instances = callPackage ( { mkDerivation, @@ -522171,6 +523214,53 @@ self: { } ) { }; + password-persistent = callPackage ( + { + mkDerivation, + base, + base-compat, + Cabal, + cabal-doctest, + doctest, + password, + password-types, + persistent, + quickcheck-instances, + tasty, + tasty-quickcheck, + text, + }: + mkDerivation { + pname = "password-persistent"; + version = "0.1.0.0"; + sha256 = "06803h6n1j72b8gdk39wh56mvxyf6s9f9yz0cb3pw85rlb2f1ml5"; + setupHaskellDepends = [ + base + Cabal + cabal-doctest + ]; + libraryHaskellDepends = [ + base + password-types + persistent + text + ]; + testHaskellDepends = [ + base + base-compat + doctest + password + password-types + persistent + quickcheck-instances + tasty + tasty-quickcheck + ]; + description = "persistent typeclass instances for password package"; + license = lib.licenses.bsd3; + } + ) { }; + password-types = callPackage ( { mkDerivation, @@ -528768,8 +529858,8 @@ self: { }: mkDerivation { pname = "persistent-mysql-pure"; - version = "1.0.3"; - sha256 = "145zjyyghsg9as5ymwgs18529vbkyrw5bq66574pbap13rhs82lk"; + version = "1.0.4"; + sha256 = "0w2am7667pmsmcx78mb73ymynl7xz68j3yrcnq85xixj0jqy4355"; isLibrary = true; isExecutable = true; libraryHaskellDepends = [ @@ -530682,10 +531772,8 @@ self: { }: mkDerivation { pname = "pg-schema"; - version = "0.5.2.0"; - sha256 = "06v2rbzkz4cl8ngfdv703yy9xiihk3mjxw8cgzsk30a0i552vy4v"; - isLibrary = true; - isExecutable = true; + version = "0.6.0.0"; + sha256 = "09ypr1az4sdqi19bqn9mv12h1aqiwc7brccp0hq2hyf8ys8bd61y"; libraryHaskellDepends = [ aeson base @@ -530703,18 +531791,13 @@ self: { time uuid-types ]; - executableHaskellDepends = [ - base - bytestring - directory - postgresql-simple - ]; testHaskellDepends = [ aeson base bytestring case-insensitive deepseq + directory hashable hedgehog postgresql-simple @@ -530731,7 +531814,6 @@ self: { ]; description = "Type-level definition of database schema and safe DML for PostgreSQL"; license = lib.meta.getLicenseFromSpdxId "BSD-3-Clause"; - mainProgram = "test-gen"; } ) { }; @@ -531660,8 +532742,8 @@ self: { }: mkDerivation { pname = "phino"; - version = "0.0.0.66"; - sha256 = "11rzwnrnnkmj10v5fmna1x48mqikdjgywcjsi1plk159fh5ip54n"; + version = "0.0.0.67"; + sha256 = "160lkhc47i3k0sranhjx5k0mk9w9gm8q8iwizrwdq1n8qcanp5vv"; isLibrary = true; isExecutable = true; libraryHaskellDepends = [ @@ -548204,8 +549286,8 @@ self: { }: mkDerivation { pname = "postgresql-operation-counting"; - version = "0.1.0.0"; - sha256 = "1dlqlz59na8yzzan2yiihyp27nkjkxx79gqffjr4rjfkkjpr0niq"; + version = "0.1.0.1"; + sha256 = "1mjrili534bc8jgkch5ndnam9wcfxrgccggvfnbf5fbx9wcf2krc"; libraryHaskellDepends = [ base containers @@ -549326,6 +550408,52 @@ self: { } ) { }; + postgresql-syntax_0_4_3_1 = callPackage ( + { + mkDerivation, + base, + bytestring, + case-insensitive, + hashable, + headed-megaparsec, + hedgehog, + megaparsec, + parser-combinators, + rerebase, + tasty, + tasty-hunit, + text, + text-builder, + unordered-containers, + }: + mkDerivation { + pname = "postgresql-syntax"; + version = "0.4.3.1"; + sha256 = "00hhws1krj80g8dkqgn45zkad1v15hiiahgq8h5wbdmqlap58pqd"; + libraryHaskellDepends = [ + base + bytestring + case-insensitive + hashable + headed-megaparsec + megaparsec + parser-combinators + text + text-builder + unordered-containers + ]; + testHaskellDepends = [ + hedgehog + rerebase + tasty + tasty-hunit + ]; + description = "PostgreSQL AST parsing and rendering"; + license = lib.meta.getLicenseFromSpdxId "MIT"; + hydraPlatforms = lib.platforms.none; + } + ) { }; + postgresql-transactional = callPackage ( { mkDerivation, @@ -549670,8 +550798,8 @@ self: { }: mkDerivation { pname = "postgresql-types"; - version = "0.1.3"; - sha256 = "1i9djnaxgkd4ljw2hynr8xyqvlr8acifdp1kfabmbpbx755jjkmr"; + version = "0.1.3.2"; + sha256 = "1g2209vs1k5s1f52x1zcg2864j41lr31m7kqmfrl5hysb7zfpn07"; libraryHaskellDepends = [ aeson attoparsec @@ -549740,8 +550868,8 @@ self: { }: mkDerivation { pname = "postgresql-types-algebra"; - version = "0.1"; - sha256 = "1r1s37nc6bk77r5fzva5nhil4rr99hc3wgcby00nq2rg8jfwlh3c"; + version = "0.1.0.1"; + sha256 = "0dc43j0xp1lc8cvcp2jxvyzav7x30alnr59j79hssf6yrdd3xjvs"; libraryHaskellDepends = [ attoparsec base @@ -552834,8 +553962,8 @@ self: { }: mkDerivation { pname = "prelate"; - version = "0.8.0.0"; - sha256 = "1qx4s7v5lx7bbfscnccjsh25lgxdvjr975ddqd2hsm5ls8qbag5p"; + version = "0.9.0.0"; + sha256 = "06bsz3jfi40dqnzwxka7k914y8gyy3i08naw36nsypakfgb376ag"; libraryHaskellDepends = [ aeson base @@ -560463,8 +561591,8 @@ self: { pname = "proto-lens-setup"; version = "0.4.0.9"; sha256 = "1j1cq7bdv0lgi9hzx9ncmn0vy5gykmfqg51cwzykri2k8623dcaw"; - revision = "1"; - editedCabalFile = "037zj963xfl4skfmbq47rzkmlvgx3smsgy5m5hyhz714s80lxd5p"; + revision = "2"; + editedCabalFile = "1bm9hpqw1yafp614x00yg2bjsl7rya0hq61bzb5jv2kvc01hlhh5"; libraryHaskellDepends = [ base bytestring @@ -562263,6 +563391,60 @@ self: { } ) { }; + ptr_0_16_8_8 = callPackage ( + { + mkDerivation, + base, + bytestring, + cereal, + contravariant, + criterion, + profunctors, + QuickCheck, + quickcheck-instances, + rerebase, + strict-list, + tasty, + tasty-hunit, + tasty-quickcheck, + text, + time, + vector, + }: + mkDerivation { + pname = "ptr"; + version = "0.16.8.8"; + sha256 = "041m1k68f4mwgbz0l2c8h2c849ckmj697nl7l7pq36m0sm2ff8im"; + libraryHaskellDepends = [ + base + bytestring + contravariant + profunctors + strict-list + text + time + vector + ]; + testHaskellDepends = [ + cereal + QuickCheck + quickcheck-instances + rerebase + tasty + tasty-hunit + tasty-quickcheck + ]; + benchmarkHaskellDepends = [ + cereal + criterion + rerebase + ]; + description = "Experimental abstractions for operations on pointers"; + license = lib.meta.getLicenseFromSpdxId "MIT"; + hydraPlatforms = lib.platforms.none; + } + ) { }; + ptr-peeker = callPackage ( { mkDerivation, @@ -568179,8 +569361,8 @@ self: { }: mkDerivation { pname = "quic"; - version = "0.3.0"; - sha256 = "0rqa4wq1s3s2bs2zcl7bvmiqpsb2zabvlv46w5pbijsj6aamjrx5"; + version = "0.3.1"; + sha256 = "1pfmdvfy4fy4422slsqqqmvp3sgrry8i0lfnfhpf7cy148ggl17h"; isLibrary = true; isExecutable = true; libraryHaskellDepends = [ @@ -568219,6 +569401,7 @@ self: { hspec network QuickCheck + ram tls unix-time ]; @@ -573159,8 +574342,8 @@ self: { }: mkDerivation { pname = "random-mhs"; - version = "1.3.2.1"; - sha256 = "0i7xwdpghss1r5sd3nrsfwri6x624anfsn8c8pdqy7cd9kqq179y"; + version = "1.3.2.2"; + sha256 = "15waqqimyhbgnhiyb3109cskv2qcl6y3zdjps0qpdsr6884kixkb"; libraryHaskellDepends = [ base bytestring @@ -573547,6 +574730,53 @@ self: { } ) { }; + range_0_3_1_0 = callPackage ( + { + mkDerivation, + base, + Cabal, + deepseq, + free, + parsec, + QuickCheck, + random, + tasty-bench, + test-framework, + test-framework-quickcheck2, + }: + mkDerivation { + pname = "range"; + version = "0.3.1.0"; + sha256 = "1fhxqqz1qxcx7cv8jby4wg08xfmc3sdj250s9g17c5h14b2vz377"; + libraryHaskellDepends = [ + base + deepseq + free + parsec + ]; + testHaskellDepends = [ + base + Cabal + deepseq + free + QuickCheck + random + test-framework + test-framework-quickcheck2 + ]; + benchmarkHaskellDepends = [ + base + deepseq + free + parsec + tasty-bench + ]; + description = "An efficient and versatile range library"; + license = lib.licenses.mit; + hydraPlatforms = lib.platforms.none; + } + ) { }; + range-set-list = callPackage ( { mkDerivation, @@ -578095,7 +579325,9 @@ self: { containers, deepseq, fin, + HUnit, mtl, + prettyprinter, QuickCheck, tasty, tasty-hunit, @@ -578104,14 +579336,16 @@ self: { }: mkDerivation { pname = "rebound"; - version = "0.1.1.0"; - sha256 = "0qg2z0fj79iyygdvi0dy7bcbgkffvnxxvspfdq30hlwhjw3h5zxn"; + version = "0.1.2.0"; + sha256 = "0p3cm6sdqh3q895jywk0sm7s38aw8rmxv283nx90giri5ql0r4wa"; libraryHaskellDepends = [ base containers deepseq fin + HUnit mtl + prettyprinter QuickCheck vec ]; @@ -578124,6 +579358,7 @@ self: { tasty-hunit tasty-quickcheck ]; + doHaddock = false; description = "A variable binding library based on well-scoped de Bruijn indices"; license = lib.meta.getLicenseFromSpdxId "MIT"; hydraPlatforms = lib.platforms.none; @@ -604440,7 +605675,7 @@ self: { } ) { inherit (pkgs) z3; }; - sbv_13_6 = callPackage ( + sbv_14_0 = callPackage ( { mkDerivation, array, @@ -604480,8 +605715,8 @@ self: { }: mkDerivation { pname = "sbv"; - version = "13.6"; - sha256 = "14znf1fl5ab5m1i3109qgzv8lmz17ir77bpc9cvw4s4qymq7i4k9"; + version = "14.0"; + sha256 = "05marjjn7ngh80lw5m1nkjyi2kilknbg0h1sjipbbjnsjp0bn3yr"; enableSeparateDataOutput = true; libraryHaskellDepends = [ array @@ -620899,6 +622134,74 @@ self: { } ) { }; + servant-tower-hs = callPackage ( + { + mkDerivation, + base, + bytestring, + containers, + hs-opentelemetry-api, + hs-opentelemetry-exporter-in-memory, + hs-opentelemetry-sdk, + hspec, + hspec-discover, + http-client, + http-types, + mtl, + servant, + servant-client, + servant-client-core, + servant-server, + stm, + text, + tower-hs, + unagi-chan, + uuid, + warp, + }: + mkDerivation { + pname = "servant-tower-hs"; + version = "0.1.2.0"; + sha256 = "05zrfpbm4f26m08w5an9611ymhvpbjllh8dqh72csjhf47llq66p"; + libraryHaskellDepends = [ + base + bytestring + containers + hs-opentelemetry-api + http-types + mtl + servant-client + servant-client-core + text + tower-hs + uuid + ]; + testHaskellDepends = [ + base + bytestring + hs-opentelemetry-api + hs-opentelemetry-exporter-in-memory + hs-opentelemetry-sdk + hspec + hspec-discover + http-client + http-types + servant + servant-client + servant-client-core + servant-server + stm + text + tower-hs + unagi-chan + warp + ]; + testToolDepends = [ hspec-discover ]; + description = "Use tower-hs middleware with servant clients"; + license = lib.licenses.mit; + } + ) { }; + servant-tracing = callPackage ( { mkDerivation, @@ -625903,6 +627206,7 @@ self: { { mkDerivation, base, + focus, hashable, list-t, resourcet, @@ -625913,10 +627217,11 @@ self: { }: mkDerivation { pname = "shared-resource-cache"; - version = "0.2.0.1"; - sha256 = "0grl87vbv3l72b6kkyrgbkl4gm69q119lgdvwvls857salkviy6s"; + version = "0.2.0.3"; + sha256 = "0zlqafkyfibnsmy4ks7nhm7ig588bsmbir81nmx2m5s84r4viafj"; libraryHaskellDepends = [ base + focus hashable list-t resourcet @@ -625927,6 +627232,7 @@ self: { ]; testHaskellDepends = [ base + focus hashable list-t resourcet @@ -633903,7 +635209,7 @@ self: { } ) { }; - skeletest_0_3_7 = callPackage ( + skeletest_0_4_1 = callPackage ( { mkDerivation, aeson, @@ -633912,6 +635218,7 @@ self: { base, containers, data-default, + deepseq, Diff, directory, exceptions, @@ -633924,16 +635231,18 @@ self: { pretty, process, recover-rtti, + strip-ansi-escape, template-haskell, terminal-size, text, + time, transformers, unliftio, }: mkDerivation { pname = "skeletest"; - version = "0.3.7"; - sha256 = "0jnwn3x0gmjavik130941d7qng8q4i20rjnhsminfirgp166bw6x"; + version = "0.4.1"; + sha256 = "0h2l27s9ys6m438l87im4i1ssz59zjmgqdj7r3xqi2yp6wx5cpnj"; isLibrary = true; isExecutable = true; libraryHaskellDepends = [ @@ -633942,6 +635251,7 @@ self: { ansi-terminal base containers + deepseq Diff directory exceptions @@ -633954,9 +635264,11 @@ self: { pretty process recover-rtti + strip-ansi-escape template-haskell terminal-size text + time transformers unliftio ]; @@ -633974,6 +635286,7 @@ self: { filepath process text + transformers unliftio ]; description = "Batteries-included, opinionated test framework"; @@ -637803,6 +639116,8 @@ self: { pname = "smtp-mail"; version = "0.5.0.1"; sha256 = "1xcs3k3p5p4qgr77icizk154fysf63c2cj04l4k2dz2bnzz1f9ih"; + revision = "1"; + editedCabalFile = "116i18fpizjqarn8sbqcykh5l1idd4imdq83akzrjpq9qjd00dq3"; libraryHaskellDepends = [ array base @@ -642175,6 +643490,8 @@ self: { pname = "soap-tls"; version = "0.2.0.0"; sha256 = "0bi5pwv49bx0hpsamr6nk9nxzx6b1cyq9rd8g9hbmz44v3n9kyqr"; + revision = "1"; + editedCabalFile = "150p892bj671z9fdjcsa3sqvxymdjm4bx6xi6i3i0w6vj9k5iyn8"; libraryHaskellDepends = [ base configurator @@ -644501,6 +645818,8 @@ self: { pname = "spacecookie"; version = "1.0.0.3"; sha256 = "1kzzbq22dk277jcx04w154y4vwa92zmnf40jcbgiihkz5rvisix0"; + revision = "1"; + editedCabalFile = "1krm92mx5dwcisfjqdyi93ffbdn7apr6gvd2mpczm2bw9gllyhc7"; isLibrary = true; isExecutable = true; libraryHaskellDepends = [ @@ -644554,6 +645873,90 @@ self: { } ) { }; + spacecookie_1_1_0_0 = callPackage ( + { + mkDerivation, + aeson, + async, + attoparsec, + base, + bytestring, + containers, + directory, + download-curl, + fast-logger, + file-io, + filepath, + mtl, + os-string, + process, + socket, + systemd, + tasty, + tasty-expected-failure, + tasty-hunit, + text, + unix, + utf8-string, + }: + mkDerivation { + pname = "spacecookie"; + version = "1.1.0.0"; + sha256 = "0b9qgajyy6r9pabqlpl9plh9k0hb7j3fy0cm9lf7q5zs5gx141pl"; + isLibrary = true; + isExecutable = true; + libraryHaskellDepends = [ + async + attoparsec + base + bytestring + containers + filepath + mtl + os-string + socket + text + utf8-string + ]; + executableHaskellDepends = [ + aeson + attoparsec + base + bytestring + containers + directory + fast-logger + file-io + filepath + os-string + socket + systemd + text + unix + utf8-string + ]; + testHaskellDepends = [ + attoparsec + base + bytestring + containers + directory + download-curl + filepath + os-string + process + tasty + tasty-expected-failure + tasty-hunit + ]; + description = "Gopher server library and daemon"; + license = lib.meta.getLicenseFromSpdxId "GPL-3.0-only"; + hydraPlatforms = lib.platforms.none; + mainProgram = "spacecookie"; + maintainers = [ lib.maintainers.sternenseemann ]; + } + ) { }; + spacefill = callPackage ( { mkDerivation, base }: mkDerivation { @@ -652938,6 +654341,62 @@ self: { } ) { }; + stacker = callPackage ( + { + mkDerivation, + aeson, + ansi-terminal, + base, + bytestring, + containers, + directory, + file-embed, + filepath, + optparse-applicative, + process, + tasty, + tasty-golden, + temporary, + text, + yaml, + }: + mkDerivation { + pname = "stacker"; + version = "0.0.0.0"; + sha256 = "1x9xcgyf2fc91iaj8jq9d14ivg2bim1qryxfmgfz0wriqzh6yfpc"; + isLibrary = true; + isExecutable = true; + enableSeparateDataOutput = true; + libraryHaskellDepends = [ + aeson + ansi-terminal + base + containers + directory + file-embed + filepath + optparse-applicative + process + text + yaml + ]; + executableHaskellDepends = [ base ]; + testHaskellDepends = [ + base + bytestring + directory + process + tasty + tasty-golden + temporary + text + ]; + description = "Bump snapshots in stack.yaml files"; + license = lib.meta.getLicenseFromSpdxId "BSD-3-Clause"; + mainProgram = "stacker"; + } + ) { }; + staf = callPackage ( { mkDerivation, base }: mkDerivation { @@ -654784,8 +656243,8 @@ self: { }: mkDerivation { pname = "status-notifier-item"; - version = "0.3.2.10"; - sha256 = "0xyfb1ffq8bhjc20j05myb1ijdxim030ax17xryjf2nfrxfq19hd"; + version = "0.3.2.13"; + sha256 = "046zsxxwwinqzisw7sfq6bp1a5liphq42lavfxs2rqhrw6v8gw78"; isLibrary = true; isExecutable = true; libraryHaskellDepends = [ @@ -655641,6 +657100,41 @@ self: { } ) { }; + stim-parser = callPackage ( + { + mkDerivation, + base, + containers, + HUnit, + megaparsec, + mtl, + unordered-containers, + }: + mkDerivation { + pname = "stim-parser"; + version = "0.1.0.0"; + sha256 = "1v7zd8cfklaafr9a97jrk9scxms5n0kqmmh6smdlgjb6iyzjs4rs"; + isLibrary = true; + isExecutable = true; + libraryHaskellDepends = [ + base + containers + megaparsec + mtl + unordered-containers + ]; + executableHaskellDepends = [ base ]; + testHaskellDepends = [ + base + HUnit + megaparsec + mtl + ]; + description = "A parser combinator library for STIM quantum circuit files"; + license = lib.meta.getLicenseFromSpdxId "MIT"; + } + ) { }; + stitch = callPackage ( { mkDerivation, @@ -665111,8 +666605,8 @@ self: { pname = "streamly"; version = "0.11.0"; sha256 = "1ha7rr6038k1hikfhg2bi0ican8b9yf1gcbaf82b4889wymy7xyc"; - revision = "1"; - editedCabalFile = "1h3vpy61p7ivc5cqjlpabz1z97vxf0c7npzkdwnk2jhabsl8wx2d"; + revision = "2"; + editedCabalFile = "0b7yp4ha7h2zgjhm36allq8s0a67mbk73ckx2al5d7vn1qcdm236"; libraryHaskellDepends = [ atomic-primops base @@ -665420,6 +666914,8 @@ self: { pname = "streamly-core"; version = "0.3.0"; sha256 = "1qycnqxc7icqfd2y06rg7bgymigmrcmm75q7l7m2c92ssh5rbv4q"; + revision = "1"; + editedCabalFile = "1hjdwsc0yk4z5lhvaxnv5yw70qlpccfrbm2s4di53fz4g5r80xh0"; libraryHaskellDepends = [ base containers @@ -666672,6 +668168,40 @@ self: { } ) { }; + strict-list_1_0_0_1 = callPackage ( + { + mkDerivation, + base, + deepseq, + hashable, + QuickCheck, + rerebase, + semigroupoids, + tasty, + tasty-quickcheck, + }: + mkDerivation { + pname = "strict-list"; + version = "1.0.0.1"; + sha256 = "1hz47cid0nfc9dgz5lkmsyi24zms0kzh8i39prm0xz4acmjf9zq5"; + libraryHaskellDepends = [ + base + deepseq + hashable + QuickCheck + semigroupoids + ]; + testHaskellDepends = [ + rerebase + tasty + tasty-quickcheck + ]; + description = "Strict linked list with stack-safe operations"; + license = lib.meta.getLicenseFromSpdxId "MIT"; + hydraPlatforms = lib.platforms.none; + } + ) { }; + strict-mutable-base = callPackage ( { mkDerivation, @@ -677067,6 +678597,70 @@ self: { } ) { }; + symplectic-chp = callPackage ( + { + mkDerivation, + base, + containers, + deepseq, + directory, + filepath, + finite-typelits, + hspec, + hspec-discover, + mtl, + primitive, + QuickCheck, + random, + stim-parser, + transformers, + vector, + vector-sized, + }: + mkDerivation { + pname = "symplectic-chp"; + version = "0.1.0.0"; + sha256 = "0qbcjmjv2xvknf4jhxpczk3ankm4zfzlqlg4g9lfy5yrz8jv61rv"; + isLibrary = true; + isExecutable = true; + libraryHaskellDepends = [ + base + deepseq + finite-typelits + mtl + primitive + random + transformers + vector + vector-sized + ]; + executableHaskellDepends = [ + base + containers + random + stim-parser + ]; + testHaskellDepends = [ + base + containers + directory + filepath + finite-typelits + hspec + hspec-discover + QuickCheck + random + stim-parser + vector + vector-sized + ]; + testToolDepends = [ hspec-discover ]; + description = "CHP Clifford simulator using symplectic geometry"; + license = lib.meta.getLicenseFromSpdxId "MIT"; + mainProgram = "symplectic-chp"; + } + ) { }; + symtegration = callPackage ( { mkDerivation, @@ -679992,6 +681586,7 @@ self: { gi-gtk-layer-shell, gi-gtk3, gi-pango, + gtk-scaling-image, gtk-sni-tray, gtk-strut, gtk3, @@ -680045,8 +681640,8 @@ self: { }: mkDerivation { pname = "taffybar"; - version = "6.0.0"; - sha256 = "1vk3vyms5zzs4mray4a9x90gdl700j6h7x4kayndaqwj418rvdjw"; + version = "7.0.1"; + sha256 = "1k2yfcnwms3b0v099ar9ygsx8a439mbbx6fgvpybhb1yi32fn32z"; isLibrary = true; isExecutable = true; enableSeparateDataOutput = true; @@ -680080,6 +681675,7 @@ self: { gi-gtk-layer-shell gi-gtk3 gi-pango + gtk-scaling-image gtk-sni-tray gtk-strut haskell-gi-base @@ -691945,7 +693541,6 @@ self: { { mkDerivation, aeson, - aeson-optics, async, base, bytestring, @@ -691957,24 +693552,24 @@ self: { http-types, mtl, network, - optics-core, process, random, resourcet, + scientific, tasty, tasty-discover, tasty-hspec, tasty-hunit, text, unliftio-core, + vector, }: mkDerivation { pname = "testcontainers"; - version = "0.5.2.0"; - sha256 = "0dvzp77gpmiswdnsksw1avxh9b4xn3pvk3q47kqxgvv41rhh5bnd"; + version = "0.5.3.0"; + sha256 = "121mg35z25bj7issgizzdn1icdhx6y4vkjppxcxzbrgdj8bajwp1"; libraryHaskellDepends = [ aeson - aeson-optics async base bytestring @@ -691984,13 +693579,14 @@ self: { http-types mtl network - optics-core process random resourcet + scientific tasty text unliftio-core + vector ]; testHaskellDepends = [ base @@ -700598,7 +702194,7 @@ self: { } ) { }; - time-manager_0_3_1_1 = callPackage ( + time-manager_0_3_2 = callPackage ( { mkDerivation, base, @@ -700609,8 +702205,8 @@ self: { }: mkDerivation { pname = "time-manager"; - version = "0.3.1.1"; - sha256 = "0d76m2qcvcl4pwdj82gvgag13mzsvrbby4s7iz2w6920qkyc31gd"; + version = "0.3.2"; + sha256 = "069nxlls9mswhf5xab0vnnk921a0q9v5fja72xmk170a00gfqvbp"; libraryHaskellDepends = [ base containers @@ -702035,6 +703631,8 @@ self: { pname = "timezone-olson"; version = "0.2.1"; sha256 = "10f5843sza2ikj2sg9fjhf5dhnhcidad86cdjmrj1y6zclkiqmdc"; + revision = "1"; + editedCabalFile = "07xqp89p7w1a54irxnvmzfw9lcqvwiw60ypxkiwxvawfncvnadg0"; libraryHaskellDepends = [ base binary @@ -702061,6 +703659,8 @@ self: { pname = "timezone-olson-th"; version = "0.1.0.11"; sha256 = "0lpsmjy99l1yqz23dqb31cx08wg19bd4qzfmsqzz7hfmz0dgjqsj"; + revision = "1"; + editedCabalFile = "1fji65x33ccb8hsya2ff5rzq8aayrmir7vb40xkpmw826zpq5h7x"; libraryHaskellDepends = [ base template-haskell @@ -702084,8 +703684,8 @@ self: { pname = "timezone-series"; version = "0.1.13"; sha256 = "18n6w7jxwlysq5mvb1sp1z57nyrsgn2ans642fy5rhmpwcavgvr8"; - revision = "1"; - editedCabalFile = "1ak05p8z1q2nispv1xw32j7lhfmf3sfj2ibjrxpm347s37fmxnwc"; + revision = "2"; + editedCabalFile = "04j9priqhfjcglp5b02spqd8mdj52kglr4hhq84qr6r2ggv01s7l"; libraryHaskellDepends = [ base deepseq @@ -702431,6 +704031,33 @@ self: { } ) { }; + tinycheck = callPackage ( + { + mkDerivation, + base, + generics-sop, + tagged, + tasty, + }: + mkDerivation { + pname = "tinycheck"; + version = "0.1.0.0"; + sha256 = "02gng1g39x28hy3r7l81fdabanhbd5vhwyam8d0p9pk788kz33r2"; + libraryHaskellDepends = [ + base + generics-sop + tagged + tasty + ]; + testHaskellDepends = [ + base + tasty + ]; + description = "A lightweight enumeration-based property testing library"; + license = lib.meta.getLicenseFromSpdxId "BSD-3-Clause"; + } + ) { }; + tinyfiledialogs = callPackage ( { mkDerivation, @@ -703612,7 +705239,7 @@ self: { } ) { }; - tls_2_3_0 = callPackage ( + tls_2_4_0 = callPackage ( { mkDerivation, async, @@ -703633,6 +705260,7 @@ self: { hpke, hspec, hspec-discover, + mlkem, mtl, network, network-run, @@ -703648,8 +705276,8 @@ self: { }: mkDerivation { pname = "tls"; - version = "2.3.0"; - sha256 = "1zjnzj12y1mc5l0ibgc549iwasp6wp2azcgv4n0927yjrayd8gx3"; + version = "2.4.0"; + sha256 = "1fjk7zgs5rags501js91g4skyar2ncp730a3lsn2nisjaqzliwlj"; isLibrary = true; isExecutable = true; libraryHaskellDepends = [ @@ -703666,6 +705294,7 @@ self: { data-default ech-config hpke + mlkem mtl network ram @@ -703687,6 +705316,7 @@ self: { ech-config hspec QuickCheck + ram serialise time-hourglass ]; @@ -703857,6 +705487,8 @@ self: { pname = "tls-session-manager"; version = "0.1.0"; sha256 = "07mxdw9rh74m7l3z1ibwc490kn093w1xhbdm6qi1qfnkz1b199r9"; + revision = "1"; + editedCabalFile = "1m2lv0fqznizwiv9kkrybvih9g1dfahbs8l9cvy5knhiv2jkdfnm"; libraryHaskellDepends = [ auto-update base @@ -704258,6 +705890,86 @@ self: { } ) { }; + tmp-proc_0_7_2_6 = callPackage ( + { + mkDerivation, + async, + base, + bytestring, + crypton-connection, + data-default, + directory, + filepath, + fmt, + hspec, + http-client, + http-client-tls, + http-types, + mtl, + mustache, + network, + process, + random, + temporary, + test-certs, + text, + tls, + unix, + unliftio, + wai, + warp, + warp-tls, + }: + mkDerivation { + pname = "tmp-proc"; + version = "0.7.2.6"; + sha256 = "1rr7mc204m23f83py01ahl9ackscp7b5s5h1zahhjfdfax1rn4wd"; + isLibrary = true; + isExecutable = true; + enableSeparateDataOutput = true; + libraryHaskellDepends = [ + async + base + bytestring + fmt + mtl + network + process + random + text + tls + unliftio + wai + warp + warp-tls + ]; + testHaskellDepends = [ + base + bytestring + crypton-connection + data-default + directory + filepath + hspec + http-client + http-client-tls + http-types + mustache + temporary + test-certs + text + tls + unix + wai + warp + warp-tls + ]; + description = "Run 'tmp' processes in integration tests"; + license = lib.meta.getLicenseFromSpdxId "BSD-3-Clause"; + hydraPlatforms = lib.platforms.none; + } + ) { }; + tmp-proc-example = callPackage ( { mkDerivation, @@ -706963,6 +708675,60 @@ self: { } ) { }; + tower-hs = callPackage ( + { + mkDerivation, + async, + base, + bytestring, + hedis, + hs-opentelemetry-api, + hspec, + hspec-discover, + process, + profunctors, + QuickCheck, + stm, + testcontainers, + text, + time, + transformers, + }: + mkDerivation { + pname = "tower-hs"; + version = "0.3.0.1"; + sha256 = "17g1zrcmvidnla8475hd2964p1qrvpamibrlr92rvbz82f20h8wm"; + libraryHaskellDepends = [ + async + base + hs-opentelemetry-api + profunctors + stm + text + time + transformers + ]; + testHaskellDepends = [ + async + base + bytestring + hedis + hs-opentelemetry-api + hspec + hspec-discover + process + QuickCheck + stm + testcontainers + text + time + ]; + testToolDepends = [ hspec-discover ]; + description = "Composable service middleware for Haskell, inspired by Rust's Tower"; + license = lib.licenses.mit; + } + ) { }; + toxcore = callPackage ( { mkDerivation, @@ -731430,8 +733196,8 @@ self: { }: mkDerivation { pname = "variant"; - version = "1.0.1"; - sha256 = "0c3c10il82php0nn9f9j6lcim27hyg8dq3bw4iqxdc3zj34plazs"; + version = "1.0.2"; + sha256 = "18nwggg8lyybfzj8ag2k2vjrf26srjqc3rp7sfb3syridcqmrwxg"; libraryHaskellDepends = [ base deepseq @@ -738368,8 +740134,8 @@ self: { }: mkDerivation { pname = "wai-control"; - version = "0.2.0.0"; - sha256 = "091plz38ixm4h54hycgyz5g24h2w1wg25bqsbsfyjyhjjzh4a150"; + version = "0.2.0.1"; + sha256 = "10qmq4yhfs080gg8j9fi77jy9mscd0zxccnfir0yyggjzlkir6fg"; libraryHaskellDepends = [ base unliftio-core @@ -740626,6 +742392,101 @@ self: { } ) { }; + wai-middleware-delegate_0_2_0_2 = callPackage ( + { + mkDerivation, + async, + base, + blaze-builder, + bytestring, + bytestring-lexing, + case-insensitive, + conduit, + conduit-extra, + crypton-connection, + data-default, + directory, + filepath, + fmt, + hspec, + hspec-tmp-proc, + http-client, + http-client-tls, + http-types, + network, + random, + resourcet, + streaming-commons, + temporary, + test-certs, + text, + tmp-proc, + unix, + vault, + wai, + wai-conduit, + warp, + warp-tls, + }: + mkDerivation { + pname = "wai-middleware-delegate"; + version = "0.2.0.2"; + sha256 = "1jkhfak7fxf782q5azyyl1zmgpa0kd05x5l2vz9mvb3yk85n4wfv"; + libraryHaskellDepends = [ + async + base + blaze-builder + bytestring + case-insensitive + conduit + conduit-extra + http-client + http-client-tls + http-types + streaming-commons + text + wai + wai-conduit + ]; + testHaskellDepends = [ + async + base + blaze-builder + bytestring + bytestring-lexing + case-insensitive + conduit + conduit-extra + crypton-connection + data-default + directory + filepath + fmt + hspec + hspec-tmp-proc + http-client + http-client-tls + http-types + network + random + resourcet + temporary + test-certs + text + tmp-proc + unix + vault + wai + wai-conduit + warp + warp-tls + ]; + description = "WAI middleware that delegates handling of requests"; + license = lib.meta.getLicenseFromSpdxId "BSD-3-Clause"; + hydraPlatforms = lib.platforms.none; + } + ) { }; + wai-middleware-etag = callPackage ( { mkDerivation, @@ -743875,8 +745736,8 @@ self: { pname = "warp-tls"; version = "3.4.13"; sha256 = "0xxcd5202qcvd1jkiaj85gd8r3www3p7mxwf2j92awvg75jh9lsi"; - revision = "2"; - editedCabalFile = "00ff52l030bhc49yclngjkn6p17zv28ycyxkdpmaiic1cipzbkaa"; + revision = "3"; + editedCabalFile = "12sx6yvy7379kq1nainlzn1wmvsxnc6rpcp2aqpmwszxzc6a3m6x"; libraryHaskellDepends = [ base bytestring @@ -745386,70 +747247,6 @@ self: { ) { }; web-rep = callPackage ( - { - mkDerivation, - async, - base, - bifunctors, - box, - box-socket, - bytestring, - flatparse, - markup-parse, - mtl, - optics-core, - optics-extra, - optparse-applicative, - profunctors, - scotty, - text, - transformers, - unordered-containers, - wai-middleware-static, - wai-websockets, - websockets, - }: - mkDerivation { - pname = "web-rep"; - version = "0.14.0.1"; - sha256 = "1ws7hyk85jwzpy6dvq7giryq8i3d04xxn4px66jlfg9pi1b1rz1x"; - isLibrary = true; - isExecutable = true; - libraryHaskellDepends = [ - async - base - bifunctors - box - box-socket - bytestring - flatparse - markup-parse - mtl - optics-core - optics-extra - profunctors - scotty - text - transformers - unordered-containers - wai-middleware-static - wai-websockets - websockets - ]; - executableHaskellDepends = [ - base - box - markup-parse - optics-core - optparse-applicative - ]; - description = "representations of a web page"; - license = lib.meta.getLicenseFromSpdxId "BSD-3-Clause"; - mainProgram = "web-rep-example"; - } - ) { }; - - web-rep_0_14_1_0 = callPackage ( { mkDerivation, async, @@ -745509,7 +747306,6 @@ self: { ]; description = "representations of a web page"; license = lib.meta.getLicenseFromSpdxId "BSD-3-Clause"; - hydraPlatforms = lib.platforms.none; mainProgram = "web-rep-example"; } ) { }; @@ -752013,6 +753809,49 @@ self: { } ) { }; + witch_1_3_1_0 = callPackage ( + { + mkDerivation, + base, + bytestring, + containers, + HUnit, + tagged, + template-haskell, + text, + time, + transformers, + }: + mkDerivation { + pname = "witch"; + version = "1.3.1.0"; + sha256 = "15pkybgf02cjrigj0n9r4yjrir3py4ap8chhqm9r3snpzy1a5jsd"; + libraryHaskellDepends = [ + base + bytestring + containers + tagged + template-haskell + text + time + ]; + testHaskellDepends = [ + base + bytestring + containers + HUnit + tagged + text + time + transformers + ]; + description = "Convert values from one type into another"; + license = lib.meta.getLicenseFromSpdxId "MIT"; + hydraPlatforms = lib.platforms.none; + maintainers = [ lib.maintainers.maralorn ]; + } + ) { }; + _with = callPackage ( { mkDerivation }: mkDerivation { @@ -753659,8 +755498,8 @@ self: { }: mkDerivation { pname = "wordify"; - version = "0.6.0.0"; - sha256 = "16gqsp7krynnn35qvv821959yl5mh1lrhz7dxsfvdaib10cxfwlj"; + version = "0.7.0.0"; + sha256 = "1cvf00c4lrkl8759w05ng70408dh2cagazydla7knxiypc71k1wd"; isLibrary = true; isExecutable = true; libraryHaskellDepends = [ @@ -754832,6 +756671,130 @@ self: { } ) { }; + wreq_0_5_4_5 = callPackage ( + { + mkDerivation, + aeson, + aeson-pretty, + attoparsec, + authenticate-oauth, + base, + base16-bytestring, + base64-bytestring, + bytestring, + Cabal, + cabal-doctest, + case-insensitive, + containers, + crypton, + directory, + doctest, + exceptions, + filepath, + hashable, + http-client, + http-client-tls, + http-types, + HUnit, + lens, + lens-aeson, + mime-types, + network-info, + psqueues, + QuickCheck, + ram, + snap-core, + snap-server, + template-haskell, + temporary, + test-framework, + test-framework-hunit, + test-framework-quickcheck2, + text, + time, + time-locale-compat, + transformers, + unix-compat, + unordered-containers, + uuid, + vector, + }: + mkDerivation { + pname = "wreq"; + version = "0.5.4.5"; + sha256 = "1gpxksm8idq75lwkqwgzkq3fszaas59xlwi3na1q7ck4wxjlqap8"; + isLibrary = true; + isExecutable = true; + setupHaskellDepends = [ + base + Cabal + cabal-doctest + ]; + libraryHaskellDepends = [ + aeson + attoparsec + authenticate-oauth + base + base16-bytestring + bytestring + case-insensitive + containers + crypton + exceptions + hashable + http-client + http-client-tls + http-types + lens + lens-aeson + mime-types + psqueues + ram + template-haskell + text + time + time-locale-compat + unordered-containers + ]; + testHaskellDepends = [ + aeson + aeson-pretty + base + base64-bytestring + bytestring + case-insensitive + containers + directory + doctest + filepath + hashable + http-client + http-types + HUnit + lens + lens-aeson + network-info + QuickCheck + snap-core + snap-server + temporary + test-framework + test-framework-hunit + test-framework-quickcheck2 + text + time + transformers + unix-compat + unordered-containers + uuid + vector + ]; + description = "An easy-to-use HTTP client library"; + license = lib.meta.getLicenseFromSpdxId "BSD-3-Clause"; + hydraPlatforms = lib.platforms.none; + } + ) { }; + wreq-effectful = callPackage ( { mkDerivation, @@ -771791,6 +773754,50 @@ self: { } ) { }; + yesod-vite = callPackage ( + { + mkDerivation, + aeson, + base, + blaze-html, + bytestring, + containers, + hspec, + HUnit, + text, + yesod-core, + yesod-static, + yesod-test, + }: + mkDerivation { + pname = "yesod-vite"; + version = "0.1.0.0"; + sha256 = "0agqdbmyyhhqyf6ycbn3ry03rz4lg3jmq0a44zs7h3m4n7l0z5xf"; + libraryHaskellDepends = [ + aeson + base + bytestring + containers + text + yesod-core + yesod-static + ]; + testHaskellDepends = [ + base + blaze-html + bytestring + hspec + HUnit + text + yesod-core + yesod-static + yesod-test + ]; + description = "An integration of vitejs with Yesod"; + license = lib.meta.getLicenseFromSpdxId "BSD-2-Clause"; + } + ) { }; + yesod-websockets = callPackage ( { mkDerivation, @@ -777837,8 +779844,8 @@ self: { }: mkDerivation { pname = "zwirn"; - version = "0.2.2.0"; - sha256 = "1sxb21fz53h5l6hm1lab9w7y4j3k8i1cg9ccbyq10hqgj84xdkvc"; + version = "0.2.2.1"; + sha256 = "1588djfl7vh1bz2r4cjhsw82xyx9f30y04fjbrzl06hfzi1yy25a"; isLibrary = false; isExecutable = true; libraryHaskellDepends = [ From 2aba6ba2d6c7a45ceab658e923cae129e59f7242 Mon Sep 17 00:00:00 2001 From: sternenseemann Date: Fri, 10 Apr 2026 20:55:21 +0200 Subject: [PATCH 49/52] hledger-interest: drop obsolete override --- pkgs/development/haskell-modules/configuration-common.nix | 4 ---- 1 file changed, 4 deletions(-) diff --git a/pkgs/development/haskell-modules/configuration-common.nix b/pkgs/development/haskell-modules/configuration-common.nix index d697c47aed3f..1eb9382486e5 100644 --- a/pkgs/development/haskell-modules/configuration-common.nix +++ b/pkgs/development/haskell-modules/configuration-common.nix @@ -1694,10 +1694,6 @@ with haskellLib; }) ] super.hledger-web; - # Allow hledger 1.52 - # https://github.com/peti/hledger-interest/issues/27 - hledger-interest = doJailbreak super.hledger-interest; - # Chart-tests needs and compiles some modules from Chart itself Chart-tests = overrideCabal (old: { # 2025-02-13: Too strict bounds on lens < 5.3 and vector < 0.13 From 9af66e9a80757d102cd154544dbce5f6993a436a Mon Sep 17 00:00:00 2001 From: Wolfgang Walther Date: Sun, 12 Apr 2026 16:07:11 +0200 Subject: [PATCH 50/52] haskellPackages: regenerate hackage-packages.nix --- .../configuration-hackage2nix/transitive-broken.yaml | 10 ++++++---- pkgs/development/haskell-modules/hackage-packages.nix | 9 ++++++--- 2 files changed, 12 insertions(+), 7 deletions(-) diff --git a/pkgs/development/haskell-modules/configuration-hackage2nix/transitive-broken.yaml b/pkgs/development/haskell-modules/configuration-hackage2nix/transitive-broken.yaml index 3f3436e74086..37f4938fab42 100644 --- a/pkgs/development/haskell-modules/configuration-hackage2nix/transitive-broken.yaml +++ b/pkgs/development/haskell-modules/configuration-hackage2nix/transitive-broken.yaml @@ -13,8 +13,6 @@ dont-distribute-packages: - ac-machine-conduit - accelerate-arithmetic - accelerate-fourier - - accelerate-llvm - - accelerate-llvm-native - accelerate-typelits - access-token-provider - acme-circular-containers @@ -356,6 +354,7 @@ dont-distribute-packages: - cabal2arch - cabalmdvrpm - cabalrpmdeps + - cadence - caffegraph - cake - cakyrespa @@ -569,7 +568,6 @@ dont-distribute-packages: - constraint-reflection - constructible - container - - containers-accelerate - content-store - control - control-invariants @@ -629,6 +627,7 @@ dont-distribute-packages: - CSPM-Interpreter - CSPM-ToProlog - cspmchecker + - css-class-bindings - csv-enumerator - ctpl - cube @@ -1044,6 +1043,7 @@ dont-distribute-packages: - ftshell - funbot - funbot-git-hook + - funcons-intgen - funcons-lambda-cbv-mp - funcons-simple - function-combine @@ -1691,6 +1691,7 @@ dont-distribute-packages: - http-client-rustls - http-enumerator - http-response-decoder + - http-tower-hs - http2-client-grpc - http2-grpc-proto-lens - http2-grpc-proto3-wire @@ -1775,12 +1776,12 @@ dont-distribute-packages: - ihp-ide - ihp-job-dashboard - ihp-mail - - ihp-migrate - ihp-schema-compiler - ihp-sitemap - ihp-ssc - ihp-typed-sql - ihp-welcome + - ihp-zip - ihttp - imap - imbib @@ -3108,6 +3109,7 @@ dont-distribute-packages: - servant-streaming-docs - servant-streaming-server - servant-swagger-tags + - servant-tower-hs - servant-util-beam-pg - servant-waargonaut - servant-zeppelin-client diff --git a/pkgs/development/haskell-modules/hackage-packages.nix b/pkgs/development/haskell-modules/hackage-packages.nix index 704d0418575a..33ca5ce1d9cf 100644 --- a/pkgs/development/haskell-modules/hackage-packages.nix +++ b/pkgs/development/haskell-modules/hackage-packages.nix @@ -51237,7 +51237,6 @@ self: { doHaddock = false; description = "Accelerate backend component generating LLVM IR"; license = lib.meta.getLicenseFromSpdxId "BSD-3-Clause"; - hydraPlatforms = lib.platforms.none; } ) { }; @@ -51315,7 +51314,6 @@ self: { ]; description = "Accelerate backend for multicore CPUs"; license = lib.meta.getLicenseFromSpdxId "BSD-3-Clause"; - hydraPlatforms = lib.platforms.none; } ) { }; @@ -129955,6 +129953,7 @@ self: { ]; description = "An ECS-based 2D game framework"; license = lib.meta.getLicenseFromSpdxId "BSD-3-Clause"; + hydraPlatforms = lib.platforms.none; } ) { }; @@ -175666,6 +175665,7 @@ self: { testToolDepends = [ tasty-discover ]; description = "generates Haskell bindings for CSS classes"; license = lib.meta.getLicenseFromSpdxId "BSD-3-Clause"; + hydraPlatforms = lib.platforms.none; } ) { }; @@ -253271,6 +253271,7 @@ self: { ]; description = "Generate Funcons interpreters from CBS description files"; license = lib.licenses.mit; + hydraPlatforms = lib.platforms.none; mainProgram = "cbsc"; } ) { }; @@ -372131,6 +372132,7 @@ self: { testToolDepends = [ hspec-discover ]; description = "Composable HTTP client middleware for Haskell, built on tower-hs"; license = lib.licenses.mit; + hydraPlatforms = lib.platforms.none; } ) { }; @@ -385607,7 +385609,6 @@ self: { ]; description = "Provides the IHP migrate binary"; license = lib.meta.getLicenseFromSpdxId "MIT"; - hydraPlatforms = lib.platforms.none; mainProgram = "migrate"; maintainers = [ lib.maintainers.mpscholten ]; } @@ -386147,6 +386148,7 @@ self: { ]; description = "Support for making ZIP archives with IHP"; license = lib.meta.getLicenseFromSpdxId "MIT"; + hydraPlatforms = lib.platforms.none; } ) { }; @@ -622199,6 +622201,7 @@ self: { testToolDepends = [ hspec-discover ]; description = "Use tower-hs middleware with servant clients"; license = lib.licenses.mit; + hydraPlatforms = lib.platforms.none; } ) { }; From c7e1be87d27d8095b1b7c9fe6ab8e842fd358ca7 Mon Sep 17 00:00:00 2001 From: Wolfgang Walther Date: Sun, 12 Apr 2026 16:00:56 +0200 Subject: [PATCH 51/52] futhark: fix build --- .../haskell-modules/configuration-common.nix | 14 ++++++++ .../configuration-hackage2nix/main.yaml | 1 - .../haskell-modules/hackage-packages.nix | 34 ------------------- 3 files changed, 14 insertions(+), 35 deletions(-) diff --git a/pkgs/development/haskell-modules/configuration-common.nix b/pkgs/development/haskell-modules/configuration-common.nix index 1eb9382486e5..2ba1b629be0f 100644 --- a/pkgs/development/haskell-modules/configuration-common.nix +++ b/pkgs/development/haskell-modules/configuration-common.nix @@ -193,6 +193,20 @@ with haskellLib; # First to upgrade to lsp >= 2.8 while HLS hasn't yet had a compatible release futhark = super.futhark.override { lsp = self.lsp_2_8_0_0; + lsp-test = + overrideCabal + (old: { + testTargets = [ + "tests" + "func-test" + ]; + }) + ( + self.lsp-test_0_18_0_0.override { + lsp = self.lsp_2_8_0_0; + lsp-types = self.lsp-types_2_4_0_0; + } + ); lsp-types = self.lsp-types_2_4_0_0; }; diff --git a/pkgs/development/haskell-modules/configuration-hackage2nix/main.yaml b/pkgs/development/haskell-modules/configuration-hackage2nix/main.yaml index 6794a86fc302..9bcbcae3953c 100644 --- a/pkgs/development/haskell-modules/configuration-hackage2nix/main.yaml +++ b/pkgs/development/haskell-modules/configuration-hackage2nix/main.yaml @@ -32,7 +32,6 @@ default-package-overrides: # 2025-12-26: Needs to match egison-pattern-src from Stackage LTS - egison-pattern-src-th-mode < 0.2.2 - extensions == 0.1.0.2 # matches Cabal 3.12 (GHC 9.10) - - futhark-server == 1.3.0.0 # required by futhark-0.25.36 # 2026-01-30: Needs to match hasql from Stackage LTS 24 - hasql-notifications < 0.2.5.0 # 2026-02-04: as requested by ghcide >= 2.13 diff --git a/pkgs/development/haskell-modules/hackage-packages.nix b/pkgs/development/haskell-modules/hackage-packages.nix index 33ca5ce1d9cf..d973d37571e4 100644 --- a/pkgs/development/haskell-modules/hackage-packages.nix +++ b/pkgs/development/haskell-modules/hackage-packages.nix @@ -255007,39 +255007,6 @@ self: { ) { }; futhark-server = callPackage ( - { - mkDerivation, - base, - binary, - bytestring, - directory, - futhark-data, - mtl, - process, - temporary, - text, - }: - mkDerivation { - pname = "futhark-server"; - version = "1.3.0.0"; - sha256 = "1v8c5zfsc6x48z31lrfcyibbj4742cql3lglg6l59ly39cxi4and"; - libraryHaskellDepends = [ - base - binary - bytestring - directory - futhark-data - mtl - process - temporary - text - ]; - description = "Client implementation of the Futhark server protocol"; - license = lib.meta.getLicenseFromSpdxId "ISC"; - } - ) { }; - - futhark-server_1_3_3_0 = callPackage ( { mkDerivation, base, @@ -255069,7 +255036,6 @@ self: { ]; description = "Client implementation of the Futhark server protocol"; license = lib.meta.getLicenseFromSpdxId "ISC"; - hydraPlatforms = lib.platforms.none; } ) { }; From 9a998f52f808f59eb6bee78963db8a8518979e85 Mon Sep 17 00:00:00 2001 From: Wolfgang Walther Date: Sun, 12 Apr 2026 17:37:23 +0200 Subject: [PATCH 52/52] haskellPackages: mark builds failing on hydra as broken This commit has been generated by maintainers/scripts/haskell/mark-broken.sh based on *evaluation [1824411](https://hydra.nixos.org/eval/1824411) of nixpkgs commit [c7e1be8](https://github.com/NixOS/nixpkgs/commits/c7e1be87d27d8095b1b7c9fe6ab8e842fd358ca7) as of 2026-04-12 15:33 UTC* from the haskell-updates jobset on hydra under https://hydra.nixos.org/jobset/nixpkgs/haskell-updates --- .../configuration-hackage2nix/broken.yaml | 38 +++++++++ .../transitive-broken.yaml | 7 ++ .../haskell-modules/hackage-packages.nix | 83 +++++++++++++++++++ 3 files changed, 128 insertions(+) diff --git a/pkgs/development/haskell-modules/configuration-hackage2nix/broken.yaml b/pkgs/development/haskell-modules/configuration-hackage2nix/broken.yaml index 2d8e0d095cdf..051d710ddee5 100644 --- a/pkgs/development/haskell-modules/configuration-hackage2nix/broken.yaml +++ b/pkgs/development/haskell-modules/configuration-hackage2nix/broken.yaml @@ -275,6 +275,7 @@ broken-packages: - asset-map # failure in job https://hydra.nixos.org/build/233218566 at 2023-09-02 - assoc-list # failure in job https://hydra.nixos.org/build/233224148 at 2023-09-02 - assoc-listlike # failure in job https://hydra.nixos.org/build/233200483 at 2023-09-02 + - associative # failure in job https://hydra.nixos.org/build/325265084 at 2026-04-12 - assumpta # failure in job https://hydra.nixos.org/build/233245580 at 2023-09-02 - assumpta-core # failure in job https://hydra.nixos.org/build/252727584 at 2024-03-16 - ast-monad # failure in job https://hydra.nixos.org/build/233192822 at 2023-09-02 @@ -797,6 +798,7 @@ broken-packages: - check-cfg-ambiguity # failure in job https://hydra.nixos.org/build/233251852 at 2023-09-02 - checked # failure in job https://hydra.nixos.org/build/233223182 at 2023-09-02 - Checked # failure in job https://hydra.nixos.org/build/233257598 at 2023-09-02 + - checked-literals # failure in job https://hydra.nixos.org/build/326308168 at 2026-04-12 - checkmate # failure in job https://hydra.nixos.org/build/233248012 at 2023-09-02 - chell-quickcheck # won't support QuickCheck >= 2.15 https://github.com/typeclasses/chell/issues/5#issuecomment-3152262118 - chessica # failure in job https://hydra.nixos.org/build/307517327 at 2025-09-19 @@ -1369,6 +1371,7 @@ broken-packages: - dhscanner-bitcode # failure in job https://hydra.nixos.org/build/270090641 at 2024-08-31 - dia-base # failure in job https://hydra.nixos.org/build/233230896 at 2023-09-02 - diagnose # failure in job https://hydra.nixos.org/build/233231767 at 2023-09-02 + - diagnostician # failure in job https://hydra.nixos.org/build/326308198 at 2026-04-12 - diagrams-boolean # failure in job https://hydra.nixos.org/build/233202036 at 2023-09-02 - diagrams-haddock # failure in job https://hydra.nixos.org/build/295092844 at 2025-04-22 - diagrams-pdf # failure in job https://hydra.nixos.org/build/233197864 at 2023-09-02 @@ -1711,6 +1714,7 @@ broken-packages: - eventloop # failure in job https://hydra.nixos.org/build/295093203 at 2025-04-22 - eventsource-api # failure in job https://hydra.nixos.org/build/233243220 at 2023-09-02 - eventsourced # failure in job https://hydra.nixos.org/build/233192731 at 2023-09-02 + - eventsourcing # failure in job https://hydra.nixos.org/build/325266425 at 2026-04-12 - eventstore # failure in job https://hydra.nixos.org/build/233202734 at 2023-09-02 - eventuo11y # failure in job https://hydra.nixos.org/build/252711747 at 2024-03-16 - eventuo11y-dsl # failure in job https://hydra.nixos.org/build/252711345 at 2024-03-16 @@ -1827,6 +1831,7 @@ broken-packages: - feed-crawl # failure in job https://hydra.nixos.org/build/233227566 at 2023-09-02 - feedback # failure in job https://hydra.nixos.org/build/295093247 at 2025-04-22 - fei-cocoapi # failure in job https://hydra.nixos.org/build/252726625 at 2024-03-16 + - feldspar-language # failure in job https://hydra.nixos.org/build/326308211 at 2026-04-12 - fenfire # failure in job https://hydra.nixos.org/build/233254038 at 2023-09-02 - fernet # failure in job https://hydra.nixos.org/build/233228830 at 2023-09-02 - FerryCore # failure in job https://hydra.nixos.org/build/233198667 at 2023-09-02 @@ -2055,6 +2060,7 @@ broken-packages: - fvars # failure in job https://hydra.nixos.org/build/234461649 at 2023-09-13 - fwgl # failure in job https://hydra.nixos.org/build/233246210 at 2023-09-02 - fwgl-javascript # broken by fwgl, manually entered here, because it does not appear in transitive-broken.yaml at 2024-07-09 + - fx # failure in job https://hydra.nixos.org/build/326308215 at 2026-04-12 - fxpak # failure in job https://hydra.nixos.org/build/309813706 at 2025-10-15 - g-npm # failure in job https://hydra.nixos.org/build/233215965 at 2023-09-02 - g4ip # failure in job https://hydra.nixos.org/build/233248315 at 2023-09-02 @@ -2114,6 +2120,7 @@ broken-packages: - GenSmsPdu # failure in job https://hydra.nixos.org/build/253702098 at 2024-03-31 - gentlemark # failure in job https://hydra.nixos.org/build/233202158 at 2023-09-02 - genvalidity-appendful # failure in job https://hydra.nixos.org/build/295093519 at 2025-04-22 + - genvalidity-hspec-hashable # failure in job https://hydra.nixos.org/build/325266754 at 2026-04-12 - genvalidity-mergeful # failure in job https://hydra.nixos.org/build/295093508 at 2025-04-22 - geo-resolver # failure in job https://hydra.nixos.org/build/233206563 at 2023-09-02 - geo-uk # failure in job https://hydra.nixos.org/build/233221284 at 2023-09-02 @@ -2425,6 +2432,7 @@ broken-packages: - hakyll-contrib-elm # failure in job https://hydra.nixos.org/build/233234686 at 2023-09-02 - hakyll-contrib-i18n # failure in job https://hydra.nixos.org/build/233218608 at 2023-09-02 - hakyll-contrib-links # failure in job https://hydra.nixos.org/build/233218456 at 2023-09-02 + - hakyll-diagrams # failure in job https://hydra.nixos.org/build/326308228 at 2026-04-12 - hakyll-dir-list # failure in job https://hydra.nixos.org/build/233221518 at 2023-09-02 - hakyll-process # failure in job https://hydra.nixos.org/build/295094014 at 2025-04-22 - hakyll-R # failure in job https://hydra.nixos.org/build/233230132 at 2023-09-02 @@ -2484,6 +2492,7 @@ broken-packages: - HaPy # failure in job https://hydra.nixos.org/build/233256693 at 2023-09-02 - haquery # failure in job https://hydra.nixos.org/build/233216714 at 2023-09-02 - harchive # failure in job https://hydra.nixos.org/build/233259819 at 2023-09-02 + - hardware-edsl # failure in job https://hydra.nixos.org/build/326308229 at 2026-04-12 - harfbuzz-pure # failure in job https://hydra.nixos.org/build/237235780 at 2023-10-21 - harg # failure in job https://hydra.nixos.org/build/233232453 at 2023-09-02 - HARM # failure in job https://hydra.nixos.org/build/233232650 at 2023-09-02 @@ -2543,6 +2552,7 @@ broken-packages: - haskell-go-checkers # failure in job https://hydra.nixos.org/build/234459896 at 2023-09-13 - haskell-halogen-core # failure in job https://hydra.nixos.org/build/299138362 at 2025-06-23 - haskell-holes-th # failure in job https://hydra.nixos.org/build/233238457 at 2023-09-02 + - haskell-igraph # failure in job https://hydra.nixos.org/build/325267326 at 2026-04-12 - haskell-import-graph # failure in job https://hydra.nixos.org/build/233225328 at 2023-09-02 - haskell-in-space # failure in job https://hydra.nixos.org/build/233207121 at 2023-09-02 - haskell-kubernetes # failure in job https://hydra.nixos.org/build/233214499 at 2023-09-02 @@ -2876,6 +2886,7 @@ broken-packages: - hmatrix-mmap # failure in job https://hydra.nixos.org/build/233233046 at 2023-09-02 - hmatrix-morpheus # failure in job https://hydra.nixos.org/build/295094280 at 2025-04-22 - hmatrix-nipals # failure in job https://hydra.nixos.org/build/233197543 at 2023-09-02 + - hmatrix-quadprogpp # failure in job https://hydra.nixos.org/build/326161220 at 2026-04-12 - hmatrix-sparse # failure in job https://hydra.nixos.org/build/233224288 at 2023-09-02 - hmatrix-static # failure in job https://hydra.nixos.org/build/233193039 at 2023-09-02 - hmatrix-svdlibc # failure in job https://hydra.nixos.org/build/233216875 at 2023-09-02 @@ -3034,6 +3045,7 @@ broken-packages: - hsay # failure in job https://hydra.nixos.org/build/233218925 at 2023-09-02 - hsbc # failure in job https://hydra.nixos.org/build/233206310 at 2023-09-02 - hsbencher # failure in job https://hydra.nixos.org/build/233214962 at 2023-09-02 + - hsblst # failure in job https://hydra.nixos.org/build/325267680 at 2026-04-12 - hsc3-cairo # failure in job https://hydra.nixos.org/build/233215926 at 2023-09-02 - hsc3-db # failure in job https://hydra.nixos.org/build/233191679 at 2023-09-02 - hsc3-dot # failure in job https://hydra.nixos.org/build/233219452 at 2023-09-02 @@ -3080,8 +3092,10 @@ broken-packages: - hslinks # failure in job https://hydra.nixos.org/build/233221444 at 2023-09-02 - hslogger-reader # failure in job https://hydra.nixos.org/build/233226346 at 2023-09-02 - hslogger-template # failure in job https://hydra.nixos.org/build/233192309 at 2023-09-02 + - hslua-annotations # failure in job https://hydra.nixos.org/build/326308258 at 2026-04-12 - hsluv-haskell # failure in job https://hydra.nixos.org/build/233239548 at 2023-09-02 - hsmagick # failure in job https://hydra.nixos.org/build/233235964 at 2023-09-02 + - hsmin # failure in job https://hydra.nixos.org/build/325267665 at 2026-04-12 - hsmodetweaks # failure in job https://hydra.nixos.org/build/233663004 at 2023-09-02 - hsmrc # failure in job https://hydra.nixos.org/build/315097363 at 2025-11-29 - Hsmtlib # failure in job https://hydra.nixos.org/build/233213073 at 2023-09-02 @@ -3288,6 +3302,7 @@ broken-packages: - ihaskell-parsec # failure in job https://hydra.nixos.org/build/233244271 at 2023-09-02 - ihaskell-plot # failure in job https://hydra.nixos.org/build/233255936 at 2023-09-02 - ihaskell-widgets # failure in job https://hydra.nixos.org/build/265955663 at 2024-07-14 + - ihp-pglistener # failure in job https://hydra.nixos.org/build/325267877 at 2026-04-12 - illuminate # failure in job https://hydra.nixos.org/build/233219478 at 2023-09-02 - image-type # failure in job https://hydra.nixos.org/build/233251466 at 2023-09-02 - imagemagick # failure in job https://hydra.nixos.org/build/233598237 at 2023-09-02 @@ -3297,6 +3312,8 @@ broken-packages: - imj-prelude # failure in job https://hydra.nixos.org/build/233234877 at 2023-09-02 - imm # failure in job https://hydra.nixos.org/build/237239261 at 2023-10-21 - immortal-worker # failure in job https://hydra.nixos.org/build/233246961 at 2023-09-02 + - imperative-edsl # failure in job https://hydra.nixos.org/build/326308263 at 2026-04-12 + - imperative-edsl-vhdl # failure in job https://hydra.nixos.org/build/326308261 at 2026-04-12 - ImperativeHaskell # failure in job https://hydra.nixos.org/build/233240920 at 2023-09-02 - impl # failure in job https://hydra.nixos.org/build/233203425 at 2023-09-02 - implicit-hie-cradle # failure in job https://hydra.nixos.org/build/252710698 at 2024-03-16 @@ -3337,6 +3354,7 @@ broken-packages: - injections # failure in job https://hydra.nixos.org/build/233207796 at 2023-09-02 - inline-c-cuda # failure in job https://hydra.nixos.org/build/237234701 at 2023-10-21 - inline-c-objc # failure in job https://hydra.nixos.org/build/233223704 at 2023-09-02 + - inline-r # failure in job https://hydra.nixos.org/build/325304052 at 2026-04-12 - inserts # failure in job https://hydra.nixos.org/build/233198758 at 2023-09-02 - instana-haskell-trace-sdk # failure in job https://hydra.nixos.org/build/233211339 at 2023-09-02 - instance-control # failure in job https://hydra.nixos.org/build/252726549 at 2024-03-16 @@ -3713,6 +3731,7 @@ broken-packages: - lhc # failure in job https://hydra.nixos.org/build/233220731 at 2023-09-02 - lhs2TeX-hl # failure in job https://hydra.nixos.org/build/233221405 at 2023-09-02 - lhslatex # failure in job https://hydra.nixos.org/build/233246375 at 2023-09-02 + - libarchive-clib # failure in job https://hydra.nixos.org/build/325268249 at 2026-04-12 - LibClang # failure in job https://hydra.nixos.org/build/233194732 at 2023-09-02 - libexpect # failure in job https://hydra.nixos.org/build/233226545 at 2023-09-02 - libGenI # failure in job https://hydra.nixos.org/build/233240857 at 2023-09-02 @@ -3778,6 +3797,7 @@ broken-packages: - lines-of-action # failure in job https://hydra.nixos.org/build/233244937 at 2023-09-02 - lingo # failure in job https://hydra.nixos.org/build/233254522 at 2023-09-02 - linguistic-ordinals # failure in job https://hydra.nixos.org/build/233228974 at 2023-09-02 + - link-canonical-effectful # failure in job https://hydra.nixos.org/build/325268303 at 2026-04-12 - linked-list-with-iterator # failure in job https://hydra.nixos.org/build/233220466 at 2023-09-02 - linkedhashmap # failure in job https://hydra.nixos.org/build/233234634 at 2023-09-02 - linklater # failure in job https://hydra.nixos.org/build/233220508 at 2023-09-02 @@ -4064,6 +4084,9 @@ broken-packages: - mios # failure in job https://hydra.nixos.org/build/233251863 at 2023-09-02 - mirror-tweet # failure in job https://hydra.nixos.org/build/233216951 at 2023-09-02 - mismi-p # failure in job https://hydra.nixos.org/build/233257227 at 2023-09-02 + - miso-aeson # failure in job https://hydra.nixos.org/build/326308286 at 2026-04-12 + - miso-from-html # failure in job https://hydra.nixos.org/build/326308289 at 2026-04-12 + - miso-optics # failure in job https://hydra.nixos.org/build/326308284 at 2026-04-12 - mit-3qvpPyAi6mH # failure in job https://hydra.nixos.org/build/233229967 at 2023-09-02 - mix-arrows # failure in job https://hydra.nixos.org/build/233257720 at 2023-09-02 - mixpanel-client # failure in job https://hydra.nixos.org/build/233220132 at 2023-09-02 @@ -4468,6 +4491,7 @@ broken-packages: - on-demand-ssh-tunnel # failure in job https://hydra.nixos.org/build/233197181 at 2023-09-02 - onama # failure in job https://hydra.nixos.org/build/307520792 at 2025-09-19 - ONC-RPC # failure in job https://hydra.nixos.org/build/233225207 at 2023-09-02 + - one # failure in job https://hydra.nixos.org/build/325268995 at 2026-04-12 - one-line-aeson-text # failure in job https://hydra.nixos.org/build/307520746 at 2025-09-19 - oneormore # failure in job https://hydra.nixos.org/build/233242475 at 2023-09-02 - online # failure in job https://hydra.nixos.org/build/233195360 at 2023-09-02 @@ -4484,6 +4508,7 @@ broken-packages: - open-haddock # failure in job https://hydra.nixos.org/build/233205112 at 2023-09-02 - open-pandoc # failure in job https://hydra.nixos.org/build/233247973 at 2023-09-02 - open-signals # failure in job https://hydra.nixos.org/build/233207409 at 2023-09-02 + - open-typerep # failure in job https://hydra.nixos.org/build/326308306 at 2026-04-12 - OpenAFP # failure in job https://hydra.nixos.org/build/233249295 at 2023-09-02 - openai # failure in job https://hydra.nixos.org/build/295095863 at 2025-04-22 - openai-servant-gen # failure in job https://hydra.nixos.org/build/295095800 at 2025-04-22 @@ -4758,6 +4783,7 @@ broken-packages: - pg-harness-server # failure in job https://hydra.nixos.org/build/233236493 at 2023-09-02 - pg-query # failure in job https://hydra.nixos.org/build/283202281 at 2024-12-31 - pg-recorder # failure in job https://hydra.nixos.org/build/233241248 at 2023-09-02 + - pg-schema # failure in job https://hydra.nixos.org/build/326308316 at 2026-04-12 - pg-store # failure in job https://hydra.nixos.org/build/233208603 at 2023-09-02 - pg-transact # failure in job https://hydra.nixos.org/build/233253337 at 2023-09-02 - pgdl # failure in job https://hydra.nixos.org/build/233203790 at 2023-09-02 @@ -4964,6 +4990,7 @@ broken-packages: - postgresql-tx-monad-logger # failure in job https://hydra.nixos.org/build/233227034 at 2023-09-02 - postgresql-tx-simple # failure in job https://hydra.nixos.org/build/233242850 at 2023-09-02 - postgresql-typed-lifted # failure in job https://hydra.nixos.org/build/233215141 at 2023-09-02 + - postgresql-types # failure in job https://hydra.nixos.org/build/326308328 at 2026-04-12 - postgrest-ws # failure in job https://hydra.nixos.org/build/233247807 at 2023-09-02 - postie # failure in job https://hydra.nixos.org/build/233259075 at 2023-09-02 - postmark-streams # failure in job https://hydra.nixos.org/build/233233210 at 2023-09-02 @@ -5016,6 +5043,7 @@ broken-packages: - prim-ref # failure in job https://hydra.nixos.org/build/233226138 at 2023-09-02 - primal # failure in job https://hydra.nixos.org/build/233260049 at 2023-09-02 - prime # failure in job https://hydra.nixos.org/build/233197550 at 2023-09-02 + - primecount # failure in job https://hydra.nixos.org/build/325269458 at 2026-04-12 - primes-type # failure in job https://hydra.nixos.org/build/233258302 at 2023-09-02 - primitive-checked # failure in job https://hydra.nixos.org/build/233211674 at 2023-09-02 - primitive-containers # failure in job https://hydra.nixos.org/build/307521213 at 2025-09-19 @@ -5232,6 +5260,7 @@ broken-packages: - rclient # failure in job https://hydra.nixos.org/build/233239290 at 2023-09-02 - rds-data # failure in job https://hydra.nixos.org/build/299186719 at 2025-06-23 - rds-data-codecs # failure in job https://hydra.nixos.org/build/253696582 at 2024-03-31 + - re2 # failure in job https://hydra.nixos.org/build/325269682 at 2026-04-12 - react # failure in job https://hydra.nixos.org/build/257372364 at 2024-04-27 - react-flux # failure in job https://hydra.nixos.org/build/233246819 at 2023-09-02 - react-haskell # failure in job https://hydra.nixos.org/build/233242976 at 2023-09-02 @@ -5370,6 +5399,7 @@ broken-packages: - request-monad # failure in job https://hydra.nixos.org/build/233204896 at 2023-09-02 - rescue # failure in job https://hydra.nixos.org/build/233230073 at 2023-09-02 - reservoir # failure in job https://hydra.nixos.org/build/233194430 at 2023-09-02 + - resin # failure in job https://hydra.nixos.org/build/326308336 at 2026-04-12 - resolve # failure in job https://hydra.nixos.org/build/233224070 at 2023-09-02 - resolve-trivial-conflicts # failure in job https://hydra.nixos.org/build/233237974 at 2023-09-02 - resource-effect # failure in job https://hydra.nixos.org/build/233253816 at 2023-09-02 @@ -5433,6 +5463,8 @@ broken-packages: - roller # failure in job https://hydra.nixos.org/build/233198848 at 2023-09-02 - roman-numerals # failure in job https://hydra.nixos.org/build/233214716 at 2023-09-02 - ron-hs # failure in job https://hydra.nixos.org/build/295096708 at 2025-04-22 + - ron-schema # failure in job https://hydra.nixos.org/build/326308345 at 2026-04-12 + - ron-storage # failure in job https://hydra.nixos.org/build/326308346 at 2026-04-12 - rope # failure in job https://hydra.nixos.org/build/233198109 at 2023-09-02 - rose # failure in job https://hydra.nixos.org/build/252717613 at 2024-03-16 - rose-trees # timeout @@ -5953,6 +5985,7 @@ broken-packages: - sqlcipher # failure in job https://hydra.nixos.org/build/233259217 at 2023-09-02 - sqlcli # failure in job https://hydra.nixos.org/build/252719841 at 2024-03-16 - sqlite # failure in job https://hydra.nixos.org/build/233215839 at 2023-09-02 + - sqlite-easy # failure in job https://hydra.nixos.org/build/326308362 at 2026-04-12 - sqlite-simple-errors # failure in job https://hydra.nixos.org/build/233232977 at 2023-09-02 - sqlvalue-list # failure in job https://hydra.nixos.org/build/233197313 at 2023-09-02 - sqsd-local # failure in updateAutotoolsGnuConfigScriptsPhase in job https://hydra.nixos.org/build/237237046 at 2023-10-21 @@ -5988,6 +6021,7 @@ broken-packages: - stackage-to-hackage # failure in job https://hydra.nixos.org/build/233233948 at 2023-09-02 - stackage-types # failure in job https://hydra.nixos.org/build/233239995 at 2023-09-02 - stackcollapse-ghc # failure in job https://hydra.nixos.org/build/233250775 at 2023-09-02 + - stacker # failure in job https://hydra.nixos.org/build/326308360 at 2026-04-12 - staged-gg # failure in job https://hydra.nixos.org/build/233252183 at 2023-09-02 - stagen # failure in job https://hydra.nixos.org/build/307611396 at 2025-09-19 - standalone-derive-topdown # failure in job https://hydra.nixos.org/build/233252467 at 2023-09-02 @@ -6736,6 +6770,7 @@ broken-packages: - TotalMap # failure in job https://hydra.nixos.org/build/233194327 at 2023-09-02 - touched # failure in job https://hydra.nixos.org/build/233199113 at 2023-09-02 - Tournament # failure in job https://hydra.nixos.org/build/233239014 at 2023-09-02 + - tower-hs # failure in job https://hydra.nixos.org/build/326308388 at 2026-04-12 - toxiproxy-haskell # failure in job https://hydra.nixos.org/build/233222810 at 2023-09-02 - tpar # failure in job https://hydra.nixos.org/build/295097738 at 2025-04-22 - tptp # failure in job https://hydra.nixos.org/build/233195607 at 2023-09-02 @@ -6924,6 +6959,7 @@ broken-packages: - unicode-prelude # failure in job https://hydra.nixos.org/build/233241723 at 2023-09-02 - unicode-symbols # failure in job https://hydra.nixos.org/build/233241639 at 2023-09-02 - unicode-tricks # failure in job https://hydra.nixos.org/build/233258238 at 2023-09-02 + - uniform-shake # failure in job https://hydra.nixos.org/build/325271124 at 2026-04-12 - unimap # failure in job https://hydra.nixos.org/build/299141969 at 2025-06-23 - union-find # failure in job https://hydra.nixos.org/build/233245476 at 2023-09-02 - union-map # failure in job https://hydra.nixos.org/build/233222765 at 2023-09-02 @@ -7016,6 +7052,7 @@ broken-packages: - validations # failure in job https://hydra.nixos.org/build/233208976 at 2023-09-02 - validationt # failure in job https://hydra.nixos.org/build/252739235 at 2024-03-16 - validators # failure in job https://hydra.nixos.org/build/233235532 at 2023-09-02 + - valuations # failure in job https://hydra.nixos.org/build/325271192 at 2026-04-12 - value-supply # failure in job https://hydra.nixos.org/build/233190936 at 2023-09-02 - ValveValueKeyvalue # failure in job https://hydra.nixos.org/build/252733320 at 2024-03-16 - vampire # failure in job https://hydra.nixos.org/build/233216179 at 2023-09-02 @@ -7434,6 +7471,7 @@ broken-packages: - yesod-tls # failure in job https://hydra.nixos.org/build/233251484 at 2023-09-02 - yesod-transloadit # failure in job https://hydra.nixos.org/build/233202132 at 2023-09-02 - yesod-vend # failure in job https://hydra.nixos.org/build/233227545 at 2023-09-02 + - yesod-vite # failure in job https://hydra.nixos.org/build/326308413 at 2026-04-12 - YFrob # failure in job https://hydra.nixos.org/build/233197612 at 2023-09-02 - yggdrasil # failure in job https://hydra.nixos.org/build/233229923 at 2023-09-02 - yggdrasil-schema # failure in job https://hydra.nixos.org/build/275135174 at 2024-10-21 diff --git a/pkgs/development/haskell-modules/configuration-hackage2nix/transitive-broken.yaml b/pkgs/development/haskell-modules/configuration-hackage2nix/transitive-broken.yaml index 37f4938fab42..621fd8d18a3e 100644 --- a/pkgs/development/haskell-modules/configuration-hackage2nix/transitive-broken.yaml +++ b/pkgs/development/haskell-modules/configuration-hackage2nix/transitive-broken.yaml @@ -487,6 +487,7 @@ dont-distribute-packages: - cmptype - cmv - cnc-spec-compiler + - co-feldspar - Coadjute - cobot-io - codec @@ -884,6 +885,7 @@ dont-distribute-packages: - eventsource-geteventstore-store - eventsource-store-specs - eventsource-stub-store + - eventsourcing-postgresql - eventuo11y-batteries - eventuo11y-json - eventuo11y-otel @@ -987,6 +989,7 @@ dont-distribute-packages: - fluid-idl-scotty - FM-SBLEX - fmt-for-rio + - fnotation - foldl-transduce-attoparsec - follower - fontwhich @@ -1766,6 +1769,7 @@ dont-distribute-packages: - iException - ige-mac-integration - igrf + - ihaskell-inline-r - ihaskell-rlangqq - ihaskell-symtegration - ihp @@ -2691,6 +2695,7 @@ dont-distribute-packages: - postgresql-common-persistent - postgresql-pure - postgresql-simple-ltree + - postgresql-simple-postgresql-types - postgresql-simple-queue - postgresql-simple-typed - postgresql-tx-query @@ -2840,6 +2845,7 @@ dont-distribute-packages: - rasa-ext-views - rasa-ext-vim - rascal + - raw-feldspar - razom-text-util - rbr - rc @@ -3161,6 +3167,7 @@ dont-distribute-packages: - si-clock - sibe - sigma-ij + - signals - signify-hs - silvi - simgi diff --git a/pkgs/development/haskell-modules/hackage-packages.nix b/pkgs/development/haskell-modules/hackage-packages.nix index d973d37571e4..bdc7b8e0f4a1 100644 --- a/pkgs/development/haskell-modules/hackage-packages.nix +++ b/pkgs/development/haskell-modules/hackage-packages.nix @@ -87249,6 +87249,8 @@ self: { testToolDepends = [ doctest ]; description = "Partial Semigroup and Semigroup operations"; license = lib.meta.getLicenseFromSpdxId "BSD-3-Clause"; + hydraPlatforms = lib.platforms.none; + broken = true; } ) { }; @@ -139896,6 +139898,8 @@ self: { doHaddock = false; description = "GHC plugin for checked numeric literals"; license = lib.meta.getLicenseFromSpdxId "BSD-2-Clause"; + hydraPlatforms = lib.platforms.none; + broken = true; } ) { }; @@ -149951,6 +149955,7 @@ self: { ]; description = "Hardware software co-design Feldspar"; license = lib.licenses.bsd3; + hydraPlatforms = lib.platforms.none; } ) { }; @@ -195637,6 +195642,8 @@ self: { containers ]; license = lib.meta.getLicenseFromSpdxId "MPL-2.0"; + hydraPlatforms = lib.platforms.none; + broken = true; } ) { }; @@ -227220,6 +227227,8 @@ self: { ]; description = "CQRS/ES library"; license = lib.licenses.isc; + hydraPlatforms = lib.platforms.none; + broken = true; } ) { }; @@ -227253,6 +227262,7 @@ self: { ]; description = "PostgreSQL adaptor for eventsourcing"; license = lib.licenses.isc; + hydraPlatforms = lib.platforms.none; } ) { }; @@ -237126,6 +237136,8 @@ self: { ]; description = "A functional embedded language for DSP and parallelism"; license = lib.licenses.bsd3; + hydraPlatforms = lib.platforms.none; + broken = true; } ) { }; @@ -245014,6 +245026,7 @@ self: { vector ]; license = lib.meta.getLicenseFromSpdxId "MPL-2.0"; + hydraPlatforms = lib.platforms.none; } ) { }; @@ -255778,6 +255791,8 @@ self: { testToolDepends = [ hspec-discover ]; description = "Modular effectful computations with explicit environments and errors"; license = lib.meta.getLicenseFromSpdxId "MIT"; + hydraPlatforms = lib.platforms.none; + broken = true; } ) { }; @@ -261618,6 +261633,8 @@ self: { ]; description = "Standard spec's for Hashable instances"; license = lib.licenses.mit; + hydraPlatforms = lib.platforms.none; + broken = true; } ) { }; @@ -300905,6 +300922,8 @@ self: { ]; description = "A Hakyll plugin for rendering diagrams figures from embedded Haskell code"; license = lib.meta.getLicenseFromSpdxId "BSD-3-Clause"; + hydraPlatforms = lib.platforms.none; + broken = true; } ) { }; @@ -305521,6 +305540,8 @@ self: { ]; description = "Deep embedding of hardware descriptions with code generation"; license = lib.licenses.bsd3; + hydraPlatforms = lib.platforms.none; + broken = true; } ) { }; @@ -310916,6 +310937,8 @@ self: { ]; description = "Bindings to the igraph C library (v0.8.5)."; license = lib.meta.getLicenseFromSpdxId "MIT"; + hydraPlatforms = lib.platforms.none; + broken = true; } ) { }; @@ -343320,6 +343343,8 @@ self: { librarySystemDepends = [ quadprogpp ]; description = "Bindings to the QuadProg++ quadratic programming library"; license = lib.licenses.bsd3; + hydraPlatforms = lib.platforms.none; + broken = true; } ) { quadprogpp = null; }; @@ -358035,6 +358060,8 @@ self: { testToolDepends = [ tasty-discover ]; description = "Haskell bindings to BLST"; license = lib.meta.getLicenseFromSpdxId "MPL-2.0"; + hydraPlatforms = lib.platforms.none; + broken = true; } ) { }; @@ -361760,6 +361787,8 @@ self: { ]; description = "A type annotation generator for HSLua"; license = "(MIT OR Apache-2.0)"; + hydraPlatforms = lib.platforms.none; + broken = true; } ) { }; @@ -362921,7 +362950,9 @@ self: { ]; description = "Haskell source code minifier for LLM token reduction"; license = lib.meta.getLicenseFromSpdxId "MIT"; + hydraPlatforms = lib.platforms.none; mainProgram = "hsmin"; + broken = true; } ) { }; @@ -384059,6 +384090,7 @@ self: { ]; description = "Embed R quasiquotes and plots in IHaskell notebooks"; license = lib.licenses.bsd3; + hydraPlatforms = lib.platforms.none; } ) { }; @@ -385746,6 +385778,8 @@ self: { ]; description = "PostgreSQL LISTEN/NOTIFY channel manager for IHP"; license = lib.meta.getLicenseFromSpdxId "MIT"; + hydraPlatforms = lib.platforms.none; + broken = true; } ) { }; @@ -387435,6 +387469,8 @@ self: { ]; description = "Deep embedding of imperative programs with code generation"; license = lib.licenses.bsd3; + hydraPlatforms = lib.platforms.none; + broken = true; } ) { }; @@ -387468,6 +387504,8 @@ self: { ]; description = "Deep embedding of VHDL programs with code generation"; license = lib.licenses.bsd3; + hydraPlatforms = lib.platforms.none; + broken = true; } ) { }; @@ -391246,6 +391284,8 @@ self: { ]; description = "Seamlessly call R from Haskell and vice versa. No FFI required."; license = lib.meta.getLicenseFromSpdxId "BSD-3-Clause"; + hydraPlatforms = lib.platforms.none; + broken = true; } ) { inherit (pkgs) R; }; @@ -428553,6 +428593,8 @@ self: { doHaddock = false; description = "Haskell interface to libarchive (C sources)"; license = "unknown"; + hydraPlatforms = lib.platforms.none; + broken = true; } ) { }; @@ -434157,6 +434199,8 @@ self: { ]; description = "Effectful integration for link-canonical"; license = lib.meta.getLicenseFromSpdxId "MIT"; + hydraPlatforms = lib.platforms.none; + broken = true; } ) { }; @@ -464381,6 +464425,8 @@ self: { ]; description = "JSON conversion library"; license = lib.meta.getLicenseFromSpdxId "BSD-3-Clause"; + hydraPlatforms = lib.platforms.none; + broken = true; } ) { }; @@ -464435,6 +464481,8 @@ self: { ]; description = "Convert HTML to miso View syntax"; license = lib.meta.getLicenseFromSpdxId "BSD-3-Clause"; + hydraPlatforms = lib.platforms.none; + broken = true; } ) { }; @@ -464456,6 +464504,8 @@ self: { ]; description = "An adaptor package for using miso with optics"; license = lib.meta.getLicenseFromSpdxId "BSD-3-Clause"; + hydraPlatforms = lib.platforms.none; + broken = true; } ) { }; @@ -505220,6 +505270,8 @@ self: { testToolDepends = [ doctest ]; description = "One"; license = lib.meta.getLicenseFromSpdxId "BSD-3-Clause"; + hydraPlatforms = lib.platforms.none; + broken = true; } ) { }; @@ -506312,6 +506364,8 @@ self: { ]; description = "Open type representations and dynamic types"; license = lib.licenses.bsd3; + hydraPlatforms = lib.platforms.none; + broken = true; } ) { }; @@ -531782,6 +531836,8 @@ self: { ]; description = "Type-level definition of database schema and safe DML for PostgreSQL"; license = lib.meta.getLicenseFromSpdxId "BSD-3-Clause"; + hydraPlatforms = lib.platforms.none; + broken = true; } ) { }; @@ -550173,6 +550229,7 @@ self: { ]; description = "Integration of \"postgresql-simple\" with \"postgresql-types\""; license = lib.meta.getLicenseFromSpdxId "MIT"; + hydraPlatforms = lib.platforms.none; } ) { }; @@ -550819,6 +550876,8 @@ self: { doHaddock = false; description = "Precise PostgreSQL types representation and driver-agnostic codecs"; license = lib.meta.getLicenseFromSpdxId "MIT"; + hydraPlatforms = lib.platforms.none; + broken = true; } ) { }; @@ -556030,6 +556089,8 @@ self: { ]; description = "Bindings to the primecount library"; license = lib.meta.getLicenseFromSpdxId "BSD-3-Clause"; + hydraPlatforms = lib.platforms.none; + broken = true; } ) { inherit (pkgs) primecount; }; @@ -576206,6 +576267,7 @@ self: { ]; description = "Resource-Aware Feldspar"; license = lib.licenses.bsd3; + hydraPlatforms = lib.platforms.none; } ) { }; @@ -577338,6 +577400,8 @@ self: { ]; description = "Bindings to the re2 regular expression library"; license = lib.licenses.mit; + hydraPlatforms = lib.platforms.none; + broken = true; } ) { inherit (pkgs) re2; }; @@ -590088,6 +590152,8 @@ self: { ]; description = "High performance variable binders"; license = lib.meta.getLicenseFromSpdxId "BSD-2-Clause"; + hydraPlatforms = lib.platforms.none; + broken = true; } ) { }; @@ -597580,6 +597646,8 @@ self: { ]; description = "RON-Schema"; license = lib.meta.getLicenseFromSpdxId "BSD-3-Clause"; + hydraPlatforms = lib.platforms.none; + broken = true; } ) { }; @@ -597625,6 +597693,8 @@ self: { ]; description = "RON Storage"; license = lib.meta.getLicenseFromSpdxId "BSD-3-Clause"; + hydraPlatforms = lib.platforms.none; + broken = true; } ) { }; @@ -630031,6 +630101,7 @@ self: { ]; description = "Synchronous signal processing for DSLs"; license = lib.licenses.bsd3; + hydraPlatforms = lib.platforms.none; } ) { }; @@ -650104,6 +650175,8 @@ self: { ]; description = "A primitive yet easy to use sqlite library"; license = lib.meta.getLicenseFromSpdxId "BSD-3-Clause"; + hydraPlatforms = lib.platforms.none; + broken = true; } ) { }; @@ -654362,7 +654435,9 @@ self: { ]; description = "Bump snapshots in stack.yaml files"; license = lib.meta.getLicenseFromSpdxId "BSD-3-Clause"; + hydraPlatforms = lib.platforms.none; mainProgram = "stacker"; + broken = true; } ) { }; @@ -708695,6 +708770,8 @@ self: { testToolDepends = [ hspec-discover ]; description = "Composable service middleware for Haskell, inspired by Rust's Tower"; license = lib.licenses.mit; + hydraPlatforms = lib.platforms.none; + broken = true; } ) { }; @@ -724681,6 +724758,8 @@ self: { ]; description = "uniform wrapper for shake"; license = "GPL"; + hydraPlatforms = lib.platforms.none; + broken = true; } ) { }; @@ -732781,6 +732860,8 @@ self: { testToolDepends = [ doctest ]; description = "Valuations"; license = lib.meta.getLicenseFromSpdxId "BSD-3-Clause"; + hydraPlatforms = lib.platforms.none; + broken = true; } ) { }; @@ -773764,6 +773845,8 @@ self: { ]; description = "An integration of vitejs with Yesod"; license = lib.meta.getLicenseFromSpdxId "BSD-2-Clause"; + hydraPlatforms = lib.platforms.none; + broken = true; } ) { };