From ac5f7b041a089b35c451f965d86f91187737d6c2 Mon Sep 17 00:00:00 2001 From: Hamish Mackenzie Date: Sun, 20 Oct 2024 12:20:58 +1300 Subject: [PATCH 01/50] Update nixpkgs and ghc HEAD --- flake.lock | 12 ++++++------ flake.nix | 2 +- lazy-inputs/ghc911/flake.lock | 8 ++++---- 3 files changed, 11 insertions(+), 11 deletions(-) diff --git a/flake.lock b/flake.lock index 5121d2f85e..08d22fef22 100644 --- a/flake.lock +++ b/flake.lock @@ -525,11 +525,11 @@ }, "nixpkgs-2405": { "locked": { - "lastModified": 1726447378, - "narHash": "sha256-2yV8nmYE1p9lfmLHhOCbYwQC/W8WYfGQABoGzJOb1JQ=", + "lastModified": 1729242558, + "narHash": "sha256-VgcLDu4igNT0eYua6OAl9pWCI0cYXhDbR+pWP44tte0=", "owner": "NixOS", "repo": "nixpkgs", - "rev": "086b448a5d54fd117f4dc2dee55c9f0ff461bdc1", + "rev": "4a3f2d3195b60d07530574988df92e049372c10e", "type": "github" }, "original": { @@ -557,11 +557,11 @@ }, "nixpkgs-unstable": { "locked": { - "lastModified": 1726583932, - "narHash": "sha256-zACxiQx8knB3F8+Ze+1BpiYrI+CbhxyWpcSID9kVhkQ=", + "lastModified": 1729265718, + "narHash": "sha256-4HQI+6LsO3kpWTYuVGIzhJs1cetFcwT7quWCk/6rqeo=", "owner": "NixOS", "repo": "nixpkgs", - "rev": "658e7223191d2598641d50ee4e898126768fe847", + "rev": "ccc0c2126893dd20963580b6478d1a10a4512185", "type": "github" }, "original": { diff --git a/flake.nix b/flake.nix index 4d7a252e95..d9624d0d4f 100644 --- a/flake.nix +++ b/flake.nix @@ -83,7 +83,7 @@ let callFlake = import flake-compat; - ifdLevel = 3; + ifdLevel = 0; runningHydraEvalTest = false; defaultCompiler = "ghc928"; config = import ./config.nix; diff --git a/lazy-inputs/ghc911/flake.lock b/lazy-inputs/ghc911/flake.lock index 1e883aec87..70d9dbcff2 100644 --- a/lazy-inputs/ghc911/flake.lock +++ b/lazy-inputs/ghc911/flake.lock @@ -3,11 +3,11 @@ "ghc911": { "flake": false, "locked": { - "lastModified": 1726660620, - "narHash": "sha256-A+vKrnt0dC9mA6vIUjeAneo6oHL/5JHmnFw/zD2K/q0=", + "lastModified": 1729344855, + "narHash": "sha256-ZrvRXbvmMwlma+2YW2aHfSKnWzkwU/TF+TSVGRNqomM=", "ref": "refs/heads/master", - "rev": "35eb4f428ab72b712ea78d6ef86b956e321c3bb2", - "revCount": 67241, + "rev": "a04959b8964c8d09897cfae1fd7b06ac53ebee95", + "revCount": 67445, "submodules": true, "type": "git", "url": "https://gitlab.haskell.org/ghc/ghc" From 7ad53ccb14a61182af933a5260e67f146d2a2c1f Mon Sep 17 00:00:00 2001 From: Hamish Mackenzie Date: Sun, 20 Oct 2024 13:23:14 +1300 Subject: [PATCH 02/50] Fix warning --- lib/pkgconf-nixpkgs-map.nix | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/lib/pkgconf-nixpkgs-map.nix b/lib/pkgconf-nixpkgs-map.nix index c9728bfb91..0de0425815 100644 --- a/lib/pkgconf-nixpkgs-map.nix +++ b/lib/pkgconf-nixpkgs-map.nix @@ -5149,7 +5149,7 @@ pkgs: "svrcore" = [ "svrcore" ]; "SvtAv1Dec" = [ "svt-av1" ]; "SvtAv1Enc" = [ "svt-av1" ]; - "swipl" = [ "swiProlog" ]; + "swipl" = [ "swi-prolog" ]; # "swipl" = [ "swiPrologWithGui" ]; "sword" = [ "sword" ]; "syncthingconnector" = [ "syncthingtray" ]; From b949f6b1e742e9c1c1f912c291b65f4a9110069c Mon Sep 17 00:00:00 2001 From: Hamish Mackenzie Date: Sun, 20 Oct 2024 13:23:48 +1300 Subject: [PATCH 03/50] Update internalHackageIndexState --- overlays/haskell.nix | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/overlays/haskell.nix b/overlays/haskell.nix index 5cad91fc63..651674bff6 100644 --- a/overlays/haskell.nix +++ b/overlays/haskell.nix @@ -433,7 +433,7 @@ final: prev: { # If you want to update this value it important to check the # materializations. Turn `checkMaterialization` on below and # check the CI results before turning it off again. - internalHackageIndexState = "2023-11-19T00:00:00Z"; # Remember to also update ../nix-tools/cabal.project and ../nix-tools/flake.lock + internalHackageIndexState = "2024-10-17T00:00:00Z"; # Remember to also update ../nix-tools/cabal.project and ../nix-tools/flake.lock checkMaterialization = false; # This is the default. Use an overlay to set it to true and test all the materialized files From e2b53b3afd6a7acc0234911fa4173e709ca603da Mon Sep 17 00:00:00 2001 From: Hamish Mackenzie Date: Mon, 21 Oct 2024 12:25:20 +1300 Subject: [PATCH 04/50] Update patch bounds --- overlays/bootstrap.nix | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/overlays/bootstrap.nix b/overlays/bootstrap.nix index 0125b188f6..fea20355d7 100644 --- a/overlays/bootstrap.nix +++ b/overlays/bootstrap.nix @@ -244,7 +244,7 @@ in { ++ onWindowsOrMusl (fromUntil "9.8.2" "9.11" ./patches/ghc/ghc-9.6-0006-Adds-support-for-Hidden-symbols.patch) ++ onWindowsOrMusl (fromUntil "9.6" "9.7" ./patches/ghc/ghc-9.6-0006-Adds-support-for-Hidden-symbols-2.patch) ++ onWindowsOrMusl (fromUntil "9.8.2" "9.11" ./patches/ghc/ghc-9.6-0006-Adds-support-for-Hidden-symbols-2.patch) - ++ fromUntil "9.9" "9.12" ./patches/ghc/ghc-9.9-Cabal-3.11.patch + ++ fromUntil "9.9" "9.11" ./patches/ghc/ghc-9.9-Cabal-3.11.patch ++ fromUntil "9.8" "9.9" ./patches/ghc/ghc-9.8-text-upper-bound.patch ++ fromUntil "9.10" "9.11" ./patches/ghc/ghc-9.10-containers-upper-bound.patch ++ fromUntil "9.10" "9.12" ./patches/ghc/ghc-9.10-merge-objects.patch From ed42119c8d06a75415ec0c843f2b7b2ea9eef467 Mon Sep 17 00:00:00 2001 From: Hamish Mackenzie Date: Tue, 22 Oct 2024 17:56:22 +1300 Subject: [PATCH 05/50] Update rcodesign for recent MacOS --- overlays/default.nix | 2 ++ overlays/rcodesign.nix | 32 ++++++++++++++++++++++++++++++++ 2 files changed, 34 insertions(+) create mode 100644 overlays/rcodesign.nix diff --git a/overlays/default.nix b/overlays/default.nix index 32710bb322..a927bcf0b2 100644 --- a/overlays/default.nix +++ b/overlays/default.nix @@ -93,6 +93,7 @@ let cacheCompilerDeps = import ./cache-compiler-deps.nix; fetch-source = import ./fetch-source.nix; lazy-inputs = import ../lazy-inputs; + rcodesign = import ./rcodesign.nix; }; composeExtensions = f: g: final: prev: @@ -133,6 +134,7 @@ let cacheCompilerDeps fetch-source lazy-inputs + rcodesign ]; combined = builtins.foldl' composeExtensions (_: _: { }) ordered; in overlays // { inherit combined; } diff --git a/overlays/rcodesign.nix b/overlays/rcodesign.nix new file mode 100644 index 0000000000..04d3fcc72b --- /dev/null +++ b/overlays/rcodesign.nix @@ -0,0 +1,32 @@ +# nixpkgs is using `rcodesign` 0.22 and it fails to build on recent +# versions of macOS (one of the tests fails validating signatures +# in `/usr/bin`). +final: prev: { + rcodesign = prev.rcodesign.override (old: { + rustPlatform = old.rustPlatform // { + buildRustPackage = args: old.rustPlatform.buildRustPackage (args // { + version = "0.27.0"; + + src = final.fetchFromGitHub { + owner = "hamishmack"; + repo = "apple-platform-rs"; + rev = "hkm/cargo-update"; + hash = "sha256-gma2e73m2MDC8BAcIuclG/RPLhAHRLkehCa56f5835g="; + }; + + cargoHash = "sha256-4ra1oBQK/kXZTKvvq17kX2+49iKyXXT484Z6ON4bFbU="; + + buildInputs = final.lib.optionals final.stdenv.hostPlatform.isDarwin [ + final.darwin.apple_sdk_11_0.frameworks.Security + final.darwin.apple_sdk_11_0.frameworks.SystemConfiguration + ]; + + checkFlags = [ + # Does network IO + "--skip=ticket_lookup::test::lookup_ticket" + "--skip=cli_tests" + ]; + }); + }; + }); +} From ea3fbace74b0d820b388fca6a461270a5a8a151f Mon Sep 17 00:00:00 2001 From: Hamish Mackenzie Date: Wed, 23 Oct 2024 00:16:00 +1300 Subject: [PATCH 06/50] Replace ghc911 with ghc912X and ghc913 --- ci.nix | 3 ++- lazy-inputs/ghc912X/flake.lock | 30 +++++++++++++++++++++++ lazy-inputs/ghc912X/flake.nix | 12 +++++++++ lazy-inputs/{ghc911 => ghc913}/flake.lock | 12 ++++----- lazy-inputs/{ghc911 => ghc913}/flake.nix | 2 +- overlays/bootstrap.nix | 11 +++++---- overlays/fetch-source.nix | 2 +- 7 files changed, 58 insertions(+), 14 deletions(-) create mode 100644 lazy-inputs/ghc912X/flake.lock create mode 100644 lazy-inputs/ghc912X/flake.nix rename lazy-inputs/{ghc911 => ghc913}/flake.lock (64%) rename lazy-inputs/{ghc911 => ghc913}/flake.nix (92%) diff --git a/ci.nix b/ci.nix index b6346c086e..d1ba37aefb 100644 --- a/ci.nix +++ b/ci.nix @@ -73,7 +73,8 @@ ghc98llvm = false; ghc910 = true; ghc910llvm = true; - ghc911 = true; + ghc912X = true; + ghc913 = true; }))); crossSystems = nixpkgsName: nixpkgs: compiler-nix-name: # We need to use the actual nixpkgs version we're working with here, since the values diff --git a/lazy-inputs/ghc912X/flake.lock b/lazy-inputs/ghc912X/flake.lock new file mode 100644 index 0000000000..16fbfe7e42 --- /dev/null +++ b/lazy-inputs/ghc912X/flake.lock @@ -0,0 +1,30 @@ +{ + "nodes": { + "ghc912X": { + "flake": false, + "locked": { + "lastModified": 1728948341, + "narHash": "sha256-yeIet7pwSkOngSTcm/E9XJAZhOalrfSbjVMOri/m1Ak=", + "ref": "ghc-9.12", + "rev": "ca2b21c3429a5ff780cb6c58c33c171a3c0af82b", + "revCount": 67355, + "submodules": true, + "type": "git", + "url": "https://gitlab.haskell.org/ghc/ghc" + }, + "original": { + "ref": "ghc-9.12", + "submodules": true, + "type": "git", + "url": "https://gitlab.haskell.org/ghc/ghc" + } + }, + "root": { + "inputs": { + "ghc912X": "ghc912X" + } + } + }, + "root": "root", + "version": 7 +} diff --git a/lazy-inputs/ghc912X/flake.nix b/lazy-inputs/ghc912X/flake.nix new file mode 100644 index 0000000000..ca7a84eea8 --- /dev/null +++ b/lazy-inputs/ghc912X/flake.nix @@ -0,0 +1,12 @@ +{ + description = "Lazy Input for Haskell.nix"; + + inputs = { + ghc912X = { + flake = false; + url = "git+https://gitlab.haskell.org/ghc/ghc?ref=ghc-9.12&submodules=1"; + }; + }; + + outputs = inputs: inputs; +} diff --git a/lazy-inputs/ghc911/flake.lock b/lazy-inputs/ghc913/flake.lock similarity index 64% rename from lazy-inputs/ghc911/flake.lock rename to lazy-inputs/ghc913/flake.lock index 70d9dbcff2..00625dbdea 100644 --- a/lazy-inputs/ghc911/flake.lock +++ b/lazy-inputs/ghc913/flake.lock @@ -1,13 +1,13 @@ { "nodes": { - "ghc911": { + "ghc913": { "flake": false, "locked": { - "lastModified": 1729344855, - "narHash": "sha256-ZrvRXbvmMwlma+2YW2aHfSKnWzkwU/TF+TSVGRNqomM=", + "lastModified": 1729558540, + "narHash": "sha256-AgGMQro2YyO2qR7YTd1JuF4X1V14AUYsnakb+1BOGB0=", "ref": "refs/heads/master", - "rev": "a04959b8964c8d09897cfae1fd7b06ac53ebee95", - "revCount": 67445, + "rev": "148059fea534aced44649c739cd0fad4c25a99f0", + "revCount": 67457, "submodules": true, "type": "git", "url": "https://gitlab.haskell.org/ghc/ghc" @@ -20,7 +20,7 @@ }, "root": { "inputs": { - "ghc911": "ghc911" + "ghc913": "ghc913" } } }, diff --git a/lazy-inputs/ghc911/flake.nix b/lazy-inputs/ghc913/flake.nix similarity index 92% rename from lazy-inputs/ghc911/flake.nix rename to lazy-inputs/ghc913/flake.nix index 7ad2912908..db172cc218 100644 --- a/lazy-inputs/ghc911/flake.nix +++ b/lazy-inputs/ghc913/flake.nix @@ -2,7 +2,7 @@ description = "Lazy Input for Haskell.nix"; inputs = { - ghc911 = { + ghc913 = { flake = false; url = "git+https://gitlab.haskell.org/ghc/ghc?submodules=1"; }; diff --git a/overlays/bootstrap.nix b/overlays/bootstrap.nix index fea20355d7..bd2a7e327a 100644 --- a/overlays/bootstrap.nix +++ b/overlays/bootstrap.nix @@ -11,7 +11,8 @@ let "9.10" = "9.10.1"; }; gitInputs = { - ghc911 = "9.11"; + ghc912X = "9.12"; + ghc913 = "9.13"; }; versionToNixName = v: "ghc${builtins.replaceStrings ["."] [""] v}"; compilerNameMap = @@ -119,7 +120,7 @@ in { ++ until "9.2" ./patches/ghc/issue-18708.patch # https://gitlab.haskell.org/ghc/ghc/-/merge_requests/6554 ++ fromUntil "9.2.2" "9.4" ./patches/ghc/ghc-9.2.2-fix-warnings-building-with-self.patch # https://gitlab.haskell.org/ghc/ghc/-/commit/c41c478eb9003eaa9fc8081a0039652448124f5d ++ until "9.6" ./patches/ghc/ghc-hpc-response-files.patch # https://gitlab.haskell.org/ghc/ghc/-/merge_requests/8194 - ++ fromUntil "9.2" "9.12" ./patches/ghc/sanity-check-find-file-name.patch + ++ fromUntil "9.2" "9.14" ./patches/ghc/sanity-check-find-file-name.patch ++ until "9.0" ./patches/ghc/dont-mark-evacuate_large-as-inline.patch ++ onWindows (fromUntil "9.4.1" "9.4.5" ./patches/ghc/ghc-9.4-hadrian-win-cross.patch) ++ onWindows (fromUntil "9.4.7" "9.4.9" ./patches/ghc/ghc-9.8-hadrian-win-cross.patch) @@ -159,7 +160,7 @@ in { ++ fromUntil "9.6.2" "9.8" ./patches/ghc/ghc-9.4.5-include-order-fix.patch ++ fromUntil "9.6.1" "9.9.20231203" ./patches/ghc/MR10116.patch ++ onNative (fromUntil "9.4.1" "9.6" ./patches/ghc/hadrian-build-deriveConstants-genprimopcode-ghc94.patch) - ++ onNative (fromUntil "9.6.1" "9.12" ./patches/ghc/hadrian-build-deriveConstants-genprimopcode.patch) + ++ onNative (fromUntil "9.6.1" "9.14" ./patches/ghc/hadrian-build-deriveConstants-genprimopcode.patch) ++ onGhcjs (fromUntil "9.6.1" "9.6.3" ./patches/ghc/ghc-9.6-Merge-libiserv-with-ghci.patch) ++ onGhcjs (fromUntil "9.6.3" "9.8" ./patches/ghc/ghc-9.6.3-Merge-libiserv-with-ghci.patch) ++ onGhcjs (fromUntil "9.6.1" "9.8" ./patches/ghc/ghc-9.6-Assorted-changes-to-avoid-head-tail.patch) @@ -247,7 +248,7 @@ in { ++ fromUntil "9.9" "9.11" ./patches/ghc/ghc-9.9-Cabal-3.11.patch ++ fromUntil "9.8" "9.9" ./patches/ghc/ghc-9.8-text-upper-bound.patch ++ fromUntil "9.10" "9.11" ./patches/ghc/ghc-9.10-containers-upper-bound.patch - ++ fromUntil "9.10" "9.12" ./patches/ghc/ghc-9.10-merge-objects.patch + ++ fromUntil "9.10" "9.14" ./patches/ghc/ghc-9.10-merge-objects.patch # This patch will make windows stop emitting absolute relocations. This is one way in which binutils 2.36+ (with ASLR enabled), will just choke on the # assembly we generate because it's always absolute (32bit) addressing modes. @@ -257,7 +258,7 @@ in { ++ onWindows (fromUntil "9.2" "9.4" ./patches/ghc/windows-pseudo-pic-9.2.patch) # Fix issue loading windows dll using `.dll.a` file - ++ onWindows (fromUntil "9.4" "9.12" ./patches/ghc/ghc-9.10-windows-dll-dependent-symbol-type-fix.patch) + ++ onWindows (fromUntil "9.4" "9.14" ./patches/ghc/ghc-9.10-windows-dll-dependent-symbol-type-fix.patch) ; in ({ ghc8107 = traceWarnOld "8.10" (final.callPackage ../compiler/ghc { diff --git a/overlays/fetch-source.nix b/overlays/fetch-source.nix index 26c0dafb30..68215b67f3 100644 --- a/overlays/fetch-source.nix +++ b/overlays/fetch-source.nix @@ -41,6 +41,6 @@ in { } // { lastModifiedDate = formatSecondsSinceEpoch lockFile.nodes.${name}.locked.lastModified; }; - }) ["ghc910X" "ghc911"]); + }) ["ghc912X" "ghc913"]); }; } From ec3e51b36b10862153edba7c4bece5991c4c0a93 Mon Sep 17 00:00:00 2001 From: Hamish Mackenzie Date: Wed, 23 Oct 2024 12:50:32 +1300 Subject: [PATCH 07/50] ifdLevel 1 --- flake.nix | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/flake.nix b/flake.nix index d9624d0d4f..c9235935ae 100644 --- a/flake.nix +++ b/flake.nix @@ -83,7 +83,7 @@ let callFlake = import flake-compat; - ifdLevel = 0; + ifdLevel = 1; runningHydraEvalTest = false; defaultCompiler = "ghc928"; config = import ./config.nix; From 52e3bca186dc7611b52542f7eb559ed20ea91b03 Mon Sep 17 00:00:00 2001 From: Hamish Mackenzie Date: Thu, 24 Oct 2024 14:00:59 +1300 Subject: [PATCH 08/50] Use lazy-inputs instead of fetch-source overlay --- lazy-inputs/default.nix | 6 +++-- overlays/default.nix | 2 -- overlays/fetch-source.nix | 46 --------------------------------------- 3 files changed, 4 insertions(+), 50 deletions(-) delete mode 100644 overlays/fetch-source.nix diff --git a/lazy-inputs/default.nix b/lazy-inputs/default.nix index 562e3776e7..3cb8446c77 100644 --- a/lazy-inputs/default.nix +++ b/lazy-inputs/default.nix @@ -3,7 +3,7 @@ let callFlake = import prev.haskell-nix.sources.flake-compat; in { haskell-nix = prev.haskell-nix // { - sources = prev.haskell-nix.sources // { + sources = { inherit ((callFlake { pkgs = final; src = ./ghc8107; }).defaultNix) ghc8107; inherit ((callFlake { pkgs = final; src = ./ghc901; }).defaultNix) ghc901; inherit ((callFlake { pkgs = final; src = ./ghc902; }).defaultNix) ghc902; @@ -32,6 +32,8 @@ in { inherit ((callFlake { pkgs = final; src = ./ghc981; }).defaultNix) ghc981; inherit ((callFlake { pkgs = final; src = ./ghc982; }).defaultNix) ghc982; inherit ((callFlake { pkgs = final; src = ./ghc9101; }).defaultNix) ghc9101; - }; + inherit ((callFlake { pkgs = final; src = ./ghc912X; }).defaultNix) ghc912X; + inherit ((callFlake { pkgs = final; src = ./ghc913; }).defaultNix) ghc913; + } // prev.haskell-nix.sources; }; } diff --git a/overlays/default.nix b/overlays/default.nix index a927bcf0b2..2a87eca025 100644 --- a/overlays/default.nix +++ b/overlays/default.nix @@ -91,7 +91,6 @@ let ghcjs = import ./ghcjs.nix; cabalPkgConfig = import ./cabal-pkg-config.nix; cacheCompilerDeps = import ./cache-compiler-deps.nix; - fetch-source = import ./fetch-source.nix; lazy-inputs = import ../lazy-inputs; rcodesign = import ./rcodesign.nix; }; @@ -132,7 +131,6 @@ let # Restore nixpkgs haskell and haskellPackages (_: prev: { inherit (prev.haskell-nix-prev) haskell haskellPackages; }) cacheCompilerDeps - fetch-source lazy-inputs rcodesign ]; diff --git a/overlays/fetch-source.nix b/overlays/fetch-source.nix deleted file mode 100644 index 68215b67f3..0000000000 --- a/overlays/fetch-source.nix +++ /dev/null @@ -1,46 +0,0 @@ -final: prev: -let - # Courtesy of `flake-compat` - # Format number of seconds in the Unix epoch as %Y%m%d%H%M%S. - formatSecondsSinceEpoch = t: - let - rem = x: y: x - x / y * y; - days = t / 86400; - secondsInDay = rem t 86400; - hours = secondsInDay / 3600; - minutes = (rem secondsInDay 3600) / 60; - seconds = rem t 60; - - # Courtesy of https://stackoverflow.com/a/32158604. - z = days + 719468; - era = (if z >= 0 then z else z - 146096) / 146097; - doe = z - era * 146097; - yoe = (doe - doe / 1460 + doe / 36524 - doe / 146096) / 365; - y = yoe + era * 400; - doy = doe - (365 * yoe + yoe / 4 - yoe / 100); - mp = (5 * doy + 2) / 153; - d = doy - (153 * mp + 2) / 5 + 1; - m = mp + (if mp < 10 then 3 else -9); - y' = y + (if m <= 2 then 1 else 0); - - pad = s: if builtins.stringLength s < 2 then "0" + s else s; - in "${toString y'}${pad (toString m)}${pad (toString d)}${pad (toString hours)}${pad (toString minutes)}${pad (toString seconds)}"; -in { - haskell-nix = prev.haskell-nix // { - sources = prev.haskell-nix.sources // builtins.listToAttrs (map (name: - let lockFile = builtins.fromJSON (builtins.readFile ../lazy-inputs/${name}/flake.lock); - in { - inherit name; - value = final.fetchFromGitLab { - domain = "gitlab.haskell.org"; - owner = "ghc"; - repo = "ghc"; - fetchSubmodules = true; - inherit (lockFile.nodes.${name}.locked) rev; - sha256 = lockFile.nodes.${name}.locked.narHash; - } // { - lastModifiedDate = formatSecondsSinceEpoch lockFile.nodes.${name}.locked.lastModified; - }; - }) ["ghc912X" "ghc913"]); - }; -} From 72c9c928de248b25655b4bd8659838fa55e7f717 Mon Sep 17 00:00:00 2001 From: Hamish Mackenzie Date: Thu, 24 Oct 2024 15:02:49 +1300 Subject: [PATCH 09/50] Skip broken mingwW64 GHC --- ci.nix | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/ci.nix b/ci.nix index d1ba37aefb..43463ef449 100644 --- a/ci.nix +++ b/ci.nix @@ -90,7 +90,7 @@ inherit (lib.systems.examples) ghcjs; } // lib.optionalAttrs ( (__match ".*llvm" compiler-nix-name == null) - && ((system == "x86_64-linux" && !builtins.elem compiler-nix-name ["ghc884" "ghc902" "ghc928" "ghc91120240918"]) # Including GHC HEAD here because the patches for rts/RtsSymbols.c no longer apply and mingwW64 GHC build fails without them + && ((system == "x86_64-linux" && !builtins.elem compiler-nix-name ["ghc884" "ghc902" "ghc928" "ghc91320241022"]) # Including GHC HEAD here because the patches for rts/RtsSymbols.c no longer apply and mingwW64 GHC build fails without them || (system == "x86_64-darwin" && builtins.elem compiler-nix-name []))) { # TODO add ghc versions when we have more darwin build capacity inherit (lib.systems.examples) mingwW64; } // lib.optionalAttrs (nixpkgsName == "unstable" From 6250a01cf274a7435838bf1b06068907fc9cc574 Mon Sep 17 00:00:00 2001 From: Hamish Mackenzie Date: Thu, 24 Oct 2024 15:04:25 +1300 Subject: [PATCH 10/50] Skip broken mingwW64 GHC --- ci.nix | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/ci.nix b/ci.nix index 43463ef449..76ad7974b0 100644 --- a/ci.nix +++ b/ci.nix @@ -90,7 +90,7 @@ inherit (lib.systems.examples) ghcjs; } // lib.optionalAttrs ( (__match ".*llvm" compiler-nix-name == null) - && ((system == "x86_64-linux" && !builtins.elem compiler-nix-name ["ghc884" "ghc902" "ghc928" "ghc91320241022"]) # Including GHC HEAD here because the patches for rts/RtsSymbols.c no longer apply and mingwW64 GHC build fails without them + && ((system == "x86_64-linux" && !builtins.elem compiler-nix-name ["ghc884" "ghc902" "ghc928" "ghc91220241014" "ghc91320241022"]) # Including GHC HEAD here because the patches for rts/RtsSymbols.c no longer apply and mingwW64 GHC build fails without them || (system == "x86_64-darwin" && builtins.elem compiler-nix-name []))) { # TODO add ghc versions when we have more darwin build capacity inherit (lib.systems.examples) mingwW64; } // lib.optionalAttrs (nixpkgsName == "unstable" From fd31f3204671f97b9c35e45f55d77f7437637cdc Mon Sep 17 00:00:00 2001 From: Hamish Mackenzie Date: Thu, 24 Oct 2024 16:28:51 +1300 Subject: [PATCH 11/50] Add GHC 9.8.3 --- ci.nix | 4 +-- lazy-inputs/default.nix | 1 + lazy-inputs/ghc983/flake.lock | 30 ++++++++++++++++ lazy-inputs/ghc983/flake.nix | 12 +++++++ overlays/bootstrap.nix | 34 +++++++++++++++++-- .../default.nix | 10 +++--- 6 files changed, 81 insertions(+), 10 deletions(-) create mode 100644 lazy-inputs/ghc983/flake.lock create mode 100644 lazy-inputs/ghc983/flake.nix diff --git a/ci.nix b/ci.nix index 76ad7974b0..4cba2038ab 100644 --- a/ci.nix +++ b/ci.nix @@ -84,8 +84,8 @@ && (__match ".*llvm" compiler-nix-name == null) && ((system == "x86_64-linux" && !builtins.elem compiler-nix-name ["ghc884" "ghc902" "ghc928" "ghc948"]) || (system == "aarch64-linux" && !builtins.elem compiler-nix-name ["ghc884" "ghc902" "ghc928" "ghc948"]) - || (system == "x86_64-darwin" && !builtins.elem compiler-nix-name ["ghc884" "ghc902" "ghc928" "ghc948" "ghc966" "ghc982"]) - || (system == "aarch64-darwin" && !builtins.elem compiler-nix-name ["ghc884" "ghc902" "ghc928" "ghc948" "ghc966" "ghc982"]) + || (system == "x86_64-darwin" && !builtins.elem compiler-nix-name ["ghc884" "ghc902" "ghc928" "ghc948" "ghc966" "ghc982" "ghc983"]) + || (system == "aarch64-darwin" && !builtins.elem compiler-nix-name ["ghc884" "ghc902" "ghc928" "ghc948" "ghc966" "ghc982" "ghc983"]) )) { inherit (lib.systems.examples) ghcjs; } // lib.optionalAttrs ( diff --git a/lazy-inputs/default.nix b/lazy-inputs/default.nix index 3cb8446c77..3b5242ab6b 100644 --- a/lazy-inputs/default.nix +++ b/lazy-inputs/default.nix @@ -31,6 +31,7 @@ in { inherit ((callFlake { pkgs = final; src = ./ghc966; }).defaultNix) ghc966; inherit ((callFlake { pkgs = final; src = ./ghc981; }).defaultNix) ghc981; inherit ((callFlake { pkgs = final; src = ./ghc982; }).defaultNix) ghc982; + inherit ((callFlake { pkgs = final; src = ./ghc983; }).defaultNix) ghc983; inherit ((callFlake { pkgs = final; src = ./ghc9101; }).defaultNix) ghc9101; inherit ((callFlake { pkgs = final; src = ./ghc912X; }).defaultNix) ghc912X; inherit ((callFlake { pkgs = final; src = ./ghc913; }).defaultNix) ghc913; diff --git a/lazy-inputs/ghc983/flake.lock b/lazy-inputs/ghc983/flake.lock new file mode 100644 index 0000000000..e5f97ab89c --- /dev/null +++ b/lazy-inputs/ghc983/flake.lock @@ -0,0 +1,30 @@ +{ + "nodes": { + "ghc983": { + "flake": false, + "locked": { + "lastModified": 1729341681, + "narHash": "sha256-6gkAFzft1DEoZvN0jhtYV49P2PGusK0duMJLzsoBmpo=", + "ref": "ghc-9.8.3-iog", + "rev": "72e041753f8d2c5b1fae0465277b187c61f17634", + "revCount": 61868, + "submodules": true, + "type": "git", + "url": "https://github.com/stable-haskell/ghc" + }, + "original": { + "ref": "ghc-9.8.3-iog", + "submodules": true, + "type": "git", + "url": "https://github.com/stable-haskell/ghc" + } + }, + "root": { + "inputs": { + "ghc983": "ghc983" + } + } + }, + "root": "root", + "version": 7 +} diff --git a/lazy-inputs/ghc983/flake.nix b/lazy-inputs/ghc983/flake.nix new file mode 100644 index 0000000000..8612fb0483 --- /dev/null +++ b/lazy-inputs/ghc983/flake.nix @@ -0,0 +1,12 @@ +{ + description = "Lazy Input for Haskell.nix"; + + inputs = { + ghc983 = { + flake = false; + url = "git+https://github.com/stable-haskell/ghc?ref=ghc-9.8.3-iog&submodules=1"; + }; + }; + + outputs = inputs: inputs; +} diff --git a/overlays/bootstrap.nix b/overlays/bootstrap.nix index bd2a7e327a..097691c90c 100644 --- a/overlays/bootstrap.nix +++ b/overlays/bootstrap.nix @@ -7,7 +7,7 @@ let "9.2" = "9.2.8"; "9.4" = "9.4.8"; "9.6" = "9.6.6"; - "9.8" = "9.8.2"; + "9.8" = "9.8.3"; "9.10" = "9.10.1"; }; gitInputs = { @@ -814,13 +814,40 @@ in { ghc-patches = ghc-patches "9.8.2"; }); + ghc983 = traceWarnOld "9.8" (final.callPackage ../compiler/ghc { + extra-passthru = { buildGHC = final.buildPackages.haskell-nix.compiler.ghc983; }; + + bootPkgs = bootPkgsGhc94 // { + ghc = if final.stdenv.buildPlatform != final.stdenv.targetPlatform + then final.buildPackages.buildPackages.haskell-nix.compiler.ghc966 + else final.buildPackages.buildPackages.haskell.compiler.ghc966 + or final.buildPackages.buildPackages.haskell.compiler.ghc965 + or final.buildPackages.buildPackages.haskell.compiler.ghc964 + or final.buildPackages.buildPackages.haskell.compiler.ghc963 + or final.buildPackages.buildPackages.haskell.compiler.ghc962 + or final.buildPackages.buildPackages.haskell.compiler.ghc945 + or final.buildPackages.buildPackages.haskell.compiler.ghc944 + or final.buildPackages.buildPackages.haskell.compiler.ghc943; + }; + inherit sphinx; + + buildLlvmPackages = final.buildPackages.llvmPackages_12; + llvmPackages = final.llvmPackages_12; + + src-spec.file = final.haskell-nix.sources.ghc983; + src-spec.version = "9.8.3"; + src-spec.needsBooting = true; + + ghc-patches = ghc-patches "9.8.3"; + }); ghc9101 = traceWarnOld "9.10" (final.callPackage ../compiler/ghc { extra-passthru = { buildGHC = final.buildPackages.haskell-nix.compiler.ghc9101; }; bootPkgs = bootPkgsGhc94 // { ghc = if final.stdenv.buildPlatform != final.stdenv.targetPlatform then final.buildPackages.buildPackages.haskell-nix.compiler.ghc9101 - else final.buildPackages.buildPackages.haskell.compiler.ghc982 + else final.buildPackages.buildPackages.haskell.compiler.ghc983 + or final.buildPackages.buildPackages.haskell.compiler.ghc982 or final.buildPackages.buildPackages.haskell.compiler.ghc981 or final.buildPackages.buildPackages.haskell.compiler.ghc966 or final.buildPackages.buildPackages.haskell.compiler.ghc965 @@ -856,7 +883,8 @@ in { bootPkgs = bootPkgsGhc94 // { ghc = if final.stdenv.buildPlatform != final.stdenv.targetPlatform then final.buildPackages.buildPackages.haskell-nix.compiler.ghc9101 # TODO use ${compiler-nix-name} - else final.buildPackages.buildPackages.haskell.compiler.ghc982 + else final.buildPackages.buildPackages.haskell.compiler.ghc983 + or final.buildPackages.buildPackages.haskell.compiler.ghc982 or final.buildPackages.buildPackages.haskell.compiler.ghc981 or final.buildPackages.buildPackages.haskell.compiler.ghc966 or final.buildPackages.buildPackages.haskell.compiler.ghc965 diff --git a/scripts/check-compiler-materialization/default.nix b/scripts/check-compiler-materialization/default.nix index dad5565220..21262ed4d6 100644 --- a/scripts/check-compiler-materialization/default.nix +++ b/scripts/check-compiler-materialization/default.nix @@ -41,16 +41,16 @@ in builtins.listToAttrs (builtins.concatMap (system: builtins.concatMap (compile ] ++ eval.lib.optionals ( (system == "aarch64-linux" && !__elem compiler-nix-name ["ghc8107" "ghc901" "ghc902" "ghc921" "ghc922" "ghc923" "ghc924" "ghc925" "ghc926" "ghc941" "ghc942" "ghc943"]) || (system == "x86_64-linux" && !__elem compiler-nix-name ["ghc8107" "ghc901" "ghc902" - "ghc921" "ghc922" "ghc923" "ghc924" "ghc925" "ghc926" "ghc941" "ghc942" "ghc943" "ghc944" "ghc945" "ghc947" "ghc961" "ghc962" "ghc963" "ghc964" "ghc965" "ghc9820230704"])) [ + "ghc921" "ghc922" "ghc923" "ghc924" "ghc925" "ghc926" "ghc941" "ghc942" "ghc943" "ghc944" "ghc945" "ghc947" "ghc961" "ghc962" "ghc963" "ghc964" "ghc965"])) [ { name = "${prefix}-arm-musl"; value = (pkgs.pkgsCross.aarch64-multiplatform-musl.haskell-nix.roots' compiler-nix-name).ghc-extra-projects-nix or {}; } { name = "${prefix}-iserv-arm-musl"; value = pkgs.pkgsCross.aarch64-multiplatform-musl.haskell-nix.iserv-proxy-exes.${compiler-nix-name}.iserv-proxy.project.plan-nix; } { name = "${prefix}-iserv-int-arm-musl"; value = pkgs.pkgsCross.aarch64-multiplatform-musl.haskell-nix.iserv-proxy-exes.${compiler-nix-name}.iserv-proxy-interpreter.project.plan-nix; } { name = "${prefix}-hello-arm-musl"; value = (pkgs.pkgsCross.aarch64-multiplatform-musl.haskell-nix.tool compiler-nix-name "hello" {}).project.plan-nix; } ] ++ eval.lib.optionals ( - (system == "x86_64-linux" && __elem compiler-nix-name ["ghc8107" "ghc961" "ghc962" "ghc963" "ghc964" "ghc965" "ghc981" "ghc982" "ghc9820230704"]) - || (system == "aarch64-linux" && __elem compiler-nix-name ["ghc961" "ghc962" "ghc963" "ghc964" "ghc965" "ghc981" "ghc982" "ghc9820230704"]) - || (system == "x86_64-darwin" && __elem compiler-nix-name ["ghc8107" "ghc961" "ghc962" "ghc963" "ghc964" "ghc964" "ghc981" "ghc982" "ghc9820230704"]) - || (system == "aarch64-darwin" && __elem compiler-nix-name ["ghc961" "ghc962" "ghc963" "ghc964" "ghc981" "ghc965" "ghc982" "ghc9820230704"])) [ + (system == "x86_64-linux" && __elem compiler-nix-name ["ghc8107" "ghc961" "ghc962" "ghc963" "ghc964" "ghc965" "ghc981" "ghc982" "ghc983" "ghc9101"]) + || (system == "aarch64-linux" && __elem compiler-nix-name ["ghc961" "ghc962" "ghc963" "ghc964" "ghc965" "ghc981" "ghc982" "ghc983" "ghc9101"]) + || (system == "x86_64-darwin" && __elem compiler-nix-name ["ghc8107" "ghc961" "ghc962" "ghc963" "ghc964" "ghc964" "ghc981" "ghc982" "ghc983" "ghc9101"]) + || (system == "aarch64-darwin" && __elem compiler-nix-name ["ghc961" "ghc962" "ghc963" "ghc964" "ghc981" "ghc965" "ghc982" "ghc983" "ghc9101"])) [ { name = "${prefix}-boot-ghcjs"; value = pkgs.pkgsCross.ghcjs.ghc-boot-packages-nix.${compiler-nix-name}; } { name = "${prefix}-ghcjs"; value = (pkgs.pkgsCross.ghcjs.haskell-nix.roots' compiler-nix-name).ghc-extra-projects-nix or {}; } { name = "${prefix}-hello-ghcjs"; value = (pkgs.pkgsCross.ghcjs.haskell-nix.tool compiler-nix-name "hello" {}).project.plan-nix; } From ed4ae560882925aa4b290fc953cfdd124745bd4e Mon Sep 17 00:00:00 2001 From: Hamish Mackenzie Date: Thu, 24 Oct 2024 16:47:29 +1300 Subject: [PATCH 12/50] Update patch bounds --- overlays/bootstrap.nix | 10 +++++----- 1 file changed, 5 insertions(+), 5 deletions(-) diff --git a/overlays/bootstrap.nix b/overlays/bootstrap.nix index 097691c90c..8f2abb2c2c 100644 --- a/overlays/bootstrap.nix +++ b/overlays/bootstrap.nix @@ -168,7 +168,7 @@ in { ++ onGhcjs (fromUntil "9.6.3" "9.8" ./patches/ghc/ghc-9.6.3-JS-implement-TH-support.patch) ++ fromUntil "9.8.1" "9.8.2" ./patches/ghc/ghc-9.8-cabal-c-soures-fix.patch ++ fromUntil "9.6.3" "9.6.5" ./patches/ghc/ghc-9.6.3-Cabal-9384.patch - ++ fromUntil "9.8.1" "9.9" ./patches/ghc/ghc-9.6.3-Cabal-9384.patch + ++ fromUntil "9.8.1" "9.8.3" ./patches/ghc/ghc-9.6.3-Cabal-9384.patch # the following is a partial reversal of https://gitlab.haskell.org/ghc/ghc/-/merge_requests/4391, to address haskell.nix#1227 ++ onAarch64 (until "9.0" ./patches/ghc/mmap-next.patch) @@ -245,10 +245,10 @@ in { ++ onWindowsOrMusl (fromUntil "9.8.2" "9.11" ./patches/ghc/ghc-9.6-0006-Adds-support-for-Hidden-symbols.patch) ++ onWindowsOrMusl (fromUntil "9.6" "9.7" ./patches/ghc/ghc-9.6-0006-Adds-support-for-Hidden-symbols-2.patch) ++ onWindowsOrMusl (fromUntil "9.8.2" "9.11" ./patches/ghc/ghc-9.6-0006-Adds-support-for-Hidden-symbols-2.patch) - ++ fromUntil "9.9" "9.11" ./patches/ghc/ghc-9.9-Cabal-3.11.patch - ++ fromUntil "9.8" "9.9" ./patches/ghc/ghc-9.8-text-upper-bound.patch - ++ fromUntil "9.10" "9.11" ./patches/ghc/ghc-9.10-containers-upper-bound.patch - ++ fromUntil "9.10" "9.14" ./patches/ghc/ghc-9.10-merge-objects.patch + ++ fromUntil "9.9" "9.11" ./patches/ghc/ghc-9.9-Cabal-3.11.patch + ++ fromUntil "9.8" "9.8.3" ./patches/ghc/ghc-9.8-text-upper-bound.patch + ++ fromUntil "9.10" "9.11" ./patches/ghc/ghc-9.10-containers-upper-bound.patch + ++ fromUntil "9.10" "9.14" ./patches/ghc/ghc-9.10-merge-objects.patch # This patch will make windows stop emitting absolute relocations. This is one way in which binutils 2.36+ (with ASLR enabled), will just choke on the # assembly we generate because it's always absolute (32bit) addressing modes. From ba4778160b5f7da7de86c4d0892859ab35b355df Mon Sep 17 00:00:00 2001 From: Hamish Mackenzie Date: Thu, 24 Oct 2024 17:17:44 +1300 Subject: [PATCH 13/50] More patch fixes --- overlays/bootstrap.nix | 6 +- ...b54a1d5725bd0d8a4b0a909d1b41d742b50b.patch | 81 +++++++++++++++++++ 2 files changed, 85 insertions(+), 2 deletions(-) create mode 100644 overlays/patches/ghc/ghc-9.8.3-f8beb54a1d5725bd0d8a4b0a909d1b41d742b50b.patch diff --git a/overlays/bootstrap.nix b/overlays/bootstrap.nix index 8f2abb2c2c..c6e8e1c985 100644 --- a/overlays/bootstrap.nix +++ b/overlays/bootstrap.nix @@ -185,7 +185,8 @@ in { ++ onAarch64 (until "9.0" ./patches/ghc/ghc-8.10-aarch64-handle-none-rela.patch) ++ onWindows (until "9.0" ./patches/ghc/5b08e0c06e038448a63aa9bd7f163b23d824ba4b.patch) ++ onAarch64 (fromUntil "9.0" "9.11" ./patches/ghc/ghc-9.0-better-symbol-addr-debug.patch) - ++ onAarch64 (fromUntil "9.0" "9.11" ./patches/ghc/ghc-9.0-aarch64-handle-none-rela.patch) + ++ onAarch64 (fromUntil "9.0" "9.8.3" ./patches/ghc/ghc-9.0-aarch64-handle-none-rela.patch) + ++ onAarch64 (fromUntil "9.10" "9.11" ./patches/ghc/ghc-9.0-aarch64-handle-none-rela.patch) ++ onWindows (fromUntil "9.6.3" "9.6.4" ./patches/ghc/ghc-9.6-hadrian-splitsections.patch) ++ onWindows (fromUntil "9.8.1" "9.8.2" ./patches/ghc/ghc-9.6-hadrian-splitsections.patch) @@ -216,7 +217,8 @@ in { # Allow loading static external plugins into cross compilers ++ onCross (fromUntil "9.6.1" "9.11" ./patches/ghc/5c80a27488acfe3610ddfcb99a1e961002e386d0.patch) - ++ onCross (fromUntil "9.6.1" "9.11" ./patches/ghc/f8beb54a1d5725bd0d8a4b0a909d1b41d742b50b.patch) + ++ onCross (fromUntil "9.6.1" "9.8.3" ./patches/ghc/f8beb54a1d5725bd0d8a4b0a909d1b41d742b50b.patch) + ++ onCross (fromUntil "9.8.3" "9.11" ./patches/ghc/ghc-9.8.3-f8beb54a1d5725bd0d8a4b0a909d1b41d742b50b.patch) ++ final.lib.optionals ( final.stdenv.targetPlatform.isAndroid && final.stdenv.targetPlatform.is32bit diff --git a/overlays/patches/ghc/ghc-9.8.3-f8beb54a1d5725bd0d8a4b0a909d1b41d742b50b.patch b/overlays/patches/ghc/ghc-9.8.3-f8beb54a1d5725bd0d8a4b0a909d1b41d742b50b.patch new file mode 100644 index 0000000000..6a6e2625b5 --- /dev/null +++ b/overlays/patches/ghc/ghc-9.8.3-f8beb54a1d5725bd0d8a4b0a909d1b41d742b50b.patch @@ -0,0 +1,81 @@ +From f8beb54a1d5725bd0d8a4b0a909d1b41d742b50b Mon Sep 17 00:00:00 2001 +From: Luite Stegeman +Date: Fri, 8 Dec 2023 12:12:20 +0100 +Subject: [PATCH] External plugins: try loading archive if loading dynamic + library fails + +--- + compiler/GHC/Driver/Plugins.hs | 27 ++++++++++----------------- + 1 file changed, 10 insertions(+), 17 deletions(-) + +diff --git a/compiler/GHC/Driver/Plugins.hs b/compiler/GHC/Driver/Plugins.hs +index 2f3bf44b408..8b06e8b16d5 100644 +--- a/compiler/GHC/Driver/Plugins.hs ++++ b/compiler/GHC/Driver/Plugins.hs +@@ -1,12 +1,9 @@ + {-# LANGUAGE RankNTypes #-} + {-# LANGUAGE CPP #-} + +-#if defined(CAN_LOAD_DLL) + {-# LANGUAGE MagicHash #-} + {-# LANGUAGE LambdaCase #-} + {-# LANGUAGE UnboxedTuples #-} +-#endif +- + + -- | Definitions for writing /plugins/ for GHC. Plugins can hook into + -- several areas of the compiler. See the 'Plugin' type. These plugins +@@ -103,11 +100,9 @@ import qualified Data.Semigroup + + import Control.Monad + +-#if defined(CAN_LOAD_DLL) + import GHCi.ObjLink + import GHC.Exts (addrToAny#, Ptr(..)) + import GHC.Utils.Encoding +-#endif + + + -- | Command line options gathered from the -PModule.Name:stuff syntax +@@ -372,10 +367,6 @@ defaultFrontendPlugin = FrontendPlugin { frontend = \_ _ -> return () } + -- | Load external plugins + loadExternalPlugins :: [ExternalPluginSpec] -> IO [ExternalPlugin] + loadExternalPlugins [] = return [] +-#if !defined(CAN_LOAD_DLL) +-loadExternalPlugins _ = do +- panic "loadExternalPlugins: loading shared libraries isn't supported by this compiler" +-#else + loadExternalPlugins ps = do + -- initialize the linker + initObjLinker RetainCAFs +@@ -400,17 +391,19 @@ loadExternalPlugins ps = do + + loadExternalPluginLib :: FilePath -> IO () + loadExternalPluginLib path = do +- -- load library ++ -- XXX we should probably use the filename to determine whether ++ -- the plugin is an archive or dynamic lib ++ ++ -- try loading it as a dynamic library + loadDLL path >>= \case +- Left errmsg -> pprPanic "loadExternalPluginLib" +- (vcat [ text "Can't load plugin library" +- , text " Library path: " <> text path +- , text " Error : " <> text errmsg +- ]) +- Right _ -> do ++ Left _errmsg -> ++ -- if that fails, try loading it as an archive ++ loadArchive path >> resolve ++ Right _ -> resolve ++ where ++ resolve = do + -- resolve objects + resolveObjs >>= \case + True -> return () + False -> pprPanic "loadExternalPluginLib" (text "Unable to resolve objects for library: " <> text path) + +-#endif +-- +GitLab + From cac67f7e1b8c8dbdef901c9dfeee62089a63e756 Mon Sep 17 00:00:00 2001 From: Hamish Mackenzie Date: Thu, 24 Oct 2024 20:04:53 +1300 Subject: [PATCH 14/50] Turn off pool allocator in favour of m32_alloc solution in ghc 9.8.3 --- overlays/bootstrap.nix | 6 ++++-- 1 file changed, 4 insertions(+), 2 deletions(-) diff --git a/overlays/bootstrap.nix b/overlays/bootstrap.nix index c6e8e1c985..09c2b33ef0 100644 --- a/overlays/bootstrap.nix +++ b/overlays/bootstrap.nix @@ -224,8 +224,10 @@ in { && final.stdenv.targetPlatform.is32bit || final.stdenv.targetPlatform.isMusl) (until "9.11" ./patches/ghc/ghc-9.6-missing-symbols-deadbeef.patch) - ++ onAarch64Musl (fromUntil "9.6" "9.11" ./patches/ghc/ghc-9.6-linker-pool-allocator.patch) - ++ onAarch64Musl (fromUntil "9.6" "9.11" ./patches/ghc/ghc-9.6-linker-pool-allocator-2.patch) + ++ onAarch64Musl (fromUntil "9.6" "9.8.3" ./patches/ghc/ghc-9.6-linker-pool-allocator.patch) + ++ onAarch64Musl (fromUntil "9.10" "9.11" ./patches/ghc/ghc-9.6-linker-pool-allocator.patch) + ++ onAarch64Musl (fromUntil "9.6" "9.8.3" ./patches/ghc/ghc-9.6-linker-pool-allocator-2.patch) + ++ onAarch64Musl (fromUntil "9.10" "9.11" ./patches/ghc/ghc-9.6-linker-pool-allocator-2.patch) ++ onMusl (fromUntil "9.6" "9.8" ./patches/ghc/ghc-9.6-0001-Refactor-IServ.hs.patch) ++ onMusl (fromUntil "9.6" "9.11" ./patches/ghc/ghc-9.6-0002-Drop-spurious-8-byte-offset-from-elf_plt.patch) From b7a6f6da6943030419726e79ebb087bb6e092288 Mon Sep 17 00:00:00 2001 From: Hamish Mackenzie Date: Thu, 24 Oct 2024 20:41:07 +1300 Subject: [PATCH 15/50] Remove another redundant patch --- overlays/bootstrap.nix | 3 ++- 1 file changed, 2 insertions(+), 1 deletion(-) diff --git a/overlays/bootstrap.nix b/overlays/bootstrap.nix index 09c2b33ef0..c73354d975 100644 --- a/overlays/bootstrap.nix +++ b/overlays/bootstrap.nix @@ -230,7 +230,8 @@ in { ++ onAarch64Musl (fromUntil "9.10" "9.11" ./patches/ghc/ghc-9.6-linker-pool-allocator-2.patch) ++ onMusl (fromUntil "9.6" "9.8" ./patches/ghc/ghc-9.6-0001-Refactor-IServ.hs.patch) - ++ onMusl (fromUntil "9.6" "9.11" ./patches/ghc/ghc-9.6-0002-Drop-spurious-8-byte-offset-from-elf_plt.patch) + ++ onMusl (fromUntil "9.6" "9.8.3" ./patches/ghc/ghc-9.6-0002-Drop-spurious-8-byte-offset-from-elf_plt.patch) + ++ onMusl (fromUntil "9.10" "9.11" ./patches/ghc/ghc-9.6-0002-Drop-spurious-8-byte-offset-from-elf_plt.patch) ++ onAarch64Musl (fromUntil "9.6" "9.11" ./patches/ghc/ghc-9.6-0003-Better-pool-alignment.-We-still-hardcode-section-ali.patch) ++ onAarch64Musl (fromUntil "9.6" "9.11" ./patches/ghc/ghc-9.6-0007-fixup-Better-pool-alignment.-We-still-hardcode-secti.patch) ++ onAarch64Musl (fromUntil "9.6" "9.11" ./patches/ghc/ghc-9.6-0008-pool-improvements.patch) From 43296b69efd2617022e8b037feec03a0242a8a68 Mon Sep 17 00:00:00 2001 From: Hamish Mackenzie Date: Thu, 24 Oct 2024 20:45:48 +1300 Subject: [PATCH 16/50] Turn off pool allocator in favour of m32_alloc solution in ghc 9.8.3 --- overlays/bootstrap.nix | 9 ++++++--- 1 file changed, 6 insertions(+), 3 deletions(-) diff --git a/overlays/bootstrap.nix b/overlays/bootstrap.nix index c73354d975..17472661a5 100644 --- a/overlays/bootstrap.nix +++ b/overlays/bootstrap.nix @@ -232,9 +232,12 @@ in { ++ onMusl (fromUntil "9.6" "9.8" ./patches/ghc/ghc-9.6-0001-Refactor-IServ.hs.patch) ++ onMusl (fromUntil "9.6" "9.8.3" ./patches/ghc/ghc-9.6-0002-Drop-spurious-8-byte-offset-from-elf_plt.patch) ++ onMusl (fromUntil "9.10" "9.11" ./patches/ghc/ghc-9.6-0002-Drop-spurious-8-byte-offset-from-elf_plt.patch) - ++ onAarch64Musl (fromUntil "9.6" "9.11" ./patches/ghc/ghc-9.6-0003-Better-pool-alignment.-We-still-hardcode-section-ali.patch) - ++ onAarch64Musl (fromUntil "9.6" "9.11" ./patches/ghc/ghc-9.6-0007-fixup-Better-pool-alignment.-We-still-hardcode-secti.patch) - ++ onAarch64Musl (fromUntil "9.6" "9.11" ./patches/ghc/ghc-9.6-0008-pool-improvements.patch) + ++ onAarch64Musl (fromUntil "9.6" "9.8.3" ./patches/ghc/ghc-9.6-0003-Better-pool-alignment.-We-still-hardcode-section-ali.patch) + ++ onAarch64Musl (fromUntil "9.10" "9.11" ./patches/ghc/ghc-9.6-0003-Better-pool-alignment.-We-still-hardcode-section-ali.patch) + ++ onAarch64Musl (fromUntil "9.6" "9.8.3" ./patches/ghc/ghc-9.6-0007-fixup-Better-pool-alignment.-We-still-hardcode-secti.patch) + ++ onAarch64Musl (fromUntil "9.10" "9.11" ./patches/ghc/ghc-9.6-0007-fixup-Better-pool-alignment.-We-still-hardcode-secti.patch) + ++ onAarch64Musl (fromUntil "9.6" "9.8.3" ./patches/ghc/ghc-9.6-0008-pool-improvements.patch) + ++ onAarch64Musl (fromUntil "9.10" "9.11" ./patches/ghc/ghc-9.6-0008-pool-improvements.patch) # these two are abit questionable. They are pretty rough, and assume static binary as well as posix. # onMusl (fromUntil "9.6" "9.11" ./patches/ghc/ghc-9.6-0004-ghcidladdr.patch) # onMusl (fromUntil "9.6" "9.11" ./patches/ghc/ghc-9.6-0005-Better-interpreter-debugging.-Needs-ghcidladdr.patch) From c6d7b8f60fc678ab2310133a92bb0c5a580e99d7 Mon Sep 17 00:00:00 2001 From: Hamish Mackenzie Date: Thu, 24 Oct 2024 20:50:41 +1300 Subject: [PATCH 17/50] Remove another redundant patch --- overlays/bootstrap.nix | 3 ++- 1 file changed, 2 insertions(+), 1 deletion(-) diff --git a/overlays/bootstrap.nix b/overlays/bootstrap.nix index 17472661a5..61fae8cffb 100644 --- a/overlays/bootstrap.nix +++ b/overlays/bootstrap.nix @@ -127,7 +127,8 @@ in { ++ onWindows (fromUntil "9.6.3" "9.11" ./patches/ghc/ghc-9.8-hadrian-win-cross.patch) # support R_X86_64_PC64 (ELF constant 24) - IMAGE_REL_AMD64_SREL32 (PE constant 14), which seems to appear with 9.6 more frequently, and # results in "unhandled PEi386 relocation type 14". - ++ onWindows (fromUntil "9.4.1" "9.11" ./patches/ghc/win-reloc-x86_64-pc64.patch) + ++ onWindows (fromUntil "9.4.1" "9.8.3" ./patches/ghc/win-reloc-x86_64-pc64.patch) + ++ onWindows (fromUntil "9.10" "9.11" ./patches/ghc/win-reloc-x86_64-pc64.patch) # ++ onWindows (fromUntil "9.4.1" "9.10" ./patches/ghc/Win32-depends-on-mingwex.patch) # if the host system provides ucrt (e.g. wine with ucrtbase.dll), we may end up linking against symbols from ucrtbase, instead of msvcrt, # thus leading to broken code. E.g. the handles we create and hand to wine will all be busted, because they come from one and are processed From 1b22b994f78bafaa613b7e73a5cabb9ec48b7548 Mon Sep 17 00:00:00 2001 From: Hamish Mackenzie Date: Thu, 24 Oct 2024 23:09:31 +1300 Subject: [PATCH 18/50] Fix ghc 9.10 --- overlays/bootstrap.nix | 3 ++- 1 file changed, 2 insertions(+), 1 deletion(-) diff --git a/overlays/bootstrap.nix b/overlays/bootstrap.nix index 61fae8cffb..30ab5138e3 100644 --- a/overlays/bootstrap.nix +++ b/overlays/bootstrap.nix @@ -219,7 +219,8 @@ in { # Allow loading static external plugins into cross compilers ++ onCross (fromUntil "9.6.1" "9.11" ./patches/ghc/5c80a27488acfe3610ddfcb99a1e961002e386d0.patch) ++ onCross (fromUntil "9.6.1" "9.8.3" ./patches/ghc/f8beb54a1d5725bd0d8a4b0a909d1b41d742b50b.patch) - ++ onCross (fromUntil "9.8.3" "9.11" ./patches/ghc/ghc-9.8.3-f8beb54a1d5725bd0d8a4b0a909d1b41d742b50b.patch) + ++ onCross (fromUntil "9.8.3" "9.10" ./patches/ghc/ghc-9.8.3-f8beb54a1d5725bd0d8a4b0a909d1b41d742b50b.patch) + ++ onCross (fromUntil "9.10" "9.11" ./patches/ghc/f8beb54a1d5725bd0d8a4b0a909d1b41d742b50b.patch) ++ final.lib.optionals ( final.stdenv.targetPlatform.isAndroid && final.stdenv.targetPlatform.is32bit From e9eceb13b7ea841466a44ee8b44d87727b47bcc2 Mon Sep 17 00:00:00 2001 From: Hamish Mackenzie Date: Thu, 24 Oct 2024 23:10:19 +1300 Subject: [PATCH 19/50] Update materialized files --- .../ghc983-ghcjs/base.nix | 49 +++++++++++ .../ghc983-ghcjs/deriveConstants.nix | 39 +++++++++ .../ghc983-ghcjs/genprimopcode.nix | 40 +++++++++ .../ghc983-ghcjs/ghc-bignum.nix | 37 +++++++++ .../ghc983-ghcjs/ghc-boot.nix | 46 +++++++++++ .../ghc983-ghcjs/ghc-heap.nix | 36 +++++++++ .../ghc983-ghcjs/ghc-prim.nix | 47 +++++++++++ .../ghc983-ghcjs/ghc.nix | 81 +++++++++++++++++++ .../ghc983-ghcjs/ghci.nix | 45 +++++++++++ .../ghc983-ghcjs/hpc.nix | 38 +++++++++ .../ghc983-ghcjs/integer-gmp.nix | 35 ++++++++ .../ghc983-ghcjs/iserv.nix | 41 ++++++++++ .../ghc983-ghcjs/remote-iserv.nix | 36 +++++++++ .../ghc983-ghcjs/template-haskell.nix | 36 +++++++++ .../ghc-boot-packages-nix/ghc983/base.nix | 49 +++++++++++ .../ghc983/deriveConstants.nix | 39 +++++++++ .../ghc983/genprimopcode.nix | 40 +++++++++ .../ghc983/ghc-bignum.nix | 37 +++++++++ .../ghc-boot-packages-nix/ghc983/ghc-boot.nix | 46 +++++++++++ .../ghc-boot-packages-nix/ghc983/ghc-heap.nix | 36 +++++++++ .../ghc-boot-packages-nix/ghc983/ghc-prim.nix | 47 +++++++++++ .../ghc-boot-packages-nix/ghc983/ghc.nix | 81 +++++++++++++++++++ .../ghc-boot-packages-nix/ghc983/ghci.nix | 45 +++++++++++ .../ghc-boot-packages-nix/ghc983/hpc.nix | 38 +++++++++ .../ghc983/integer-gmp.nix | 35 ++++++++ .../ghc-boot-packages-nix/ghc983/iserv.nix | 41 ++++++++++ .../ghc983/remote-iserv.nix | 36 +++++++++ .../ghc983/template-haskell.nix | 36 +++++++++ .../hadrian/cabal-files/cryptohash-sha256.nix | 4 +- .../hadrian/cabal-files/extra.nix | 10 +-- .../hadrian/cabal-files/hashable.nix | 54 +++++++------ .../hadrian/cabal-files/os-string.nix | 79 ++++++++++++++++++ .../hadrian/cabal-files/primitive.nix | 2 +- .../hadrian/cabal-files/random.nix | 8 +- .../hadrian/cabal-files/shake.nix | 17 ++-- .../hadrian/cabal-files/splitmix.nix | 2 +- .../cabal-files/unordered-containers.nix | 8 +- .../ghc964/hadrian-ghc910/hadrian/default.nix | 5 +- materialized/ghc964/hadrian-ghc910/plan.json | 2 +- .../hadrian/cabal-files/extra.nix | 10 +-- .../hadrian/cabal-files/hashable.nix | 54 +++++++------ .../hadrian/cabal-files/os-string.nix | 79 ++++++++++++++++++ .../hadrian/cabal-files/primitive.nix | 2 +- .../hadrian/cabal-files/random.nix | 8 +- .../hadrian/cabal-files/shake.nix | 17 ++-- .../hadrian/cabal-files/splitmix.nix | 2 +- .../cabal-files/unordered-containers.nix | 8 +- .../ghc964/hadrian-ghc96/hadrian/default.nix | 5 +- materialized/ghc964/hadrian-ghc96/plan.json | 2 +- .../hadrian/cabal-files/Cabal-syntax.nix | 55 ------------- .../hadrian/cabal-files/Cabal.nix | 56 ------------- .../hadrian/cabal-files/cryptohash-sha256.nix | 4 +- .../hadrian/cabal-files/extra.nix | 10 +-- .../hadrian/cabal-files/hashable.nix | 54 +++++++------ .../hadrian/cabal-files/os-string.nix | 79 ++++++++++++++++++ .../hadrian/cabal-files/primitive.nix | 2 +- .../hadrian/cabal-files/random.nix | 8 +- .../hadrian/cabal-files/shake.nix | 17 ++-- .../hadrian/cabal-files/splitmix.nix | 2 +- .../cabal-files/unordered-containers.nix | 8 +- .../ghc964/hadrian-ghc98/hadrian/default.nix | 13 ++- materialized/ghc964/hadrian-ghc98/plan.json | 2 +- 62 files changed, 1639 insertions(+), 261 deletions(-) create mode 100644 materialized/ghc-boot-packages-nix/ghc983-ghcjs/base.nix create mode 100644 materialized/ghc-boot-packages-nix/ghc983-ghcjs/deriveConstants.nix create mode 100644 materialized/ghc-boot-packages-nix/ghc983-ghcjs/genprimopcode.nix create mode 100644 materialized/ghc-boot-packages-nix/ghc983-ghcjs/ghc-bignum.nix create mode 100644 materialized/ghc-boot-packages-nix/ghc983-ghcjs/ghc-boot.nix create mode 100644 materialized/ghc-boot-packages-nix/ghc983-ghcjs/ghc-heap.nix create mode 100644 materialized/ghc-boot-packages-nix/ghc983-ghcjs/ghc-prim.nix create mode 100644 materialized/ghc-boot-packages-nix/ghc983-ghcjs/ghc.nix create mode 100644 materialized/ghc-boot-packages-nix/ghc983-ghcjs/ghci.nix create mode 100644 materialized/ghc-boot-packages-nix/ghc983-ghcjs/hpc.nix create mode 100644 materialized/ghc-boot-packages-nix/ghc983-ghcjs/integer-gmp.nix create mode 100644 materialized/ghc-boot-packages-nix/ghc983-ghcjs/iserv.nix create mode 100644 materialized/ghc-boot-packages-nix/ghc983-ghcjs/remote-iserv.nix create mode 100644 materialized/ghc-boot-packages-nix/ghc983-ghcjs/template-haskell.nix create mode 100644 materialized/ghc-boot-packages-nix/ghc983/base.nix create mode 100644 materialized/ghc-boot-packages-nix/ghc983/deriveConstants.nix create mode 100644 materialized/ghc-boot-packages-nix/ghc983/genprimopcode.nix create mode 100644 materialized/ghc-boot-packages-nix/ghc983/ghc-bignum.nix create mode 100644 materialized/ghc-boot-packages-nix/ghc983/ghc-boot.nix create mode 100644 materialized/ghc-boot-packages-nix/ghc983/ghc-heap.nix create mode 100644 materialized/ghc-boot-packages-nix/ghc983/ghc-prim.nix create mode 100644 materialized/ghc-boot-packages-nix/ghc983/ghc.nix create mode 100644 materialized/ghc-boot-packages-nix/ghc983/ghci.nix create mode 100644 materialized/ghc-boot-packages-nix/ghc983/hpc.nix create mode 100644 materialized/ghc-boot-packages-nix/ghc983/integer-gmp.nix create mode 100644 materialized/ghc-boot-packages-nix/ghc983/iserv.nix create mode 100644 materialized/ghc-boot-packages-nix/ghc983/remote-iserv.nix create mode 100644 materialized/ghc-boot-packages-nix/ghc983/template-haskell.nix create mode 100644 materialized/ghc964/hadrian-ghc910/hadrian/cabal-files/os-string.nix create mode 100644 materialized/ghc964/hadrian-ghc96/hadrian/cabal-files/os-string.nix delete mode 100644 materialized/ghc964/hadrian-ghc98/hadrian/cabal-files/Cabal-syntax.nix delete mode 100644 materialized/ghc964/hadrian-ghc98/hadrian/cabal-files/Cabal.nix create mode 100644 materialized/ghc964/hadrian-ghc98/hadrian/cabal-files/os-string.nix diff --git a/materialized/ghc-boot-packages-nix/ghc983-ghcjs/base.nix b/materialized/ghc-boot-packages-nix/ghc983-ghcjs/base.nix new file mode 100644 index 0000000000..d918879f6f --- /dev/null +++ b/materialized/ghc-boot-packages-nix/ghc983-ghcjs/base.nix @@ -0,0 +1,49 @@ +{ system + , compiler + , flags + , pkgs + , hsPkgs + , pkgconfPkgs + , errorHandler + , config + , ... }: + { + flags = {}; + package = { + specVersion = "3.0"; + identifier = { name = "base"; version = "4.19.2.0"; }; + license = "BSD-3-Clause"; + copyright = ""; + maintainer = "Core Libraries Committee "; + author = ""; + homepage = ""; + url = ""; + synopsis = "Core data structures and operations"; + description = "Haskell's base library provides, among other things, core types (e.g. [Bool](\"Data.Bool\") and [Int](\"Data.Int\")),\ndata structures (e.g. [List](\"Data.List\"), [Tuple](\"Data.Tuple\") and [Maybe](\"Data.Maybe\")),\nthe [Exception](\"Control.Exception\") mechanism, and the [IO](\"System.IO\") & [Concurrency](\"Control.Concurrent\") operations.\nThe \"Prelude\" module, which is imported by default, exposes a curated set of types and functions from other modules.\n\nOther data structures like [Map](https://hackage.haskell.org/package/containers/docs/Data-Map.html),\n[Set](https://hackage.haskell.org/package/containers/docs/Data-Set.html) are available in the [containers](https://hackage.haskell.org/package/containers) library.\nTo work with textual data, use the [text](https://hackage.haskell.org/package/text/docs/Data-Text.html) library."; + buildType = "Configure"; + }; + components = { + "library" = { + depends = [ + (hsPkgs."rts" or (errorHandler.buildDepError "rts")) + (hsPkgs."ghc-prim" or (errorHandler.buildDepError "ghc-prim")) + (hsPkgs."ghc-bignum" or (errorHandler.buildDepError "ghc-bignum")) + ]; + libs = pkgs.lib.optionals (system.isWindows) [ + (pkgs."wsock32" or (errorHandler.sysDepError "wsock32")) + (pkgs."user32" or (errorHandler.sysDepError "user32")) + (pkgs."shell32" or (errorHandler.sysDepError "shell32")) + (pkgs."mingw32" or (errorHandler.sysDepError "mingw32")) + (pkgs."kernel32" or (errorHandler.sysDepError "kernel32")) + (pkgs."advapi32" or (errorHandler.sysDepError "advapi32")) + (pkgs."mingwex" or (errorHandler.sysDepError "mingwex")) + (pkgs."ws2_32" or (errorHandler.sysDepError "ws2_32")) + (pkgs."shlwapi" or (errorHandler.sysDepError "shlwapi")) + (pkgs."ole32" or (errorHandler.sysDepError "ole32")) + (pkgs."rpcrt4" or (errorHandler.sysDepError "rpcrt4")) + (pkgs."ntdll" or (errorHandler.sysDepError "ntdll")) + ]; + buildable = true; + }; + }; + } // rec { src = pkgs.lib.mkDefault ./.; } diff --git a/materialized/ghc-boot-packages-nix/ghc983-ghcjs/deriveConstants.nix b/materialized/ghc-boot-packages-nix/ghc983-ghcjs/deriveConstants.nix new file mode 100644 index 0000000000..135cdd02f6 --- /dev/null +++ b/materialized/ghc-boot-packages-nix/ghc983-ghcjs/deriveConstants.nix @@ -0,0 +1,39 @@ +{ system + , compiler + , flags + , pkgs + , hsPkgs + , pkgconfPkgs + , errorHandler + , config + , ... }: + { + flags = {}; + package = { + specVersion = "1.10"; + identifier = { name = "deriveConstants"; version = "0.1"; }; + license = "BSD-3-Clause"; + copyright = "XXX"; + maintainer = "XXX"; + author = "XXX"; + homepage = ""; + url = ""; + synopsis = "Derive header files containing various constants for the GHC build process"; + description = "This utility is responsible for generating a number of C header files\nneeded during the GHC build process. See @rts/include/ghc.mk@ in the GHC\nbuild system for details."; + buildType = "Simple"; + }; + components = { + exes = { + "deriveConstants" = { + depends = [ + (hsPkgs."base" or (errorHandler.buildDepError "base")) + (hsPkgs."containers" or (errorHandler.buildDepError "containers")) + (hsPkgs."process" or (errorHandler.buildDepError "process")) + (hsPkgs."filepath" or (errorHandler.buildDepError "filepath")) + (hsPkgs."directory" or (errorHandler.buildDepError "directory")) + ]; + buildable = true; + }; + }; + }; + } // rec { src = pkgs.lib.mkDefault ./.; } diff --git a/materialized/ghc-boot-packages-nix/ghc983-ghcjs/genprimopcode.nix b/materialized/ghc-boot-packages-nix/ghc983-ghcjs/genprimopcode.nix new file mode 100644 index 0000000000..49bbe516ba --- /dev/null +++ b/materialized/ghc-boot-packages-nix/ghc983-ghcjs/genprimopcode.nix @@ -0,0 +1,40 @@ +{ system + , compiler + , flags + , pkgs + , hsPkgs + , pkgconfPkgs + , errorHandler + , config + , ... }: + { + flags = { build-tool-depends = true; }; + package = { + specVersion = "2.0"; + identifier = { name = "genprimopcode"; version = "0.1"; }; + license = "BSD-3-Clause"; + copyright = "XXX"; + maintainer = "XXX"; + author = "XXX"; + homepage = ""; + url = ""; + synopsis = "Generates various files implementing GHC's primitive operations."; + description = "This utility reads a textual description of GHC's primitive operations\n(@primops.txt.pp@) and produces a number of outputs. These include,\n\n* the @GHC.Prim@ module included in the @ghc-prim@ package.\n* the @GHC.PrimopWrappers@ module included in the @ghc-prim@ package.\n* an LaTeX document describing the primitive operations."; + buildType = "Simple"; + }; + components = { + exes = { + "genprimopcode" = { + depends = [ + (hsPkgs."base" or (errorHandler.buildDepError "base")) + (hsPkgs."array" or (errorHandler.buildDepError "array")) + ]; + build-tools = pkgs.lib.optionals (flags.build-tool-depends) [ + (hsPkgs.pkgsBuildBuild.alex.components.exes.alex or (pkgs.pkgsBuildBuild.alex or (errorHandler.buildToolDepError "alex:alex"))) + (hsPkgs.pkgsBuildBuild.happy.components.exes.happy or (pkgs.pkgsBuildBuild.happy or (errorHandler.buildToolDepError "happy:happy"))) + ]; + buildable = true; + }; + }; + }; + } // rec { src = pkgs.lib.mkDefault ./.; } diff --git a/materialized/ghc-boot-packages-nix/ghc983-ghcjs/ghc-bignum.nix b/materialized/ghc-boot-packages-nix/ghc983-ghcjs/ghc-bignum.nix new file mode 100644 index 0000000000..46af6e0e9f --- /dev/null +++ b/materialized/ghc-boot-packages-nix/ghc983-ghcjs/ghc-bignum.nix @@ -0,0 +1,37 @@ +{ system + , compiler + , flags + , pkgs + , hsPkgs + , pkgconfPkgs + , errorHandler + , config + , ... }: + { + flags = { native = false; ffi = false; gmp = false; check = false; }; + package = { + specVersion = "2.0"; + identifier = { name = "ghc-bignum"; version = "1.3"; }; + license = "BSD-3-Clause"; + copyright = ""; + maintainer = "libraries@haskell.org"; + author = "Sylvain Henry"; + homepage = ""; + url = ""; + synopsis = "GHC BigNum library"; + description = "This package provides the low-level implementation of the standard\n'BigNat', 'Natural' and 'Integer' types."; + buildType = "Configure"; + }; + components = { + "library" = { + depends = [ + (hsPkgs."ghc-prim" or (errorHandler.buildDepError "ghc-prim")) + ]; + buildable = (if !flags.native && !flags.gmp && !flags.ffi + then false + else true) && (if flags.native && (flags.gmp || flags.ffi) + then false + else true) && (if flags.gmp && flags.ffi then false else true); + }; + }; + } // rec { src = pkgs.lib.mkDefault ./.; } diff --git a/materialized/ghc-boot-packages-nix/ghc983-ghcjs/ghc-boot.nix b/materialized/ghc-boot-packages-nix/ghc983-ghcjs/ghc-boot.nix new file mode 100644 index 0000000000..276da77ac7 --- /dev/null +++ b/materialized/ghc-boot-packages-nix/ghc983-ghcjs/ghc-boot.nix @@ -0,0 +1,46 @@ +{ system + , compiler + , flags + , pkgs + , hsPkgs + , pkgconfPkgs + , errorHandler + , config + , ... }: + { + flags = {}; + package = { + specVersion = "3.0"; + identifier = { name = "ghc-boot"; version = "9.8.3"; }; + license = "BSD-3-Clause"; + copyright = ""; + maintainer = "ghc-devs@haskell.org"; + author = ""; + homepage = ""; + url = ""; + synopsis = "Shared functionality between GHC and its boot libraries"; + description = "This library is shared between GHC, ghc-pkg, and other boot\nlibraries.\n.\nA note about \"GHC.Unit.Database\": it only deals with the subset of\nthe package database that the compiler cares about: modules\npaths etc and not package metadata like description, authors\netc. It is thus not a library interface to ghc-pkg and is *not*\nsuitable for modifying GHC package databases.\n.\nThe package database format and this library are constructed in\nsuch a way that while ghc-pkg depends on Cabal, the GHC library\nand program do not have to depend on Cabal."; + buildType = "Custom"; + setup-depends = [ + (hsPkgs.pkgsBuildBuild.base or (pkgs.pkgsBuildBuild.base or (errorHandler.setupDepError "base"))) + (hsPkgs.pkgsBuildBuild.Cabal or (pkgs.pkgsBuildBuild.Cabal or (errorHandler.setupDepError "Cabal"))) + (hsPkgs.pkgsBuildBuild.directory or (pkgs.pkgsBuildBuild.directory or (errorHandler.setupDepError "directory"))) + (hsPkgs.pkgsBuildBuild.filepath or (pkgs.pkgsBuildBuild.filepath or (errorHandler.setupDepError "filepath"))) + ]; + }; + components = { + "library" = { + depends = [ + (hsPkgs."base" or (errorHandler.buildDepError "base")) + (hsPkgs."binary" or (errorHandler.buildDepError "binary")) + (hsPkgs."bytestring" or (errorHandler.buildDepError "bytestring")) + (hsPkgs."containers" or (errorHandler.buildDepError "containers")) + (hsPkgs."directory" or (errorHandler.buildDepError "directory")) + (hsPkgs."filepath" or (errorHandler.buildDepError "filepath")) + (hsPkgs."deepseq" or (errorHandler.buildDepError "deepseq")) + (hsPkgs."ghc-boot-th" or (errorHandler.buildDepError "ghc-boot-th")) + ] ++ pkgs.lib.optional (!system.isWindows) (hsPkgs."unix" or (errorHandler.buildDepError "unix")); + buildable = true; + }; + }; + } // rec { src = pkgs.lib.mkDefault ./.; } diff --git a/materialized/ghc-boot-packages-nix/ghc983-ghcjs/ghc-heap.nix b/materialized/ghc-boot-packages-nix/ghc983-ghcjs/ghc-heap.nix new file mode 100644 index 0000000000..d85b660a50 --- /dev/null +++ b/materialized/ghc-boot-packages-nix/ghc983-ghcjs/ghc-heap.nix @@ -0,0 +1,36 @@ +{ system + , compiler + , flags + , pkgs + , hsPkgs + , pkgconfPkgs + , errorHandler + , config + , ... }: + { + flags = {}; + package = { + specVersion = "3.0"; + identifier = { name = "ghc-heap"; version = "9.8.3"; }; + license = "BSD-3-Clause"; + copyright = ""; + maintainer = "libraries@haskell.org"; + author = ""; + homepage = ""; + url = ""; + synopsis = "Functions for walking GHC's heap"; + description = "This package provides functions for walking the GHC heap data structures\nand retrieving information about those data structures."; + buildType = "Simple"; + }; + components = { + "library" = { + depends = [ + (hsPkgs."base" or (errorHandler.buildDepError "base")) + (hsPkgs."ghc-prim" or (errorHandler.buildDepError "ghc-prim")) + (hsPkgs."rts" or (errorHandler.buildDepError "rts")) + (hsPkgs."containers" or (errorHandler.buildDepError "containers")) + ]; + buildable = true; + }; + }; + } // rec { src = pkgs.lib.mkDefault ./.; } diff --git a/materialized/ghc-boot-packages-nix/ghc983-ghcjs/ghc-prim.nix b/materialized/ghc-boot-packages-nix/ghc983-ghcjs/ghc-prim.nix new file mode 100644 index 0000000000..546c5704d0 --- /dev/null +++ b/materialized/ghc-boot-packages-nix/ghc983-ghcjs/ghc-prim.nix @@ -0,0 +1,47 @@ +{ system + , compiler + , flags + , pkgs + , hsPkgs + , pkgconfPkgs + , errorHandler + , config + , ... }: + { + flags = { need-atomic = false; }; + package = { + specVersion = "2.2"; + identifier = { name = "ghc-prim"; version = "0.11.0"; }; + license = "BSD-3-Clause"; + copyright = ""; + maintainer = "libraries@haskell.org"; + author = ""; + homepage = ""; + url = ""; + synopsis = "GHC primitives"; + description = "This package contains the primitive types and operations supplied by GHC.\nIt is an internal package, only for the use of GHC developers.\nGHC users should not use it! If you do use it then expect\nbreaking changes at any time without warning. You should prefer\nto import @GHC.Exts@ from the @base@ package instead."; + buildType = "Custom"; + setup-depends = [ + (hsPkgs.pkgsBuildBuild.base or (pkgs.pkgsBuildBuild.base or (errorHandler.setupDepError "base"))) + (hsPkgs.pkgsBuildBuild.process or (pkgs.pkgsBuildBuild.process or (errorHandler.setupDepError "process"))) + (hsPkgs.pkgsBuildBuild.filepath or (pkgs.pkgsBuildBuild.filepath or (errorHandler.setupDepError "filepath"))) + (hsPkgs.pkgsBuildBuild.directory or (pkgs.pkgsBuildBuild.directory or (errorHandler.setupDepError "directory"))) + (hsPkgs.pkgsBuildBuild.Cabal or (pkgs.pkgsBuildBuild.Cabal or (errorHandler.setupDepError "Cabal"))) + ]; + }; + components = { + "library" = { + depends = [ (hsPkgs."rts" or (errorHandler.buildDepError "rts")) ]; + libs = (pkgs.lib.optionals (system.isWindows) [ + (pkgs."user32" or (errorHandler.sysDepError "user32")) + (pkgs."mingw32" or (errorHandler.sysDepError "mingw32")) + (pkgs."mingwex" or (errorHandler.sysDepError "mingwex")) + (pkgs."ucrt" or (errorHandler.sysDepError "ucrt")) + ] ++ pkgs.lib.optionals (system.isLinux) [ + (pkgs."c" or (errorHandler.sysDepError "c")) + (pkgs."m" or (errorHandler.sysDepError "m")) + ]) ++ pkgs.lib.optional (flags.need-atomic) (pkgs."atomic" or (errorHandler.sysDepError "atomic")); + buildable = true; + }; + }; + } // rec { src = pkgs.lib.mkDefault ./.; } diff --git a/materialized/ghc-boot-packages-nix/ghc983-ghcjs/ghc.nix b/materialized/ghc-boot-packages-nix/ghc983-ghcjs/ghc.nix new file mode 100644 index 0000000000..a4a239d30c --- /dev/null +++ b/materialized/ghc-boot-packages-nix/ghc983-ghcjs/ghc.nix @@ -0,0 +1,81 @@ +{ system + , compiler + , flags + , pkgs + , hsPkgs + , pkgconfPkgs + , errorHandler + , config + , ... }: + { + flags = { + internal-interpreter = false; + dynamic-system-linker = true; + build-tool-depends = true; + with-libzstd = false; + static-libzstd = false; + hadrian-stage0 = false; + }; + package = { + specVersion = "2.2"; + identifier = { name = "ghc"; version = "9.8.3"; }; + license = "BSD-3-Clause"; + copyright = ""; + maintainer = "glasgow-haskell-users@haskell.org"; + author = "The GHC Team"; + homepage = "http://www.haskell.org/ghc/"; + url = ""; + synopsis = "The GHC API"; + description = "GHC's functionality can be useful for more things than just\ncompiling Haskell programs. Important use cases are programs\nthat analyse (and perhaps transform) Haskell code. Others\ninclude loading Haskell code dynamically in a GHCi-like manner.\nFor this reason, a lot of GHC's functionality is made available\nthrough this package.\n\nSee \nfor more information."; + buildType = "Custom"; + setup-depends = [ + (hsPkgs.pkgsBuildBuild.base or (pkgs.pkgsBuildBuild.base or (errorHandler.setupDepError "base"))) + (hsPkgs.pkgsBuildBuild.Cabal or (pkgs.pkgsBuildBuild.Cabal or (errorHandler.setupDepError "Cabal"))) + (hsPkgs.pkgsBuildBuild.directory or (pkgs.pkgsBuildBuild.directory or (errorHandler.setupDepError "directory"))) + (hsPkgs.pkgsBuildBuild.process or (pkgs.pkgsBuildBuild.process or (errorHandler.setupDepError "process"))) + (hsPkgs.pkgsBuildBuild.filepath or (pkgs.pkgsBuildBuild.filepath or (errorHandler.setupDepError "filepath"))) + (hsPkgs.pkgsBuildBuild.containers or (pkgs.pkgsBuildBuild.containers or (errorHandler.setupDepError "containers"))) + ]; + }; + components = { + "library" = { + depends = [ + (hsPkgs."base" or (errorHandler.buildDepError "base")) + (hsPkgs."deepseq" or (errorHandler.buildDepError "deepseq")) + (hsPkgs."directory" or (errorHandler.buildDepError "directory")) + (hsPkgs."process" or (errorHandler.buildDepError "process")) + (hsPkgs."bytestring" or (errorHandler.buildDepError "bytestring")) + (hsPkgs."binary" or (errorHandler.buildDepError "binary")) + (hsPkgs."time" or (errorHandler.buildDepError "time")) + (hsPkgs."containers" or (errorHandler.buildDepError "containers")) + (hsPkgs."array" or (errorHandler.buildDepError "array")) + (hsPkgs."filepath" or (errorHandler.buildDepError "filepath")) + (hsPkgs."template-haskell" or (errorHandler.buildDepError "template-haskell")) + (hsPkgs."hpc" or (errorHandler.buildDepError "hpc")) + (hsPkgs."transformers" or (errorHandler.buildDepError "transformers")) + (hsPkgs."exceptions" or (errorHandler.buildDepError "exceptions")) + (hsPkgs."semaphore-compat" or (errorHandler.buildDepError "semaphore-compat")) + (hsPkgs."stm" or (errorHandler.buildDepError "stm")) + (hsPkgs."ghc-boot" or (errorHandler.buildDepError "ghc-boot")) + (hsPkgs."ghc-heap" or (errorHandler.buildDepError "ghc-heap")) + (hsPkgs."ghci" or (errorHandler.buildDepError "ghci")) + ] ++ (if system.isWindows + then [ (hsPkgs."Win32" or (errorHandler.buildDepError "Win32")) ] + else [ (hsPkgs."unix" or (errorHandler.buildDepError "unix")) ]); + libs = pkgs.lib.optionals (flags.with-libzstd) (if flags.static-libzstd + then pkgs.lib.optional (!system.isOsx) (pkgs.":libzstd.a" or (errorHandler.sysDepError ":libzstd.a")) + else [ (pkgs."zstd" or (errorHandler.sysDepError "zstd")) ]); + build-tools = pkgs.lib.optionals (flags.build-tool-depends) [ + (hsPkgs.pkgsBuildBuild.alex.components.exes.alex or (pkgs.pkgsBuildBuild.alex or (errorHandler.buildToolDepError "alex:alex"))) + (hsPkgs.pkgsBuildBuild.happy.components.exes.happy or (pkgs.pkgsBuildBuild.happy or (errorHandler.buildToolDepError "happy:happy"))) + (hsPkgs.pkgsBuildBuild.genprimopcode.components.exes.genprimopcode or (pkgs.pkgsBuildBuild.genprimopcode or (errorHandler.buildToolDepError "genprimopcode:genprimopcode"))) + (hsPkgs.pkgsBuildBuild.deriveConstants.components.exes.deriveConstants or (pkgs.pkgsBuildBuild.deriveConstants or (errorHandler.buildToolDepError "deriveConstants:deriveConstants"))) + ]; + buildable = if flags.with-libzstd + then if flags.static-libzstd + then if system.isOsx then false else true + else true + else true; + }; + }; + } // rec { src = pkgs.lib.mkDefault ./.; } diff --git a/materialized/ghc-boot-packages-nix/ghc983-ghcjs/ghci.nix b/materialized/ghc-boot-packages-nix/ghc983-ghcjs/ghci.nix new file mode 100644 index 0000000000..a7a99f7cb6 --- /dev/null +++ b/materialized/ghc-boot-packages-nix/ghc983-ghcjs/ghci.nix @@ -0,0 +1,45 @@ +{ system + , compiler + , flags + , pkgs + , hsPkgs + , pkgconfPkgs + , errorHandler + , config + , ... }: + { + flags = { internal-interpreter = false; }; + package = { + specVersion = "1.10"; + identifier = { name = "ghci"; version = "9.8.3"; }; + license = "BSD-3-Clause"; + copyright = ""; + maintainer = "ghc-devs@haskell.org"; + author = ""; + homepage = ""; + url = ""; + synopsis = "The library supporting GHC's interactive interpreter"; + description = "This library offers interfaces which mediate interactions between the\n@ghci@ interactive shell and @iserv@, GHC's out-of-process interpreter\nbackend."; + buildType = "Simple"; + }; + components = { + "library" = { + depends = [ + (hsPkgs."rts" or (errorHandler.buildDepError "rts")) + (hsPkgs."array" or (errorHandler.buildDepError "array")) + (hsPkgs."base" or (errorHandler.buildDepError "base")) + (hsPkgs."ghc-prim" or (errorHandler.buildDepError "ghc-prim")) + (hsPkgs."binary" or (errorHandler.buildDepError "binary")) + (hsPkgs."bytestring" or (errorHandler.buildDepError "bytestring")) + (hsPkgs."containers" or (errorHandler.buildDepError "containers")) + (hsPkgs."deepseq" or (errorHandler.buildDepError "deepseq")) + (hsPkgs."filepath" or (errorHandler.buildDepError "filepath")) + (hsPkgs."ghc-boot" or (errorHandler.buildDepError "ghc-boot")) + (hsPkgs."ghc-heap" or (errorHandler.buildDepError "ghc-heap")) + (hsPkgs."template-haskell" or (errorHandler.buildDepError "template-haskell")) + (hsPkgs."transformers" or (errorHandler.buildDepError "transformers")) + ] ++ pkgs.lib.optional (!system.isWindows) (hsPkgs."unix" or (errorHandler.buildDepError "unix")); + buildable = true; + }; + }; + } // rec { src = pkgs.lib.mkDefault ./.; } diff --git a/materialized/ghc-boot-packages-nix/ghc983-ghcjs/hpc.nix b/materialized/ghc-boot-packages-nix/ghc983-ghcjs/hpc.nix new file mode 100644 index 0000000000..f6b275cfd1 --- /dev/null +++ b/materialized/ghc-boot-packages-nix/ghc983-ghcjs/hpc.nix @@ -0,0 +1,38 @@ +{ system + , compiler + , flags + , pkgs + , hsPkgs + , pkgconfPkgs + , errorHandler + , config + , ... }: + { + flags = {}; + package = { + specVersion = "2.2"; + identifier = { name = "hpc"; version = "0.7.0.0"; }; + license = "BSD-3-Clause"; + copyright = ""; + maintainer = "ghc-devs@haskell.org"; + author = "Andy Gill"; + homepage = ""; + url = ""; + synopsis = "Code Coverage Library for Haskell"; + description = "This package provides the code coverage library for Haskell.\n\nSee for more\ninformation."; + buildType = "Simple"; + }; + components = { + "library" = { + depends = [ + (hsPkgs."base" or (errorHandler.buildDepError "base")) + (hsPkgs."containers" or (errorHandler.buildDepError "containers")) + (hsPkgs."deepseq" or (errorHandler.buildDepError "deepseq")) + (hsPkgs."directory" or (errorHandler.buildDepError "directory")) + (hsPkgs."filepath" or (errorHandler.buildDepError "filepath")) + (hsPkgs."time" or (errorHandler.buildDepError "time")) + ]; + buildable = true; + }; + }; + } // rec { src = pkgs.lib.mkDefault ./.; } diff --git a/materialized/ghc-boot-packages-nix/ghc983-ghcjs/integer-gmp.nix b/materialized/ghc-boot-packages-nix/ghc983-ghcjs/integer-gmp.nix new file mode 100644 index 0000000000..94f930e70e --- /dev/null +++ b/materialized/ghc-boot-packages-nix/ghc983-ghcjs/integer-gmp.nix @@ -0,0 +1,35 @@ +{ system + , compiler + , flags + , pkgs + , hsPkgs + , pkgconfPkgs + , errorHandler + , config + , ... }: + { + flags = {}; + package = { + specVersion = "2.0"; + identifier = { name = "integer-gmp"; version = "1.1"; }; + license = "BSD-3-Clause"; + copyright = ""; + maintainer = "hvr@gnu.org"; + author = "Herbert Valerio Riedel"; + homepage = "https://www.haskell.org/ghc/"; + url = ""; + synopsis = "Integer library based on GMP"; + description = "This package used to provide an implementation of the standard 'Integer'\ntype based on the\n.\n\nIt is now deprecated in favor of the 'ghc-bignum' package.\n\nIts purpose is to provide backward compatibility for codes directly\ndepending on the `integer-gmp` package."; + buildType = "Simple"; + }; + components = { + "library" = { + depends = [ + (hsPkgs."base" or (errorHandler.buildDepError "base")) + (hsPkgs."ghc-prim" or (errorHandler.buildDepError "ghc-prim")) + (hsPkgs."ghc-bignum" or (errorHandler.buildDepError "ghc-bignum")) + ]; + buildable = true; + }; + }; + } // rec { src = pkgs.lib.mkDefault ./.; } diff --git a/materialized/ghc-boot-packages-nix/ghc983-ghcjs/iserv.nix b/materialized/ghc-boot-packages-nix/ghc983-ghcjs/iserv.nix new file mode 100644 index 0000000000..297f43290c --- /dev/null +++ b/materialized/ghc-boot-packages-nix/ghc983-ghcjs/iserv.nix @@ -0,0 +1,41 @@ +{ system + , compiler + , flags + , pkgs + , hsPkgs + , pkgconfPkgs + , errorHandler + , config + , ... }: + { + flags = {}; + package = { + specVersion = "1.10"; + identifier = { name = "iserv"; version = "9.8.3"; }; + license = "BSD-3-Clause"; + copyright = "XXX"; + maintainer = "XXX"; + author = "XXX"; + homepage = ""; + url = ""; + synopsis = "iserv allows GHC to delegate Template Haskell computations"; + description = "GHC can be provided with a path to the iserv binary with\n@-pgmi=/path/to/iserv-bin@, and will in combination with\n@-fexternal-interpreter@, compile Template Haskell though the\n@iserv-bin@ delegate. This is very similar to how ghcjs has been\ncompiling Template Haskell, by spawning a separate delegate (so\ncalled runner on the javascript vm) and evaluating the splices\nthere."; + buildType = "Simple"; + }; + components = { + exes = { + "iserv" = { + depends = [ + (hsPkgs."array" or (errorHandler.buildDepError "array")) + (hsPkgs."base" or (errorHandler.buildDepError "base")) + (hsPkgs."binary" or (errorHandler.buildDepError "binary")) + (hsPkgs."bytestring" or (errorHandler.buildDepError "bytestring")) + (hsPkgs."containers" or (errorHandler.buildDepError "containers")) + (hsPkgs."deepseq" or (errorHandler.buildDepError "deepseq")) + (hsPkgs."ghci" or (errorHandler.buildDepError "ghci")) + ] ++ pkgs.lib.optional (!system.isWindows) (hsPkgs."unix" or (errorHandler.buildDepError "unix")); + buildable = true; + }; + }; + }; + } // rec { src = pkgs.lib.mkDefault ./.; } diff --git a/materialized/ghc-boot-packages-nix/ghc983-ghcjs/remote-iserv.nix b/materialized/ghc-boot-packages-nix/ghc983-ghcjs/remote-iserv.nix new file mode 100644 index 0000000000..bfce58fa33 --- /dev/null +++ b/materialized/ghc-boot-packages-nix/ghc983-ghcjs/remote-iserv.nix @@ -0,0 +1,36 @@ +{ system + , compiler + , flags + , pkgs + , hsPkgs + , pkgconfPkgs + , errorHandler + , config + , ... }: + { + flags = {}; + package = { + specVersion = "1.10"; + identifier = { name = "remote-iserv"; version = "9.8.3"; }; + license = "BSD-3-Clause"; + copyright = "XXX"; + maintainer = "Moritz Angermann "; + author = "Moritz Angermann "; + homepage = ""; + url = ""; + synopsis = "iserv allows GHC to delegate Template Haskell computations"; + description = "This is a very simple remote runner for iserv, to be used together\nwith iserv-proxy. The foundamental idea is that this this wrapper\nstarts running the GHCi server on a given port to which iserv-proxy will\nthen connect."; + buildType = "Simple"; + }; + components = { + exes = { + "remote-iserv" = { + depends = [ + (hsPkgs."base" or (errorHandler.buildDepError "base")) + (hsPkgs."ghci" or (errorHandler.buildDepError "ghci")) + ]; + buildable = true; + }; + }; + }; + } // rec { src = pkgs.lib.mkDefault ./.; } diff --git a/materialized/ghc-boot-packages-nix/ghc983-ghcjs/template-haskell.nix b/materialized/ghc-boot-packages-nix/ghc983-ghcjs/template-haskell.nix new file mode 100644 index 0000000000..3e26556434 --- /dev/null +++ b/materialized/ghc-boot-packages-nix/ghc983-ghcjs/template-haskell.nix @@ -0,0 +1,36 @@ +{ system + , compiler + , flags + , pkgs + , hsPkgs + , pkgconfPkgs + , errorHandler + , config + , ... }: + { + flags = {}; + package = { + specVersion = "1.10"; + identifier = { name = "template-haskell"; version = "2.21.0.0"; }; + license = "BSD-3-Clause"; + copyright = ""; + maintainer = "libraries@haskell.org"; + author = ""; + homepage = ""; + url = ""; + synopsis = "Support library for Template Haskell"; + description = "This package provides modules containing facilities for manipulating\nHaskell source code using Template Haskell.\n\nSee for more\ninformation."; + buildType = "Simple"; + }; + components = { + "library" = { + depends = [ + (hsPkgs."base" or (errorHandler.buildDepError "base")) + (hsPkgs."ghc-boot-th" or (errorHandler.buildDepError "ghc-boot-th")) + (hsPkgs."ghc-prim" or (errorHandler.buildDepError "ghc-prim")) + (hsPkgs."pretty" or (errorHandler.buildDepError "pretty")) + ]; + buildable = true; + }; + }; + } // rec { src = pkgs.lib.mkDefault ./.; } diff --git a/materialized/ghc-boot-packages-nix/ghc983/base.nix b/materialized/ghc-boot-packages-nix/ghc983/base.nix new file mode 100644 index 0000000000..d918879f6f --- /dev/null +++ b/materialized/ghc-boot-packages-nix/ghc983/base.nix @@ -0,0 +1,49 @@ +{ system + , compiler + , flags + , pkgs + , hsPkgs + , pkgconfPkgs + , errorHandler + , config + , ... }: + { + flags = {}; + package = { + specVersion = "3.0"; + identifier = { name = "base"; version = "4.19.2.0"; }; + license = "BSD-3-Clause"; + copyright = ""; + maintainer = "Core Libraries Committee "; + author = ""; + homepage = ""; + url = ""; + synopsis = "Core data structures and operations"; + description = "Haskell's base library provides, among other things, core types (e.g. [Bool](\"Data.Bool\") and [Int](\"Data.Int\")),\ndata structures (e.g. [List](\"Data.List\"), [Tuple](\"Data.Tuple\") and [Maybe](\"Data.Maybe\")),\nthe [Exception](\"Control.Exception\") mechanism, and the [IO](\"System.IO\") & [Concurrency](\"Control.Concurrent\") operations.\nThe \"Prelude\" module, which is imported by default, exposes a curated set of types and functions from other modules.\n\nOther data structures like [Map](https://hackage.haskell.org/package/containers/docs/Data-Map.html),\n[Set](https://hackage.haskell.org/package/containers/docs/Data-Set.html) are available in the [containers](https://hackage.haskell.org/package/containers) library.\nTo work with textual data, use the [text](https://hackage.haskell.org/package/text/docs/Data-Text.html) library."; + buildType = "Configure"; + }; + components = { + "library" = { + depends = [ + (hsPkgs."rts" or (errorHandler.buildDepError "rts")) + (hsPkgs."ghc-prim" or (errorHandler.buildDepError "ghc-prim")) + (hsPkgs."ghc-bignum" or (errorHandler.buildDepError "ghc-bignum")) + ]; + libs = pkgs.lib.optionals (system.isWindows) [ + (pkgs."wsock32" or (errorHandler.sysDepError "wsock32")) + (pkgs."user32" or (errorHandler.sysDepError "user32")) + (pkgs."shell32" or (errorHandler.sysDepError "shell32")) + (pkgs."mingw32" or (errorHandler.sysDepError "mingw32")) + (pkgs."kernel32" or (errorHandler.sysDepError "kernel32")) + (pkgs."advapi32" or (errorHandler.sysDepError "advapi32")) + (pkgs."mingwex" or (errorHandler.sysDepError "mingwex")) + (pkgs."ws2_32" or (errorHandler.sysDepError "ws2_32")) + (pkgs."shlwapi" or (errorHandler.sysDepError "shlwapi")) + (pkgs."ole32" or (errorHandler.sysDepError "ole32")) + (pkgs."rpcrt4" or (errorHandler.sysDepError "rpcrt4")) + (pkgs."ntdll" or (errorHandler.sysDepError "ntdll")) + ]; + buildable = true; + }; + }; + } // rec { src = pkgs.lib.mkDefault ./.; } diff --git a/materialized/ghc-boot-packages-nix/ghc983/deriveConstants.nix b/materialized/ghc-boot-packages-nix/ghc983/deriveConstants.nix new file mode 100644 index 0000000000..135cdd02f6 --- /dev/null +++ b/materialized/ghc-boot-packages-nix/ghc983/deriveConstants.nix @@ -0,0 +1,39 @@ +{ system + , compiler + , flags + , pkgs + , hsPkgs + , pkgconfPkgs + , errorHandler + , config + , ... }: + { + flags = {}; + package = { + specVersion = "1.10"; + identifier = { name = "deriveConstants"; version = "0.1"; }; + license = "BSD-3-Clause"; + copyright = "XXX"; + maintainer = "XXX"; + author = "XXX"; + homepage = ""; + url = ""; + synopsis = "Derive header files containing various constants for the GHC build process"; + description = "This utility is responsible for generating a number of C header files\nneeded during the GHC build process. See @rts/include/ghc.mk@ in the GHC\nbuild system for details."; + buildType = "Simple"; + }; + components = { + exes = { + "deriveConstants" = { + depends = [ + (hsPkgs."base" or (errorHandler.buildDepError "base")) + (hsPkgs."containers" or (errorHandler.buildDepError "containers")) + (hsPkgs."process" or (errorHandler.buildDepError "process")) + (hsPkgs."filepath" or (errorHandler.buildDepError "filepath")) + (hsPkgs."directory" or (errorHandler.buildDepError "directory")) + ]; + buildable = true; + }; + }; + }; + } // rec { src = pkgs.lib.mkDefault ./.; } diff --git a/materialized/ghc-boot-packages-nix/ghc983/genprimopcode.nix b/materialized/ghc-boot-packages-nix/ghc983/genprimopcode.nix new file mode 100644 index 0000000000..49bbe516ba --- /dev/null +++ b/materialized/ghc-boot-packages-nix/ghc983/genprimopcode.nix @@ -0,0 +1,40 @@ +{ system + , compiler + , flags + , pkgs + , hsPkgs + , pkgconfPkgs + , errorHandler + , config + , ... }: + { + flags = { build-tool-depends = true; }; + package = { + specVersion = "2.0"; + identifier = { name = "genprimopcode"; version = "0.1"; }; + license = "BSD-3-Clause"; + copyright = "XXX"; + maintainer = "XXX"; + author = "XXX"; + homepage = ""; + url = ""; + synopsis = "Generates various files implementing GHC's primitive operations."; + description = "This utility reads a textual description of GHC's primitive operations\n(@primops.txt.pp@) and produces a number of outputs. These include,\n\n* the @GHC.Prim@ module included in the @ghc-prim@ package.\n* the @GHC.PrimopWrappers@ module included in the @ghc-prim@ package.\n* an LaTeX document describing the primitive operations."; + buildType = "Simple"; + }; + components = { + exes = { + "genprimopcode" = { + depends = [ + (hsPkgs."base" or (errorHandler.buildDepError "base")) + (hsPkgs."array" or (errorHandler.buildDepError "array")) + ]; + build-tools = pkgs.lib.optionals (flags.build-tool-depends) [ + (hsPkgs.pkgsBuildBuild.alex.components.exes.alex or (pkgs.pkgsBuildBuild.alex or (errorHandler.buildToolDepError "alex:alex"))) + (hsPkgs.pkgsBuildBuild.happy.components.exes.happy or (pkgs.pkgsBuildBuild.happy or (errorHandler.buildToolDepError "happy:happy"))) + ]; + buildable = true; + }; + }; + }; + } // rec { src = pkgs.lib.mkDefault ./.; } diff --git a/materialized/ghc-boot-packages-nix/ghc983/ghc-bignum.nix b/materialized/ghc-boot-packages-nix/ghc983/ghc-bignum.nix new file mode 100644 index 0000000000..46af6e0e9f --- /dev/null +++ b/materialized/ghc-boot-packages-nix/ghc983/ghc-bignum.nix @@ -0,0 +1,37 @@ +{ system + , compiler + , flags + , pkgs + , hsPkgs + , pkgconfPkgs + , errorHandler + , config + , ... }: + { + flags = { native = false; ffi = false; gmp = false; check = false; }; + package = { + specVersion = "2.0"; + identifier = { name = "ghc-bignum"; version = "1.3"; }; + license = "BSD-3-Clause"; + copyright = ""; + maintainer = "libraries@haskell.org"; + author = "Sylvain Henry"; + homepage = ""; + url = ""; + synopsis = "GHC BigNum library"; + description = "This package provides the low-level implementation of the standard\n'BigNat', 'Natural' and 'Integer' types."; + buildType = "Configure"; + }; + components = { + "library" = { + depends = [ + (hsPkgs."ghc-prim" or (errorHandler.buildDepError "ghc-prim")) + ]; + buildable = (if !flags.native && !flags.gmp && !flags.ffi + then false + else true) && (if flags.native && (flags.gmp || flags.ffi) + then false + else true) && (if flags.gmp && flags.ffi then false else true); + }; + }; + } // rec { src = pkgs.lib.mkDefault ./.; } diff --git a/materialized/ghc-boot-packages-nix/ghc983/ghc-boot.nix b/materialized/ghc-boot-packages-nix/ghc983/ghc-boot.nix new file mode 100644 index 0000000000..276da77ac7 --- /dev/null +++ b/materialized/ghc-boot-packages-nix/ghc983/ghc-boot.nix @@ -0,0 +1,46 @@ +{ system + , compiler + , flags + , pkgs + , hsPkgs + , pkgconfPkgs + , errorHandler + , config + , ... }: + { + flags = {}; + package = { + specVersion = "3.0"; + identifier = { name = "ghc-boot"; version = "9.8.3"; }; + license = "BSD-3-Clause"; + copyright = ""; + maintainer = "ghc-devs@haskell.org"; + author = ""; + homepage = ""; + url = ""; + synopsis = "Shared functionality between GHC and its boot libraries"; + description = "This library is shared between GHC, ghc-pkg, and other boot\nlibraries.\n.\nA note about \"GHC.Unit.Database\": it only deals with the subset of\nthe package database that the compiler cares about: modules\npaths etc and not package metadata like description, authors\netc. It is thus not a library interface to ghc-pkg and is *not*\nsuitable for modifying GHC package databases.\n.\nThe package database format and this library are constructed in\nsuch a way that while ghc-pkg depends on Cabal, the GHC library\nand program do not have to depend on Cabal."; + buildType = "Custom"; + setup-depends = [ + (hsPkgs.pkgsBuildBuild.base or (pkgs.pkgsBuildBuild.base or (errorHandler.setupDepError "base"))) + (hsPkgs.pkgsBuildBuild.Cabal or (pkgs.pkgsBuildBuild.Cabal or (errorHandler.setupDepError "Cabal"))) + (hsPkgs.pkgsBuildBuild.directory or (pkgs.pkgsBuildBuild.directory or (errorHandler.setupDepError "directory"))) + (hsPkgs.pkgsBuildBuild.filepath or (pkgs.pkgsBuildBuild.filepath or (errorHandler.setupDepError "filepath"))) + ]; + }; + components = { + "library" = { + depends = [ + (hsPkgs."base" or (errorHandler.buildDepError "base")) + (hsPkgs."binary" or (errorHandler.buildDepError "binary")) + (hsPkgs."bytestring" or (errorHandler.buildDepError "bytestring")) + (hsPkgs."containers" or (errorHandler.buildDepError "containers")) + (hsPkgs."directory" or (errorHandler.buildDepError "directory")) + (hsPkgs."filepath" or (errorHandler.buildDepError "filepath")) + (hsPkgs."deepseq" or (errorHandler.buildDepError "deepseq")) + (hsPkgs."ghc-boot-th" or (errorHandler.buildDepError "ghc-boot-th")) + ] ++ pkgs.lib.optional (!system.isWindows) (hsPkgs."unix" or (errorHandler.buildDepError "unix")); + buildable = true; + }; + }; + } // rec { src = pkgs.lib.mkDefault ./.; } diff --git a/materialized/ghc-boot-packages-nix/ghc983/ghc-heap.nix b/materialized/ghc-boot-packages-nix/ghc983/ghc-heap.nix new file mode 100644 index 0000000000..d85b660a50 --- /dev/null +++ b/materialized/ghc-boot-packages-nix/ghc983/ghc-heap.nix @@ -0,0 +1,36 @@ +{ system + , compiler + , flags + , pkgs + , hsPkgs + , pkgconfPkgs + , errorHandler + , config + , ... }: + { + flags = {}; + package = { + specVersion = "3.0"; + identifier = { name = "ghc-heap"; version = "9.8.3"; }; + license = "BSD-3-Clause"; + copyright = ""; + maintainer = "libraries@haskell.org"; + author = ""; + homepage = ""; + url = ""; + synopsis = "Functions for walking GHC's heap"; + description = "This package provides functions for walking the GHC heap data structures\nand retrieving information about those data structures."; + buildType = "Simple"; + }; + components = { + "library" = { + depends = [ + (hsPkgs."base" or (errorHandler.buildDepError "base")) + (hsPkgs."ghc-prim" or (errorHandler.buildDepError "ghc-prim")) + (hsPkgs."rts" or (errorHandler.buildDepError "rts")) + (hsPkgs."containers" or (errorHandler.buildDepError "containers")) + ]; + buildable = true; + }; + }; + } // rec { src = pkgs.lib.mkDefault ./.; } diff --git a/materialized/ghc-boot-packages-nix/ghc983/ghc-prim.nix b/materialized/ghc-boot-packages-nix/ghc983/ghc-prim.nix new file mode 100644 index 0000000000..546c5704d0 --- /dev/null +++ b/materialized/ghc-boot-packages-nix/ghc983/ghc-prim.nix @@ -0,0 +1,47 @@ +{ system + , compiler + , flags + , pkgs + , hsPkgs + , pkgconfPkgs + , errorHandler + , config + , ... }: + { + flags = { need-atomic = false; }; + package = { + specVersion = "2.2"; + identifier = { name = "ghc-prim"; version = "0.11.0"; }; + license = "BSD-3-Clause"; + copyright = ""; + maintainer = "libraries@haskell.org"; + author = ""; + homepage = ""; + url = ""; + synopsis = "GHC primitives"; + description = "This package contains the primitive types and operations supplied by GHC.\nIt is an internal package, only for the use of GHC developers.\nGHC users should not use it! If you do use it then expect\nbreaking changes at any time without warning. You should prefer\nto import @GHC.Exts@ from the @base@ package instead."; + buildType = "Custom"; + setup-depends = [ + (hsPkgs.pkgsBuildBuild.base or (pkgs.pkgsBuildBuild.base or (errorHandler.setupDepError "base"))) + (hsPkgs.pkgsBuildBuild.process or (pkgs.pkgsBuildBuild.process or (errorHandler.setupDepError "process"))) + (hsPkgs.pkgsBuildBuild.filepath or (pkgs.pkgsBuildBuild.filepath or (errorHandler.setupDepError "filepath"))) + (hsPkgs.pkgsBuildBuild.directory or (pkgs.pkgsBuildBuild.directory or (errorHandler.setupDepError "directory"))) + (hsPkgs.pkgsBuildBuild.Cabal or (pkgs.pkgsBuildBuild.Cabal or (errorHandler.setupDepError "Cabal"))) + ]; + }; + components = { + "library" = { + depends = [ (hsPkgs."rts" or (errorHandler.buildDepError "rts")) ]; + libs = (pkgs.lib.optionals (system.isWindows) [ + (pkgs."user32" or (errorHandler.sysDepError "user32")) + (pkgs."mingw32" or (errorHandler.sysDepError "mingw32")) + (pkgs."mingwex" or (errorHandler.sysDepError "mingwex")) + (pkgs."ucrt" or (errorHandler.sysDepError "ucrt")) + ] ++ pkgs.lib.optionals (system.isLinux) [ + (pkgs."c" or (errorHandler.sysDepError "c")) + (pkgs."m" or (errorHandler.sysDepError "m")) + ]) ++ pkgs.lib.optional (flags.need-atomic) (pkgs."atomic" or (errorHandler.sysDepError "atomic")); + buildable = true; + }; + }; + } // rec { src = pkgs.lib.mkDefault ./.; } diff --git a/materialized/ghc-boot-packages-nix/ghc983/ghc.nix b/materialized/ghc-boot-packages-nix/ghc983/ghc.nix new file mode 100644 index 0000000000..a4a239d30c --- /dev/null +++ b/materialized/ghc-boot-packages-nix/ghc983/ghc.nix @@ -0,0 +1,81 @@ +{ system + , compiler + , flags + , pkgs + , hsPkgs + , pkgconfPkgs + , errorHandler + , config + , ... }: + { + flags = { + internal-interpreter = false; + dynamic-system-linker = true; + build-tool-depends = true; + with-libzstd = false; + static-libzstd = false; + hadrian-stage0 = false; + }; + package = { + specVersion = "2.2"; + identifier = { name = "ghc"; version = "9.8.3"; }; + license = "BSD-3-Clause"; + copyright = ""; + maintainer = "glasgow-haskell-users@haskell.org"; + author = "The GHC Team"; + homepage = "http://www.haskell.org/ghc/"; + url = ""; + synopsis = "The GHC API"; + description = "GHC's functionality can be useful for more things than just\ncompiling Haskell programs. Important use cases are programs\nthat analyse (and perhaps transform) Haskell code. Others\ninclude loading Haskell code dynamically in a GHCi-like manner.\nFor this reason, a lot of GHC's functionality is made available\nthrough this package.\n\nSee \nfor more information."; + buildType = "Custom"; + setup-depends = [ + (hsPkgs.pkgsBuildBuild.base or (pkgs.pkgsBuildBuild.base or (errorHandler.setupDepError "base"))) + (hsPkgs.pkgsBuildBuild.Cabal or (pkgs.pkgsBuildBuild.Cabal or (errorHandler.setupDepError "Cabal"))) + (hsPkgs.pkgsBuildBuild.directory or (pkgs.pkgsBuildBuild.directory or (errorHandler.setupDepError "directory"))) + (hsPkgs.pkgsBuildBuild.process or (pkgs.pkgsBuildBuild.process or (errorHandler.setupDepError "process"))) + (hsPkgs.pkgsBuildBuild.filepath or (pkgs.pkgsBuildBuild.filepath or (errorHandler.setupDepError "filepath"))) + (hsPkgs.pkgsBuildBuild.containers or (pkgs.pkgsBuildBuild.containers or (errorHandler.setupDepError "containers"))) + ]; + }; + components = { + "library" = { + depends = [ + (hsPkgs."base" or (errorHandler.buildDepError "base")) + (hsPkgs."deepseq" or (errorHandler.buildDepError "deepseq")) + (hsPkgs."directory" or (errorHandler.buildDepError "directory")) + (hsPkgs."process" or (errorHandler.buildDepError "process")) + (hsPkgs."bytestring" or (errorHandler.buildDepError "bytestring")) + (hsPkgs."binary" or (errorHandler.buildDepError "binary")) + (hsPkgs."time" or (errorHandler.buildDepError "time")) + (hsPkgs."containers" or (errorHandler.buildDepError "containers")) + (hsPkgs."array" or (errorHandler.buildDepError "array")) + (hsPkgs."filepath" or (errorHandler.buildDepError "filepath")) + (hsPkgs."template-haskell" or (errorHandler.buildDepError "template-haskell")) + (hsPkgs."hpc" or (errorHandler.buildDepError "hpc")) + (hsPkgs."transformers" or (errorHandler.buildDepError "transformers")) + (hsPkgs."exceptions" or (errorHandler.buildDepError "exceptions")) + (hsPkgs."semaphore-compat" or (errorHandler.buildDepError "semaphore-compat")) + (hsPkgs."stm" or (errorHandler.buildDepError "stm")) + (hsPkgs."ghc-boot" or (errorHandler.buildDepError "ghc-boot")) + (hsPkgs."ghc-heap" or (errorHandler.buildDepError "ghc-heap")) + (hsPkgs."ghci" or (errorHandler.buildDepError "ghci")) + ] ++ (if system.isWindows + then [ (hsPkgs."Win32" or (errorHandler.buildDepError "Win32")) ] + else [ (hsPkgs."unix" or (errorHandler.buildDepError "unix")) ]); + libs = pkgs.lib.optionals (flags.with-libzstd) (if flags.static-libzstd + then pkgs.lib.optional (!system.isOsx) (pkgs.":libzstd.a" or (errorHandler.sysDepError ":libzstd.a")) + else [ (pkgs."zstd" or (errorHandler.sysDepError "zstd")) ]); + build-tools = pkgs.lib.optionals (flags.build-tool-depends) [ + (hsPkgs.pkgsBuildBuild.alex.components.exes.alex or (pkgs.pkgsBuildBuild.alex or (errorHandler.buildToolDepError "alex:alex"))) + (hsPkgs.pkgsBuildBuild.happy.components.exes.happy or (pkgs.pkgsBuildBuild.happy or (errorHandler.buildToolDepError "happy:happy"))) + (hsPkgs.pkgsBuildBuild.genprimopcode.components.exes.genprimopcode or (pkgs.pkgsBuildBuild.genprimopcode or (errorHandler.buildToolDepError "genprimopcode:genprimopcode"))) + (hsPkgs.pkgsBuildBuild.deriveConstants.components.exes.deriveConstants or (pkgs.pkgsBuildBuild.deriveConstants or (errorHandler.buildToolDepError "deriveConstants:deriveConstants"))) + ]; + buildable = if flags.with-libzstd + then if flags.static-libzstd + then if system.isOsx then false else true + else true + else true; + }; + }; + } // rec { src = pkgs.lib.mkDefault ./.; } diff --git a/materialized/ghc-boot-packages-nix/ghc983/ghci.nix b/materialized/ghc-boot-packages-nix/ghc983/ghci.nix new file mode 100644 index 0000000000..a7a99f7cb6 --- /dev/null +++ b/materialized/ghc-boot-packages-nix/ghc983/ghci.nix @@ -0,0 +1,45 @@ +{ system + , compiler + , flags + , pkgs + , hsPkgs + , pkgconfPkgs + , errorHandler + , config + , ... }: + { + flags = { internal-interpreter = false; }; + package = { + specVersion = "1.10"; + identifier = { name = "ghci"; version = "9.8.3"; }; + license = "BSD-3-Clause"; + copyright = ""; + maintainer = "ghc-devs@haskell.org"; + author = ""; + homepage = ""; + url = ""; + synopsis = "The library supporting GHC's interactive interpreter"; + description = "This library offers interfaces which mediate interactions between the\n@ghci@ interactive shell and @iserv@, GHC's out-of-process interpreter\nbackend."; + buildType = "Simple"; + }; + components = { + "library" = { + depends = [ + (hsPkgs."rts" or (errorHandler.buildDepError "rts")) + (hsPkgs."array" or (errorHandler.buildDepError "array")) + (hsPkgs."base" or (errorHandler.buildDepError "base")) + (hsPkgs."ghc-prim" or (errorHandler.buildDepError "ghc-prim")) + (hsPkgs."binary" or (errorHandler.buildDepError "binary")) + (hsPkgs."bytestring" or (errorHandler.buildDepError "bytestring")) + (hsPkgs."containers" or (errorHandler.buildDepError "containers")) + (hsPkgs."deepseq" or (errorHandler.buildDepError "deepseq")) + (hsPkgs."filepath" or (errorHandler.buildDepError "filepath")) + (hsPkgs."ghc-boot" or (errorHandler.buildDepError "ghc-boot")) + (hsPkgs."ghc-heap" or (errorHandler.buildDepError "ghc-heap")) + (hsPkgs."template-haskell" or (errorHandler.buildDepError "template-haskell")) + (hsPkgs."transformers" or (errorHandler.buildDepError "transformers")) + ] ++ pkgs.lib.optional (!system.isWindows) (hsPkgs."unix" or (errorHandler.buildDepError "unix")); + buildable = true; + }; + }; + } // rec { src = pkgs.lib.mkDefault ./.; } diff --git a/materialized/ghc-boot-packages-nix/ghc983/hpc.nix b/materialized/ghc-boot-packages-nix/ghc983/hpc.nix new file mode 100644 index 0000000000..f6b275cfd1 --- /dev/null +++ b/materialized/ghc-boot-packages-nix/ghc983/hpc.nix @@ -0,0 +1,38 @@ +{ system + , compiler + , flags + , pkgs + , hsPkgs + , pkgconfPkgs + , errorHandler + , config + , ... }: + { + flags = {}; + package = { + specVersion = "2.2"; + identifier = { name = "hpc"; version = "0.7.0.0"; }; + license = "BSD-3-Clause"; + copyright = ""; + maintainer = "ghc-devs@haskell.org"; + author = "Andy Gill"; + homepage = ""; + url = ""; + synopsis = "Code Coverage Library for Haskell"; + description = "This package provides the code coverage library for Haskell.\n\nSee for more\ninformation."; + buildType = "Simple"; + }; + components = { + "library" = { + depends = [ + (hsPkgs."base" or (errorHandler.buildDepError "base")) + (hsPkgs."containers" or (errorHandler.buildDepError "containers")) + (hsPkgs."deepseq" or (errorHandler.buildDepError "deepseq")) + (hsPkgs."directory" or (errorHandler.buildDepError "directory")) + (hsPkgs."filepath" or (errorHandler.buildDepError "filepath")) + (hsPkgs."time" or (errorHandler.buildDepError "time")) + ]; + buildable = true; + }; + }; + } // rec { src = pkgs.lib.mkDefault ./.; } diff --git a/materialized/ghc-boot-packages-nix/ghc983/integer-gmp.nix b/materialized/ghc-boot-packages-nix/ghc983/integer-gmp.nix new file mode 100644 index 0000000000..94f930e70e --- /dev/null +++ b/materialized/ghc-boot-packages-nix/ghc983/integer-gmp.nix @@ -0,0 +1,35 @@ +{ system + , compiler + , flags + , pkgs + , hsPkgs + , pkgconfPkgs + , errorHandler + , config + , ... }: + { + flags = {}; + package = { + specVersion = "2.0"; + identifier = { name = "integer-gmp"; version = "1.1"; }; + license = "BSD-3-Clause"; + copyright = ""; + maintainer = "hvr@gnu.org"; + author = "Herbert Valerio Riedel"; + homepage = "https://www.haskell.org/ghc/"; + url = ""; + synopsis = "Integer library based on GMP"; + description = "This package used to provide an implementation of the standard 'Integer'\ntype based on the\n.\n\nIt is now deprecated in favor of the 'ghc-bignum' package.\n\nIts purpose is to provide backward compatibility for codes directly\ndepending on the `integer-gmp` package."; + buildType = "Simple"; + }; + components = { + "library" = { + depends = [ + (hsPkgs."base" or (errorHandler.buildDepError "base")) + (hsPkgs."ghc-prim" or (errorHandler.buildDepError "ghc-prim")) + (hsPkgs."ghc-bignum" or (errorHandler.buildDepError "ghc-bignum")) + ]; + buildable = true; + }; + }; + } // rec { src = pkgs.lib.mkDefault ./.; } diff --git a/materialized/ghc-boot-packages-nix/ghc983/iserv.nix b/materialized/ghc-boot-packages-nix/ghc983/iserv.nix new file mode 100644 index 0000000000..297f43290c --- /dev/null +++ b/materialized/ghc-boot-packages-nix/ghc983/iserv.nix @@ -0,0 +1,41 @@ +{ system + , compiler + , flags + , pkgs + , hsPkgs + , pkgconfPkgs + , errorHandler + , config + , ... }: + { + flags = {}; + package = { + specVersion = "1.10"; + identifier = { name = "iserv"; version = "9.8.3"; }; + license = "BSD-3-Clause"; + copyright = "XXX"; + maintainer = "XXX"; + author = "XXX"; + homepage = ""; + url = ""; + synopsis = "iserv allows GHC to delegate Template Haskell computations"; + description = "GHC can be provided with a path to the iserv binary with\n@-pgmi=/path/to/iserv-bin@, and will in combination with\n@-fexternal-interpreter@, compile Template Haskell though the\n@iserv-bin@ delegate. This is very similar to how ghcjs has been\ncompiling Template Haskell, by spawning a separate delegate (so\ncalled runner on the javascript vm) and evaluating the splices\nthere."; + buildType = "Simple"; + }; + components = { + exes = { + "iserv" = { + depends = [ + (hsPkgs."array" or (errorHandler.buildDepError "array")) + (hsPkgs."base" or (errorHandler.buildDepError "base")) + (hsPkgs."binary" or (errorHandler.buildDepError "binary")) + (hsPkgs."bytestring" or (errorHandler.buildDepError "bytestring")) + (hsPkgs."containers" or (errorHandler.buildDepError "containers")) + (hsPkgs."deepseq" or (errorHandler.buildDepError "deepseq")) + (hsPkgs."ghci" or (errorHandler.buildDepError "ghci")) + ] ++ pkgs.lib.optional (!system.isWindows) (hsPkgs."unix" or (errorHandler.buildDepError "unix")); + buildable = true; + }; + }; + }; + } // rec { src = pkgs.lib.mkDefault ./.; } diff --git a/materialized/ghc-boot-packages-nix/ghc983/remote-iserv.nix b/materialized/ghc-boot-packages-nix/ghc983/remote-iserv.nix new file mode 100644 index 0000000000..bfce58fa33 --- /dev/null +++ b/materialized/ghc-boot-packages-nix/ghc983/remote-iserv.nix @@ -0,0 +1,36 @@ +{ system + , compiler + , flags + , pkgs + , hsPkgs + , pkgconfPkgs + , errorHandler + , config + , ... }: + { + flags = {}; + package = { + specVersion = "1.10"; + identifier = { name = "remote-iserv"; version = "9.8.3"; }; + license = "BSD-3-Clause"; + copyright = "XXX"; + maintainer = "Moritz Angermann "; + author = "Moritz Angermann "; + homepage = ""; + url = ""; + synopsis = "iserv allows GHC to delegate Template Haskell computations"; + description = "This is a very simple remote runner for iserv, to be used together\nwith iserv-proxy. The foundamental idea is that this this wrapper\nstarts running the GHCi server on a given port to which iserv-proxy will\nthen connect."; + buildType = "Simple"; + }; + components = { + exes = { + "remote-iserv" = { + depends = [ + (hsPkgs."base" or (errorHandler.buildDepError "base")) + (hsPkgs."ghci" or (errorHandler.buildDepError "ghci")) + ]; + buildable = true; + }; + }; + }; + } // rec { src = pkgs.lib.mkDefault ./.; } diff --git a/materialized/ghc-boot-packages-nix/ghc983/template-haskell.nix b/materialized/ghc-boot-packages-nix/ghc983/template-haskell.nix new file mode 100644 index 0000000000..3e26556434 --- /dev/null +++ b/materialized/ghc-boot-packages-nix/ghc983/template-haskell.nix @@ -0,0 +1,36 @@ +{ system + , compiler + , flags + , pkgs + , hsPkgs + , pkgconfPkgs + , errorHandler + , config + , ... }: + { + flags = {}; + package = { + specVersion = "1.10"; + identifier = { name = "template-haskell"; version = "2.21.0.0"; }; + license = "BSD-3-Clause"; + copyright = ""; + maintainer = "libraries@haskell.org"; + author = ""; + homepage = ""; + url = ""; + synopsis = "Support library for Template Haskell"; + description = "This package provides modules containing facilities for manipulating\nHaskell source code using Template Haskell.\n\nSee for more\ninformation."; + buildType = "Simple"; + }; + components = { + "library" = { + depends = [ + (hsPkgs."base" or (errorHandler.buildDepError "base")) + (hsPkgs."ghc-boot-th" or (errorHandler.buildDepError "ghc-boot-th")) + (hsPkgs."ghc-prim" or (errorHandler.buildDepError "ghc-prim")) + (hsPkgs."pretty" or (errorHandler.buildDepError "pretty")) + ]; + buildable = true; + }; + }; + } // rec { src = pkgs.lib.mkDefault ./.; } diff --git a/materialized/ghc964/hadrian-ghc910/hadrian/cabal-files/cryptohash-sha256.nix b/materialized/ghc964/hadrian-ghc910/hadrian/cabal-files/cryptohash-sha256.nix index 7fe8a112a9..e7efd5f428 100644 --- a/materialized/ghc964/hadrian-ghc910/hadrian/cabal-files/cryptohash-sha256.nix +++ b/materialized/ghc964/hadrian-ghc910/hadrian/cabal-files/cryptohash-sha256.nix @@ -16,7 +16,7 @@ copyright = "Vincent Hanquez, Herbert Valerio Riedel"; maintainer = "Herbert Valerio Riedel "; author = ""; - homepage = "https://github.com/hvr/cryptohash-sha256"; + homepage = "https://github.com/haskell-hvr/cryptohash-sha256"; url = ""; synopsis = "Fast, pure and practical SHA-256 implementation"; description = "A practical incremental and one-pass, pure API to\nthe [SHA-256 cryptographic hash algorithm](https://en.wikipedia.org/wiki/SHA-2) according\nto [FIPS 180-4](http://dx.doi.org/10.6028/NIST.FIPS.180-4)\nwith performance close to the fastest implementations available in other languages.\n\nThe core SHA-256 algorithm is implemented in C and is thus expected\nto be as fast as the standard [sha256sum(1) tool](https://linux.die.net/man/1/sha256sum);\nfor instance, on an /Intel Core i7-3770/ at 3.40GHz this implementation can\ncompute a SHA-256 hash over 230 MiB of data in under one second.\n(If, instead, you require a pure Haskell implementation and performance is secondary, please refer to the [SHA package](https://hackage.haskell.org/package/SHA).)\n\n\nAdditionally, this package provides support for\n\n- HMAC-SHA-256: SHA-256-based [Hashed Message Authentication Codes](https://en.wikipedia.org/wiki/HMAC) (HMAC)\n- HKDF-SHA-256: [HMAC-SHA-256-based Key Derivation Function](https://en.wikipedia.org/wiki/HKDF) (HKDF)\n\nconforming to [RFC6234](https://tools.ietf.org/html/rfc6234), [RFC4231](https://tools.ietf.org/html/rfc4231), [RFC5869](https://tools.ietf.org/html/rfc5869), et al..\n\n=== Relationship to the @cryptohash@ package and its API\n\nThis package has been originally a fork of @cryptohash-0.11.7@ because the @cryptohash@\npackage had been deprecated and so this package continues to satisfy the need for a\nlightweight package providing the SHA-256 hash algorithm without any dependencies on packages\nother than @base@ and @bytestring@. The API exposed by @cryptohash-sha256-0.11.*@'s\n\"Crypto.Hash.SHA256\" module is guaranteed to remain a compatible superset of the API provided\nby the @cryptohash-0.11.7@'s module of the same name.\n\nConsequently, this package is designed to be used as a drop-in replacement for @cryptohash-0.11.7@'s\n\"Crypto.Hash.SHA256\" module, though with\na [clearly smaller footprint by almost 3 orders of magnitude](https://www.reddit.com/r/haskell/comments/5lxv75/psa_please_use_unique_module_names_when_uploading/dbzegx3/)."; @@ -80,5 +80,5 @@ sha256 = "73a7dc7163871a80837495039a099967b11f5c4fe70a118277842f7a713c6bf6"; }); }) // { - package-description-override = "cabal-version: 2.0\nname: cryptohash-sha256\nversion: 0.11.102.1\nx-revision: 3\n\nsynopsis: Fast, pure and practical SHA-256 implementation\ndescription: {\n\nA practical incremental and one-pass, pure API to\nthe [SHA-256 cryptographic hash algorithm](https://en.wikipedia.org/wiki/SHA-2) according\nto [FIPS 180-4](http://dx.doi.org/10.6028/NIST.FIPS.180-4)\nwith performance close to the fastest implementations available in other languages.\n.\nThe core SHA-256 algorithm is implemented in C and is thus expected\nto be as fast as the standard [sha256sum(1) tool](https://linux.die.net/man/1/sha256sum);\nfor instance, on an /Intel Core i7-3770/ at 3.40GHz this implementation can\ncompute a SHA-256 hash over 230 MiB of data in under one second.\n(If, instead, you require a pure Haskell implementation and performance is secondary, please refer to the [SHA package](https://hackage.haskell.org/package/SHA).)\n.\n\n.\nAdditionally, this package provides support for\n.\n- HMAC-SHA-256: SHA-256-based [Hashed Message Authentication Codes](https://en.wikipedia.org/wiki/HMAC) (HMAC)\n- HKDF-SHA-256: [HMAC-SHA-256-based Key Derivation Function](https://en.wikipedia.org/wiki/HKDF) (HKDF)\n.\nconforming to [RFC6234](https://tools.ietf.org/html/rfc6234), [RFC4231](https://tools.ietf.org/html/rfc4231), [RFC5869](https://tools.ietf.org/html/rfc5869), et al..\n.\n=== Relationship to the @cryptohash@ package and its API\n.\nThis package has been originally a fork of @cryptohash-0.11.7@ because the @cryptohash@\npackage had been deprecated and so this package continues to satisfy the need for a\nlightweight package providing the SHA-256 hash algorithm without any dependencies on packages\nother than @base@ and @bytestring@. The API exposed by @cryptohash-sha256-0.11.*@'s\n\"Crypto.Hash.SHA256\" module is guaranteed to remain a compatible superset of the API provided\nby the @cryptohash-0.11.7@'s module of the same name.\n.\nConsequently, this package is designed to be used as a drop-in replacement for @cryptohash-0.11.7@'s\n\"Crypto.Hash.SHA256\" module, though with\na [clearly smaller footprint by almost 3 orders of magnitude](https://www.reddit.com/r/haskell/comments/5lxv75/psa_please_use_unique_module_names_when_uploading/dbzegx3/).\n\n}\n\nlicense: BSD3\nlicense-file: LICENSE\ncopyright: Vincent Hanquez, Herbert Valerio Riedel\nmaintainer: Herbert Valerio Riedel \nhomepage: https://github.com/hvr/cryptohash-sha256\nbug-reports: https://github.com/hvr/cryptohash-sha256/issues\ncategory: Data, Cryptography\nbuild-type: Simple\n\ntested-with:\n GHC == 9.8.0\n GHC == 9.6.2\n GHC == 9.4.7\n GHC == 9.2.8\n GHC == 9.0.2\n GHC == 8.10.7\n GHC == 8.8.4\n GHC == 8.6.5\n GHC == 8.4.4\n GHC == 8.2.2\n GHC == 8.0.2\n GHC == 7.10.3\n\nextra-source-files: cbits/hs_sha256.h\n changelog.md\n\nsource-repository head\n type: git\n location: https://github.com/hvr/cryptohash-sha256.git\n\nflag exe\n description: Enable building @sha256sum@ executable\n manual: True\n default: False\n\nflag use-cbits\n description: Use fast optimized C routines via FFI; if flag is disabled falls back to non-FFI Haskell optimized implementation.\n manual: True\n default: True\n\nlibrary\n default-language: Haskell2010\n\n ghc-options: -Wall\n\n build-depends: base >= 4.5 && < 4.20\n\n exposed-modules: Crypto.Hash.SHA256\n\n if flag(use-cbits)\n build-depends: bytestring ^>= 0.9.2.0 || ^>= 0.10.0.0 || ^>= 0.11.0.0 || ^>= 0.12.0.2\n\n other-extensions: BangPatterns\n CApiFFI\n CPP\n Trustworthy\n Unsafe\n\n hs-source-dirs: src\n other-modules: Crypto.Hash.SHA256.FFI\n Compat\n include-dirs: cbits\n else\n hs-source-dirs: src-pure\n build-depends: cryptohash-sha256-pure ^>= 0.1.0\n\nexecutable sha256sum\n default-language: Haskell2010\n hs-source-dirs: src-exe\n main-is: sha256sum.hs\n ghc-options: -Wall -threaded\n if flag(exe)\n other-extensions: RecordWildCards\n build-depends: cryptohash-sha256\n , base\n , bytestring\n\n , base16-bytestring ^>= 0.1.1 || ^>= 1.0.0\n else\n buildable: False\n\ntest-suite test-sha256\n default-language: Haskell2010\n other-extensions: OverloadedStrings\n type: exitcode-stdio-1.0\n hs-source-dirs: src-tests\n main-is: test-sha256.hs\n ghc-options: -Wall -threaded\n build-depends: cryptohash-sha256\n , base\n , bytestring\n\n , base16-bytestring ^>= 0.1.1 || ^>= 1.0.0\n , SHA ^>= 1.6.4\n , tasty ^>= 1.4 || ^>= 1.5\n , tasty-quickcheck ^>= 0.10\n , tasty-hunit ^>= 0.10\n\nbenchmark bench-sha256\n default-language: Haskell2010\n other-extensions: BangPatterns\n type: exitcode-stdio-1.0\n main-is: bench-sha256.hs\n hs-source-dirs: src-bench\n build-depends: cryptohash-sha256\n , SHA ^>= 1.6.4\n , base\n , bytestring\n , criterion ^>= 1.5 || ^>=1.6\n\n -- not yet public\n -- build-depends: cryptohash-sha256-pure ^>= 0.1.0\n"; + package-description-override = "cabal-version: 2.0\nname: cryptohash-sha256\nversion: 0.11.102.1\nx-revision: 5\n\nsynopsis: Fast, pure and practical SHA-256 implementation\ndescription: {\n\nA practical incremental and one-pass, pure API to\nthe [SHA-256 cryptographic hash algorithm](https://en.wikipedia.org/wiki/SHA-2) according\nto [FIPS 180-4](http://dx.doi.org/10.6028/NIST.FIPS.180-4)\nwith performance close to the fastest implementations available in other languages.\n.\nThe core SHA-256 algorithm is implemented in C and is thus expected\nto be as fast as the standard [sha256sum(1) tool](https://linux.die.net/man/1/sha256sum);\nfor instance, on an /Intel Core i7-3770/ at 3.40GHz this implementation can\ncompute a SHA-256 hash over 230 MiB of data in under one second.\n(If, instead, you require a pure Haskell implementation and performance is secondary, please refer to the [SHA package](https://hackage.haskell.org/package/SHA).)\n.\n\n.\nAdditionally, this package provides support for\n.\n- HMAC-SHA-256: SHA-256-based [Hashed Message Authentication Codes](https://en.wikipedia.org/wiki/HMAC) (HMAC)\n- HKDF-SHA-256: [HMAC-SHA-256-based Key Derivation Function](https://en.wikipedia.org/wiki/HKDF) (HKDF)\n.\nconforming to [RFC6234](https://tools.ietf.org/html/rfc6234), [RFC4231](https://tools.ietf.org/html/rfc4231), [RFC5869](https://tools.ietf.org/html/rfc5869), et al..\n.\n=== Relationship to the @cryptohash@ package and its API\n.\nThis package has been originally a fork of @cryptohash-0.11.7@ because the @cryptohash@\npackage had been deprecated and so this package continues to satisfy the need for a\nlightweight package providing the SHA-256 hash algorithm without any dependencies on packages\nother than @base@ and @bytestring@. The API exposed by @cryptohash-sha256-0.11.*@'s\n\"Crypto.Hash.SHA256\" module is guaranteed to remain a compatible superset of the API provided\nby the @cryptohash-0.11.7@'s module of the same name.\n.\nConsequently, this package is designed to be used as a drop-in replacement for @cryptohash-0.11.7@'s\n\"Crypto.Hash.SHA256\" module, though with\na [clearly smaller footprint by almost 3 orders of magnitude](https://www.reddit.com/r/haskell/comments/5lxv75/psa_please_use_unique_module_names_when_uploading/dbzegx3/).\n\n}\n\nlicense: BSD3\nlicense-file: LICENSE\ncopyright: Vincent Hanquez, Herbert Valerio Riedel\nmaintainer: Herbert Valerio Riedel \nhomepage: https://github.com/haskell-hvr/cryptohash-sha256\nbug-reports: https://github.com/haskell-hvr/cryptohash-sha256/issues\ncategory: Data, Cryptography\nbuild-type: Simple\n\ntested-with:\n GHC == 9.10.1\n GHC == 9.8.2\n GHC == 9.6.5\n GHC == 9.4.8\n GHC == 9.2.8\n GHC == 9.0.2\n GHC == 8.10.7\n GHC == 8.8.4\n GHC == 8.6.5\n GHC == 8.4.4\n GHC == 8.2.2\n GHC == 8.0.2\n\nextra-source-files: cbits/hs_sha256.h\n changelog.md\n\nsource-repository head\n type: git\n location: https://github.com/haskell-hvr/cryptohash-sha256.git\n\nflag exe\n description: Enable building @sha256sum@ executable\n manual: True\n default: False\n\nflag use-cbits\n description: Use fast optimized C routines via FFI; if flag is disabled falls back to non-FFI Haskell optimized implementation.\n manual: True\n default: True\n\nlibrary\n default-language: Haskell2010\n\n ghc-options: -Wall\n\n build-depends: base >= 4.5 && < 4.21\n\n exposed-modules: Crypto.Hash.SHA256\n\n if flag(use-cbits)\n build-depends: bytestring ^>= 0.9.2.0 || ^>= 0.10.0.0 || ^>= 0.11.0.0 || ^>= 0.12.0.2\n\n other-extensions: BangPatterns\n CApiFFI\n CPP\n Trustworthy\n Unsafe\n\n hs-source-dirs: src\n other-modules: Crypto.Hash.SHA256.FFI\n Compat\n include-dirs: cbits\n else\n hs-source-dirs: src-pure\n build-depends: cryptohash-sha256-pure ^>= 0.1.0\n\nexecutable sha256sum\n default-language: Haskell2010\n hs-source-dirs: src-exe\n main-is: sha256sum.hs\n ghc-options: -Wall -threaded\n if flag(exe)\n other-extensions: RecordWildCards\n build-depends: cryptohash-sha256\n , base\n , bytestring\n\n , base16-bytestring ^>= 0.1.1 || ^>= 1.0.0\n else\n buildable: False\n\ntest-suite test-sha256\n default-language: Haskell2010\n other-extensions: OverloadedStrings\n type: exitcode-stdio-1.0\n hs-source-dirs: src-tests\n main-is: test-sha256.hs\n ghc-options: -Wall -threaded\n build-depends: cryptohash-sha256\n , base\n , bytestring\n\n , base16-bytestring ^>= 0.1.1 || ^>= 1.0.0\n , SHA ^>= 1.6.4\n , tasty ^>= 1.4 || ^>= 1.5\n , tasty-quickcheck >= 0.10 && < 1\n , tasty-hunit ^>= 0.10\n\nbenchmark bench-sha256\n default-language: Haskell2010\n other-extensions: BangPatterns\n type: exitcode-stdio-1.0\n main-is: bench-sha256.hs\n hs-source-dirs: src-bench\n build-depends: cryptohash-sha256\n , SHA ^>= 1.6.4\n , base\n , bytestring\n , criterion ^>= 1.5 || ^>=1.6\n\n -- not yet public\n -- build-depends: cryptohash-sha256-pure ^>= 0.1.0\n"; } \ No newline at end of file diff --git a/materialized/ghc964/hadrian-ghc910/hadrian/cabal-files/extra.nix b/materialized/ghc964/hadrian-ghc910/hadrian/cabal-files/extra.nix index 41668cf6bc..26ff289717 100644 --- a/materialized/ghc964/hadrian-ghc910/hadrian/cabal-files/extra.nix +++ b/materialized/ghc964/hadrian-ghc910/hadrian/cabal-files/extra.nix @@ -11,9 +11,9 @@ flags = {}; package = { specVersion = "1.18"; - identifier = { name = "extra"; version = "1.7.14"; }; + identifier = { name = "extra"; version = "1.7.16"; }; license = "BSD-3-Clause"; - copyright = "Neil Mitchell 2014-2023"; + copyright = "Neil Mitchell 2014-2024"; maintainer = "Neil Mitchell "; author = "Neil Mitchell "; homepage = "https://github.com/ndmitchell/extra#readme"; @@ -50,9 +50,9 @@ }; } // { src = pkgs.lib.mkDefault (pkgs.fetchurl { - url = "http://hackage.haskell.org/package/extra-1.7.14.tar.gz"; - sha256 = "b6a909f8f0e4b8076a1653b4d34815a782f0a8c1e83d5267f4d00496471ef567"; + url = "http://hackage.haskell.org/package/extra-1.7.16.tar.gz"; + sha256 = "250c6d43c30b2c71f2cf498a10e69e43ac035974d3819529385d99e42ce77c70"; }); }) // { - package-description-override = "cabal-version: 1.18\nbuild-type: Simple\nname: extra\nversion: 1.7.14\nlicense: BSD3\nlicense-file: LICENSE\ncategory: Development\nauthor: Neil Mitchell \nmaintainer: Neil Mitchell \ncopyright: Neil Mitchell 2014-2023\nsynopsis: Extra functions I use.\ndescription:\n A library of extra functions for the standard Haskell libraries. Most functions are simple additions, filling out missing functionality. A few functions are available in later versions of GHC, but this package makes them available back to GHC 7.2.\n .\n The module \"Extra\" documents all functions provided by this library. Modules such as \"Data.List.Extra\" provide extra functions over \"Data.List\" and also reexport \"Data.List\". Users are recommended to replace \"Data.List\" imports with \"Data.List.Extra\" if they need the extra functionality.\nhomepage: https://github.com/ndmitchell/extra#readme\nbug-reports: https://github.com/ndmitchell/extra/issues\ntested-with: GHC==9.6, GHC==9.4, GHC==9.2, GHC==9.0, GHC==8.10, GHC==8.8\n\nextra-doc-files:\n CHANGES.txt\n README.md\nextra-source-files:\n Generate.hs\n\nsource-repository head\n type: git\n location: https://github.com/ndmitchell/extra.git\n\nlibrary\n default-language: Haskell2010\n hs-source-dirs: src\n build-depends:\n base >= 4.9 && < 5,\n directory,\n filepath,\n process,\n clock >= 0.7,\n time\n if !os(windows)\n build-depends: unix\n\n other-modules:\n Partial\n exposed-modules:\n Extra\n Control.Concurrent.Extra\n Control.Exception.Extra\n Control.Monad.Extra\n Data.Foldable.Extra\n Data.Either.Extra\n Data.IORef.Extra\n Data.List.Extra\n Data.List.NonEmpty.Extra\n Data.Monoid.Extra\n Data.Tuple.Extra\n Data.Typeable.Extra\n Data.Version.Extra\n Numeric.Extra\n System.Directory.Extra\n System.Environment.Extra\n System.Info.Extra\n System.IO.Extra\n System.Process.Extra\n System.Time.Extra\n Text.Read.Extra\n\ntest-suite extra-test\n type: exitcode-stdio-1.0\n default-language: Haskell2010\n build-depends:\n base == 4.*,\n directory,\n filepath,\n extra,\n QuickCheck >= 2.10,\n quickcheck-instances >= 0.3.17\n if !os(windows)\n build-depends: unix\n hs-source-dirs: test\n ghc-options: -main-is Test -threaded \"-with-rtsopts=-N4 -K1K\"\n main-is: Test.hs\n other-modules:\n TestCustom\n TestGen\n TestUtil\n"; + package-description-override = "cabal-version: 1.18\nbuild-type: Simple\nname: extra\nversion: 1.7.16\nlicense: BSD3\nlicense-file: LICENSE\ncategory: Development\nauthor: Neil Mitchell \nmaintainer: Neil Mitchell \ncopyright: Neil Mitchell 2014-2024\nsynopsis: Extra functions I use.\ndescription:\n A library of extra functions for the standard Haskell libraries. Most functions are simple additions, filling out missing functionality. A few functions are available in later versions of GHC, but this package makes them available back to GHC 7.2.\n .\n The module \"Extra\" documents all functions provided by this library. Modules such as \"Data.List.Extra\" provide extra functions over \"Data.List\" and also reexport \"Data.List\". Users are recommended to replace \"Data.List\" imports with \"Data.List.Extra\" if they need the extra functionality.\nhomepage: https://github.com/ndmitchell/extra#readme\nbug-reports: https://github.com/ndmitchell/extra/issues\ntested-with: GHC==9.8, GHC==9.6, GHC==9.4, GHC==9.2, GHC==9.0, GHC==8.10, GHC==8.8\n\nextra-doc-files:\n CHANGES.txt\n README.md\nextra-source-files:\n Generate.hs\n\nsource-repository head\n type: git\n location: https://github.com/ndmitchell/extra.git\n\nlibrary\n default-language: Haskell2010\n hs-source-dirs: src\n build-depends:\n base >= 4.9 && < 5,\n directory,\n filepath,\n process,\n clock >= 0.7,\n time\n if !os(windows)\n build-depends: unix\n\n other-modules:\n Partial\n exposed-modules:\n Extra\n Control.Concurrent.Extra\n Control.Exception.Extra\n Control.Monad.Extra\n Data.Foldable.Extra\n Data.Either.Extra\n Data.IORef.Extra\n Data.List.Extra\n Data.List.NonEmpty.Extra\n Data.Monoid.Extra\n Data.Tuple.Extra\n Data.Typeable.Extra\n Data.Version.Extra\n Numeric.Extra\n System.Directory.Extra\n System.Environment.Extra\n System.Info.Extra\n System.IO.Extra\n System.Process.Extra\n System.Time.Extra\n Text.Read.Extra\n\ntest-suite extra-test\n type: exitcode-stdio-1.0\n default-language: Haskell2010\n build-depends:\n base == 4.*,\n directory,\n filepath,\n extra,\n QuickCheck >= 2.10,\n quickcheck-instances >= 0.3.17\n if !os(windows)\n build-depends: unix\n hs-source-dirs: test\n ghc-options: -main-is Test -threaded \"-with-rtsopts=-N4 -K1K\"\n main-is: Test.hs\n other-modules:\n TestCustom\n TestGen\n TestUtil\n"; } \ No newline at end of file diff --git a/materialized/ghc964/hadrian-ghc910/hadrian/cabal-files/hashable.nix b/materialized/ghc964/hadrian-ghc910/hadrian/cabal-files/hashable.nix index 4b125fa0bc..68ae273859 100644 --- a/materialized/ghc964/hadrian-ghc910/hadrian/cabal-files/hashable.nix +++ b/materialized/ghc964/hadrian-ghc910/hadrian/cabal-files/hashable.nix @@ -8,10 +8,10 @@ , config , ... }: ({ - flags = { integer-gmp = true; random-initial-seed = false; }; + flags = { arch-native = false; random-initial-seed = false; }; package = { - specVersion = "1.12"; - identifier = { name = "hashable"; version = "1.4.3.0"; }; + specVersion = "2.2"; + identifier = { name = "hashable"; version = "1.5.0.0"; }; license = "BSD-3-Clause"; copyright = ""; maintainer = "Oleg Grenrus "; @@ -19,47 +19,51 @@ homepage = "http://github.com/haskell-unordered-containers/hashable"; url = ""; synopsis = "A class for types that can be converted to a hash value"; - description = "This package defines a class, 'Hashable', for types that\ncan be converted to a hash value. This class\nexists for the benefit of hashing-based data\nstructures. The package provides instances for\nbasic types and a way to combine hash values.\n\nThe 'Hashable' 'hash' values are not guaranteed to be stable across library versions, operating systems or architectures. For stable hashing use named hashes: SHA256, CRC32 etc."; + description = "This package defines a class, 'Hashable', for types that can be converted to a hash value.\nThis class exists for the benefit of hashing-based data structures.\nThe package provides instances for basic types and a way to combine hash values.\n\n'Hashable' is intended exclusively for use in in-memory data structures.\n\n'Hashable' does /not/ have a fixed standard.\nThis allows it to improve over time.\n\nBecause it does not have a fixed standard, different computers or computers on different versions of the code will observe different hash values.\nAs such, 'hashable' is not recommended for use other than in-memory datastructures.\nSpecifically, 'hashable' is not intended for network use or in applications which persist hashed values.\nFor stable hashing use named hashes: sha256, crc32, xxhash etc."; buildType = "Simple"; }; components = { "library" = { - depends = (([ + depends = [ (hsPkgs."base" or (errorHandler.buildDepError "base")) (hsPkgs."bytestring" or (errorHandler.buildDepError "bytestring")) (hsPkgs."containers" or (errorHandler.buildDepError "containers")) (hsPkgs."deepseq" or (errorHandler.buildDepError "deepseq")) - (hsPkgs."filepath" or (errorHandler.buildDepError "filepath")) (hsPkgs."ghc-prim" or (errorHandler.buildDepError "ghc-prim")) (hsPkgs."text" or (errorHandler.buildDepError "text")) - ] ++ pkgs.lib.optional (!(compiler.isGhc && compiler.version.ge "9.2")) (hsPkgs."base-orphans" or (errorHandler.buildDepError "base-orphans"))) ++ pkgs.lib.optional (!(compiler.isGhc && compiler.version.ge "9.4")) (hsPkgs."data-array-byte" or (errorHandler.buildDepError "data-array-byte"))) ++ (if compiler.isGhc && compiler.version.ge "9" - then [ - (hsPkgs."ghc-bignum" or (errorHandler.buildDepError "ghc-bignum")) - ] ++ pkgs.lib.optional (!(compiler.isGhc && compiler.version.ge "9.0.2")) (hsPkgs."ghc-bignum-orphans" or (errorHandler.buildDepError "ghc-bignum-orphans")) - else if flags.integer-gmp - then [ - (hsPkgs."integer-gmp" or (errorHandler.buildDepError "integer-gmp")) - ] - else [ - (hsPkgs."integer-simple" or (errorHandler.buildDepError "integer-simple")) - ]); + (hsPkgs."os-string" or (errorHandler.buildDepError "os-string")) + (hsPkgs."filepath" or (errorHandler.buildDepError "filepath")) + (hsPkgs."ghc-bignum" or (errorHandler.buildDepError "ghc-bignum")) + ]; buildable = true; }; tests = { "hashable-tests" = { - depends = [ + depends = ([ (hsPkgs."base" or (errorHandler.buildDepError "base")) (hsPkgs."bytestring" or (errorHandler.buildDepError "bytestring")) + (hsPkgs."filepath" or (errorHandler.buildDepError "filepath")) (hsPkgs."ghc-prim" or (errorHandler.buildDepError "ghc-prim")) (hsPkgs."hashable" or (errorHandler.buildDepError "hashable")) (hsPkgs."HUnit" or (errorHandler.buildDepError "HUnit")) (hsPkgs."QuickCheck" or (errorHandler.buildDepError "QuickCheck")) (hsPkgs."random" or (errorHandler.buildDepError "random")) - (hsPkgs."test-framework" or (errorHandler.buildDepError "test-framework")) - (hsPkgs."test-framework-hunit" or (errorHandler.buildDepError "test-framework-hunit")) - (hsPkgs."test-framework-quickcheck2" or (errorHandler.buildDepError "test-framework-quickcheck2")) + (hsPkgs."tasty" or (errorHandler.buildDepError "tasty")) + (hsPkgs."tasty-hunit" or (errorHandler.buildDepError "tasty-hunit")) + (hsPkgs."tasty-quickcheck" or (errorHandler.buildDepError "tasty-quickcheck")) (hsPkgs."text" or (errorHandler.buildDepError "text")) - ] ++ pkgs.lib.optional (!system.isWindows) (hsPkgs."unix" or (errorHandler.buildDepError "unix")); + ] ++ pkgs.lib.optional (compiler.isGhc && compiler.version.ge "9.2") (hsPkgs."os-string" or (errorHandler.buildDepError "os-string"))) ++ pkgs.lib.optional (!system.isWindows) (hsPkgs."unix" or (errorHandler.buildDepError "unix")); + buildable = true; + }; + "xxhash-tests" = { + depends = [ + (hsPkgs."base" or (errorHandler.buildDepError "base")) + (hsPkgs."bytestring" or (errorHandler.buildDepError "bytestring")) + (hsPkgs."primitive" or (errorHandler.buildDepError "primitive")) + (hsPkgs."tasty" or (errorHandler.buildDepError "tasty")) + (hsPkgs."tasty-hunit" or (errorHandler.buildDepError "tasty-hunit")) + (hsPkgs."tasty-quickcheck" or (errorHandler.buildDepError "tasty-quickcheck")) + ] ++ pkgs.lib.optional (!(compiler.isGhc && compiler.version.ge "9.4")) (hsPkgs."data-array-byte" or (errorHandler.buildDepError "data-array-byte")); buildable = true; }; "hashable-examples" = { @@ -74,9 +78,9 @@ }; } // { src = pkgs.lib.mkDefault (pkgs.fetchurl { - url = "http://hackage.haskell.org/package/hashable-1.4.3.0.tar.gz"; - sha256 = "32efb16c2891786209b7cbe5c39df9b3a9ae51e836f1a54f646bc4602b7ab0f5"; + url = "http://hackage.haskell.org/package/hashable-1.5.0.0.tar.gz"; + sha256 = "e58b3a8e18da5f6cd7e937e5fd683e500bb1f8276b3768269759119ca0cddb6a"; }); }) // { - package-description-override = "cabal-version: 1.12\nname: hashable\nversion: 1.4.3.0\nx-revision: 1\nsynopsis: A class for types that can be converted to a hash value\ndescription:\n This package defines a class, 'Hashable', for types that\n can be converted to a hash value. This class\n exists for the benefit of hashing-based data\n structures. The package provides instances for\n basic types and a way to combine hash values.\n .\n The 'Hashable' 'hash' values are not guaranteed to be stable across library versions, operating systems or architectures. For stable hashing use named hashes: SHA256, CRC32 etc.\n\nhomepage: http://github.com/haskell-unordered-containers/hashable\n\n-- SPDX-License-Identifier : BSD-3-Clause\nlicense: BSD3\nlicense-file: LICENSE\nauthor:\n Milan Straka \n Johan Tibell \n\nmaintainer: Oleg Grenrus \nbug-reports:\n https://github.com/haskell-unordered-containers/hashable/issues\n\nstability: Provisional\ncategory: Data\nbuild-type: Simple\ntested-with:\n GHC ==8.2.2\n || ==8.4.4\n || ==8.6.5\n || ==8.8.3\n || ==8.10.4\n || ==8.10.7\n || ==9.0.1\n || ==9.0.2\n || ==9.2.8\n || ==9.4.7\n || ==9.6.3\n || ==9.8.1\n\nextra-source-files:\n CHANGES.md\n include/HsHashable.h\n README.md\n\nflag integer-gmp\n description:\n Are we using @integer-gmp@ to provide fast Integer instances? No effect on GHC-9.0 or later.\n\n manual: False\n default: True\n\nflag random-initial-seed\n description:\n Randomly initialize the initial seed on each final executable invocation\n This is useful for catching cases when you rely on (non-existent)\n stability of hashable's hash functions.\n This is not a security feature.\n\n manual: True\n default: False\n\nlibrary\n exposed-modules:\n Data.Hashable\n Data.Hashable.Generic\n Data.Hashable.Lifted\n\n other-modules:\n Data.Hashable.Class\n Data.Hashable.Generic.Instances\n Data.Hashable.Imports\n Data.Hashable.LowLevel\n\n c-sources: cbits/fnv.c\n include-dirs: include\n hs-source-dirs: src\n build-depends:\n base >=4.10.1.0 && <4.20\n , bytestring >=0.10.8.2 && <0.13\n , containers >=0.5.10.2 && <0.7\n , deepseq >=1.4.3.0 && <1.6\n , filepath >=1.4.1.2 && <1.5\n , ghc-prim\n , text >=1.2.3.0 && <1.3 || >=2.0 && <2.2\n\n if !impl(ghc >=9.2)\n build-depends: base-orphans >=0.8.6 && <0.10\n\n if !impl(ghc >=9.4)\n build-depends: data-array-byte >=0.1.0.1 && <0.2\n\n -- Integer internals\n if impl(ghc >=9)\n build-depends: ghc-bignum >=1.0 && <1.4\n\n if !impl(ghc >=9.0.2)\n build-depends: ghc-bignum-orphans >=0.1 && <0.2\n\n else\n if flag(integer-gmp)\n build-depends: integer-gmp >=0.4 && <1.1\n\n else\n -- this is needed for the automatic flag to be well-balanced\n build-depends: integer-simple\n\n if (flag(random-initial-seed) && impl(ghc))\n cpp-options: -DHASHABLE_RANDOM_SEED=1\n\n if os(windows)\n c-sources: cbits-win/init.c\n\n else\n c-sources: cbits-unix/init.c\n\n default-language: Haskell2010\n other-extensions:\n BangPatterns\n CPP\n DeriveDataTypeable\n FlexibleContexts\n FlexibleInstances\n GADTs\n KindSignatures\n MagicHash\n MultiParamTypeClasses\n ScopedTypeVariables\n Trustworthy\n TypeOperators\n UnliftedFFITypes\n\n ghc-options: -Wall -fwarn-tabs\n\n if impl(ghc >=9.0)\n -- these flags may abort compilation with GHC-8.10\n -- https://gitlab.haskell.org/ghc/ghc/-/merge_requests/3295\n ghc-options: -Winferred-safe-imports -Wmissing-safe-haskell-mode\n\ntest-suite hashable-tests\n type: exitcode-stdio-1.0\n hs-source-dirs: tests\n main-is: Main.hs\n other-modules:\n Properties\n Regress\n\n build-depends:\n base\n , bytestring\n , ghc-prim\n , hashable\n , HUnit\n , QuickCheck >=2.4.0.1\n , random >=1.0 && <1.3\n , test-framework >=0.3.3\n , test-framework-hunit\n , test-framework-quickcheck2 >=0.2.9\n , text >=0.11.0.5\n\n if !os(windows)\n build-depends: unix\n cpp-options: -DHAVE_MMAP\n other-modules: Regress.Mmap\n other-extensions: CApiFFI\n\n ghc-options: -Wall -fno-warn-orphans\n default-language: Haskell2010\n\ntest-suite hashable-examples\n type: exitcode-stdio-1.0\n build-depends:\n base\n , ghc-prim\n , hashable\n\n hs-source-dirs: examples\n main-is: Main.hs\n default-language: Haskell2010\n\nsource-repository head\n type: git\n location:\n https://github.com/haskell-unordered-containers/hashable.git\n"; + package-description-override = "cabal-version: 2.2\nname: hashable\nversion: 1.5.0.0\nsynopsis: A class for types that can be converted to a hash value\ndescription:\n This package defines a class, 'Hashable', for types that can be converted to a hash value.\n This class exists for the benefit of hashing-based data structures.\n The package provides instances for basic types and a way to combine hash values.\n .\n 'Hashable' is intended exclusively for use in in-memory data structures.\n .\n 'Hashable' does /not/ have a fixed standard.\n This allows it to improve over time.\n .\n Because it does not have a fixed standard, different computers or computers on different versions of the code will observe different hash values.\n As such, 'hashable' is not recommended for use other than in-memory datastructures.\n Specifically, 'hashable' is not intended for network use or in applications which persist hashed values.\n For stable hashing use named hashes: sha256, crc32, xxhash etc.\n\nhomepage: http://github.com/haskell-unordered-containers/hashable\nlicense: BSD-3-Clause\nlicense-file: LICENSE\nauthor:\n Milan Straka \n Johan Tibell \n\nmaintainer: Oleg Grenrus \nbug-reports:\n https://github.com/haskell-unordered-containers/hashable/issues\n\nstability: Provisional\ncategory: Data\nbuild-type: Simple\ntested-with: GHC ==9.6.5 || ==9.8.2 || ==9.10.1\nextra-source-files:\n CHANGES.md\n include/HsHashable.h\n include/HsXXHash.h\n README.md\n xxHash-0.8.2/xxhash.h\n\nflag arch-native\n description:\n Use @-march=native@ when compiling C sources.\n Portable implementation is 15-50% slower.\n Consider enabling this flag if hashing performance is important.\n\n manual: True\n default: False\n\nflag random-initial-seed\n description:\n Randomly initialize the initial seed on each final executable invocation\n This is useful for catching cases when you rely on (non-existent)\n stability of hashable's hash functions.\n This is not a security feature.\n\n manual: True\n default: False\n\nlibrary\n exposed-modules:\n Data.Hashable\n Data.Hashable.Generic\n Data.Hashable.Lifted\n\n other-modules:\n Data.Hashable.Class\n Data.Hashable.FFI\n Data.Hashable.Generic.Instances\n Data.Hashable.Imports\n Data.Hashable.LowLevel\n Data.Hashable.Mix\n Data.Hashable.XXH3\n\n include-dirs: include xxHash-0.8.2\n includes:\n HsHashable.h\n HsXXHash.h\n xxhash.h\n\n hs-source-dirs: src\n build-depends:\n , base >=4.18.0.0 && <4.21\n , bytestring >=0.11.5.3 && <0.13\n , containers >=0.6.7 && <0.8\n , deepseq >=1.4.8.1 && <1.6\n , ghc-prim\n , text >=2.0.2 && <2.2\n\n -- depend on os-string on newer GHCs only.\n -- os-string has tight lower bound on bytestring, which prevents\n -- using bundled version on older GHCs.\n build-depends: os-string >=2.0.2 && <2.1\n\n -- we also ensure that we can get filepath-1.5 only with GHC-9.2\n -- therefore there is else-branch with stricter upper bound.\n build-depends: filepath >=1.4.200.1 && <1.6\n\n -- Integer internals\n build-depends: ghc-bignum >=1.3 && <1.4\n\n if (flag(random-initial-seed) && impl(ghc))\n cpp-options: -DHASHABLE_RANDOM_SEED=1\n\n if os(windows)\n c-sources: cbits-win/init.c\n\n else\n c-sources: cbits-unix/init.c\n\n default-language: Haskell2010\n other-extensions:\n BangPatterns\n CPP\n DeriveDataTypeable\n FlexibleContexts\n FlexibleInstances\n GADTs\n KindSignatures\n MagicHash\n MultiParamTypeClasses\n QuantifiedConstraints\n ScopedTypeVariables\n Trustworthy\n TypeOperators\n UnliftedFFITypes\n\n ghc-options: -Wall\n\n if flag(arch-native)\n -- Cabal doesn't pass cc-options to \"ordinary\" Haskell source compilation\n -- https://github.com/haskell/cabal/issues/9801\n ghc-options: -optc=-march=native -optc-mtune=native\n\n if impl(ghc >=9.0)\n -- these flags may abort compilation with GHC-8.10\n -- https://gitlab.haskell.org/ghc/ghc/-/merge_requests/3295\n ghc-options: -Winferred-safe-imports -Wmissing-safe-haskell-mode\n\ntest-suite hashable-tests\n type: exitcode-stdio-1.0\n hs-source-dirs: tests\n main-is: Main.hs\n other-modules:\n Properties\n Regress\n\n build-depends:\n , base\n , bytestring\n , filepath\n , ghc-prim\n , hashable\n , HUnit\n , QuickCheck >=2.15\n , random >=1.0 && <1.3\n , tasty ^>=1.5\n , tasty-hunit ^>=0.10.1\n , tasty-quickcheck ^>=0.10.3\n , text >=0.11.0.5\n\n if impl(ghc >=9.2)\n build-depends: os-string\n\n if !os(windows)\n build-depends: unix\n cpp-options: -DHAVE_MMAP\n other-modules: Regress.Mmap\n other-extensions: CApiFFI\n\n ghc-options: -Wall -fno-warn-orphans\n default-language: Haskell2010\n\ntest-suite xxhash-tests\n type: exitcode-stdio-1.0\n hs-source-dirs: tests src\n main-is: xxhash-tests.hs\n other-modules:\n Data.Hashable.FFI\n Data.Hashable.XXH3\n\n default-language: Haskell2010\n build-depends:\n , base\n , bytestring\n , primitive ^>=0.9.0.0\n , tasty ^>=1.5\n , tasty-hunit ^>=0.10.1\n , tasty-quickcheck ^>=0.10.3\n\n include-dirs: include xxHash-0.8.2\n includes:\n HsXXHash.h\n xxhash.h\n\n if !impl(ghc >=9.4)\n build-depends: data-array-byte >=0.1.0.1 && <0.2\n\ntest-suite hashable-examples\n type: exitcode-stdio-1.0\n build-depends:\n , base\n , ghc-prim\n , hashable\n\n hs-source-dirs: examples\n main-is: Main.hs\n default-language: Haskell2010\n\nsource-repository head\n type: git\n location:\n https://github.com/haskell-unordered-containers/hashable.git\n"; } \ No newline at end of file diff --git a/materialized/ghc964/hadrian-ghc910/hadrian/cabal-files/os-string.nix b/materialized/ghc964/hadrian-ghc910/hadrian/cabal-files/os-string.nix new file mode 100644 index 0000000000..761c0cf7ee --- /dev/null +++ b/materialized/ghc964/hadrian-ghc910/hadrian/cabal-files/os-string.nix @@ -0,0 +1,79 @@ +{ system + , compiler + , flags + , pkgs + , hsPkgs + , pkgconfPkgs + , errorHandler + , config + , ... }: + ({ + flags = {}; + package = { + specVersion = "2.2"; + identifier = { name = "os-string"; version = "2.0.6"; }; + license = "BSD-3-Clause"; + copyright = "Julain Ospald 2021-2023"; + maintainer = "Julian Ospald "; + author = "Julian Ospald "; + homepage = "https://github.com/haskell/os-string/blob/master/README.md"; + url = ""; + synopsis = "Library for manipulating Operating system strings."; + description = "This package provides functionality for manipulating @OsString@ values, and is shipped with ."; + buildType = "Simple"; + }; + components = { + "library" = { + depends = [ + (hsPkgs."base" or (errorHandler.buildDepError "base")) + (hsPkgs."bytestring" or (errorHandler.buildDepError "bytestring")) + (hsPkgs."deepseq" or (errorHandler.buildDepError "deepseq")) + (hsPkgs."exceptions" or (errorHandler.buildDepError "exceptions")) + (hsPkgs."template-haskell" or (errorHandler.buildDepError "template-haskell")) + ]; + buildable = true; + }; + tests = { + "bytestring-tests" = { + depends = [ + (hsPkgs."base" or (errorHandler.buildDepError "base")) + (hsPkgs."bytestring" or (errorHandler.buildDepError "bytestring")) + (hsPkgs."os-string" or (errorHandler.buildDepError "os-string")) + (hsPkgs."QuickCheck" or (errorHandler.buildDepError "QuickCheck")) + ]; + buildable = true; + }; + "encoding-tests" = { + depends = [ + (hsPkgs."base" or (errorHandler.buildDepError "base")) + (hsPkgs."bytestring" or (errorHandler.buildDepError "bytestring")) + (hsPkgs."deepseq" or (errorHandler.buildDepError "deepseq")) + (hsPkgs."os-string" or (errorHandler.buildDepError "os-string")) + (hsPkgs."QuickCheck" or (errorHandler.buildDepError "QuickCheck")) + (hsPkgs."quickcheck-classes-base" or (errorHandler.buildDepError "quickcheck-classes-base")) + ]; + buildable = true; + }; + }; + benchmarks = { + "bench" = { + depends = [ + (hsPkgs."base" or (errorHandler.buildDepError "base")) + (hsPkgs."bytestring" or (errorHandler.buildDepError "bytestring")) + (hsPkgs."os-string" or (errorHandler.buildDepError "os-string")) + (hsPkgs."deepseq" or (errorHandler.buildDepError "deepseq")) + (hsPkgs."tasty-bench" or (errorHandler.buildDepError "tasty-bench")) + (hsPkgs."random" or (errorHandler.buildDepError "random")) + ]; + buildable = true; + }; + }; + }; + } // { + src = pkgs.lib.mkDefault (pkgs.fetchurl { + url = "http://hackage.haskell.org/package/os-string-2.0.6.tar.gz"; + sha256 = "22fcc7d5fc66676b5dfc57b714d2caf93cce2d5a79d242168352f9eb0fe2f18a"; + }); + }) // { + package-description-override = "cabal-version: 2.2\nname: os-string\nversion: 2.0.6\n\n-- NOTE: Don't forget to update ./changelog.md\nlicense: BSD-3-Clause\nlicense-file: LICENSE\nauthor: Julian Ospald \nmaintainer: Julian Ospald \ncopyright: Julain Ospald 2021-2023\nbug-reports: https://github.com/haskell/os-string/issues\nhomepage:\n https://github.com/haskell/os-string/blob/master/README.md\n\ncategory: System\nbuild-type: Simple\nsynopsis: Library for manipulating Operating system strings.\ntested-with:\n GHC ==8.6.5\n || ==8.8.4\n || ==8.10.7\n || ==9.0.2\n || ==9.2.8\n || ==9.4.8\n || ==9.6.3\n || ==9.8.1\n\ndescription:\n This package provides functionality for manipulating @OsString@ values, and is shipped with .\n\nextra-source-files:\n System/OsString/Common.hs\n tests/bytestring-tests/Properties/Common.hs\n bench/Common.hs\n\nextra-doc-files:\n changelog.md\n README.md\n\nsource-repository head\n type: git\n location: https://github.com/haskell/os-string\n\nlibrary\n exposed-modules:\n System.OsString.Data.ByteString.Short\n System.OsString.Data.ByteString.Short.Internal\n System.OsString.Data.ByteString.Short.Word16\n System.OsString.Encoding\n System.OsString.Encoding.Internal\n System.OsString\n System.OsString.Internal\n System.OsString.Internal.Types\n System.OsString.Posix\n System.OsString.Windows\n\n other-extensions:\n CPP\n PatternGuards\n\n if impl(ghc >=7.2)\n other-extensions: Safe\n\n default-language: Haskell2010\n build-depends:\n , base >=4.12.0.0 && <4.21\n , bytestring >=0.11.3.0\n , deepseq\n , exceptions\n , template-haskell\n\n ghc-options: -Wall\n\ntest-suite bytestring-tests\n default-language: Haskell2010\n ghc-options: -Wall\n type: exitcode-stdio-1.0\n main-is: Main.hs\n hs-source-dirs: tests tests/bytestring-tests\n other-modules:\n Properties.ShortByteString\n Properties.WindowsString\n Properties.PosixString\n Properties.OsString\n Properties.ShortByteString.Word16\n TestUtil\n\n build-depends:\n , base\n , bytestring >=0.11.3.0\n , os-string\n , QuickCheck >=2.7 && <2.16\n\ntest-suite encoding-tests\n default-language: Haskell2010\n ghc-options: -Wall\n type: exitcode-stdio-1.0\n main-is: Main.hs\n hs-source-dirs: tests tests/encoding\n other-modules:\n Arbitrary\n EncodingSpec\n TestUtil\n\n build-depends:\n , base\n , bytestring >=0.11.3.0\n , deepseq\n , os-string\n , QuickCheck >=2.7 && <2.16\n , quickcheck-classes-base ^>=0.6.2\n\nbenchmark bench\n main-is: Bench.hs\n other-modules: BenchOsString\n BenchPosixString\n BenchWindowsString\n type: exitcode-stdio-1.0\n hs-source-dirs: bench\n default-language: Haskell2010\n ghc-options: -O2 \"-with-rtsopts=-A32m\"\n if impl(ghc >= 8.6)\n ghc-options: -fproc-alignment=64\n build-depends: base,\n bytestring,\n os-string,\n deepseq,\n tasty-bench,\n random\n"; + } \ No newline at end of file diff --git a/materialized/ghc964/hadrian-ghc910/hadrian/cabal-files/primitive.nix b/materialized/ghc964/hadrian-ghc910/hadrian/cabal-files/primitive.nix index b5683f2c83..bbba6b670f 100644 --- a/materialized/ghc964/hadrian-ghc910/hadrian/cabal-files/primitive.nix +++ b/materialized/ghc964/hadrian-ghc910/hadrian/cabal-files/primitive.nix @@ -69,5 +69,5 @@ sha256 = "696d4bd291c94d736142d6182117dca4258d3ef28bfefdb649ac8b5ecd0999c7"; }); }) // { - package-description-override = "Cabal-Version: 2.0\nName: primitive\nVersion: 0.9.0.0\nLicense: BSD3\nLicense-File: LICENSE\n\nAuthor: Roman Leshchinskiy \nMaintainer: libraries@haskell.org\nCopyright: (c) Roman Leshchinskiy 2009-2012\nHomepage: https://github.com/haskell/primitive\nBug-Reports: https://github.com/haskell/primitive/issues\nCategory: Data\nSynopsis: Primitive memory-related operations\nBuild-Type: Simple\nDescription: This package provides various primitive memory-related operations.\n\nExtra-Source-Files: changelog.md\n test/*.hs\n test/LICENSE\n\nTested-With:\n GHC == 8.0.2\n GHC == 8.2.2\n GHC == 8.4.4\n GHC == 8.6.5\n GHC == 8.8.4\n GHC == 8.10.7\n GHC == 9.0.2\n GHC == 9.2.5\n GHC == 9.4.4\n\nLibrary\n Default-Language: Haskell2010\n Default-Extensions:\n TypeOperators\n Other-Extensions:\n BangPatterns, CPP, DeriveDataTypeable,\n MagicHash, TypeFamilies, UnboxedTuples, UnliftedFFITypes\n\n Exposed-Modules:\n Control.Monad.Primitive\n Data.Primitive\n Data.Primitive.MachDeps\n Data.Primitive.Types\n Data.Primitive.Array\n Data.Primitive.ByteArray\n Data.Primitive.PrimArray\n Data.Primitive.SmallArray\n Data.Primitive.Ptr\n Data.Primitive.MutVar\n Data.Primitive.MVar\n Data.Primitive.PrimVar\n\n Other-Modules:\n Data.Primitive.Internal.Operations\n Data.Primitive.Internal.Read\n\n Build-Depends: base >= 4.9 && < 4.20\n , deepseq >= 1.1 && < 1.6\n , transformers >= 0.5 && < 0.7\n , template-haskell >= 2.11\n\n if impl(ghc >= 9.2)\n cpp-options: -DHAVE_KEEPALIVE\n\n if impl(ghc < 9.4)\n build-depends: data-array-byte >= 0.1 && < 0.1.1\n\n Ghc-Options: -O2\n\n Include-Dirs: cbits\n Install-Includes: primitive-memops.h\n includes: primitive-memops.h\n c-sources: cbits/primitive-memops.c\n if !os(solaris)\n cc-options: -ftree-vectorize\n if arch(i386) || arch(x86_64)\n cc-options: -msse2\n\ntest-suite test-qc\n Default-Language: Haskell2010\n hs-source-dirs: test\n test/src\n main-is: Main.hs\n Other-Modules: PrimLaws\n type: exitcode-stdio-1.0\n build-depends: base\n , base-orphans\n , ghc-prim\n , primitive\n , quickcheck-classes-base >= 0.6 && <0.7\n , QuickCheck >= 2.13 && < 2.15\n , tasty ^>= 1.2 || ^>= 1.3 || ^>= 1.4\n , tasty-quickcheck\n , tagged\n , transformers >= 0.5\n , transformers-compat\n\n cpp-options: -DHAVE_UNARY_LAWS\n ghc-options: -O2\n\nbenchmark bench\n Default-Language: Haskell2010\n hs-source-dirs: bench\n main-is: main.hs\n type: exitcode-stdio-1.0\n ghc-options: -O2\n other-modules:\n Array.Traverse.Closure\n Array.Traverse.Unsafe\n ByteArray.Compare\n PrimArray.Compare\n PrimArray.Traverse\n build-depends:\n base\n , primitive\n , deepseq\n , tasty-bench\n , transformers >= 0.5\n\nsource-repository head\n type: git\n location: https://github.com/haskell/primitive\n"; + package-description-override = "Cabal-Version: 2.0\nName: primitive\nVersion: 0.9.0.0\nx-revision: 1\nLicense: BSD3\nLicense-File: LICENSE\n\nAuthor: Roman Leshchinskiy \nMaintainer: libraries@haskell.org\nCopyright: (c) Roman Leshchinskiy 2009-2012\nHomepage: https://github.com/haskell/primitive\nBug-Reports: https://github.com/haskell/primitive/issues\nCategory: Data\nSynopsis: Primitive memory-related operations\nBuild-Type: Simple\nDescription: This package provides various primitive memory-related operations.\n\nExtra-Source-Files: changelog.md\n test/*.hs\n test/LICENSE\n\nTested-With:\n GHC == 8.0.2\n GHC == 8.2.2\n GHC == 8.4.4\n GHC == 8.6.5\n GHC == 8.8.4\n GHC == 8.10.7\n GHC == 9.0.2\n GHC == 9.2.8\n GHC == 9.4.8\n GHC == 9.6.4\n GHC == 9.8.2\n\nLibrary\n Default-Language: Haskell2010\n Default-Extensions:\n TypeOperators\n Other-Extensions:\n BangPatterns, CPP, DeriveDataTypeable,\n MagicHash, TypeFamilies, UnboxedTuples, UnliftedFFITypes\n\n Exposed-Modules:\n Control.Monad.Primitive\n Data.Primitive\n Data.Primitive.MachDeps\n Data.Primitive.Types\n Data.Primitive.Array\n Data.Primitive.ByteArray\n Data.Primitive.PrimArray\n Data.Primitive.SmallArray\n Data.Primitive.Ptr\n Data.Primitive.MutVar\n Data.Primitive.MVar\n Data.Primitive.PrimVar\n\n Other-Modules:\n Data.Primitive.Internal.Operations\n Data.Primitive.Internal.Read\n\n Build-Depends: base >= 4.9 && < 4.21\n , deepseq >= 1.1 && < 1.6\n , transformers >= 0.5 && < 0.7\n , template-haskell >= 2.11\n\n if impl(ghc >= 9.2)\n cpp-options: -DHAVE_KEEPALIVE\n\n if impl(ghc < 9.4)\n build-depends: data-array-byte >= 0.1 && < 0.1.1\n\n Ghc-Options: -O2\n\n Include-Dirs: cbits\n Install-Includes: primitive-memops.h\n includes: primitive-memops.h\n c-sources: cbits/primitive-memops.c\n if !os(solaris)\n cc-options: -ftree-vectorize\n if arch(i386) || arch(x86_64)\n cc-options: -msse2\n\ntest-suite test-qc\n Default-Language: Haskell2010\n hs-source-dirs: test\n test/src\n main-is: Main.hs\n Other-Modules: PrimLaws\n type: exitcode-stdio-1.0\n build-depends: base\n , base-orphans\n , ghc-prim\n , primitive\n , quickcheck-classes-base >= 0.6 && <0.7\n , QuickCheck >= 2.13 && < 2.15\n , tasty >= 1.2 && < 1.6\n , tasty-quickcheck\n , tagged\n , transformers >= 0.5\n , transformers-compat\n\n cpp-options: -DHAVE_UNARY_LAWS\n ghc-options: -O2\n\nbenchmark bench\n Default-Language: Haskell2010\n hs-source-dirs: bench\n main-is: main.hs\n type: exitcode-stdio-1.0\n ghc-options: -O2\n other-modules:\n Array.Traverse.Closure\n Array.Traverse.Unsafe\n ByteArray.Compare\n PrimArray.Compare\n PrimArray.Traverse\n build-depends:\n base\n , primitive\n , deepseq\n , tasty-bench\n , transformers >= 0.5\n\nsource-repository head\n type: git\n location: https://github.com/haskell/primitive\n"; } \ No newline at end of file diff --git a/materialized/ghc964/hadrian-ghc910/hadrian/cabal-files/random.nix b/materialized/ghc964/hadrian-ghc910/hadrian/cabal-files/random.nix index 0dbaf8b099..2d04734f5b 100644 --- a/materialized/ghc964/hadrian-ghc910/hadrian/cabal-files/random.nix +++ b/materialized/ghc964/hadrian-ghc910/hadrian/cabal-files/random.nix @@ -11,7 +11,7 @@ flags = {}; package = { specVersion = "1.10"; - identifier = { name = "random"; version = "1.2.1.1"; }; + identifier = { name = "random"; version = "1.2.1.2"; }; license = "BSD-3-Clause"; copyright = ""; maintainer = "core-libraries-committee@haskell.org"; @@ -105,9 +105,9 @@ }; } // { src = pkgs.lib.mkDefault (pkgs.fetchurl { - url = "http://hackage.haskell.org/package/random-1.2.1.1.tar.gz"; - sha256 = "3e1272f7ed6a4d7bd1712b90143ec326fee9b225789222379fea20a9c90c9b76"; + url = "http://hackage.haskell.org/package/random-1.2.1.2.tar.gz"; + sha256 = "790f4dc2d2327c453ff6aac7bf15399fd123d55e927935f68f84b5df42d9a4b4"; }); }) // { - package-description-override = "cabal-version: >=1.10\r\nname: random\r\nversion: 1.2.1.1\r\nx-revision: 1\r\nlicense: BSD3\r\nlicense-file: LICENSE\r\nmaintainer: core-libraries-committee@haskell.org\r\nbug-reports: https://github.com/haskell/random/issues\r\nsynopsis: Pseudo-random number generation\r\ndescription:\r\n This package provides basic pseudo-random number generation, including the\r\n ability to split random number generators.\r\n .\r\n == \"System.Random\": pure pseudo-random number interface\r\n .\r\n In pure code, use 'System.Random.uniform' and 'System.Random.uniformR' from\r\n \"System.Random\" to generate pseudo-random numbers with a pure pseudo-random\r\n number generator like 'System.Random.StdGen'.\r\n .\r\n As an example, here is how you can simulate rolls of a six-sided die using\r\n 'System.Random.uniformR':\r\n .\r\n >>> let roll = uniformR (1, 6) :: RandomGen g => g -> (Word, g)\r\n >>> let rolls = unfoldr (Just . roll) :: RandomGen g => g -> [Word]\r\n >>> let pureGen = mkStdGen 42\r\n >>> take 10 (rolls pureGen) :: [Word]\r\n [1,1,3,2,4,5,3,4,6,2]\r\n .\r\n See \"System.Random\" for more details.\r\n .\r\n == \"System.Random.Stateful\": monadic pseudo-random number interface\r\n .\r\n In monadic code, use 'System.Random.Stateful.uniformM' and\r\n 'System.Random.Stateful.uniformRM' from \"System.Random.Stateful\" to generate\r\n pseudo-random numbers with a monadic pseudo-random number generator, or\r\n using a monadic adapter.\r\n .\r\n As an example, here is how you can simulate rolls of a six-sided die using\r\n 'System.Random.Stateful.uniformRM':\r\n .\r\n >>> let rollM = uniformRM (1, 6) :: StatefulGen g m => g -> m Word\r\n >>> let pureGen = mkStdGen 42\r\n >>> runStateGen_ pureGen (replicateM 10 . rollM) :: [Word]\r\n [1,1,3,2,4,5,3,4,6,2]\r\n .\r\n The monadic adapter 'System.Random.Stateful.runStateGen_' is used here to lift\r\n the pure pseudo-random number generator @pureGen@ into the\r\n 'System.Random.Stateful.StatefulGen' context.\r\n .\r\n The monadic interface can also be used with existing monadic pseudo-random\r\n number generators. In this example, we use the one provided in the\r\n package:\r\n .\r\n >>> import System.Random.MWC as MWC\r\n >>> let rollM = uniformRM (1, 6) :: StatefulGen g m => g -> m Word\r\n >>> monadicGen <- MWC.create\r\n >>> replicateM 10 (rollM monadicGen) :: IO [Word]\r\n [2,3,6,6,4,4,3,1,5,4]\r\n .\r\n See \"System.Random.Stateful\" for more details.\r\n\r\ncategory: System\r\nbuild-type: Simple\r\nextra-source-files:\r\n README.md\r\n CHANGELOG.md\r\ntested-with: GHC == 7.10.2\r\n , GHC == 7.10.3\r\n , GHC == 8.0.2\r\n , GHC == 8.2.2\r\n , GHC == 8.4.3\r\n , GHC == 8.4.4\r\n , GHC == 8.6.3\r\n , GHC == 8.6.4\r\n , GHC == 8.6.5\r\n , GHC == 8.8.1\r\n , GHC == 8.8.2\r\n , GHC == 8.10.1\r\n\r\nsource-repository head\r\n type: git\r\n location: https://github.com/haskell/random.git\r\n\r\n\r\nlibrary\r\n exposed-modules:\r\n System.Random\r\n System.Random.Internal\r\n System.Random.Stateful\r\n other-modules:\r\n System.Random.GFinite\r\n\r\n hs-source-dirs: src\r\n default-language: Haskell2010\r\n ghc-options:\r\n -Wall\r\n if impl(ghc >= 8.0)\r\n ghc-options:\r\n -Wincomplete-record-updates -Wincomplete-uni-patterns\r\n\r\n build-depends:\r\n base >=4.8 && <5,\r\n bytestring >=0.10.4 && <0.13,\r\n deepseq >=1.1 && <2,\r\n mtl >=2.2 && <2.4,\r\n splitmix >=0.1 && <0.2\r\n if impl(ghc < 8.0)\r\n build-depends:\r\n transformers\r\n\r\ntest-suite legacy-test\r\n type: exitcode-stdio-1.0\r\n main-is: Legacy.hs\r\n hs-source-dirs: test-legacy\r\n other-modules:\r\n T7936\r\n TestRandomIOs\r\n TestRandomRs\r\n Random1283\r\n RangeTest\r\n\r\n default-language: Haskell2010\r\n ghc-options: -with-rtsopts=-M8M\r\n if impl(ghc >= 8.0)\r\n ghc-options:\r\n -Wno-deprecations\r\n build-depends:\r\n base,\r\n containers >=0.5 && <0.7,\r\n random\r\n\r\ntest-suite doctests\r\n type: exitcode-stdio-1.0\r\n main-is: doctests.hs\r\n hs-source-dirs: test\r\n default-language: Haskell2010\r\n build-depends:\r\n base,\r\n doctest >=0.15 && <0.21\r\n if impl(ghc >= 8.2) && impl(ghc < 8.10)\r\n build-depends:\r\n mwc-random >=0.13 && <0.16,\r\n primitive >=0.6 && <0.8,\r\n random,\r\n stm,\r\n unliftio >=0.2 && <0.3,\r\n vector >= 0.10 && <0.14\r\n\r\ntest-suite spec\r\n type: exitcode-stdio-1.0\r\n main-is: Spec.hs\r\n hs-source-dirs: test\r\n other-modules:\r\n Spec.Range\r\n Spec.Run\r\n Spec.Stateful\r\n\r\n default-language: Haskell2010\r\n ghc-options: -Wall\r\n build-depends:\r\n base,\r\n bytestring,\r\n random,\r\n smallcheck >=1.2 && <1.3,\r\n stm,\r\n tasty >=1.0 && <1.5,\r\n tasty-smallcheck >=0.8 && <0.9,\r\n tasty-hunit >=0.10 && <0.11,\r\n transformers\r\n\r\n-- Note. Fails when compiled with coverage:\r\n-- https://github.com/haskell/random/issues/107\r\ntest-suite spec-inspection\r\n type: exitcode-stdio-1.0\r\n main-is: Spec.hs\r\n hs-source-dirs: test-inspection\r\n build-depends:\r\n\r\n default-language: Haskell2010\r\n ghc-options: -Wall\r\n build-depends:\r\n base,\r\n random,\r\n tasty >=1.0 && <1.5\r\n if impl(ghc >= 8.0)\r\n build-depends:\r\n tasty-inspection-testing\r\n other-modules:\r\n Spec.Inspection\r\n\r\nbenchmark legacy-bench\r\n type: exitcode-stdio-1.0\r\n main-is: SimpleRNGBench.hs\r\n hs-source-dirs: bench-legacy\r\n other-modules: BinSearch\r\n default-language: Haskell2010\r\n ghc-options:\r\n -Wall -O2 -threaded -rtsopts -with-rtsopts=-N\r\n if impl(ghc >= 8.0)\r\n ghc-options:\r\n -Wno-deprecations\r\n\r\n build-depends:\r\n base,\r\n random,\r\n rdtsc,\r\n split >=0.2 && <0.3,\r\n time >=1.4 && <1.13\r\n\r\nbenchmark bench\r\n type: exitcode-stdio-1.0\r\n main-is: Main.hs\r\n hs-source-dirs: bench\r\n default-language: Haskell2010\r\n ghc-options: -Wall -O2\r\n build-depends:\r\n base,\r\n mtl,\r\n primitive >= 0.7.1,\r\n random,\r\n splitmix >=0.1 && <0.2,\r\n tasty-bench\r\n"; + package-description-override = "cabal-version: >=1.10\nname: random\nversion: 1.2.1.2\nlicense: BSD3\nlicense-file: LICENSE\nmaintainer: core-libraries-committee@haskell.org\nbug-reports: https://github.com/haskell/random/issues\nsynopsis: Pseudo-random number generation\ndescription:\n This package provides basic pseudo-random number generation, including the\n ability to split random number generators.\n .\n == \"System.Random\": pure pseudo-random number interface\n .\n In pure code, use 'System.Random.uniform' and 'System.Random.uniformR' from\n \"System.Random\" to generate pseudo-random numbers with a pure pseudo-random\n number generator like 'System.Random.StdGen'.\n .\n As an example, here is how you can simulate rolls of a six-sided die using\n 'System.Random.uniformR':\n .\n >>> let roll = uniformR (1, 6) :: RandomGen g => g -> (Word, g)\n >>> let rolls = unfoldr (Just . roll) :: RandomGen g => g -> [Word]\n >>> let pureGen = mkStdGen 42\n >>> take 10 (rolls pureGen) :: [Word]\n [1,1,3,2,4,5,3,4,6,2]\n .\n See \"System.Random\" for more details.\n .\n == \"System.Random.Stateful\": monadic pseudo-random number interface\n .\n In monadic code, use 'System.Random.Stateful.uniformM' and\n 'System.Random.Stateful.uniformRM' from \"System.Random.Stateful\" to generate\n pseudo-random numbers with a monadic pseudo-random number generator, or\n using a monadic adapter.\n .\n As an example, here is how you can simulate rolls of a six-sided die using\n 'System.Random.Stateful.uniformRM':\n .\n >>> let rollM = uniformRM (1, 6) :: StatefulGen g m => g -> m Word\n >>> let pureGen = mkStdGen 42\n >>> runStateGen_ pureGen (replicateM 10 . rollM) :: [Word]\n [1,1,3,2,4,5,3,4,6,2]\n .\n The monadic adapter 'System.Random.Stateful.runStateGen_' is used here to lift\n the pure pseudo-random number generator @pureGen@ into the\n 'System.Random.Stateful.StatefulGen' context.\n .\n The monadic interface can also be used with existing monadic pseudo-random\n number generators. In this example, we use the one provided in the\n package:\n .\n >>> import System.Random.MWC as MWC\n >>> let rollM = uniformRM (1, 6) :: StatefulGen g m => g -> m Word\n >>> monadicGen <- MWC.create\n >>> replicateM 10 (rollM monadicGen) :: IO [Word]\n [2,3,6,6,4,4,3,1,5,4]\n .\n See \"System.Random.Stateful\" for more details.\n\ncategory: System\nbuild-type: Simple\nextra-source-files:\n README.md\n CHANGELOG.md\ntested-with: GHC == 8.0.2\n , GHC == 8.2.2\n , GHC == 8.4.3\n , GHC == 8.4.4\n , GHC == 8.6.3\n , GHC == 8.6.4\n , GHC == 8.6.5\n , GHC == 8.8.1\n , GHC == 8.8.2\n , GHC == 8.10.1\n\nsource-repository head\n type: git\n location: https://github.com/haskell/random.git\n\n\nlibrary\n exposed-modules:\n System.Random\n System.Random.Internal\n System.Random.Stateful\n other-modules:\n System.Random.GFinite\n\n hs-source-dirs: src\n default-language: Haskell2010\n ghc-options:\n -Wall\n if impl(ghc >= 8.0)\n ghc-options:\n -Wincomplete-record-updates -Wincomplete-uni-patterns\n\n build-depends:\n base >=4.8 && <5,\n bytestring >=0.10.4 && <0.13,\n deepseq >=1.1 && <2,\n mtl >=2.2 && <2.4,\n splitmix >=0.1 && <0.2\n if impl(ghc < 8.0)\n build-depends:\n transformers\n\ntest-suite legacy-test\n type: exitcode-stdio-1.0\n main-is: Legacy.hs\n hs-source-dirs: test-legacy\n other-modules:\n T7936\n TestRandomIOs\n TestRandomRs\n Random1283\n RangeTest\n\n default-language: Haskell2010\n ghc-options: -rtsopts -with-rtsopts=-M9M\n if impl(ghc >= 8.0)\n ghc-options:\n -Wno-deprecations\n build-depends:\n base,\n containers >=0.5 && <0.7,\n random\n\ntest-suite doctests\n type: exitcode-stdio-1.0\n main-is: doctests.hs\n hs-source-dirs: test\n default-language: Haskell2010\n build-depends:\n base,\n doctest >=0.15 && <0.23\n if impl(ghc >= 8.2) && impl(ghc < 8.10)\n build-depends:\n mwc-random >=0.13 && <0.16,\n primitive >=0.6 && <0.8,\n random,\n stm,\n unliftio >=0.2 && <0.3,\n vector >= 0.10 && <0.14\n\ntest-suite spec\n type: exitcode-stdio-1.0\n main-is: Spec.hs\n hs-source-dirs: test\n other-modules:\n Spec.Range\n Spec.Run\n Spec.Stateful\n\n default-language: Haskell2010\n ghc-options: -Wall\n build-depends:\n base,\n bytestring,\n random,\n smallcheck >=1.2 && <1.3,\n stm,\n tasty >=1.0 && <1.6,\n tasty-smallcheck >=0.8 && <0.9,\n tasty-hunit >=0.10 && <0.11,\n transformers\n\n-- Note. Fails when compiled with coverage:\n-- https://github.com/haskell/random/issues/107\ntest-suite spec-inspection\n type: exitcode-stdio-1.0\n main-is: Spec.hs\n hs-source-dirs: test-inspection\n default-language: Haskell2010\n ghc-options: -Wall\n build-depends:\n base,\n random,\n tasty >=1.0 && <1.6\n if impl(ghc >= 8.0)\n build-depends:\n tasty-inspection-testing\n other-modules:\n Spec.Inspection\n\nbenchmark legacy-bench\n type: exitcode-stdio-1.0\n main-is: SimpleRNGBench.hs\n hs-source-dirs: bench-legacy\n other-modules: BinSearch\n default-language: Haskell2010\n ghc-options:\n -Wall -O2 -threaded -rtsopts -with-rtsopts=-N\n if impl(ghc >= 8.0)\n ghc-options:\n -Wno-deprecations\n\n build-depends:\n base,\n random,\n rdtsc,\n split >=0.2 && <0.3,\n time >=1.4 && <1.13\n\nbenchmark bench\n type: exitcode-stdio-1.0\n main-is: Main.hs\n hs-source-dirs: bench\n default-language: Haskell2010\n ghc-options: -Wall -O2\n build-depends:\n base,\n mtl,\n primitive >= 0.7.1,\n random,\n splitmix >=0.1 && <0.2,\n tasty-bench\n"; } \ No newline at end of file diff --git a/materialized/ghc964/hadrian-ghc910/hadrian/cabal-files/shake.nix b/materialized/ghc964/hadrian-ghc910/hadrian/cabal-files/shake.nix index d40c2a8bbc..d643f68037 100644 --- a/materialized/ghc964/hadrian-ghc910/hadrian/cabal-files/shake.nix +++ b/materialized/ghc964/hadrian-ghc910/hadrian/cabal-files/shake.nix @@ -8,12 +8,17 @@ , config , ... }: ({ - flags = { portable = false; cloud = false; embed-files = false; }; + flags = { + portable = false; + cloud = false; + embed-files = false; + threaded = true; + }; package = { specVersion = "1.18"; - identifier = { name = "shake"; version = "0.19.7"; }; + identifier = { name = "shake"; version = "0.19.8"; }; license = "BSD-3-Clause"; - copyright = "Neil Mitchell 2011-2022"; + copyright = "Neil Mitchell 2011-2024"; maintainer = "Neil Mitchell "; author = "Neil Mitchell "; homepage = "https://shakebuild.com"; @@ -124,9 +129,9 @@ }; } // { src = pkgs.lib.mkDefault (pkgs.fetchurl { - url = "http://hackage.haskell.org/package/shake-0.19.7.tar.gz"; - sha256 = "352a56af12f70b50d564dcb61131555577281957ee196f1702a3723c0a3699d1"; + url = "http://hackage.haskell.org/package/shake-0.19.8.tar.gz"; + sha256 = "6384e33a26a2590bf33719e88881076b899ac4b5340c1c9271e4caa37e9d6535"; }); }) // { - package-description-override = "cabal-version: 1.18\nbuild-type: Simple\nname: shake\nversion: 0.19.7\nx-revision: 1\nlicense: BSD3\nlicense-file: LICENSE\ncategory: Development, Shake\nauthor: Neil Mitchell \nmaintainer: Neil Mitchell \ncopyright: Neil Mitchell 2011-2022\nsynopsis: Build system library, like Make, but more accurate dependencies.\ndescription:\n Shake is a Haskell library for writing build systems - designed as a\n replacement for @make@. See \"Development.Shake\" for an introduction,\n including an example. The homepage contains links to a user\n manual, an academic paper and further information:\n \n .\n To use Shake the user writes a Haskell program\n that imports \"Development.Shake\", defines some build rules, and calls\n the 'Development.Shake.shakeArgs' function. Thanks to do notation and infix\n operators, a simple Shake build system\n is not too dissimilar from a simple Makefile. However, as build systems\n get more complex, Shake is able to take advantage of the excellent\n abstraction facilities offered by Haskell and easily support much larger\n projects. The Shake library provides all the standard features available in other\n build systems, including automatic parallelism and minimal rebuilds.\n Shake also provides more accurate dependency tracking, including seamless\n support for generated files, and dependencies on system information\n (e.g. compiler version).\nhomepage: https://shakebuild.com\nbug-reports: https://github.com/ndmitchell/shake/issues\ntested-with: GHC==9.0, GHC==8.10, GHC==8.8, GHC==8.6\nextra-doc-files:\n CHANGES.txt\n README.md\n docs/Manual.md\n docs/shake-progress.png\nextra-source-files:\n src/Paths.hs\n src/Test/C/constants.c\n src/Test/C/constants.h\n src/Test/C/main.c\n src/Test/Ninja/*.ninja\n src/Test/Ninja/*.output\n src/Test/Ninja/subdir/*.ninja\n src/Test/Progress/*.prog\n src/Test/Tar/list.txt\n src/Test/Tup/hello.c\n src/Test/Tup/newmath/root.cfg\n src/Test/Tup/newmath/square.c\n src/Test/Tup/newmath/square.h\n src/Test/Tup/root.cfg\ndata-files:\n docs/manual/build.bat\n docs/manual/Shakefile.hs\n docs/manual/build.sh\n docs/manual/constants.c\n docs/manual/constants.h\n docs/manual/main.c\n html/profile.html\n html/progress.html\n html/shake.js\n\nsource-repository head\n type: git\n location: https://github.com/ndmitchell/shake.git\n\nflag portable\n default: False\n manual: True\n description: Obtain FileTime using portable functions\n\nflag cloud\n default: False\n manual: True\n description: Enable cloud build features\n\nflag embed-files\n default: False\n manual: True\n description: Embed data files into the shake library\n\nlibrary\n default-language: Haskell2010\n hs-source-dirs: src\n build-depends:\n base >= 4.9,\n binary,\n bytestring,\n deepseq >= 1.1,\n directory >= 1.2.7.0,\n extra >= 1.6.19,\n filepath >= 1.4,\n filepattern,\n hashable >= 1.1.2.3,\n heaps >= 0.3.6.1,\n js-dgtable,\n js-flot,\n js-jquery,\n primitive,\n process >= 1.1,\n random,\n time,\n transformers >= 0.2,\n unordered-containers >= 0.2.7,\n utf8-string >= 0.3\n\n if flag(embed-files)\n cpp-options: -DFILE_EMBED\n build-depends:\n file-embed >= 0.0.11,\n template-haskell\n\n if flag(portable)\n cpp-options: -DPORTABLE\n else\n if !os(windows)\n build-depends: unix >= 2.5.1\n if !os(windows)\n build-depends: unix\n\n if flag(cloud)\n cpp-options: -DNETWORK\n build-depends: network, network-uri\n\n exposed-modules:\n Development.Shake\n Development.Shake.Classes\n Development.Shake.Command\n Development.Shake.Config\n Development.Shake.Database\n Development.Shake.FilePath\n Development.Shake.Forward\n Development.Shake.Rule\n Development.Shake.Util\n\n other-modules:\n Development.Ninja.Env\n Development.Ninja.Lexer\n Development.Ninja.Parse\n Development.Ninja.Type\n Development.Shake.Internal.Args\n Development.Shake.Internal.CmdOption\n Development.Shake.Internal.CompactUI\n Development.Shake.Internal.Core.Action\n Development.Shake.Internal.Core.Build\n Development.Shake.Internal.Core.Database\n Development.Shake.Internal.History.Shared\n Development.Shake.Internal.History.Symlink\n Development.Shake.Internal.History.Bloom\n Development.Shake.Internal.History.Cloud\n Development.Shake.Internal.History.Network\n Development.Shake.Internal.History.Server\n Development.Shake.Internal.History.Serialise\n Development.Shake.Internal.History.Types\n Development.Shake.Internal.Core.Monad\n Development.Shake.Internal.Core.Pool\n Development.Shake.Internal.Core.Rules\n Development.Shake.Internal.Core.Run\n Development.Shake.Internal.Core.Storage\n Development.Shake.Internal.Core.Types\n Development.Shake.Internal.Demo\n Development.Shake.Internal.Derived\n Development.Shake.Internal.Errors\n Development.Shake.Internal.FileInfo\n Development.Shake.Internal.FileName\n Development.Shake.Internal.FilePattern\n Development.Shake.Internal.Options\n Development.Shake.Internal.Paths\n Development.Shake.Internal.Profile\n Development.Shake.Internal.Progress\n Development.Shake.Internal.Resource\n Development.Shake.Internal.Rules.Default\n Development.Shake.Internal.Rules.Directory\n Development.Shake.Internal.Rules.File\n Development.Shake.Internal.Rules.Files\n Development.Shake.Internal.Rules.Oracle\n Development.Shake.Internal.Rules.OrderOnly\n Development.Shake.Internal.Rules.Rerun\n Development.Shake.Internal.Value\n General.Bilist\n General.Binary\n General.Chunks\n General.Cleanup\n General.Fence\n General.EscCodes\n General.Extra\n General.FileLock\n General.GetOpt\n General.Ids\n General.Intern\n General.ListBuilder\n General.Makefile\n General.Pool\n General.Process\n General.Template\n General.Thread\n General.Timing\n General.TypeMap\n General.Wait\n Paths_shake\n\n\nexecutable shake\n default-language: Haskell2010\n hs-source-dirs: src\n ghc-options: -main-is Run.main -rtsopts -threaded \"-with-rtsopts=-I0 -qg\"\n main-is: Run.hs\n build-depends:\n base == 4.*,\n binary,\n bytestring,\n deepseq >= 1.1,\n directory,\n extra >= 1.6.19,\n filepath,\n filepattern,\n hashable >= 1.1.2.3,\n heaps >= 0.3.6.1,\n js-dgtable,\n js-flot,\n js-jquery,\n primitive,\n process >= 1.1,\n random,\n time,\n transformers >= 0.2,\n unordered-containers >= 0.2.7,\n utf8-string >= 0.3\n\n if flag(embed-files)\n cpp-options: -DFILE_EMBED\n build-depends:\n file-embed >= 0.0.11,\n template-haskell\n\n if flag(portable)\n cpp-options: -DPORTABLE\n else\n if !os(windows)\n build-depends: unix >= 2.5.1\n if !os(windows)\n build-depends: unix\n\n if flag(cloud)\n cpp-options: -DNETWORK\n build-depends: network, network-uri\n\n if impl(ghc < 8.0)\n build-depends: semigroups >= 0.18\n\n other-modules:\n Development.Ninja.All\n Development.Ninja.Env\n Development.Ninja.Lexer\n Development.Ninja.Parse\n Development.Ninja.Type\n Development.Shake\n Development.Shake.Classes\n Development.Shake.Command\n Development.Shake.Database\n Development.Shake.FilePath\n Development.Shake.Internal.Args\n Development.Shake.Internal.CmdOption\n Development.Shake.Internal.CompactUI\n Development.Shake.Internal.Core.Action\n Development.Shake.Internal.Core.Build\n Development.Shake.Internal.Core.Database\n Development.Shake.Internal.History.Shared\n Development.Shake.Internal.History.Symlink\n Development.Shake.Internal.History.Bloom\n Development.Shake.Internal.History.Cloud\n Development.Shake.Internal.History.Network\n Development.Shake.Internal.History.Server\n Development.Shake.Internal.History.Serialise\n Development.Shake.Internal.History.Types\n Development.Shake.Internal.Core.Monad\n Development.Shake.Internal.Core.Pool\n Development.Shake.Internal.Core.Rules\n Development.Shake.Internal.Core.Run\n Development.Shake.Internal.Core.Storage\n Development.Shake.Internal.Core.Types\n Development.Shake.Internal.Demo\n Development.Shake.Internal.Derived\n Development.Shake.Internal.Errors\n Development.Shake.Internal.FileInfo\n Development.Shake.Internal.FileName\n Development.Shake.Internal.FilePattern\n Development.Shake.Internal.Options\n Development.Shake.Internal.Paths\n Development.Shake.Internal.Profile\n Development.Shake.Internal.Progress\n Development.Shake.Internal.Resource\n Development.Shake.Internal.Rules.Default\n Development.Shake.Internal.Rules.Directory\n Development.Shake.Internal.Rules.File\n Development.Shake.Internal.Rules.Files\n Development.Shake.Internal.Rules.Oracle\n Development.Shake.Internal.Rules.OrderOnly\n Development.Shake.Internal.Rules.Rerun\n Development.Shake.Internal.Value\n General.Bilist\n General.Binary\n General.Chunks\n General.Cleanup\n General.Fence\n General.EscCodes\n General.Extra\n General.FileLock\n General.GetOpt\n General.Ids\n General.Intern\n General.ListBuilder\n General.Makefile\n General.Pool\n General.Process\n General.Template\n General.Thread\n General.Timing\n General.TypeMap\n General.Wait\n Paths_shake\n\n\ntest-suite shake-test\n default-language: Haskell2010\n type: exitcode-stdio-1.0\n main-is: Test.hs\n hs-source-dirs: src\n ghc-options: -main-is Test.main -rtsopts -with-rtsopts=-K1K -threaded\n\n build-depends:\n base == 4.*,\n binary,\n bytestring,\n deepseq >= 1.1,\n directory,\n extra >= 1.6.19,\n filepath,\n filepattern,\n hashable >= 1.1.2.3,\n heaps >= 0.3.6.1,\n js-dgtable,\n js-flot,\n js-jquery,\n primitive,\n process >= 1.1,\n QuickCheck >= 2.0,\n random,\n time,\n transformers >= 0.2,\n unordered-containers >= 0.2.7,\n utf8-string >= 0.3\n\n if flag(embed-files)\n cpp-options: -DFILE_EMBED\n build-depends:\n file-embed >= 0.0.11,\n template-haskell\n\n if flag(portable)\n cpp-options: -DPORTABLE\n else\n if !os(windows)\n build-depends: unix >= 2.5.1\n if !os(windows)\n build-depends: unix\n\n if flag(cloud)\n cpp-options: -DNETWORK\n build-depends: network, network-uri\n\n if impl(ghc < 8.0)\n build-depends: semigroups >= 0.18\n\n other-modules:\n Development.Ninja.All\n Development.Ninja.Env\n Development.Ninja.Lexer\n Development.Ninja.Parse\n Development.Ninja.Type\n Development.Shake\n Development.Shake.Classes\n Development.Shake.Command\n Development.Shake.Config\n Development.Shake.Database\n Development.Shake.FilePath\n Development.Shake.Forward\n Development.Shake.Internal.Args\n Development.Shake.Internal.CmdOption\n Development.Shake.Internal.CompactUI\n Development.Shake.Internal.Core.Action\n Development.Shake.Internal.Core.Build\n Development.Shake.Internal.Core.Database\n Development.Shake.Internal.History.Shared\n Development.Shake.Internal.History.Symlink\n Development.Shake.Internal.History.Bloom\n Development.Shake.Internal.History.Cloud\n Development.Shake.Internal.History.Network\n Development.Shake.Internal.History.Server\n Development.Shake.Internal.History.Serialise\n Development.Shake.Internal.History.Types\n Development.Shake.Internal.Core.Monad\n Development.Shake.Internal.Core.Pool\n Development.Shake.Internal.Core.Rules\n Development.Shake.Internal.Core.Run\n Development.Shake.Internal.Core.Storage\n Development.Shake.Internal.Core.Types\n Development.Shake.Internal.Demo\n Development.Shake.Internal.Derived\n Development.Shake.Internal.Errors\n Development.Shake.Internal.FileInfo\n Development.Shake.Internal.FileName\n Development.Shake.Internal.FilePattern\n Development.Shake.Internal.Options\n Development.Shake.Internal.Paths\n Development.Shake.Internal.Profile\n Development.Shake.Internal.Progress\n Development.Shake.Internal.Resource\n Development.Shake.Internal.Rules.Default\n Development.Shake.Internal.Rules.Directory\n Development.Shake.Internal.Rules.File\n Development.Shake.Internal.Rules.Files\n Development.Shake.Internal.Rules.Oracle\n Development.Shake.Internal.Rules.OrderOnly\n Development.Shake.Internal.Rules.Rerun\n Development.Shake.Internal.Value\n Development.Shake.Rule\n Development.Shake.Util\n General.Bilist\n General.Binary\n General.Chunks\n General.Cleanup\n General.Fence\n General.EscCodes\n General.Extra\n General.FileLock\n General.GetOpt\n General.Ids\n General.Intern\n General.ListBuilder\n General.Makefile\n General.Pool\n General.Process\n General.Template\n General.Thread\n General.Timing\n General.TypeMap\n General.Wait\n Paths_shake\n Run\n Test.Basic\n Test.Batch\n Test.Benchmark\n Test.Builtin\n Test.BuiltinOverride\n Test.C\n Test.Cache\n Test.Cleanup\n Test.CloseFileHandles\n Test.Command\n Test.Config\n Test.Database\n Test.Digest\n Test.Directory\n Test.Docs\n Test.Errors\n Test.Existence\n Test.FileLock\n Test.FilePath\n Test.FilePattern\n Test.Files\n Test.Forward\n Test.History\n Test.Journal\n Test.Lint\n Test.Live\n Test.Manual\n Test.Match\n Test.Monad\n Test.Ninja\n Test.Oracle\n Test.OrderOnly\n Test.Parallel\n Test.Pool\n Test.Progress\n Test.Random\n Test.Rebuild\n Test.Reschedule\n Test.Resources\n Test.Self\n Test.SelfMake\n Test.Tar\n Test.Targets\n Test.Thread\n Test.Tup\n Test.Type\n Test.Unicode\n Test.Util\n Test.Verbosity\n Test.Version\n"; + package-description-override = "cabal-version: 1.18\nbuild-type: Simple\nname: shake\nversion: 0.19.8\nlicense: BSD3\nlicense-file: LICENSE\ncategory: Development, Shake\nauthor: Neil Mitchell \nmaintainer: Neil Mitchell \ncopyright: Neil Mitchell 2011-2024\nsynopsis: Build system library, like Make, but more accurate dependencies.\ndescription:\n Shake is a Haskell library for writing build systems - designed as a\n replacement for @make@. See \"Development.Shake\" for an introduction,\n including an example. The homepage contains links to a user\n manual, an academic paper and further information:\n \n .\n To use Shake the user writes a Haskell program\n that imports \"Development.Shake\", defines some build rules, and calls\n the 'Development.Shake.shakeArgs' function. Thanks to do notation and infix\n operators, a simple Shake build system\n is not too dissimilar from a simple Makefile. However, as build systems\n get more complex, Shake is able to take advantage of the excellent\n abstraction facilities offered by Haskell and easily support much larger\n projects. The Shake library provides all the standard features available in other\n build systems, including automatic parallelism and minimal rebuilds.\n Shake also provides more accurate dependency tracking, including seamless\n support for generated files, and dependencies on system information\n (e.g. compiler version).\nhomepage: https://shakebuild.com\nbug-reports: https://github.com/ndmitchell/shake/issues\ntested-with: GHC==9.8, GHC==9.6, GHC==9.4, GHC==9.2, GHC==9.0, GHC==8.10, GHC==8.8\nextra-doc-files:\n CHANGES.txt\n README.md\n docs/Manual.md\n docs/shake-progress.png\nextra-source-files:\n src/Paths.hs\n src/Test/C/constants.c\n src/Test/C/constants.h\n src/Test/C/main.c\n src/Test/Ninja/*.ninja\n src/Test/Ninja/*.output\n src/Test/Ninja/subdir/*.ninja\n src/Test/Progress/*.prog\n src/Test/Tar/list.txt\n src/Test/Tup/hello.c\n src/Test/Tup/newmath/root.cfg\n src/Test/Tup/newmath/square.c\n src/Test/Tup/newmath/square.h\n src/Test/Tup/root.cfg\ndata-files:\n docs/manual/build.bat\n docs/manual/Shakefile.hs\n docs/manual/build.sh\n docs/manual/constants.c\n docs/manual/constants.h\n docs/manual/main.c\n html/profile.html\n html/progress.html\n html/shake.js\n\nsource-repository head\n type: git\n location: https://github.com/ndmitchell/shake.git\n\nflag portable\n default: False\n manual: True\n description: Obtain FileTime using portable functions\n\nflag cloud\n default: False\n manual: True\n description: Enable cloud build features\n\nflag embed-files\n default: False\n manual: True\n description: Embed data files into the shake library\n\nflag threaded\n default: True\n manual: True\n description: Build shake with the threaded RTS\n\nlibrary\n default-language: Haskell2010\n hs-source-dirs: src\n build-depends:\n base >= 4.9,\n binary,\n bytestring,\n deepseq >= 1.1,\n directory >= 1.2.7.0,\n extra >= 1.6.19,\n filepath >= 1.4,\n filepattern,\n hashable >= 1.1.2.3,\n heaps >= 0.3.6.1,\n js-dgtable,\n js-flot,\n js-jquery,\n primitive,\n process >= 1.1,\n random,\n time,\n transformers >= 0.2,\n unordered-containers >= 0.2.7,\n utf8-string >= 0.3\n\n if flag(embed-files)\n cpp-options: -DFILE_EMBED\n build-depends:\n file-embed >= 0.0.11,\n template-haskell\n\n if flag(portable)\n cpp-options: -DPORTABLE\n else\n if !os(windows)\n build-depends: unix >= 2.5.1\n if !os(windows)\n build-depends: unix\n\n if flag(cloud)\n cpp-options: -DNETWORK\n build-depends: network, network-uri\n\n exposed-modules:\n Development.Shake\n Development.Shake.Classes\n Development.Shake.Command\n Development.Shake.Config\n Development.Shake.Database\n Development.Shake.FilePath\n Development.Shake.Forward\n Development.Shake.Rule\n Development.Shake.Util\n\n other-modules:\n Development.Ninja.Env\n Development.Ninja.Lexer\n Development.Ninja.Parse\n Development.Ninja.Type\n Development.Shake.Internal.Args\n Development.Shake.Internal.CmdOption\n Development.Shake.Internal.CompactUI\n Development.Shake.Internal.Core.Action\n Development.Shake.Internal.Core.Build\n Development.Shake.Internal.Core.Database\n Development.Shake.Internal.History.Shared\n Development.Shake.Internal.History.Symlink\n Development.Shake.Internal.History.Bloom\n Development.Shake.Internal.History.Cloud\n Development.Shake.Internal.History.Network\n Development.Shake.Internal.History.Server\n Development.Shake.Internal.History.Serialise\n Development.Shake.Internal.History.Types\n Development.Shake.Internal.Core.Monad\n Development.Shake.Internal.Core.Pool\n Development.Shake.Internal.Core.Rules\n Development.Shake.Internal.Core.Run\n Development.Shake.Internal.Core.Storage\n Development.Shake.Internal.Core.Types\n Development.Shake.Internal.Demo\n Development.Shake.Internal.Derived\n Development.Shake.Internal.Errors\n Development.Shake.Internal.FileInfo\n Development.Shake.Internal.FileName\n Development.Shake.Internal.FilePattern\n Development.Shake.Internal.Options\n Development.Shake.Internal.Paths\n Development.Shake.Internal.Profile\n Development.Shake.Internal.Progress\n Development.Shake.Internal.Resource\n Development.Shake.Internal.Rules.Default\n Development.Shake.Internal.Rules.Directory\n Development.Shake.Internal.Rules.File\n Development.Shake.Internal.Rules.Files\n Development.Shake.Internal.Rules.Oracle\n Development.Shake.Internal.Rules.OrderOnly\n Development.Shake.Internal.Rules.Rerun\n Development.Shake.Internal.Value\n General.Bilist\n General.Binary\n General.Chunks\n General.Cleanup\n General.Fence\n General.EscCodes\n General.Extra\n General.FileLock\n General.GetOpt\n General.Ids\n General.Intern\n General.ListBuilder\n General.Makefile\n General.Pool\n General.Process\n General.Template\n General.Thread\n General.Timing\n General.TypeMap\n General.Wait\n Paths_shake\n\n\nexecutable shake\n default-language: Haskell2010\n hs-source-dirs: src\n ghc-options: -main-is Run.main -rtsopts\n if flag(threaded)\n ghc-options: -threaded \"-with-rtsopts=-I0 -qg\"\n main-is: Run.hs\n build-depends:\n base == 4.*,\n binary,\n bytestring,\n deepseq >= 1.1,\n directory,\n extra >= 1.6.19,\n filepath,\n filepattern,\n hashable >= 1.1.2.3,\n heaps >= 0.3.6.1,\n js-dgtable,\n js-flot,\n js-jquery,\n primitive,\n process >= 1.1,\n random,\n time,\n transformers >= 0.2,\n unordered-containers >= 0.2.7,\n utf8-string >= 0.3\n\n if flag(embed-files)\n cpp-options: -DFILE_EMBED\n build-depends:\n file-embed >= 0.0.11,\n template-haskell\n\n if flag(portable)\n cpp-options: -DPORTABLE\n else\n if !os(windows)\n build-depends: unix >= 2.5.1\n if !os(windows)\n build-depends: unix\n\n if flag(cloud)\n cpp-options: -DNETWORK\n build-depends: network, network-uri\n\n if impl(ghc < 8.0)\n build-depends: semigroups >= 0.18\n\n other-modules:\n Development.Ninja.All\n Development.Ninja.Env\n Development.Ninja.Lexer\n Development.Ninja.Parse\n Development.Ninja.Type\n Development.Shake\n Development.Shake.Classes\n Development.Shake.Command\n Development.Shake.Database\n Development.Shake.FilePath\n Development.Shake.Internal.Args\n Development.Shake.Internal.CmdOption\n Development.Shake.Internal.CompactUI\n Development.Shake.Internal.Core.Action\n Development.Shake.Internal.Core.Build\n Development.Shake.Internal.Core.Database\n Development.Shake.Internal.History.Shared\n Development.Shake.Internal.History.Symlink\n Development.Shake.Internal.History.Bloom\n Development.Shake.Internal.History.Cloud\n Development.Shake.Internal.History.Network\n Development.Shake.Internal.History.Server\n Development.Shake.Internal.History.Serialise\n Development.Shake.Internal.History.Types\n Development.Shake.Internal.Core.Monad\n Development.Shake.Internal.Core.Pool\n Development.Shake.Internal.Core.Rules\n Development.Shake.Internal.Core.Run\n Development.Shake.Internal.Core.Storage\n Development.Shake.Internal.Core.Types\n Development.Shake.Internal.Demo\n Development.Shake.Internal.Derived\n Development.Shake.Internal.Errors\n Development.Shake.Internal.FileInfo\n Development.Shake.Internal.FileName\n Development.Shake.Internal.FilePattern\n Development.Shake.Internal.Options\n Development.Shake.Internal.Paths\n Development.Shake.Internal.Profile\n Development.Shake.Internal.Progress\n Development.Shake.Internal.Resource\n Development.Shake.Internal.Rules.Default\n Development.Shake.Internal.Rules.Directory\n Development.Shake.Internal.Rules.File\n Development.Shake.Internal.Rules.Files\n Development.Shake.Internal.Rules.Oracle\n Development.Shake.Internal.Rules.OrderOnly\n Development.Shake.Internal.Rules.Rerun\n Development.Shake.Internal.Value\n General.Bilist\n General.Binary\n General.Chunks\n General.Cleanup\n General.Fence\n General.EscCodes\n General.Extra\n General.FileLock\n General.GetOpt\n General.Ids\n General.Intern\n General.ListBuilder\n General.Makefile\n General.Pool\n General.Process\n General.Template\n General.Thread\n General.Timing\n General.TypeMap\n General.Wait\n Paths_shake\n\n\ntest-suite shake-test\n default-language: Haskell2010\n type: exitcode-stdio-1.0\n main-is: Test.hs\n hs-source-dirs: src\n ghc-options: -main-is Test.main -rtsopts -with-rtsopts=-K1K\n if flag(threaded)\n ghc-options: -threaded\n\n build-depends:\n base == 4.*,\n binary,\n bytestring,\n deepseq >= 1.1,\n directory,\n extra >= 1.6.19,\n filepath,\n filepattern,\n hashable >= 1.1.2.3,\n heaps >= 0.3.6.1,\n js-dgtable,\n js-flot,\n js-jquery,\n primitive,\n process >= 1.1,\n QuickCheck >= 2.0,\n random,\n time,\n transformers >= 0.2,\n unordered-containers >= 0.2.7,\n utf8-string >= 0.3\n\n if flag(embed-files)\n cpp-options: -DFILE_EMBED\n build-depends:\n file-embed >= 0.0.11,\n template-haskell\n\n if flag(portable)\n cpp-options: -DPORTABLE\n else\n if !os(windows)\n build-depends: unix >= 2.5.1\n if !os(windows)\n build-depends: unix\n\n if flag(cloud)\n cpp-options: -DNETWORK\n build-depends: network, network-uri\n\n if impl(ghc < 8.0)\n build-depends: semigroups >= 0.18\n\n other-modules:\n Development.Ninja.All\n Development.Ninja.Env\n Development.Ninja.Lexer\n Development.Ninja.Parse\n Development.Ninja.Type\n Development.Shake\n Development.Shake.Classes\n Development.Shake.Command\n Development.Shake.Config\n Development.Shake.Database\n Development.Shake.FilePath\n Development.Shake.Forward\n Development.Shake.Internal.Args\n Development.Shake.Internal.CmdOption\n Development.Shake.Internal.CompactUI\n Development.Shake.Internal.Core.Action\n Development.Shake.Internal.Core.Build\n Development.Shake.Internal.Core.Database\n Development.Shake.Internal.History.Shared\n Development.Shake.Internal.History.Symlink\n Development.Shake.Internal.History.Bloom\n Development.Shake.Internal.History.Cloud\n Development.Shake.Internal.History.Network\n Development.Shake.Internal.History.Server\n Development.Shake.Internal.History.Serialise\n Development.Shake.Internal.History.Types\n Development.Shake.Internal.Core.Monad\n Development.Shake.Internal.Core.Pool\n Development.Shake.Internal.Core.Rules\n Development.Shake.Internal.Core.Run\n Development.Shake.Internal.Core.Storage\n Development.Shake.Internal.Core.Types\n Development.Shake.Internal.Demo\n Development.Shake.Internal.Derived\n Development.Shake.Internal.Errors\n Development.Shake.Internal.FileInfo\n Development.Shake.Internal.FileName\n Development.Shake.Internal.FilePattern\n Development.Shake.Internal.Options\n Development.Shake.Internal.Paths\n Development.Shake.Internal.Profile\n Development.Shake.Internal.Progress\n Development.Shake.Internal.Resource\n Development.Shake.Internal.Rules.Default\n Development.Shake.Internal.Rules.Directory\n Development.Shake.Internal.Rules.File\n Development.Shake.Internal.Rules.Files\n Development.Shake.Internal.Rules.Oracle\n Development.Shake.Internal.Rules.OrderOnly\n Development.Shake.Internal.Rules.Rerun\n Development.Shake.Internal.Value\n Development.Shake.Rule\n Development.Shake.Util\n General.Bilist\n General.Binary\n General.Chunks\n General.Cleanup\n General.Fence\n General.EscCodes\n General.Extra\n General.FileLock\n General.GetOpt\n General.Ids\n General.Intern\n General.ListBuilder\n General.Makefile\n General.Pool\n General.Process\n General.Template\n General.Thread\n General.Timing\n General.TypeMap\n General.Wait\n Paths_shake\n Run\n Test.Basic\n Test.Batch\n Test.Benchmark\n Test.Builtin\n Test.BuiltinOverride\n Test.C\n Test.Cache\n Test.Cleanup\n Test.CloseFileHandles\n Test.Command\n Test.Config\n Test.Database\n Test.Digest\n Test.Directory\n Test.Docs\n Test.Errors\n Test.Existence\n Test.FileLock\n Test.FilePath\n Test.FilePattern\n Test.Files\n Test.Forward\n Test.History\n Test.Journal\n Test.Lint\n Test.Live\n Test.Manual\n Test.Match\n Test.Monad\n Test.Ninja\n Test.Oracle\n Test.OrderOnly\n Test.Parallel\n Test.Pool\n Test.Progress\n Test.Random\n Test.Rebuild\n Test.Reschedule\n Test.Resources\n Test.Self\n Test.SelfMake\n Test.Tar\n Test.Targets\n Test.Thread\n Test.Tup\n Test.Type\n Test.Unicode\n Test.Util\n Test.Verbosity\n Test.Version\n"; } \ No newline at end of file diff --git a/materialized/ghc964/hadrian-ghc910/hadrian/cabal-files/splitmix.nix b/materialized/ghc964/hadrian-ghc910/hadrian/cabal-files/splitmix.nix index aa0dd88d31..633d8e112a 100644 --- a/materialized/ghc964/hadrian-ghc910/hadrian/cabal-files/splitmix.nix +++ b/materialized/ghc964/hadrian-ghc910/hadrian/cabal-files/splitmix.nix @@ -135,5 +135,5 @@ sha256 = "9df07a9611ef45f1b1258a0b412f4d02c920248f69d2e2ce8ccda328f7e13002"; }); }) // { - package-description-override = "cabal-version: >=1.10\nname: splitmix\nversion: 0.1.0.5\nsynopsis: Fast Splittable PRNG\ndescription:\n Pure Haskell implementation of SplitMix described in\n .\n Guy L. Steele, Jr., Doug Lea, and Christine H. Flood. 2014.\n Fast splittable pseudorandom number generators. In Proceedings\n of the 2014 ACM International Conference on Object Oriented\n Programming Systems Languages & Applications (OOPSLA '14). ACM,\n New York, NY, USA, 453-472. DOI:\n \n .\n The paper describes a new algorithm /SplitMix/ for /splittable/\n pseudorandom number generator that is quite fast: 9 64 bit arithmetic/logical\n operations per 64 bits generated.\n .\n /SplitMix/ is tested with two standard statistical test suites (DieHarder and\n TestU01, this implementation only using the former) and it appears to be\n adequate for \"everyday\" use, such as Monte Carlo algorithms and randomized\n data structures where speed is important.\n .\n In particular, it __should not be used for cryptographic or security applications__,\n because generated sequences of pseudorandom values are too predictable\n (the mixing functions are easily inverted, and two successive outputs\n suffice to reconstruct the internal state).\n\nlicense: BSD3\nlicense-file: LICENSE\nmaintainer: Oleg Grenrus \nbug-reports: https://github.com/haskellari/splitmix/issues\ncategory: System, Random\nbuild-type: Simple\ntested-with:\n GHC ==7.0.4\n || ==7.2.2\n || ==7.4.2\n || ==7.6.3\n || ==7.8.4\n || ==7.10.3\n || ==8.0.2\n || ==8.2.2\n || ==8.4.4\n || ==8.6.5\n || ==8.8.4\n || ==8.10.4\n || ==9.0.2\n || ==9.2.8\n || ==9.4.7\n || ==9.6.3\n || ==9.8.1\n , GHCJS ==8.4\n\nextra-source-files:\n Changelog.md\n make-hugs.sh\n README.md\n test-hugs.sh\n\nflag optimised-mixer\n description: Use JavaScript for mix32\n manual: True\n default: False\n\nlibrary\n default-language: Haskell2010\n ghc-options: -Wall\n hs-source-dirs: src src-compat\n exposed-modules:\n System.Random.SplitMix\n System.Random.SplitMix32\n\n other-modules:\n Data.Bits.Compat\n System.Random.SplitMix.Init\n\n -- dump-core\n -- build-depends: dump-core\n -- ghc-options: -fplugin=DumpCore -fplugin-opt DumpCore:core-html\n\n build-depends:\n base >=4.3 && <4.20\n , deepseq >=1.3.0.0 && <1.6\n\n if flag(optimised-mixer)\n cpp-options: -DOPTIMISED_MIX32=1\n\n -- We don't want to depend on time, nor unix or Win32 packages\n -- because it's valuable that splitmix and QuickCheck doesn't\n -- depend on about anything\n\n if impl(ghcjs)\n cpp-options: -DSPLITMIX_INIT_GHCJS=1\n\n else\n if impl(ghc)\n cpp-options: -DSPLITMIX_INIT_C=1\n\n if os(windows)\n c-sources: cbits-win/init.c\n\n else\n c-sources: cbits-unix/init.c\n\n else\n cpp-options: -DSPLITMIX_INIT_COMPAT=1\n build-depends: time >=1.2.0.3 && <1.13\n\nsource-repository head\n type: git\n location: https://github.com/haskellari/splitmix.git\n\nbenchmark comparison\n type: exitcode-stdio-1.0\n default-language: Haskell2010\n ghc-options: -Wall\n hs-source-dirs: bench\n main-is: Bench.hs\n build-depends:\n base\n , containers >=0.4.2.1 && <0.7\n , criterion >=1.1.0.0 && <1.7\n , random\n , splitmix\n , tf-random >=0.5 && <0.6\n\nbenchmark simple-sum\n type: exitcode-stdio-1.0\n default-language: Haskell2010\n ghc-options: -Wall\n hs-source-dirs: bench\n main-is: SimpleSum.hs\n build-depends:\n base\n , random\n , splitmix\n\nbenchmark range\n type: exitcode-stdio-1.0\n default-language: Haskell2010\n ghc-options: -Wall\n hs-source-dirs: bench src-compat\n main-is: Range.hs\n other-modules: Data.Bits.Compat\n build-depends:\n base\n , random\n , splitmix\n\n if !impl(ghcjs)\n build-depends: clock >=0.8 && <0.9\n\ntest-suite examples\n type: exitcode-stdio-1.0\n default-language: Haskell2010\n ghc-options: -Wall\n hs-source-dirs: tests\n main-is: Examples.hs\n build-depends:\n base\n , HUnit ==1.3.1.2 || >=1.6.0.0 && <1.7\n , splitmix\n\ntest-suite splitmix-tests\n type: exitcode-stdio-1.0\n default-language: Haskell2010\n ghc-options: -Wall\n hs-source-dirs: tests\n main-is: Tests.hs\n other-modules:\n MiniQC\n Uniformity\n\n build-depends:\n base\n , base-compat >=0.11.1 && <0.14\n , containers >=0.4.0.0 && <0.7\n , HUnit ==1.3.1.2 || >=1.6.0.0 && <1.7\n , math-functions ==0.1.7.0 || >=0.3.3.0 && <0.4\n , splitmix\n , test-framework >=0.8.2.0 && <0.9\n , test-framework-hunit >=0.3.0.2 && <0.4\n\ntest-suite montecarlo-pi\n type: exitcode-stdio-1.0\n default-language: Haskell2010\n ghc-options: -Wall\n hs-source-dirs: tests\n main-is: SplitMixPi.hs\n build-depends:\n base\n , splitmix\n\ntest-suite montecarlo-pi-32\n type: exitcode-stdio-1.0\n default-language: Haskell2010\n ghc-options: -Wall\n hs-source-dirs: tests\n main-is: SplitMixPi32.hs\n build-depends:\n base\n , splitmix\n\ntest-suite splitmix-dieharder\n default-language: Haskell2010\n type: exitcode-stdio-1.0\n ghc-options: -Wall -threaded -rtsopts\n hs-source-dirs: tests\n main-is: Dieharder.hs\n build-depends:\n async >=2.2.1 && <2.3\n , base\n , base-compat-batteries >=0.10.5 && <0.14\n , bytestring >=0.9.1.8 && <0.13\n , deepseq\n , process >=1.0.1.5 && <1.7\n , random\n , splitmix\n , tf-random >=0.5 && <0.6\n , vector >=0.11.0.0 && <0.14\n\ntest-suite splitmix-testu01\n if !os(linux)\n buildable: False\n\n default-language: Haskell2010\n type: exitcode-stdio-1.0\n ghc-options: -Wall -threaded -rtsopts\n hs-source-dirs: tests\n main-is: TestU01.hs\n c-sources: tests/cbits/testu01.c\n extra-libraries: testu01\n build-depends:\n base\n , base-compat-batteries >=0.10.5 && <0.14\n , splitmix\n\ntest-suite initialization\n default-language: Haskell2010\n type: exitcode-stdio-1.0\n ghc-options: -Wall -threaded -rtsopts\n hs-source-dirs: tests\n main-is: Initialization.hs\n build-depends:\n base\n , HUnit ==1.3.1.2 || >=1.6.0.0 && <1.7\n , splitmix\n"; + package-description-override = "cabal-version: >=1.10\nname: splitmix\nversion: 0.1.0.5\nx-revision: 1\nsynopsis: Fast Splittable PRNG\ndescription:\n Pure Haskell implementation of SplitMix described in\n .\n Guy L. Steele, Jr., Doug Lea, and Christine H. Flood. 2014.\n Fast splittable pseudorandom number generators. In Proceedings\n of the 2014 ACM International Conference on Object Oriented\n Programming Systems Languages & Applications (OOPSLA '14). ACM,\n New York, NY, USA, 453-472. DOI:\n \n .\n The paper describes a new algorithm /SplitMix/ for /splittable/\n pseudorandom number generator that is quite fast: 9 64 bit arithmetic/logical\n operations per 64 bits generated.\n .\n /SplitMix/ is tested with two standard statistical test suites (DieHarder and\n TestU01, this implementation only using the former) and it appears to be\n adequate for \"everyday\" use, such as Monte Carlo algorithms and randomized\n data structures where speed is important.\n .\n In particular, it __should not be used for cryptographic or security applications__,\n because generated sequences of pseudorandom values are too predictable\n (the mixing functions are easily inverted, and two successive outputs\n suffice to reconstruct the internal state).\n\nlicense: BSD3\nlicense-file: LICENSE\nmaintainer: Oleg Grenrus \nbug-reports: https://github.com/haskellari/splitmix/issues\ncategory: System, Random\nbuild-type: Simple\ntested-with:\n GHC ==7.0.4\n || ==7.2.2\n || ==7.4.2\n || ==7.6.3\n || ==7.8.4\n || ==7.10.3\n || ==8.0.2\n || ==8.2.2\n || ==8.4.4\n || ==8.6.5\n || ==8.8.4\n || ==8.10.4\n || ==9.0.2\n || ==9.2.8\n || ==9.4.8\n || ==9.6.4\n || ==9.8.2\n || ==9.10.1\n , GHCJS ==8.4\n\nextra-source-files:\n Changelog.md\n make-hugs.sh\n README.md\n test-hugs.sh\n\nflag optimised-mixer\n description: Use JavaScript for mix32\n manual: True\n default: False\n\nlibrary\n default-language: Haskell2010\n ghc-options: -Wall\n hs-source-dirs: src src-compat\n exposed-modules:\n System.Random.SplitMix\n System.Random.SplitMix32\n\n other-modules:\n Data.Bits.Compat\n System.Random.SplitMix.Init\n\n -- dump-core\n -- build-depends: dump-core\n -- ghc-options: -fplugin=DumpCore -fplugin-opt DumpCore:core-html\n\n build-depends:\n base >=4.3 && <4.21\n , deepseq >=1.3.0.0 && <1.6\n\n if flag(optimised-mixer)\n cpp-options: -DOPTIMISED_MIX32=1\n\n -- We don't want to depend on time, nor unix or Win32 packages\n -- because it's valuable that splitmix and QuickCheck doesn't\n -- depend on about anything\n\n if impl(ghcjs)\n cpp-options: -DSPLITMIX_INIT_GHCJS=1\n\n else\n if impl(ghc)\n cpp-options: -DSPLITMIX_INIT_C=1\n\n if os(windows)\n c-sources: cbits-win/init.c\n\n else\n c-sources: cbits-unix/init.c\n\n else\n cpp-options: -DSPLITMIX_INIT_COMPAT=1\n build-depends: time >=1.2.0.3 && <1.13\n\nsource-repository head\n type: git\n location: https://github.com/haskellari/splitmix.git\n\nbenchmark comparison\n type: exitcode-stdio-1.0\n default-language: Haskell2010\n ghc-options: -Wall\n hs-source-dirs: bench\n main-is: Bench.hs\n build-depends:\n base\n , containers >=0.4.2.1 && <0.8\n , criterion >=1.1.0.0 && <1.7\n , random\n , splitmix\n , tf-random >=0.5 && <0.6\n\nbenchmark simple-sum\n type: exitcode-stdio-1.0\n default-language: Haskell2010\n ghc-options: -Wall\n hs-source-dirs: bench\n main-is: SimpleSum.hs\n build-depends:\n base\n , random\n , splitmix\n\nbenchmark range\n type: exitcode-stdio-1.0\n default-language: Haskell2010\n ghc-options: -Wall\n hs-source-dirs: bench src-compat\n main-is: Range.hs\n other-modules: Data.Bits.Compat\n build-depends:\n base\n , random\n , splitmix\n\n if !impl(ghcjs)\n build-depends: clock >=0.8 && <0.9\n\ntest-suite examples\n type: exitcode-stdio-1.0\n default-language: Haskell2010\n ghc-options: -Wall\n hs-source-dirs: tests\n main-is: Examples.hs\n build-depends:\n base\n , HUnit ==1.3.1.2 || >=1.6.0.0 && <1.7\n , splitmix\n\ntest-suite splitmix-tests\n type: exitcode-stdio-1.0\n default-language: Haskell2010\n ghc-options: -Wall\n hs-source-dirs: tests\n main-is: Tests.hs\n other-modules:\n MiniQC\n Uniformity\n\n build-depends:\n base\n , base-compat >=0.11.1 && <0.14\n , containers >=0.4.0.0 && <0.8\n , HUnit ==1.3.1.2 || >=1.6.0.0 && <1.7\n , math-functions ==0.1.7.0 || >=0.3.3.0 && <0.4\n , splitmix\n , test-framework >=0.8.2.0 && <0.9\n , test-framework-hunit >=0.3.0.2 && <0.4\n\ntest-suite montecarlo-pi\n type: exitcode-stdio-1.0\n default-language: Haskell2010\n ghc-options: -Wall\n hs-source-dirs: tests\n main-is: SplitMixPi.hs\n build-depends:\n base\n , splitmix\n\ntest-suite montecarlo-pi-32\n type: exitcode-stdio-1.0\n default-language: Haskell2010\n ghc-options: -Wall\n hs-source-dirs: tests\n main-is: SplitMixPi32.hs\n build-depends:\n base\n , splitmix\n\ntest-suite splitmix-dieharder\n default-language: Haskell2010\n type: exitcode-stdio-1.0\n ghc-options: -Wall -threaded -rtsopts\n hs-source-dirs: tests\n main-is: Dieharder.hs\n build-depends:\n async >=2.2.1 && <2.3\n , base\n , base-compat-batteries >=0.10.5 && <0.14\n , bytestring >=0.9.1.8 && <0.13\n , deepseq\n , process >=1.0.1.5 && <1.7\n , random\n , splitmix\n , tf-random >=0.5 && <0.6\n , vector >=0.11.0.0 && <0.14\n\ntest-suite splitmix-testu01\n if !os(linux)\n buildable: False\n\n default-language: Haskell2010\n type: exitcode-stdio-1.0\n ghc-options: -Wall -threaded -rtsopts\n hs-source-dirs: tests\n main-is: TestU01.hs\n c-sources: tests/cbits/testu01.c\n extra-libraries: testu01\n build-depends:\n base\n , base-compat-batteries >=0.10.5 && <0.14\n , splitmix\n\ntest-suite initialization\n default-language: Haskell2010\n type: exitcode-stdio-1.0\n ghc-options: -Wall -threaded -rtsopts\n hs-source-dirs: tests\n main-is: Initialization.hs\n build-depends:\n base\n , HUnit ==1.3.1.2 || >=1.6.0.0 && <1.7\n , splitmix\n"; } \ No newline at end of file diff --git a/materialized/ghc964/hadrian-ghc910/hadrian/cabal-files/unordered-containers.nix b/materialized/ghc964/hadrian-ghc910/hadrian/cabal-files/unordered-containers.nix index 0aeaccb277..816666c80f 100644 --- a/materialized/ghc964/hadrian-ghc910/hadrian/cabal-files/unordered-containers.nix +++ b/materialized/ghc964/hadrian-ghc910/hadrian/cabal-files/unordered-containers.nix @@ -11,7 +11,7 @@ flags = { debug = false; }; package = { specVersion = "1.10"; - identifier = { name = "unordered-containers"; version = "0.2.19.1"; }; + identifier = { name = "unordered-containers"; version = "0.2.20"; }; license = "BSD-3-Clause"; copyright = "2010-2014 Johan Tibell\n2010 Edward Z. Yang"; maintainer = "simon.jakobi@gmail.com, David.Feuer@gmail.com"; @@ -70,9 +70,9 @@ }; } // { src = pkgs.lib.mkDefault (pkgs.fetchurl { - url = "http://hackage.haskell.org/package/unordered-containers-0.2.19.1.tar.gz"; - sha256 = "1b27bec5e0d522b27a6029ebf4c4a6d40acbc083c787008e32fb55c4b1d128d2"; + url = "http://hackage.haskell.org/package/unordered-containers-0.2.20.tar.gz"; + sha256 = "d9cfb287cf00592d39dc9c3cac8b99627ea08f2c01798e70130fc39f7c90f11d"; }); }) // { - package-description-override = "name: unordered-containers\nversion: 0.2.19.1\nx-revision: 3\nsynopsis: Efficient hashing-based container types\ndescription:\n Efficient hashing-based container types. The containers have been\n optimized for performance critical use, both in terms of large data\n quantities and high speed.\n .\n The declared cost of each operation is either worst-case or\n amortized, but remains valid even if structures are shared.\n .\n /Security/\n .\n This package currently provides no defenses against hash collision attacks\n such as HashDoS.\n Users who need to store input from untrusted sources are advised to use\n @Data.Map@ or @Data.Set@ from the @containers@ package instead.\nlicense: BSD3\nlicense-file: LICENSE\nauthor: Johan Tibell\nmaintainer: simon.jakobi@gmail.com, David.Feuer@gmail.com\nHomepage: https://github.com/haskell-unordered-containers/unordered-containers\nbug-reports: https://github.com/haskell-unordered-containers/unordered-containers/issues\ncopyright: 2010-2014 Johan Tibell\n 2010 Edward Z. Yang\ncategory: Data\nbuild-type: Simple\ncabal-version: >=1.10\nextra-source-files: CHANGES.md\n\ntested-with:\n GHC ==9.8.1\n || ==9.6.3\n || ==9.4.7\n || ==9.2.8\n || ==9.0.2\n || ==8.10.7\n || ==8.8.4\n || ==8.6.5\n || ==8.4.4\n || ==8.2.2\n\nflag debug\n description: Enable debug support\n default: False\n\nlibrary\n exposed-modules:\n Data.HashMap.Internal\n Data.HashMap.Internal.Array\n Data.HashMap.Internal.List\n Data.HashMap.Internal.Strict\n Data.HashMap.Lazy\n Data.HashMap.Strict\n Data.HashSet\n Data.HashSet.Internal\n\n build-depends:\n base >= 4.10 && < 5,\n deepseq >= 1.4.3,\n hashable >= 1.2.5 && < 1.5,\n template-haskell < 2.22\n\n default-language: Haskell2010\n\n other-extensions:\n RoleAnnotations,\n UnboxedTuples,\n ScopedTypeVariables,\n MagicHash,\n BangPatterns\n\n ghc-options: -Wall -O2 -fwarn-tabs -ferror-spans\n\n -- For dumping the generated code:\n -- ghc-options: -ddump-simpl -ddump-stg-final -ddump-cmm -ddump-asm -ddump-to-file\n -- ghc-options: -dsuppress-coercions -dsuppress-unfoldings -dsuppress-module-prefixes\n -- ghc-options: -dsuppress-uniques -dsuppress-timestamps\n\n if flag(debug)\n cpp-options: -DASSERTS\n\ntest-suite unordered-containers-tests\n hs-source-dirs: tests\n main-is: Main.hs\n type: exitcode-stdio-1.0\n other-modules:\n Regressions\n Properties\n Properties.HashMapLazy\n Properties.HashMapStrict\n Properties.HashSet\n Properties.List\n Strictness\n\n build-depends:\n base,\n ChasingBottoms,\n containers >= 0.5.8,\n hashable,\n HUnit,\n QuickCheck >= 2.4.0.1,\n random,\n tasty >= 1.4.0.3,\n tasty-hunit >= 0.10.0.3,\n tasty-quickcheck >= 0.10.1.2,\n unordered-containers\n\n if impl(ghc >= 8.6)\n build-depends:\n nothunks >= 0.1.3\n\n default-language: Haskell2010\n ghc-options: -Wall\n cpp-options: -DASSERTS\n\nbenchmark benchmarks\n hs-source-dirs: benchmarks\n main-is: Benchmarks.hs\n type: exitcode-stdio-1.0\n\n other-modules:\n Util.ByteString\n Util.String\n Util.Int\n\n build-depends:\n base >= 4.8.0,\n bytestring >= 0.10.0.0,\n containers,\n deepseq,\n hashable,\n hashmap,\n mtl,\n random,\n tasty-bench >= 0.3.1,\n unordered-containers\n\n default-language: Haskell2010\n ghc-options: -Wall -O2 -rtsopts -with-rtsopts=-A32m\n if impl(ghc >= 8.10)\n ghc-options: \"-with-rtsopts=-A32m --nonmoving-gc\"\n -- cpp-options: -DBENCH_containers_Map -DBENCH_containers_IntMap -DBENCH_hashmap_Map\n\nsource-repository head\n type: git\n location: https://github.com/haskell-unordered-containers/unordered-containers.git\n"; + package-description-override = "name: unordered-containers\r\nversion: 0.2.20\r\nx-revision: 3\r\nsynopsis: Efficient hashing-based container types\r\ndescription:\r\n Efficient hashing-based container types. The containers have been\r\n optimized for performance critical use, both in terms of large data\r\n quantities and high speed.\r\n .\r\n The declared cost of each operation is either worst-case or\r\n amortized, but remains valid even if structures are shared.\r\n .\r\n /Security/\r\n .\r\n This package currently provides no defenses against hash collision attacks\r\n such as HashDoS.\r\n Users who need to store input from untrusted sources are advised to use\r\n @Data.Map@ or @Data.Set@ from the @containers@ package instead.\r\nlicense: BSD3\r\nlicense-file: LICENSE\r\nauthor: Johan Tibell\r\nmaintainer: simon.jakobi@gmail.com, David.Feuer@gmail.com\r\nHomepage: https://github.com/haskell-unordered-containers/unordered-containers\r\nbug-reports: https://github.com/haskell-unordered-containers/unordered-containers/issues\r\ncopyright: 2010-2014 Johan Tibell\r\n 2010 Edward Z. Yang\r\ncategory: Data\r\nbuild-type: Simple\r\ncabal-version: >=1.10\r\nextra-source-files: CHANGES.md\r\n\r\ntested-with:\r\n GHC ==9.8.1\r\n || ==9.6.3\r\n || ==9.4.7\r\n || ==9.2.8\r\n || ==9.0.2\r\n || ==8.10.7\r\n || ==8.8.4\r\n || ==8.6.5\r\n || ==8.4.4\r\n || ==8.2.2\r\n\r\nflag debug\r\n description: Enable debug support\r\n default: False\r\n\r\nlibrary\r\n exposed-modules:\r\n Data.HashMap.Internal\r\n Data.HashMap.Internal.Array\r\n Data.HashMap.Internal.Debug\r\n Data.HashMap.Internal.List\r\n Data.HashMap.Internal.Strict\r\n Data.HashMap.Lazy\r\n Data.HashMap.Strict\r\n Data.HashSet\r\n Data.HashSet.Internal\r\n\r\n build-depends:\r\n base >= 4.10 && < 5,\r\n deepseq >= 1.4.3,\r\n hashable >= 1.4 && < 1.6,\r\n template-haskell < 2.23\r\n\r\n default-language: Haskell2010\r\n\r\n other-extensions:\r\n RoleAnnotations,\r\n UnboxedTuples,\r\n ScopedTypeVariables,\r\n MagicHash,\r\n BangPatterns\r\n\r\n ghc-options: -Wall -O2 -fwarn-tabs -ferror-spans\r\n\r\n -- For dumping the generated code:\r\n -- ghc-options: -ddump-simpl -ddump-stg-final -ddump-cmm -ddump-asm -ddump-to-file\r\n -- ghc-options: -dsuppress-coercions -dsuppress-unfoldings -dsuppress-module-prefixes\r\n -- ghc-options: -dsuppress-uniques -dsuppress-timestamps\r\n\r\n if flag(debug)\r\n cpp-options: -DASSERTS\r\n\r\ntest-suite unordered-containers-tests\r\n hs-source-dirs: tests\r\n main-is: Main.hs\r\n type: exitcode-stdio-1.0\r\n other-modules:\r\n Regressions\r\n Properties\r\n Properties.HashMapLazy\r\n Properties.HashMapStrict\r\n Properties.HashSet\r\n Properties.List\r\n Strictness\r\n Util.Key\r\n\r\n build-depends:\r\n base,\r\n ChasingBottoms,\r\n containers >= 0.5.8,\r\n hashable,\r\n HUnit,\r\n QuickCheck >= 2.4.0.1,\r\n random,\r\n tasty >= 1.4.0.3,\r\n tasty-hunit >= 0.10.0.3,\r\n tasty-quickcheck >= 0.10.1.2,\r\n unordered-containers\r\n\r\n if impl(ghc >= 8.6)\r\n build-depends:\r\n nothunks >= 0.1.3\r\n\r\n default-language: Haskell2010\r\n ghc-options: -Wall -threaded -rtsopts -with-rtsopts=-N\r\n cpp-options: -DASSERTS\r\n\r\nbenchmark benchmarks\r\n hs-source-dirs: benchmarks\r\n main-is: Benchmarks.hs\r\n type: exitcode-stdio-1.0\r\n\r\n other-modules:\r\n Util.ByteString\r\n Util.String\r\n Util.Int\r\n\r\n build-depends:\r\n base >= 4.8.0,\r\n bytestring >= 0.10.0.0,\r\n containers,\r\n deepseq,\r\n hashable,\r\n hashmap,\r\n mtl,\r\n random,\r\n tasty-bench >= 0.3.1,\r\n unordered-containers\r\n\r\n default-language: Haskell2010\r\n ghc-options: -Wall -O2 -rtsopts -with-rtsopts=-A32m\r\n if impl(ghc >= 8.10)\r\n ghc-options: \"-with-rtsopts=-A32m --nonmoving-gc\"\r\n -- cpp-options: -DBENCH_containers_Map -DBENCH_containers_IntMap -DBENCH_hashmap_Map\r\n\r\nsource-repository head\r\n type: git\r\n location: https://github.com/haskell-unordered-containers/unordered-containers.git\r\n"; } \ No newline at end of file diff --git a/materialized/ghc964/hadrian-ghc910/hadrian/default.nix b/materialized/ghc964/hadrian-ghc910/hadrian/default.nix index 3a9d912802..9f70c8ea43 100644 --- a/materialized/ghc964/hadrian-ghc910/hadrian/default.nix +++ b/materialized/ghc964/hadrian-ghc910/hadrian/default.nix @@ -17,7 +17,7 @@ pretty.revision = hackage.pretty."1.1.3.6".revisions.default; hashable.revision = import ./cabal-files/hashable.nix; hashable.flags.random-initial-seed = false; - hashable.flags.integer-gmp = true; + hashable.flags.arch-native = false; heaps.revision = import ./cabal-files/heaps.nix; Cabal-syntax.revision = hackage.Cabal-syntax."3.10.1.0".revisions.default; process.revision = hackage.process."1.6.17.0".revisions.default; @@ -31,6 +31,7 @@ deepseq.revision = hackage.deepseq."1.4.8.1".revisions.default; utf8-string.revision = import ./cabal-files/utf8-string.nix; js-jquery.revision = import ./cabal-files/js-jquery.nix; + os-string.revision = import ./cabal-files/os-string.nix; text.revision = hackage.text."2.0.2".revisions.default; QuickCheck.revision = import ./cabal-files/QuickCheck.nix; QuickCheck.flags.old-random = false; @@ -40,6 +41,7 @@ containers.revision = hackage.containers."0.6.7".revisions.default; array.revision = hackage.array."0.5.6.0".revisions.default; shake.revision = import ./cabal-files/shake.nix; + shake.flags.threaded = true; shake.flags.cloud = false; shake.flags.embed-files = false; shake.flags.portable = false; @@ -163,6 +165,7 @@ "hashable".components.library.planned = lib.mkOverride 900 true; "primitive".components.library.planned = lib.mkOverride 900 true; "Cabal-syntax".components.library.planned = lib.mkOverride 900 true; + "os-string".components.library.planned = lib.mkOverride 900 true; "QuickCheck".components.library.planned = lib.mkOverride 900 true; "js-jquery".components.library.planned = lib.mkOverride 900 true; "ghc-platform".components.library.planned = lib.mkOverride 900 true; diff --git a/materialized/ghc964/hadrian-ghc910/plan.json b/materialized/ghc964/hadrian-ghc910/plan.json index d620fb747b..47a1222d80 100644 --- a/materialized/ghc964/hadrian-ghc910/plan.json +++ b/materialized/ghc964/hadrian-ghc910/plan.json @@ -1 +1 @@ -{"cabal-version":"3.10.3.0","cabal-lib-version":"3.10.3.0","compiler-id":"ghc-9.6.4","os":"linux","arch":"x86_64","install-plan":[{"type":"pre-existing","id":"Cabal-3.10.1.0","pkg-name":"Cabal","pkg-version":"3.10.1.0","depends":["Cabal-syntax-3.10.1.0","array-0.5.6.0","base-4.18.2.0","bytestring-0.11.5.3","containers-0.6.7","deepseq-1.4.8.1","directory-1.3.8.1","filepath-1.4.200.1","mtl-2.3.1","parsec-3.1.16.1","pretty-1.1.3.6","process-1.6.17.0","text-2.0.2","time-1.12.2","transformers-0.6.1.0","unix-2.8.4.0"]},{"type":"pre-existing","id":"Cabal-syntax-3.10.1.0","pkg-name":"Cabal-syntax","pkg-version":"3.10.1.0","depends":["array-0.5.6.0","base-4.18.2.0","binary-0.8.9.1","bytestring-0.11.5.3","containers-0.6.7","deepseq-1.4.8.1","directory-1.3.8.1","filepath-1.4.200.1","mtl-2.3.1","parsec-3.1.16.1","pretty-1.1.3.6","text-2.0.2","time-1.12.2","transformers-0.6.1.0","unix-2.8.4.0"]},{"type":"configured","id":"QuickCheck-2.14.3-116702925e70e233df64507a5cae969ff9c69efe35b3cc35e56c87d47168ff11","pkg-name":"QuickCheck","pkg-version":"2.14.3","flags":{"old-random":false,"templatehaskell":true},"style":"global","pkg-src":{"type":"repo-tar","repo":{"type":"secure-repo","uri":"http://hackage.haskell.org/"}},"pkg-cabal-sha256":"f03d2f404d5ba465453d0fbc1944832789a759fe7c4f9bf8616bc1378a02fde4","pkg-src-sha256":"5c0f22b36b28a1a8fa110b3819818d3f29494a3b0dedbae299f064123ca70501","depends":["base-4.18.2.0","containers-0.6.7","deepseq-1.4.8.1","random-1.2.1.1-e2b8c23c50d3a2e2d7c30c46d2a3344a9c2a38bf319885311c62efb7342cb80b","splitmix-0.1.0.5-232d2b1a4ce5cacd620dd2472d411c8d63e777af17182b5d56b631942f729187","template-haskell-2.20.0.0","transformers-0.6.1.0"],"exe-depends":[],"component-name":"lib"},{"type":"pre-existing","id":"array-0.5.6.0","pkg-name":"array","pkg-version":"0.5.6.0","depends":["base-4.18.2.0"]},{"type":"pre-existing","id":"base-4.18.2.0","pkg-name":"base","pkg-version":"4.18.2.0","depends":["ghc-bignum-1.3","ghc-prim-0.10.0"]},{"type":"configured","id":"base16-bytestring-1.0.2.0-48e234cd9d2674d718111ce6f52d0142cc28a3c5a0493618f8fb6a8b7f7dd1f7","pkg-name":"base16-bytestring","pkg-version":"1.0.2.0","flags":{},"style":"global","pkg-src":{"type":"repo-tar","repo":{"type":"secure-repo","uri":"http://hackage.haskell.org/"}},"pkg-cabal-sha256":"a694e88f9ec9fc79f0b03f233d3fea592b68f70a34aac2ddb5bcaecb6562e2fd","pkg-src-sha256":"1d5a91143ef0e22157536093ec8e59d226a68220ec89378d5dcaeea86472c784","depends":["base-4.18.2.0","bytestring-0.11.5.3"],"exe-depends":[],"component-name":"lib"},{"type":"pre-existing","id":"binary-0.8.9.1","pkg-name":"binary","pkg-version":"0.8.9.1","depends":["array-0.5.6.0","base-4.18.2.0","bytestring-0.11.5.3","containers-0.6.7","ghc-prim-0.10.0"]},{"type":"pre-existing","id":"bytestring-0.11.5.3","pkg-name":"bytestring","pkg-version":"0.11.5.3","depends":["base-4.18.2.0","deepseq-1.4.8.1","ghc-prim-0.10.0","template-haskell-2.20.0.0"]},{"type":"configured","id":"clock-0.8.4-b6af39fafa1fb93e9520050c562fc2d9803a08bc83cda5d8b8d907beefe150aa","pkg-name":"clock","pkg-version":"0.8.4","flags":{"llvm":false},"style":"global","pkg-src":{"type":"repo-tar","repo":{"type":"secure-repo","uri":"http://hackage.haskell.org/"}},"pkg-cabal-sha256":"b938655b00cf204ce69abfff946021bed111d2609a9f7a9c22e28a1a202e9115","pkg-src-sha256":"6ae9898afe788a5e334cd5fad5d18a3c2e8e59fa09aaf7b957dbb38a4767df2e","depends":["base-4.18.2.0"],"exe-depends":[],"component-name":"lib"},{"type":"pre-existing","id":"containers-0.6.7","pkg-name":"containers","pkg-version":"0.6.7","depends":["array-0.5.6.0","base-4.18.2.0","deepseq-1.4.8.1","template-haskell-2.20.0.0"]},{"type":"configured","id":"cryptohash-sha256-0.11.102.1-898616048405d66a1ac2538c4878965bc94c2902780e27b3e48e171cdfe34cf8","pkg-name":"cryptohash-sha256","pkg-version":"0.11.102.1","flags":{"exe":false,"use-cbits":true},"style":"global","pkg-src":{"type":"repo-tar","repo":{"type":"secure-repo","uri":"http://hackage.haskell.org/"}},"pkg-cabal-sha256":"03db065161987f614a3a2bbcd16264f78e47efe231fb5bd161be2043eaf20488","pkg-src-sha256":"73a7dc7163871a80837495039a099967b11f5c4fe70a118277842f7a713c6bf6","depends":["base-4.18.2.0","bytestring-0.11.5.3"],"exe-depends":[],"component-name":"lib"},{"type":"pre-existing","id":"deepseq-1.4.8.1","pkg-name":"deepseq","pkg-version":"1.4.8.1","depends":["array-0.5.6.0","base-4.18.2.0","ghc-prim-0.10.0"]},{"type":"pre-existing","id":"directory-1.3.8.1","pkg-name":"directory","pkg-version":"1.3.8.1","depends":["base-4.18.2.0","filepath-1.4.200.1","time-1.12.2","unix-2.8.4.0"]},{"type":"pre-existing","id":"exceptions-0.10.7","pkg-name":"exceptions","pkg-version":"0.10.7","depends":["base-4.18.2.0","mtl-2.3.1","stm-2.5.1.0","template-haskell-2.20.0.0","transformers-0.6.1.0"]},{"type":"configured","id":"extra-1.7.14-5b3875febb50e86e1fd0471cb61fc83c08afae84f74dd82e3fe23bdc226bd3c9","pkg-name":"extra","pkg-version":"1.7.14","flags":{},"style":"global","pkg-src":{"type":"repo-tar","repo":{"type":"secure-repo","uri":"http://hackage.haskell.org/"}},"pkg-cabal-sha256":"e3d3ce1dc7746b1132930e48c59fb5e8c51a09e92e0c031316be031067a273fb","pkg-src-sha256":"b6a909f8f0e4b8076a1653b4d34815a782f0a8c1e83d5267f4d00496471ef567","depends":["base-4.18.2.0","clock-0.8.4-b6af39fafa1fb93e9520050c562fc2d9803a08bc83cda5d8b8d907beefe150aa","directory-1.3.8.1","filepath-1.4.200.1","process-1.6.17.0","time-1.12.2","unix-2.8.4.0"],"exe-depends":[],"component-name":"lib"},{"type":"pre-existing","id":"filepath-1.4.200.1","pkg-name":"filepath","pkg-version":"1.4.200.1","depends":["base-4.18.2.0","bytestring-0.11.5.3","deepseq-1.4.8.1","exceptions-0.10.7","template-haskell-2.20.0.0"]},{"type":"configured","id":"filepattern-0.1.3-e0b05225cb586afea88cbd5fba3b81dbc7d8925b44e8dd467cfd9ed208da351b","pkg-name":"filepattern","pkg-version":"0.1.3","flags":{},"style":"global","pkg-src":{"type":"repo-tar","repo":{"type":"secure-repo","uri":"http://hackage.haskell.org/"}},"pkg-cabal-sha256":"372c1733d83b90045eb29da9f010fed79bfef8771ce65eb126a1d83ecc54a9a2","pkg-src-sha256":"cc445d439ea2f65cac7604d3578aa2c3a62e5a91dc989f4ce5b3390db9e59636","depends":["base-4.18.2.0","directory-1.3.8.1","extra-1.7.14-5b3875febb50e86e1fd0471cb61fc83c08afae84f74dd82e3fe23bdc226bd3c9","filepath-1.4.200.1"],"exe-depends":[],"component-name":"lib"},{"type":"pre-existing","id":"ghc-bignum-1.3","pkg-name":"ghc-bignum","pkg-version":"1.3","depends":["ghc-prim-0.10.0"]},{"type":"pre-existing","id":"ghc-boot-th-9.6.4","pkg-name":"ghc-boot-th","pkg-version":"9.6.4","depends":["base-4.18.2.0"]},{"type":"configured","id":"ghc-platform-0.1.0.0-inplace","pkg-name":"ghc-platform","pkg-version":"0.1.0.0","flags":{},"style":"local","pkg-src":{"type":"local","path":"./hadrian/../libraries/ghc-platform"},"dist-dir":"./hadrian/dist-newstyle/build/x86_64-linux/ghc-9.6.4/ghc-platform-0.1.0.0","build-info":"./hadrian/dist-newstyle/build/x86_64-linux/ghc-9.6.4/ghc-platform-0.1.0.0/build-info.json","depends":["base-4.18.2.0"],"exe-depends":[],"component-name":"lib"},{"type":"pre-existing","id":"ghc-prim-0.10.0","pkg-name":"ghc-prim","pkg-version":"0.10.0","depends":[]},{"type":"configured","id":"ghc-toolchain-0.1.0.0-inplace","pkg-name":"ghc-toolchain","pkg-version":"0.1.0.0","flags":{},"style":"local","pkg-src":{"type":"local","path":"./hadrian/../utils/ghc-toolchain"},"dist-dir":"./hadrian/dist-newstyle/build/x86_64-linux/ghc-9.6.4/ghc-toolchain-0.1.0.0","build-info":"./hadrian/dist-newstyle/build/x86_64-linux/ghc-9.6.4/ghc-toolchain-0.1.0.0/build-info.json","depends":["base-4.18.2.0","directory-1.3.8.1","filepath-1.4.200.1","ghc-platform-0.1.0.0-inplace","process-1.6.17.0","text-2.0.2","transformers-0.6.1.0"],"exe-depends":[],"component-name":"lib"},{"type":"configured","id":"hadrian-0.1.0.0-inplace-hadrian","pkg-name":"hadrian","pkg-version":"0.1.0.0","flags":{"selftest":true,"threaded":true},"style":"local","pkg-src":{"type":"local","path":"./hadrian/."},"dist-dir":"./hadrian/dist-newstyle/build/x86_64-linux/ghc-9.6.4/hadrian-0.1.0.0/x/hadrian","build-info":"./hadrian/dist-newstyle/build/x86_64-linux/ghc-9.6.4/hadrian-0.1.0.0/x/hadrian/build-info.json","depends":["Cabal-3.10.1.0","QuickCheck-2.14.3-116702925e70e233df64507a5cae969ff9c69efe35b3cc35e56c87d47168ff11","base-4.18.2.0","base16-bytestring-1.0.2.0-48e234cd9d2674d718111ce6f52d0142cc28a3c5a0493618f8fb6a8b7f7dd1f7","bytestring-0.11.5.3","containers-0.6.7","cryptohash-sha256-0.11.102.1-898616048405d66a1ac2538c4878965bc94c2902780e27b3e48e171cdfe34cf8","directory-1.3.8.1","extra-1.7.14-5b3875febb50e86e1fd0471cb61fc83c08afae84f74dd82e3fe23bdc226bd3c9","filepath-1.4.200.1","ghc-platform-0.1.0.0-inplace","ghc-toolchain-0.1.0.0-inplace","mtl-2.3.1","parsec-3.1.16.1","shake-0.19.7-9369313762a66f683383a6b11b819b9aafcd8f0d518c176b2cb1f5a198ccf8cd","text-2.0.2","time-1.12.2","transformers-0.6.1.0","unordered-containers-0.2.19.1-0eb0d95c2f270578763e7cbc938fd7d57fa65a8f3c10aa64b616bc79bbf6b993"],"exe-depends":[],"component-name":"exe:hadrian","bin-file":"./hadrian/dist-newstyle/build/x86_64-linux/ghc-9.6.4/hadrian-0.1.0.0/x/hadrian/build/hadrian/hadrian"},{"type":"configured","id":"hashable-1.4.3.0-cf03199beb9180bbbb9b383e3088c03deb3be32037dd08933c3d3ba08171d03e","pkg-name":"hashable","pkg-version":"1.4.3.0","flags":{"integer-gmp":true,"random-initial-seed":false},"style":"global","pkg-src":{"type":"repo-tar","repo":{"type":"secure-repo","uri":"http://hackage.haskell.org/"}},"pkg-cabal-sha256":"f3bf68acfa0df7a064a378ef2cdcfeb55e6fb96100675f4c593556dcbf3d7194","pkg-src-sha256":"32efb16c2891786209b7cbe5c39df9b3a9ae51e836f1a54f646bc4602b7ab0f5","depends":["base-4.18.2.0","bytestring-0.11.5.3","containers-0.6.7","deepseq-1.4.8.1","filepath-1.4.200.1","ghc-bignum-1.3","ghc-prim-0.10.0","text-2.0.2"],"exe-depends":[],"component-name":"lib"},{"type":"configured","id":"heaps-0.4-582bc0f356369f4ac6a9badb439391d1ff82a6d0d7a4a55fe3db91d6d1a32875","pkg-name":"heaps","pkg-version":"0.4","flags":{},"style":"global","pkg-src":{"type":"repo-tar","repo":{"type":"secure-repo","uri":"http://hackage.haskell.org/"}},"pkg-cabal-sha256":"66b19fcd813b0e4db3e0bac541bd46606c3b13d3d081d9f9666f4be0f5ff14b8","pkg-src-sha256":"89329df8b95ae99ef272e41e7a2d0fe2f1bb7eacfcc34bc01664414b33067cfd","depends":["base-4.18.2.0"],"exe-depends":[],"component-name":"lib"},{"type":"configured","id":"js-dgtable-0.5.2-40721bc9982faf5e0f71e3119e01102f429fefca9219230921535f5382e177f7","pkg-name":"js-dgtable","pkg-version":"0.5.2","flags":{},"style":"global","pkg-src":{"type":"repo-tar","repo":{"type":"secure-repo","uri":"http://hackage.haskell.org/"}},"pkg-cabal-sha256":"f75cb4fa53c88c65794becdd48eb0d3b2b8abd89a3d5c19e87af91f5225c15e4","pkg-src-sha256":"e28dd65bee8083b17210134e22e01c6349dc33c3b7bd17705973cd014e9f20ac","depends":["base-4.18.2.0"],"exe-depends":[],"component-name":"lib"},{"type":"configured","id":"js-flot-0.8.3-fadd4ccb467ede662552cdc382e02fb02027d8181620f296bae75d1f76774b0b","pkg-name":"js-flot","pkg-version":"0.8.3","flags":{},"style":"global","pkg-src":{"type":"repo-tar","repo":{"type":"secure-repo","uri":"http://hackage.haskell.org/"}},"pkg-cabal-sha256":"4c1c447a9a2fba0adba6d30678302a30c32b9dfde9e7aa9e9156483e1545096d","pkg-src-sha256":"1ba2f2a6b8d85da76c41f526c98903cbb107f8642e506c072c1e7e3c20fe5e7a","depends":["base-4.18.2.0"],"exe-depends":[],"component-name":"lib"},{"type":"configured","id":"js-jquery-3.3.1-6a8cc1e84fc203e099644c71b32217b6615b055459038eb73f1b008db4b2f236","pkg-name":"js-jquery","pkg-version":"3.3.1","flags":{},"style":"global","pkg-src":{"type":"repo-tar","repo":{"type":"secure-repo","uri":"http://hackage.haskell.org/"}},"pkg-cabal-sha256":"59ab6c79159549ef94b584abce8e6d3b336014c2cce1337b59a8f637e2856df5","pkg-src-sha256":"e0e0681f0da1130ede4e03a051630ea439c458cb97216cdb01771ebdbe44069b","depends":["base-4.18.2.0"],"exe-depends":[],"component-name":"lib"},{"type":"pre-existing","id":"mtl-2.3.1","pkg-name":"mtl","pkg-version":"2.3.1","depends":["base-4.18.2.0","transformers-0.6.1.0"]},{"type":"pre-existing","id":"parsec-3.1.16.1","pkg-name":"parsec","pkg-version":"3.1.16.1","depends":["base-4.18.2.0","bytestring-0.11.5.3","mtl-2.3.1","text-2.0.2"]},{"type":"pre-existing","id":"pretty-1.1.3.6","pkg-name":"pretty","pkg-version":"1.1.3.6","depends":["base-4.18.2.0","deepseq-1.4.8.1","ghc-prim-0.10.0"]},{"type":"configured","id":"primitive-0.9.0.0-b327a6c8ea4577ea7938607770d363048048a528efdff4bc67a582b5feac66fc","pkg-name":"primitive","pkg-version":"0.9.0.0","flags":{},"style":"global","pkg-src":{"type":"repo-tar","repo":{"type":"secure-repo","uri":"http://hackage.haskell.org/"}},"pkg-cabal-sha256":"1ceb39f67c0e614180f2992a6d30f26603ab2cd23c4f8e25b30213f98807f6f1","pkg-src-sha256":"696d4bd291c94d736142d6182117dca4258d3ef28bfefdb649ac8b5ecd0999c7","depends":["base-4.18.2.0","deepseq-1.4.8.1","template-haskell-2.20.0.0","transformers-0.6.1.0"],"exe-depends":[],"component-name":"lib"},{"type":"pre-existing","id":"process-1.6.17.0","pkg-name":"process","pkg-version":"1.6.17.0","depends":["base-4.18.2.0","deepseq-1.4.8.1","directory-1.3.8.1","filepath-1.4.200.1","unix-2.8.4.0"]},{"type":"configured","id":"random-1.2.1.1-e2b8c23c50d3a2e2d7c30c46d2a3344a9c2a38bf319885311c62efb7342cb80b","pkg-name":"random","pkg-version":"1.2.1.1","flags":{},"style":"global","pkg-src":{"type":"repo-tar","repo":{"type":"secure-repo","uri":"http://hackage.haskell.org/"}},"pkg-cabal-sha256":"e7c1f881159d5cc788619c9ee8b8f340ba2ff0db571cdf3d1a1968ebc5108789","pkg-src-sha256":"3e1272f7ed6a4d7bd1712b90143ec326fee9b225789222379fea20a9c90c9b76","depends":["base-4.18.2.0","bytestring-0.11.5.3","deepseq-1.4.8.1","mtl-2.3.1","splitmix-0.1.0.5-232d2b1a4ce5cacd620dd2472d411c8d63e777af17182b5d56b631942f729187"],"exe-depends":[],"component-name":"lib"},{"type":"configured","id":"shake-0.19.7-9369313762a66f683383a6b11b819b9aafcd8f0d518c176b2cb1f5a198ccf8cd","pkg-name":"shake","pkg-version":"0.19.7","flags":{"cloud":false,"embed-files":false,"portable":false},"style":"global","pkg-src":{"type":"repo-tar","repo":{"type":"secure-repo","uri":"http://hackage.haskell.org/"}},"pkg-cabal-sha256":"3cb5814cce210b9756fa9246ff1b2a1e1b86be46fdc4c5e2baacdc5bf83ce5c3","pkg-src-sha256":"352a56af12f70b50d564dcb61131555577281957ee196f1702a3723c0a3699d1","depends":["base-4.18.2.0","binary-0.8.9.1","bytestring-0.11.5.3","deepseq-1.4.8.1","directory-1.3.8.1","extra-1.7.14-5b3875febb50e86e1fd0471cb61fc83c08afae84f74dd82e3fe23bdc226bd3c9","filepath-1.4.200.1","filepattern-0.1.3-e0b05225cb586afea88cbd5fba3b81dbc7d8925b44e8dd467cfd9ed208da351b","hashable-1.4.3.0-cf03199beb9180bbbb9b383e3088c03deb3be32037dd08933c3d3ba08171d03e","heaps-0.4-582bc0f356369f4ac6a9badb439391d1ff82a6d0d7a4a55fe3db91d6d1a32875","js-dgtable-0.5.2-40721bc9982faf5e0f71e3119e01102f429fefca9219230921535f5382e177f7","js-flot-0.8.3-fadd4ccb467ede662552cdc382e02fb02027d8181620f296bae75d1f76774b0b","js-jquery-3.3.1-6a8cc1e84fc203e099644c71b32217b6615b055459038eb73f1b008db4b2f236","primitive-0.9.0.0-b327a6c8ea4577ea7938607770d363048048a528efdff4bc67a582b5feac66fc","process-1.6.17.0","random-1.2.1.1-e2b8c23c50d3a2e2d7c30c46d2a3344a9c2a38bf319885311c62efb7342cb80b","time-1.12.2","transformers-0.6.1.0","unix-2.8.4.0","unordered-containers-0.2.19.1-0eb0d95c2f270578763e7cbc938fd7d57fa65a8f3c10aa64b616bc79bbf6b993","utf8-string-1.0.2-134849f72bdb35a6754bed838d5c0f0412c3ca2863338b599b4cd9b0af070e05"],"exe-depends":[],"component-name":"lib"},{"type":"configured","id":"shake-0.19.7-e-shake-74d898c5705f61c05a8a7aee14d32e6ef38e5584b58da7af7f06efe4c3c36716","pkg-name":"shake","pkg-version":"0.19.7","flags":{"cloud":false,"embed-files":false,"portable":false},"style":"global","pkg-src":{"type":"repo-tar","repo":{"type":"secure-repo","uri":"http://hackage.haskell.org/"}},"pkg-cabal-sha256":"3cb5814cce210b9756fa9246ff1b2a1e1b86be46fdc4c5e2baacdc5bf83ce5c3","pkg-src-sha256":"352a56af12f70b50d564dcb61131555577281957ee196f1702a3723c0a3699d1","depends":["base-4.18.2.0","binary-0.8.9.1","bytestring-0.11.5.3","deepseq-1.4.8.1","directory-1.3.8.1","extra-1.7.14-5b3875febb50e86e1fd0471cb61fc83c08afae84f74dd82e3fe23bdc226bd3c9","filepath-1.4.200.1","filepattern-0.1.3-e0b05225cb586afea88cbd5fba3b81dbc7d8925b44e8dd467cfd9ed208da351b","hashable-1.4.3.0-cf03199beb9180bbbb9b383e3088c03deb3be32037dd08933c3d3ba08171d03e","heaps-0.4-582bc0f356369f4ac6a9badb439391d1ff82a6d0d7a4a55fe3db91d6d1a32875","js-dgtable-0.5.2-40721bc9982faf5e0f71e3119e01102f429fefca9219230921535f5382e177f7","js-flot-0.8.3-fadd4ccb467ede662552cdc382e02fb02027d8181620f296bae75d1f76774b0b","js-jquery-3.3.1-6a8cc1e84fc203e099644c71b32217b6615b055459038eb73f1b008db4b2f236","primitive-0.9.0.0-b327a6c8ea4577ea7938607770d363048048a528efdff4bc67a582b5feac66fc","process-1.6.17.0","random-1.2.1.1-e2b8c23c50d3a2e2d7c30c46d2a3344a9c2a38bf319885311c62efb7342cb80b","time-1.12.2","transformers-0.6.1.0","unix-2.8.4.0","unordered-containers-0.2.19.1-0eb0d95c2f270578763e7cbc938fd7d57fa65a8f3c10aa64b616bc79bbf6b993","utf8-string-1.0.2-134849f72bdb35a6754bed838d5c0f0412c3ca2863338b599b4cd9b0af070e05"],"exe-depends":[],"component-name":"exe:shake","bin-file":"/store/ghc-9.6.4/shake-0.19.7-e-shake-74d898c5705f61c05a8a7aee14d32e6ef38e5584b58da7af7f06efe4c3c36716/bin/shake"},{"type":"configured","id":"splitmix-0.1.0.5-232d2b1a4ce5cacd620dd2472d411c8d63e777af17182b5d56b631942f729187","pkg-name":"splitmix","pkg-version":"0.1.0.5","flags":{"optimised-mixer":false},"style":"global","pkg-src":{"type":"repo-tar","repo":{"type":"secure-repo","uri":"http://hackage.haskell.org/"}},"pkg-cabal-sha256":"bac0ae8d46a04e410666b0c8081cff63f060f29157983b569ca86ddb6e6e0dc6","pkg-src-sha256":"9df07a9611ef45f1b1258a0b412f4d02c920248f69d2e2ce8ccda328f7e13002","depends":["base-4.18.2.0","deepseq-1.4.8.1"],"exe-depends":[],"component-name":"lib"},{"type":"pre-existing","id":"stm-2.5.1.0","pkg-name":"stm","pkg-version":"2.5.1.0","depends":["array-0.5.6.0","base-4.18.2.0"]},{"type":"pre-existing","id":"system-cxx-std-lib-1.0","pkg-name":"system-cxx-std-lib","pkg-version":"1.0","depends":[]},{"type":"pre-existing","id":"template-haskell-2.20.0.0","pkg-name":"template-haskell","pkg-version":"2.20.0.0","depends":["base-4.18.2.0","ghc-boot-th-9.6.4","ghc-prim-0.10.0","pretty-1.1.3.6"]},{"type":"pre-existing","id":"text-2.0.2","pkg-name":"text","pkg-version":"2.0.2","depends":["array-0.5.6.0","base-4.18.2.0","binary-0.8.9.1","bytestring-0.11.5.3","deepseq-1.4.8.1","ghc-prim-0.10.0","system-cxx-std-lib-1.0","template-haskell-2.20.0.0"]},{"type":"pre-existing","id":"time-1.12.2","pkg-name":"time","pkg-version":"1.12.2","depends":["base-4.18.2.0","deepseq-1.4.8.1"]},{"type":"pre-existing","id":"transformers-0.6.1.0","pkg-name":"transformers","pkg-version":"0.6.1.0","depends":["base-4.18.2.0","ghc-prim-0.10.0"]},{"type":"pre-existing","id":"unix-2.8.4.0","pkg-name":"unix","pkg-version":"2.8.4.0","depends":["base-4.18.2.0","bytestring-0.11.5.3","filepath-1.4.200.1","time-1.12.2"]},{"type":"configured","id":"unordered-containers-0.2.19.1-0eb0d95c2f270578763e7cbc938fd7d57fa65a8f3c10aa64b616bc79bbf6b993","pkg-name":"unordered-containers","pkg-version":"0.2.19.1","flags":{"debug":false},"style":"global","pkg-src":{"type":"repo-tar","repo":{"type":"secure-repo","uri":"http://hackage.haskell.org/"}},"pkg-cabal-sha256":"1c28ca429e3960de0330908579a427ccacddd700cb84ec1969e2bbe576152add","pkg-src-sha256":"1b27bec5e0d522b27a6029ebf4c4a6d40acbc083c787008e32fb55c4b1d128d2","depends":["base-4.18.2.0","deepseq-1.4.8.1","hashable-1.4.3.0-cf03199beb9180bbbb9b383e3088c03deb3be32037dd08933c3d3ba08171d03e","template-haskell-2.20.0.0"],"exe-depends":[],"component-name":"lib"},{"type":"configured","id":"utf8-string-1.0.2-134849f72bdb35a6754bed838d5c0f0412c3ca2863338b599b4cd9b0af070e05","pkg-name":"utf8-string","pkg-version":"1.0.2","flags":{},"style":"global","pkg-src":{"type":"repo-tar","repo":{"type":"secure-repo","uri":"http://hackage.haskell.org/"}},"pkg-cabal-sha256":"79416292186feeaf1f60e49ac5a1ffae9bf1b120e040a74bf0e81ca7f1d31d3f","pkg-src-sha256":"ee48deada7600370728c4156cb002441de770d0121ae33a68139a9ed9c19b09a","depends":["base-4.18.2.0","bytestring-0.11.5.3"],"exe-depends":[],"component-name":"lib"}],"targets":[{"pkg-name":"Cabal","pkg-version":"3.10.1.0","component-name":"lib","available":[{"id":"Cabal-3.10.1.0","component-name":"lib","build-by-default":true}]},{"pkg-name":"Cabal-syntax","pkg-version":"3.10.1.0","component-name":"lib","available":[{"id":"Cabal-syntax-3.10.1.0","component-name":"lib","build-by-default":true}]},{"pkg-name":"QuickCheck","pkg-version":"2.14.3","component-name":"lib","available":[{"id":"QuickCheck-2.14.3-116702925e70e233df64507a5cae969ff9c69efe35b3cc35e56c87d47168ff11","component-name":"lib","build-by-default":true}]},{"pkg-name":"QuickCheck","pkg-version":"2.14.3","component-name":"test:test-quickcheck","available":["TargetNotLocal"]},{"pkg-name":"QuickCheck","pkg-version":"2.14.3","component-name":"test:test-quickcheck-gcoarbitrary","available":["TargetNotLocal"]},{"pkg-name":"QuickCheck","pkg-version":"2.14.3","component-name":"test:test-quickcheck-generators","available":["TargetNotLocal"]},{"pkg-name":"QuickCheck","pkg-version":"2.14.3","component-name":"test:test-quickcheck-gshrink","available":["TargetNotLocal"]},{"pkg-name":"QuickCheck","pkg-version":"2.14.3","component-name":"test:test-quickcheck-misc","available":["TargetNotLocal"]},{"pkg-name":"QuickCheck","pkg-version":"2.14.3","component-name":"test:test-quickcheck-monadfix","available":["TargetNotLocal"]},{"pkg-name":"QuickCheck","pkg-version":"2.14.3","component-name":"test:test-quickcheck-split","available":["TargetNotLocal"]},{"pkg-name":"QuickCheck","pkg-version":"2.14.3","component-name":"test:test-quickcheck-terminal","available":["TargetNotLocal"]},{"pkg-name":"array","pkg-version":"0.5.6.0","component-name":"lib","available":[{"id":"array-0.5.6.0","component-name":"lib","build-by-default":true}]},{"pkg-name":"base","pkg-version":"4.18.2.0","component-name":"lib","available":[{"id":"base-4.18.2.0","component-name":"lib","build-by-default":true}]},{"pkg-name":"base16-bytestring","pkg-version":"1.0.2.0","component-name":"lib","available":[{"id":"base16-bytestring-1.0.2.0-48e234cd9d2674d718111ce6f52d0142cc28a3c5a0493618f8fb6a8b7f7dd1f7","component-name":"lib","build-by-default":true}]},{"pkg-name":"base16-bytestring","pkg-version":"1.0.2.0","component-name":"test:test","available":["TargetNotLocal"]},{"pkg-name":"base16-bytestring","pkg-version":"1.0.2.0","component-name":"bench:bench","available":["TargetNotLocal"]},{"pkg-name":"binary","pkg-version":"0.8.9.1","component-name":"lib","available":[{"id":"binary-0.8.9.1","component-name":"lib","build-by-default":true}]},{"pkg-name":"bytestring","pkg-version":"0.11.5.3","component-name":"lib","available":[{"id":"bytestring-0.11.5.3","component-name":"lib","build-by-default":true}]},{"pkg-name":"clock","pkg-version":"0.8.4","component-name":"lib","available":[{"id":"clock-0.8.4-b6af39fafa1fb93e9520050c562fc2d9803a08bc83cda5d8b8d907beefe150aa","component-name":"lib","build-by-default":true}]},{"pkg-name":"clock","pkg-version":"0.8.4","component-name":"test:test","available":["TargetNotLocal"]},{"pkg-name":"clock","pkg-version":"0.8.4","component-name":"bench:benchmarks","available":["TargetNotLocal"]},{"pkg-name":"containers","pkg-version":"0.6.7","component-name":"lib","available":[{"id":"containers-0.6.7","component-name":"lib","build-by-default":true}]},{"pkg-name":"cryptohash-sha256","pkg-version":"0.11.102.1","component-name":"lib","available":[{"id":"cryptohash-sha256-0.11.102.1-898616048405d66a1ac2538c4878965bc94c2902780e27b3e48e171cdfe34cf8","component-name":"lib","build-by-default":true}]},{"pkg-name":"cryptohash-sha256","pkg-version":"0.11.102.1","component-name":"exe:sha256sum","available":["TargetNotBuildable"]},{"pkg-name":"cryptohash-sha256","pkg-version":"0.11.102.1","component-name":"test:test-sha256","available":["TargetNotLocal"]},{"pkg-name":"cryptohash-sha256","pkg-version":"0.11.102.1","component-name":"bench:bench-sha256","available":["TargetNotLocal"]},{"pkg-name":"deepseq","pkg-version":"1.4.8.1","component-name":"lib","available":[{"id":"deepseq-1.4.8.1","component-name":"lib","build-by-default":true}]},{"pkg-name":"directory","pkg-version":"1.3.8.1","component-name":"lib","available":[{"id":"directory-1.3.8.1","component-name":"lib","build-by-default":true}]},{"pkg-name":"exceptions","pkg-version":"0.10.7","component-name":"lib","available":[{"id":"exceptions-0.10.7","component-name":"lib","build-by-default":true}]},{"pkg-name":"extra","pkg-version":"1.7.14","component-name":"lib","available":[{"id":"extra-1.7.14-5b3875febb50e86e1fd0471cb61fc83c08afae84f74dd82e3fe23bdc226bd3c9","component-name":"lib","build-by-default":true}]},{"pkg-name":"extra","pkg-version":"1.7.14","component-name":"test:extra-test","available":["TargetNotLocal"]},{"pkg-name":"filepath","pkg-version":"1.4.200.1","component-name":"lib","available":[{"id":"filepath-1.4.200.1","component-name":"lib","build-by-default":true}]},{"pkg-name":"filepattern","pkg-version":"0.1.3","component-name":"lib","available":[{"id":"filepattern-0.1.3-e0b05225cb586afea88cbd5fba3b81dbc7d8925b44e8dd467cfd9ed208da351b","component-name":"lib","build-by-default":true}]},{"pkg-name":"filepattern","pkg-version":"0.1.3","component-name":"test:filepattern-test","available":["TargetNotLocal"]},{"pkg-name":"ghc-bignum","pkg-version":"1.3","component-name":"lib","available":[{"id":"ghc-bignum-1.3","component-name":"lib","build-by-default":true}]},{"pkg-name":"ghc-boot-th","pkg-version":"9.6.4","component-name":"lib","available":[{"id":"ghc-boot-th-9.6.4","component-name":"lib","build-by-default":true}]},{"pkg-name":"ghc-platform","pkg-version":"0.1.0.0","component-name":"lib","available":[{"id":"ghc-platform-0.1.0.0-inplace","component-name":"lib","build-by-default":true}]},{"pkg-name":"ghc-prim","pkg-version":"0.10.0","component-name":"lib","available":[{"id":"ghc-prim-0.10.0","component-name":"lib","build-by-default":true}]},{"pkg-name":"ghc-toolchain","pkg-version":"0.1.0.0","component-name":"lib","available":[{"id":"ghc-toolchain-0.1.0.0-inplace","component-name":"lib","build-by-default":true}]},{"pkg-name":"hadrian","pkg-version":"0.1.0.0","component-name":"exe:hadrian","available":[{"id":"hadrian-0.1.0.0-inplace-hadrian","component-name":"exe:hadrian","build-by-default":true}]},{"pkg-name":"hashable","pkg-version":"1.4.3.0","component-name":"lib","available":[{"id":"hashable-1.4.3.0-cf03199beb9180bbbb9b383e3088c03deb3be32037dd08933c3d3ba08171d03e","component-name":"lib","build-by-default":true}]},{"pkg-name":"hashable","pkg-version":"1.4.3.0","component-name":"test:hashable-examples","available":["TargetNotLocal"]},{"pkg-name":"hashable","pkg-version":"1.4.3.0","component-name":"test:hashable-tests","available":["TargetNotLocal"]},{"pkg-name":"heaps","pkg-version":"0.4","component-name":"lib","available":[{"id":"heaps-0.4-582bc0f356369f4ac6a9badb439391d1ff82a6d0d7a4a55fe3db91d6d1a32875","component-name":"lib","build-by-default":true}]},{"pkg-name":"js-dgtable","pkg-version":"0.5.2","component-name":"lib","available":[{"id":"js-dgtable-0.5.2-40721bc9982faf5e0f71e3119e01102f429fefca9219230921535f5382e177f7","component-name":"lib","build-by-default":true}]},{"pkg-name":"js-dgtable","pkg-version":"0.5.2","component-name":"test:js-dgtable-test","available":["TargetNotLocal"]},{"pkg-name":"js-flot","pkg-version":"0.8.3","component-name":"lib","available":[{"id":"js-flot-0.8.3-fadd4ccb467ede662552cdc382e02fb02027d8181620f296bae75d1f76774b0b","component-name":"lib","build-by-default":true}]},{"pkg-name":"js-flot","pkg-version":"0.8.3","component-name":"test:js-flot-test","available":["TargetNotLocal"]},{"pkg-name":"js-jquery","pkg-version":"3.3.1","component-name":"lib","available":[{"id":"js-jquery-3.3.1-6a8cc1e84fc203e099644c71b32217b6615b055459038eb73f1b008db4b2f236","component-name":"lib","build-by-default":true}]},{"pkg-name":"js-jquery","pkg-version":"3.3.1","component-name":"test:js-jquery-test","available":["TargetNotLocal"]},{"pkg-name":"mtl","pkg-version":"2.3.1","component-name":"lib","available":[{"id":"mtl-2.3.1","component-name":"lib","build-by-default":true}]},{"pkg-name":"parsec","pkg-version":"3.1.16.1","component-name":"lib","available":[{"id":"parsec-3.1.16.1","component-name":"lib","build-by-default":true}]},{"pkg-name":"pretty","pkg-version":"1.1.3.6","component-name":"lib","available":[{"id":"pretty-1.1.3.6","component-name":"lib","build-by-default":true}]},{"pkg-name":"primitive","pkg-version":"0.9.0.0","component-name":"lib","available":[{"id":"primitive-0.9.0.0-b327a6c8ea4577ea7938607770d363048048a528efdff4bc67a582b5feac66fc","component-name":"lib","build-by-default":true}]},{"pkg-name":"primitive","pkg-version":"0.9.0.0","component-name":"test:test-qc","available":["TargetNotLocal"]},{"pkg-name":"primitive","pkg-version":"0.9.0.0","component-name":"bench:bench","available":["TargetNotLocal"]},{"pkg-name":"process","pkg-version":"1.6.17.0","component-name":"lib","available":[{"id":"process-1.6.17.0","component-name":"lib","build-by-default":true}]},{"pkg-name":"random","pkg-version":"1.2.1.1","component-name":"lib","available":[{"id":"random-1.2.1.1-e2b8c23c50d3a2e2d7c30c46d2a3344a9c2a38bf319885311c62efb7342cb80b","component-name":"lib","build-by-default":true}]},{"pkg-name":"random","pkg-version":"1.2.1.1","component-name":"test:doctests","available":["TargetNotLocal"]},{"pkg-name":"random","pkg-version":"1.2.1.1","component-name":"test:legacy-test","available":["TargetNotLocal"]},{"pkg-name":"random","pkg-version":"1.2.1.1","component-name":"test:spec","available":["TargetNotLocal"]},{"pkg-name":"random","pkg-version":"1.2.1.1","component-name":"test:spec-inspection","available":["TargetNotLocal"]},{"pkg-name":"random","pkg-version":"1.2.1.1","component-name":"bench:bench","available":["TargetNotLocal"]},{"pkg-name":"random","pkg-version":"1.2.1.1","component-name":"bench:legacy-bench","available":["TargetNotLocal"]},{"pkg-name":"shake","pkg-version":"0.19.7","component-name":"lib","available":[{"id":"shake-0.19.7-9369313762a66f683383a6b11b819b9aafcd8f0d518c176b2cb1f5a198ccf8cd","component-name":"lib","build-by-default":true}]},{"pkg-name":"shake","pkg-version":"0.19.7","component-name":"exe:shake","available":[{"id":"shake-0.19.7-e-shake-74d898c5705f61c05a8a7aee14d32e6ef38e5584b58da7af7f06efe4c3c36716","component-name":"exe:shake","build-by-default":true}]},{"pkg-name":"shake","pkg-version":"0.19.7","component-name":"test:shake-test","available":["TargetNotLocal"]},{"pkg-name":"splitmix","pkg-version":"0.1.0.5","component-name":"lib","available":[{"id":"splitmix-0.1.0.5-232d2b1a4ce5cacd620dd2472d411c8d63e777af17182b5d56b631942f729187","component-name":"lib","build-by-default":true}]},{"pkg-name":"splitmix","pkg-version":"0.1.0.5","component-name":"test:examples","available":["TargetNotLocal"]},{"pkg-name":"splitmix","pkg-version":"0.1.0.5","component-name":"test:initialization","available":["TargetNotLocal"]},{"pkg-name":"splitmix","pkg-version":"0.1.0.5","component-name":"test:montecarlo-pi","available":["TargetNotLocal"]},{"pkg-name":"splitmix","pkg-version":"0.1.0.5","component-name":"test:montecarlo-pi-32","available":["TargetNotLocal"]},{"pkg-name":"splitmix","pkg-version":"0.1.0.5","component-name":"test:splitmix-dieharder","available":["TargetNotLocal"]},{"pkg-name":"splitmix","pkg-version":"0.1.0.5","component-name":"test:splitmix-tests","available":["TargetNotLocal"]},{"pkg-name":"splitmix","pkg-version":"0.1.0.5","component-name":"test:splitmix-testu01","available":["TargetNotLocal"]},{"pkg-name":"splitmix","pkg-version":"0.1.0.5","component-name":"bench:comparison","available":["TargetNotLocal"]},{"pkg-name":"splitmix","pkg-version":"0.1.0.5","component-name":"bench:range","available":["TargetNotLocal"]},{"pkg-name":"splitmix","pkg-version":"0.1.0.5","component-name":"bench:simple-sum","available":["TargetNotLocal"]},{"pkg-name":"stm","pkg-version":"2.5.1.0","component-name":"lib","available":[{"id":"stm-2.5.1.0","component-name":"lib","build-by-default":true}]},{"pkg-name":"system-cxx-std-lib","pkg-version":"1.0","component-name":"lib","available":[{"id":"system-cxx-std-lib-1.0","component-name":"lib","build-by-default":true}]},{"pkg-name":"template-haskell","pkg-version":"2.20.0.0","component-name":"lib","available":[{"id":"template-haskell-2.20.0.0","component-name":"lib","build-by-default":true}]},{"pkg-name":"text","pkg-version":"2.0.2","component-name":"lib","available":[{"id":"text-2.0.2","component-name":"lib","build-by-default":true}]},{"pkg-name":"time","pkg-version":"1.12.2","component-name":"lib","available":[{"id":"time-1.12.2","component-name":"lib","build-by-default":true}]},{"pkg-name":"transformers","pkg-version":"0.6.1.0","component-name":"lib","available":[{"id":"transformers-0.6.1.0","component-name":"lib","build-by-default":true}]},{"pkg-name":"unix","pkg-version":"2.8.4.0","component-name":"lib","available":[{"id":"unix-2.8.4.0","component-name":"lib","build-by-default":true}]},{"pkg-name":"unordered-containers","pkg-version":"0.2.19.1","component-name":"lib","available":[{"id":"unordered-containers-0.2.19.1-0eb0d95c2f270578763e7cbc938fd7d57fa65a8f3c10aa64b616bc79bbf6b993","component-name":"lib","build-by-default":true}]},{"pkg-name":"unordered-containers","pkg-version":"0.2.19.1","component-name":"test:unordered-containers-tests","available":["TargetNotLocal"]},{"pkg-name":"unordered-containers","pkg-version":"0.2.19.1","component-name":"bench:benchmarks","available":["TargetNotLocal"]},{"pkg-name":"utf8-string","pkg-version":"1.0.2","component-name":"lib","available":[{"id":"utf8-string-1.0.2-134849f72bdb35a6754bed838d5c0f0412c3ca2863338b599b4cd9b0af070e05","component-name":"lib","build-by-default":true}]},{"pkg-name":"utf8-string","pkg-version":"1.0.2","component-name":"test:unit-tests","available":["TargetNotLocal"]}]} \ No newline at end of file +{"cabal-version":"3.10.3.0","cabal-lib-version":"3.10.3.0","compiler-id":"ghc-9.6.4","os":"linux","arch":"x86_64","install-plan":[{"type":"pre-existing","id":"Cabal-3.10.1.0","pkg-name":"Cabal","pkg-version":"3.10.1.0","depends":["Cabal-syntax-3.10.1.0","array-0.5.6.0","base-4.18.2.0","bytestring-0.11.5.3","containers-0.6.7","deepseq-1.4.8.1","directory-1.3.8.1","filepath-1.4.200.1","mtl-2.3.1","parsec-3.1.16.1","pretty-1.1.3.6","process-1.6.17.0","text-2.0.2","time-1.12.2","transformers-0.6.1.0","unix-2.8.4.0"]},{"type":"pre-existing","id":"Cabal-syntax-3.10.1.0","pkg-name":"Cabal-syntax","pkg-version":"3.10.1.0","depends":["array-0.5.6.0","base-4.18.2.0","binary-0.8.9.1","bytestring-0.11.5.3","containers-0.6.7","deepseq-1.4.8.1","directory-1.3.8.1","filepath-1.4.200.1","mtl-2.3.1","parsec-3.1.16.1","pretty-1.1.3.6","text-2.0.2","time-1.12.2","transformers-0.6.1.0","unix-2.8.4.0"]},{"type":"configured","id":"QuickCheck-2.14.3-12660abe9f5c6a28f87584c784112e82267cee7f5b9b5a1823ce30f9270ebf1a","pkg-name":"QuickCheck","pkg-version":"2.14.3","flags":{"old-random":false,"templatehaskell":true},"style":"global","pkg-src":{"type":"repo-tar","repo":{"type":"secure-repo","uri":"http://hackage.haskell.org/"}},"pkg-cabal-sha256":"f03d2f404d5ba465453d0fbc1944832789a759fe7c4f9bf8616bc1378a02fde4","pkg-src-sha256":"5c0f22b36b28a1a8fa110b3819818d3f29494a3b0dedbae299f064123ca70501","depends":["base-4.18.2.0","containers-0.6.7","deepseq-1.4.8.1","random-1.2.1.2-ccb717c59af131f21dfc040f6185e9cbf4f0b5a3f6de1b3b376d50859a348586","splitmix-0.1.0.5-232d2b1a4ce5cacd620dd2472d411c8d63e777af17182b5d56b631942f729187","template-haskell-2.20.0.0","transformers-0.6.1.0"],"exe-depends":[],"component-name":"lib"},{"type":"pre-existing","id":"array-0.5.6.0","pkg-name":"array","pkg-version":"0.5.6.0","depends":["base-4.18.2.0"]},{"type":"pre-existing","id":"base-4.18.2.0","pkg-name":"base","pkg-version":"4.18.2.0","depends":["ghc-bignum-1.3","ghc-prim-0.10.0"]},{"type":"configured","id":"base16-bytestring-1.0.2.0-48e234cd9d2674d718111ce6f52d0142cc28a3c5a0493618f8fb6a8b7f7dd1f7","pkg-name":"base16-bytestring","pkg-version":"1.0.2.0","flags":{},"style":"global","pkg-src":{"type":"repo-tar","repo":{"type":"secure-repo","uri":"http://hackage.haskell.org/"}},"pkg-cabal-sha256":"a694e88f9ec9fc79f0b03f233d3fea592b68f70a34aac2ddb5bcaecb6562e2fd","pkg-src-sha256":"1d5a91143ef0e22157536093ec8e59d226a68220ec89378d5dcaeea86472c784","depends":["base-4.18.2.0","bytestring-0.11.5.3"],"exe-depends":[],"component-name":"lib"},{"type":"pre-existing","id":"binary-0.8.9.1","pkg-name":"binary","pkg-version":"0.8.9.1","depends":["array-0.5.6.0","base-4.18.2.0","bytestring-0.11.5.3","containers-0.6.7","ghc-prim-0.10.0"]},{"type":"pre-existing","id":"bytestring-0.11.5.3","pkg-name":"bytestring","pkg-version":"0.11.5.3","depends":["base-4.18.2.0","deepseq-1.4.8.1","ghc-prim-0.10.0","template-haskell-2.20.0.0"]},{"type":"configured","id":"clock-0.8.4-b6af39fafa1fb93e9520050c562fc2d9803a08bc83cda5d8b8d907beefe150aa","pkg-name":"clock","pkg-version":"0.8.4","flags":{"llvm":false},"style":"global","pkg-src":{"type":"repo-tar","repo":{"type":"secure-repo","uri":"http://hackage.haskell.org/"}},"pkg-cabal-sha256":"b938655b00cf204ce69abfff946021bed111d2609a9f7a9c22e28a1a202e9115","pkg-src-sha256":"6ae9898afe788a5e334cd5fad5d18a3c2e8e59fa09aaf7b957dbb38a4767df2e","depends":["base-4.18.2.0"],"exe-depends":[],"component-name":"lib"},{"type":"pre-existing","id":"containers-0.6.7","pkg-name":"containers","pkg-version":"0.6.7","depends":["array-0.5.6.0","base-4.18.2.0","deepseq-1.4.8.1","template-haskell-2.20.0.0"]},{"type":"configured","id":"cryptohash-sha256-0.11.102.1-898616048405d66a1ac2538c4878965bc94c2902780e27b3e48e171cdfe34cf8","pkg-name":"cryptohash-sha256","pkg-version":"0.11.102.1","flags":{"exe":false,"use-cbits":true},"style":"global","pkg-src":{"type":"repo-tar","repo":{"type":"secure-repo","uri":"http://hackage.haskell.org/"}},"pkg-cabal-sha256":"acb64f2af52d81b0bb92c266f11d43def726a7a7b74a2c23d219e160b54edec7","pkg-src-sha256":"73a7dc7163871a80837495039a099967b11f5c4fe70a118277842f7a713c6bf6","depends":["base-4.18.2.0","bytestring-0.11.5.3"],"exe-depends":[],"component-name":"lib"},{"type":"pre-existing","id":"deepseq-1.4.8.1","pkg-name":"deepseq","pkg-version":"1.4.8.1","depends":["array-0.5.6.0","base-4.18.2.0","ghc-prim-0.10.0"]},{"type":"pre-existing","id":"directory-1.3.8.1","pkg-name":"directory","pkg-version":"1.3.8.1","depends":["base-4.18.2.0","filepath-1.4.200.1","time-1.12.2","unix-2.8.4.0"]},{"type":"pre-existing","id":"exceptions-0.10.7","pkg-name":"exceptions","pkg-version":"0.10.7","depends":["base-4.18.2.0","mtl-2.3.1","stm-2.5.1.0","template-haskell-2.20.0.0","transformers-0.6.1.0"]},{"type":"configured","id":"extra-1.7.16-dc63228cbe6629bad55bc0268aff37cd1d9389acb03be20763ed611a10fe3efc","pkg-name":"extra","pkg-version":"1.7.16","flags":{},"style":"global","pkg-src":{"type":"repo-tar","repo":{"type":"secure-repo","uri":"http://hackage.haskell.org/"}},"pkg-cabal-sha256":"edd191f77adf31acb1b53960b4d1ca9fca925ac28345a396c614414cb7bfa7ec","pkg-src-sha256":"250c6d43c30b2c71f2cf498a10e69e43ac035974d3819529385d99e42ce77c70","depends":["base-4.18.2.0","clock-0.8.4-b6af39fafa1fb93e9520050c562fc2d9803a08bc83cda5d8b8d907beefe150aa","directory-1.3.8.1","filepath-1.4.200.1","process-1.6.17.0","time-1.12.2","unix-2.8.4.0"],"exe-depends":[],"component-name":"lib"},{"type":"pre-existing","id":"filepath-1.4.200.1","pkg-name":"filepath","pkg-version":"1.4.200.1","depends":["base-4.18.2.0","bytestring-0.11.5.3","deepseq-1.4.8.1","exceptions-0.10.7","template-haskell-2.20.0.0"]},{"type":"configured","id":"filepattern-0.1.3-c45690bc0b4b5c677f6943e7896ddd599d085687db6e459293ba6fa381af7c6e","pkg-name":"filepattern","pkg-version":"0.1.3","flags":{},"style":"global","pkg-src":{"type":"repo-tar","repo":{"type":"secure-repo","uri":"http://hackage.haskell.org/"}},"pkg-cabal-sha256":"372c1733d83b90045eb29da9f010fed79bfef8771ce65eb126a1d83ecc54a9a2","pkg-src-sha256":"cc445d439ea2f65cac7604d3578aa2c3a62e5a91dc989f4ce5b3390db9e59636","depends":["base-4.18.2.0","directory-1.3.8.1","extra-1.7.16-dc63228cbe6629bad55bc0268aff37cd1d9389acb03be20763ed611a10fe3efc","filepath-1.4.200.1"],"exe-depends":[],"component-name":"lib"},{"type":"pre-existing","id":"ghc-bignum-1.3","pkg-name":"ghc-bignum","pkg-version":"1.3","depends":["ghc-prim-0.10.0"]},{"type":"pre-existing","id":"ghc-boot-th-9.6.4","pkg-name":"ghc-boot-th","pkg-version":"9.6.4","depends":["base-4.18.2.0"]},{"type":"configured","id":"ghc-platform-0.1.0.0-inplace","pkg-name":"ghc-platform","pkg-version":"0.1.0.0","flags":{},"style":"local","pkg-src":{"type":"local","path":"./hadrian/../libraries/ghc-platform"},"dist-dir":"./hadrian/dist-newstyle/build/x86_64-linux/ghc-9.6.4/ghc-platform-0.1.0.0","build-info":"./hadrian/dist-newstyle/build/x86_64-linux/ghc-9.6.4/ghc-platform-0.1.0.0/build-info.json","depends":["base-4.18.2.0"],"exe-depends":[],"component-name":"lib"},{"type":"pre-existing","id":"ghc-prim-0.10.0","pkg-name":"ghc-prim","pkg-version":"0.10.0","depends":[]},{"type":"configured","id":"ghc-toolchain-0.1.0.0-inplace","pkg-name":"ghc-toolchain","pkg-version":"0.1.0.0","flags":{},"style":"local","pkg-src":{"type":"local","path":"./hadrian/../utils/ghc-toolchain"},"dist-dir":"./hadrian/dist-newstyle/build/x86_64-linux/ghc-9.6.4/ghc-toolchain-0.1.0.0","build-info":"./hadrian/dist-newstyle/build/x86_64-linux/ghc-9.6.4/ghc-toolchain-0.1.0.0/build-info.json","depends":["base-4.18.2.0","directory-1.3.8.1","filepath-1.4.200.1","ghc-platform-0.1.0.0-inplace","process-1.6.17.0","text-2.0.2","transformers-0.6.1.0"],"exe-depends":[],"component-name":"lib"},{"type":"configured","id":"hadrian-0.1.0.0-inplace-hadrian","pkg-name":"hadrian","pkg-version":"0.1.0.0","flags":{"selftest":true,"threaded":true},"style":"local","pkg-src":{"type":"local","path":"./hadrian/."},"dist-dir":"./hadrian/dist-newstyle/build/x86_64-linux/ghc-9.6.4/hadrian-0.1.0.0/x/hadrian","build-info":"./hadrian/dist-newstyle/build/x86_64-linux/ghc-9.6.4/hadrian-0.1.0.0/x/hadrian/build-info.json","depends":["Cabal-3.10.1.0","QuickCheck-2.14.3-12660abe9f5c6a28f87584c784112e82267cee7f5b9b5a1823ce30f9270ebf1a","base-4.18.2.0","base16-bytestring-1.0.2.0-48e234cd9d2674d718111ce6f52d0142cc28a3c5a0493618f8fb6a8b7f7dd1f7","bytestring-0.11.5.3","containers-0.6.7","cryptohash-sha256-0.11.102.1-898616048405d66a1ac2538c4878965bc94c2902780e27b3e48e171cdfe34cf8","directory-1.3.8.1","extra-1.7.16-dc63228cbe6629bad55bc0268aff37cd1d9389acb03be20763ed611a10fe3efc","filepath-1.4.200.1","ghc-platform-0.1.0.0-inplace","ghc-toolchain-0.1.0.0-inplace","mtl-2.3.1","parsec-3.1.16.1","shake-0.19.8-0ddb83d9db09621c7b8f326abc494d14323dc5751be6943ac5b5e19c9347d5c3","text-2.0.2","time-1.12.2","transformers-0.6.1.0","unordered-containers-0.2.20-0a8211d6220ec0e6694f219bbea9da08528b897266f5898f98f4d6e1ab6fd737"],"exe-depends":[],"component-name":"exe:hadrian","bin-file":"./hadrian/dist-newstyle/build/x86_64-linux/ghc-9.6.4/hadrian-0.1.0.0/x/hadrian/build/hadrian/hadrian"},{"type":"configured","id":"hashable-1.5.0.0-0ac0785933877296ccb7501af740625424a60e762d9e13c3f7fb819fa7014b88","pkg-name":"hashable","pkg-version":"1.5.0.0","flags":{"arch-native":false,"random-initial-seed":false},"style":"global","pkg-src":{"type":"repo-tar","repo":{"type":"secure-repo","uri":"http://hackage.haskell.org/"}},"pkg-cabal-sha256":"fc68b07d957ade5a0a0beadd560a8d093ceac30b2f35c85eed3bcf7889a25975","pkg-src-sha256":"e58b3a8e18da5f6cd7e937e5fd683e500bb1f8276b3768269759119ca0cddb6a","depends":["base-4.18.2.0","bytestring-0.11.5.3","containers-0.6.7","deepseq-1.4.8.1","filepath-1.4.200.1","ghc-bignum-1.3","ghc-prim-0.10.0","os-string-2.0.6-01e3c1e4563fbed004a4ac273e2beea9dfd497789ab9039e09b96161f470a497","text-2.0.2"],"exe-depends":[],"component-name":"lib"},{"type":"configured","id":"heaps-0.4-582bc0f356369f4ac6a9badb439391d1ff82a6d0d7a4a55fe3db91d6d1a32875","pkg-name":"heaps","pkg-version":"0.4","flags":{},"style":"global","pkg-src":{"type":"repo-tar","repo":{"type":"secure-repo","uri":"http://hackage.haskell.org/"}},"pkg-cabal-sha256":"66b19fcd813b0e4db3e0bac541bd46606c3b13d3d081d9f9666f4be0f5ff14b8","pkg-src-sha256":"89329df8b95ae99ef272e41e7a2d0fe2f1bb7eacfcc34bc01664414b33067cfd","depends":["base-4.18.2.0"],"exe-depends":[],"component-name":"lib"},{"type":"configured","id":"js-dgtable-0.5.2-40721bc9982faf5e0f71e3119e01102f429fefca9219230921535f5382e177f7","pkg-name":"js-dgtable","pkg-version":"0.5.2","flags":{},"style":"global","pkg-src":{"type":"repo-tar","repo":{"type":"secure-repo","uri":"http://hackage.haskell.org/"}},"pkg-cabal-sha256":"f75cb4fa53c88c65794becdd48eb0d3b2b8abd89a3d5c19e87af91f5225c15e4","pkg-src-sha256":"e28dd65bee8083b17210134e22e01c6349dc33c3b7bd17705973cd014e9f20ac","depends":["base-4.18.2.0"],"exe-depends":[],"component-name":"lib"},{"type":"configured","id":"js-flot-0.8.3-fadd4ccb467ede662552cdc382e02fb02027d8181620f296bae75d1f76774b0b","pkg-name":"js-flot","pkg-version":"0.8.3","flags":{},"style":"global","pkg-src":{"type":"repo-tar","repo":{"type":"secure-repo","uri":"http://hackage.haskell.org/"}},"pkg-cabal-sha256":"4c1c447a9a2fba0adba6d30678302a30c32b9dfde9e7aa9e9156483e1545096d","pkg-src-sha256":"1ba2f2a6b8d85da76c41f526c98903cbb107f8642e506c072c1e7e3c20fe5e7a","depends":["base-4.18.2.0"],"exe-depends":[],"component-name":"lib"},{"type":"configured","id":"js-jquery-3.3.1-6a8cc1e84fc203e099644c71b32217b6615b055459038eb73f1b008db4b2f236","pkg-name":"js-jquery","pkg-version":"3.3.1","flags":{},"style":"global","pkg-src":{"type":"repo-tar","repo":{"type":"secure-repo","uri":"http://hackage.haskell.org/"}},"pkg-cabal-sha256":"59ab6c79159549ef94b584abce8e6d3b336014c2cce1337b59a8f637e2856df5","pkg-src-sha256":"e0e0681f0da1130ede4e03a051630ea439c458cb97216cdb01771ebdbe44069b","depends":["base-4.18.2.0"],"exe-depends":[],"component-name":"lib"},{"type":"pre-existing","id":"mtl-2.3.1","pkg-name":"mtl","pkg-version":"2.3.1","depends":["base-4.18.2.0","transformers-0.6.1.0"]},{"type":"configured","id":"os-string-2.0.6-01e3c1e4563fbed004a4ac273e2beea9dfd497789ab9039e09b96161f470a497","pkg-name":"os-string","pkg-version":"2.0.6","flags":{},"style":"global","pkg-src":{"type":"repo-tar","repo":{"type":"secure-repo","uri":"http://hackage.haskell.org/"}},"pkg-cabal-sha256":"7699e7ae9bf74d056a62f384ceef8dfb2aa660f3f7c8016e9703f3b995e5e030","pkg-src-sha256":"22fcc7d5fc66676b5dfc57b714d2caf93cce2d5a79d242168352f9eb0fe2f18a","depends":["base-4.18.2.0","bytestring-0.11.5.3","deepseq-1.4.8.1","exceptions-0.10.7","template-haskell-2.20.0.0"],"exe-depends":[],"component-name":"lib"},{"type":"pre-existing","id":"parsec-3.1.16.1","pkg-name":"parsec","pkg-version":"3.1.16.1","depends":["base-4.18.2.0","bytestring-0.11.5.3","mtl-2.3.1","text-2.0.2"]},{"type":"pre-existing","id":"pretty-1.1.3.6","pkg-name":"pretty","pkg-version":"1.1.3.6","depends":["base-4.18.2.0","deepseq-1.4.8.1","ghc-prim-0.10.0"]},{"type":"configured","id":"primitive-0.9.0.0-b327a6c8ea4577ea7938607770d363048048a528efdff4bc67a582b5feac66fc","pkg-name":"primitive","pkg-version":"0.9.0.0","flags":{},"style":"global","pkg-src":{"type":"repo-tar","repo":{"type":"secure-repo","uri":"http://hackage.haskell.org/"}},"pkg-cabal-sha256":"2e08c5409e3559c7f1669ef50e9a0d9a397e68ecf51110d5e2cedf05cdd7d93c","pkg-src-sha256":"696d4bd291c94d736142d6182117dca4258d3ef28bfefdb649ac8b5ecd0999c7","depends":["base-4.18.2.0","deepseq-1.4.8.1","template-haskell-2.20.0.0","transformers-0.6.1.0"],"exe-depends":[],"component-name":"lib"},{"type":"pre-existing","id":"process-1.6.17.0","pkg-name":"process","pkg-version":"1.6.17.0","depends":["base-4.18.2.0","deepseq-1.4.8.1","directory-1.3.8.1","filepath-1.4.200.1","unix-2.8.4.0"]},{"type":"configured","id":"random-1.2.1.2-ccb717c59af131f21dfc040f6185e9cbf4f0b5a3f6de1b3b376d50859a348586","pkg-name":"random","pkg-version":"1.2.1.2","flags":{},"style":"global","pkg-src":{"type":"repo-tar","repo":{"type":"secure-repo","uri":"http://hackage.haskell.org/"}},"pkg-cabal-sha256":"32397de181e20ccaacf806ec70de9308cf044f089a2be37c936f3f8967bde867","pkg-src-sha256":"790f4dc2d2327c453ff6aac7bf15399fd123d55e927935f68f84b5df42d9a4b4","depends":["base-4.18.2.0","bytestring-0.11.5.3","deepseq-1.4.8.1","mtl-2.3.1","splitmix-0.1.0.5-232d2b1a4ce5cacd620dd2472d411c8d63e777af17182b5d56b631942f729187"],"exe-depends":[],"component-name":"lib"},{"type":"configured","id":"shake-0.19.8-0ddb83d9db09621c7b8f326abc494d14323dc5751be6943ac5b5e19c9347d5c3","pkg-name":"shake","pkg-version":"0.19.8","flags":{"cloud":false,"embed-files":false,"portable":false,"threaded":true},"style":"global","pkg-src":{"type":"repo-tar","repo":{"type":"secure-repo","uri":"http://hackage.haskell.org/"}},"pkg-cabal-sha256":"03c8f06de478e07ad6fde95984c9206920106d0d8432ecb7ab825ef108d45382","pkg-src-sha256":"6384e33a26a2590bf33719e88881076b899ac4b5340c1c9271e4caa37e9d6535","depends":["base-4.18.2.0","binary-0.8.9.1","bytestring-0.11.5.3","deepseq-1.4.8.1","directory-1.3.8.1","extra-1.7.16-dc63228cbe6629bad55bc0268aff37cd1d9389acb03be20763ed611a10fe3efc","filepath-1.4.200.1","filepattern-0.1.3-c45690bc0b4b5c677f6943e7896ddd599d085687db6e459293ba6fa381af7c6e","hashable-1.5.0.0-0ac0785933877296ccb7501af740625424a60e762d9e13c3f7fb819fa7014b88","heaps-0.4-582bc0f356369f4ac6a9badb439391d1ff82a6d0d7a4a55fe3db91d6d1a32875","js-dgtable-0.5.2-40721bc9982faf5e0f71e3119e01102f429fefca9219230921535f5382e177f7","js-flot-0.8.3-fadd4ccb467ede662552cdc382e02fb02027d8181620f296bae75d1f76774b0b","js-jquery-3.3.1-6a8cc1e84fc203e099644c71b32217b6615b055459038eb73f1b008db4b2f236","primitive-0.9.0.0-b327a6c8ea4577ea7938607770d363048048a528efdff4bc67a582b5feac66fc","process-1.6.17.0","random-1.2.1.2-ccb717c59af131f21dfc040f6185e9cbf4f0b5a3f6de1b3b376d50859a348586","time-1.12.2","transformers-0.6.1.0","unix-2.8.4.0","unordered-containers-0.2.20-0a8211d6220ec0e6694f219bbea9da08528b897266f5898f98f4d6e1ab6fd737","utf8-string-1.0.2-134849f72bdb35a6754bed838d5c0f0412c3ca2863338b599b4cd9b0af070e05"],"exe-depends":[],"component-name":"lib"},{"type":"configured","id":"shake-0.19.8-e-shake-7559c7ff704c4f74648b4baa6b6f1b1db1f99fa251704d87397a432f656a4846","pkg-name":"shake","pkg-version":"0.19.8","flags":{"cloud":false,"embed-files":false,"portable":false,"threaded":true},"style":"global","pkg-src":{"type":"repo-tar","repo":{"type":"secure-repo","uri":"http://hackage.haskell.org/"}},"pkg-cabal-sha256":"03c8f06de478e07ad6fde95984c9206920106d0d8432ecb7ab825ef108d45382","pkg-src-sha256":"6384e33a26a2590bf33719e88881076b899ac4b5340c1c9271e4caa37e9d6535","depends":["base-4.18.2.0","binary-0.8.9.1","bytestring-0.11.5.3","deepseq-1.4.8.1","directory-1.3.8.1","extra-1.7.16-dc63228cbe6629bad55bc0268aff37cd1d9389acb03be20763ed611a10fe3efc","filepath-1.4.200.1","filepattern-0.1.3-c45690bc0b4b5c677f6943e7896ddd599d085687db6e459293ba6fa381af7c6e","hashable-1.5.0.0-0ac0785933877296ccb7501af740625424a60e762d9e13c3f7fb819fa7014b88","heaps-0.4-582bc0f356369f4ac6a9badb439391d1ff82a6d0d7a4a55fe3db91d6d1a32875","js-dgtable-0.5.2-40721bc9982faf5e0f71e3119e01102f429fefca9219230921535f5382e177f7","js-flot-0.8.3-fadd4ccb467ede662552cdc382e02fb02027d8181620f296bae75d1f76774b0b","js-jquery-3.3.1-6a8cc1e84fc203e099644c71b32217b6615b055459038eb73f1b008db4b2f236","primitive-0.9.0.0-b327a6c8ea4577ea7938607770d363048048a528efdff4bc67a582b5feac66fc","process-1.6.17.0","random-1.2.1.2-ccb717c59af131f21dfc040f6185e9cbf4f0b5a3f6de1b3b376d50859a348586","time-1.12.2","transformers-0.6.1.0","unix-2.8.4.0","unordered-containers-0.2.20-0a8211d6220ec0e6694f219bbea9da08528b897266f5898f98f4d6e1ab6fd737","utf8-string-1.0.2-134849f72bdb35a6754bed838d5c0f0412c3ca2863338b599b4cd9b0af070e05"],"exe-depends":[],"component-name":"exe:shake","bin-file":"/store/ghc-9.6.4/shake-0.19.8-e-shake-7559c7ff704c4f74648b4baa6b6f1b1db1f99fa251704d87397a432f656a4846/bin/shake"},{"type":"configured","id":"splitmix-0.1.0.5-232d2b1a4ce5cacd620dd2472d411c8d63e777af17182b5d56b631942f729187","pkg-name":"splitmix","pkg-version":"0.1.0.5","flags":{"optimised-mixer":false},"style":"global","pkg-src":{"type":"repo-tar","repo":{"type":"secure-repo","uri":"http://hackage.haskell.org/"}},"pkg-cabal-sha256":"caa9b4a92abf1496c7f6a3c0f4e357426a54880077cb9f04e260a8bfa034b77b","pkg-src-sha256":"9df07a9611ef45f1b1258a0b412f4d02c920248f69d2e2ce8ccda328f7e13002","depends":["base-4.18.2.0","deepseq-1.4.8.1"],"exe-depends":[],"component-name":"lib"},{"type":"pre-existing","id":"stm-2.5.1.0","pkg-name":"stm","pkg-version":"2.5.1.0","depends":["array-0.5.6.0","base-4.18.2.0"]},{"type":"pre-existing","id":"system-cxx-std-lib-1.0","pkg-name":"system-cxx-std-lib","pkg-version":"1.0","depends":[]},{"type":"pre-existing","id":"template-haskell-2.20.0.0","pkg-name":"template-haskell","pkg-version":"2.20.0.0","depends":["base-4.18.2.0","ghc-boot-th-9.6.4","ghc-prim-0.10.0","pretty-1.1.3.6"]},{"type":"pre-existing","id":"text-2.0.2","pkg-name":"text","pkg-version":"2.0.2","depends":["array-0.5.6.0","base-4.18.2.0","binary-0.8.9.1","bytestring-0.11.5.3","deepseq-1.4.8.1","ghc-prim-0.10.0","system-cxx-std-lib-1.0","template-haskell-2.20.0.0"]},{"type":"pre-existing","id":"time-1.12.2","pkg-name":"time","pkg-version":"1.12.2","depends":["base-4.18.2.0","deepseq-1.4.8.1"]},{"type":"pre-existing","id":"transformers-0.6.1.0","pkg-name":"transformers","pkg-version":"0.6.1.0","depends":["base-4.18.2.0","ghc-prim-0.10.0"]},{"type":"pre-existing","id":"unix-2.8.4.0","pkg-name":"unix","pkg-version":"2.8.4.0","depends":["base-4.18.2.0","bytestring-0.11.5.3","filepath-1.4.200.1","time-1.12.2"]},{"type":"configured","id":"unordered-containers-0.2.20-0a8211d6220ec0e6694f219bbea9da08528b897266f5898f98f4d6e1ab6fd737","pkg-name":"unordered-containers","pkg-version":"0.2.20","flags":{"debug":false},"style":"global","pkg-src":{"type":"repo-tar","repo":{"type":"secure-repo","uri":"http://hackage.haskell.org/"}},"pkg-cabal-sha256":"c7fe9cba405ed9905e12d89c7add3b3eb9868dfba7975e70ba0cdd64b7b11abc","pkg-src-sha256":"d9cfb287cf00592d39dc9c3cac8b99627ea08f2c01798e70130fc39f7c90f11d","depends":["base-4.18.2.0","deepseq-1.4.8.1","hashable-1.5.0.0-0ac0785933877296ccb7501af740625424a60e762d9e13c3f7fb819fa7014b88","template-haskell-2.20.0.0"],"exe-depends":[],"component-name":"lib"},{"type":"configured","id":"utf8-string-1.0.2-134849f72bdb35a6754bed838d5c0f0412c3ca2863338b599b4cd9b0af070e05","pkg-name":"utf8-string","pkg-version":"1.0.2","flags":{},"style":"global","pkg-src":{"type":"repo-tar","repo":{"type":"secure-repo","uri":"http://hackage.haskell.org/"}},"pkg-cabal-sha256":"79416292186feeaf1f60e49ac5a1ffae9bf1b120e040a74bf0e81ca7f1d31d3f","pkg-src-sha256":"ee48deada7600370728c4156cb002441de770d0121ae33a68139a9ed9c19b09a","depends":["base-4.18.2.0","bytestring-0.11.5.3"],"exe-depends":[],"component-name":"lib"}],"targets":[{"pkg-name":"Cabal","pkg-version":"3.10.1.0","component-name":"lib","available":[{"id":"Cabal-3.10.1.0","component-name":"lib","build-by-default":true}]},{"pkg-name":"Cabal-syntax","pkg-version":"3.10.1.0","component-name":"lib","available":[{"id":"Cabal-syntax-3.10.1.0","component-name":"lib","build-by-default":true}]},{"pkg-name":"QuickCheck","pkg-version":"2.14.3","component-name":"lib","available":[{"id":"QuickCheck-2.14.3-12660abe9f5c6a28f87584c784112e82267cee7f5b9b5a1823ce30f9270ebf1a","component-name":"lib","build-by-default":true}]},{"pkg-name":"QuickCheck","pkg-version":"2.14.3","component-name":"test:test-quickcheck","available":["TargetNotLocal"]},{"pkg-name":"QuickCheck","pkg-version":"2.14.3","component-name":"test:test-quickcheck-gcoarbitrary","available":["TargetNotLocal"]},{"pkg-name":"QuickCheck","pkg-version":"2.14.3","component-name":"test:test-quickcheck-generators","available":["TargetNotLocal"]},{"pkg-name":"QuickCheck","pkg-version":"2.14.3","component-name":"test:test-quickcheck-gshrink","available":["TargetNotLocal"]},{"pkg-name":"QuickCheck","pkg-version":"2.14.3","component-name":"test:test-quickcheck-misc","available":["TargetNotLocal"]},{"pkg-name":"QuickCheck","pkg-version":"2.14.3","component-name":"test:test-quickcheck-monadfix","available":["TargetNotLocal"]},{"pkg-name":"QuickCheck","pkg-version":"2.14.3","component-name":"test:test-quickcheck-split","available":["TargetNotLocal"]},{"pkg-name":"QuickCheck","pkg-version":"2.14.3","component-name":"test:test-quickcheck-terminal","available":["TargetNotLocal"]},{"pkg-name":"array","pkg-version":"0.5.6.0","component-name":"lib","available":[{"id":"array-0.5.6.0","component-name":"lib","build-by-default":true}]},{"pkg-name":"base","pkg-version":"4.18.2.0","component-name":"lib","available":[{"id":"base-4.18.2.0","component-name":"lib","build-by-default":true}]},{"pkg-name":"base16-bytestring","pkg-version":"1.0.2.0","component-name":"lib","available":[{"id":"base16-bytestring-1.0.2.0-48e234cd9d2674d718111ce6f52d0142cc28a3c5a0493618f8fb6a8b7f7dd1f7","component-name":"lib","build-by-default":true}]},{"pkg-name":"base16-bytestring","pkg-version":"1.0.2.0","component-name":"test:test","available":["TargetNotLocal"]},{"pkg-name":"base16-bytestring","pkg-version":"1.0.2.0","component-name":"bench:bench","available":["TargetNotLocal"]},{"pkg-name":"binary","pkg-version":"0.8.9.1","component-name":"lib","available":[{"id":"binary-0.8.9.1","component-name":"lib","build-by-default":true}]},{"pkg-name":"bytestring","pkg-version":"0.11.5.3","component-name":"lib","available":[{"id":"bytestring-0.11.5.3","component-name":"lib","build-by-default":true}]},{"pkg-name":"clock","pkg-version":"0.8.4","component-name":"lib","available":[{"id":"clock-0.8.4-b6af39fafa1fb93e9520050c562fc2d9803a08bc83cda5d8b8d907beefe150aa","component-name":"lib","build-by-default":true}]},{"pkg-name":"clock","pkg-version":"0.8.4","component-name":"test:test","available":["TargetNotLocal"]},{"pkg-name":"clock","pkg-version":"0.8.4","component-name":"bench:benchmarks","available":["TargetNotLocal"]},{"pkg-name":"containers","pkg-version":"0.6.7","component-name":"lib","available":[{"id":"containers-0.6.7","component-name":"lib","build-by-default":true}]},{"pkg-name":"cryptohash-sha256","pkg-version":"0.11.102.1","component-name":"lib","available":[{"id":"cryptohash-sha256-0.11.102.1-898616048405d66a1ac2538c4878965bc94c2902780e27b3e48e171cdfe34cf8","component-name":"lib","build-by-default":true}]},{"pkg-name":"cryptohash-sha256","pkg-version":"0.11.102.1","component-name":"exe:sha256sum","available":["TargetNotBuildable"]},{"pkg-name":"cryptohash-sha256","pkg-version":"0.11.102.1","component-name":"test:test-sha256","available":["TargetNotLocal"]},{"pkg-name":"cryptohash-sha256","pkg-version":"0.11.102.1","component-name":"bench:bench-sha256","available":["TargetNotLocal"]},{"pkg-name":"deepseq","pkg-version":"1.4.8.1","component-name":"lib","available":[{"id":"deepseq-1.4.8.1","component-name":"lib","build-by-default":true}]},{"pkg-name":"directory","pkg-version":"1.3.8.1","component-name":"lib","available":[{"id":"directory-1.3.8.1","component-name":"lib","build-by-default":true}]},{"pkg-name":"exceptions","pkg-version":"0.10.7","component-name":"lib","available":[{"id":"exceptions-0.10.7","component-name":"lib","build-by-default":true}]},{"pkg-name":"extra","pkg-version":"1.7.16","component-name":"lib","available":[{"id":"extra-1.7.16-dc63228cbe6629bad55bc0268aff37cd1d9389acb03be20763ed611a10fe3efc","component-name":"lib","build-by-default":true}]},{"pkg-name":"extra","pkg-version":"1.7.16","component-name":"test:extra-test","available":["TargetNotLocal"]},{"pkg-name":"filepath","pkg-version":"1.4.200.1","component-name":"lib","available":[{"id":"filepath-1.4.200.1","component-name":"lib","build-by-default":true}]},{"pkg-name":"filepattern","pkg-version":"0.1.3","component-name":"lib","available":[{"id":"filepattern-0.1.3-c45690bc0b4b5c677f6943e7896ddd599d085687db6e459293ba6fa381af7c6e","component-name":"lib","build-by-default":true}]},{"pkg-name":"filepattern","pkg-version":"0.1.3","component-name":"test:filepattern-test","available":["TargetNotLocal"]},{"pkg-name":"ghc-bignum","pkg-version":"1.3","component-name":"lib","available":[{"id":"ghc-bignum-1.3","component-name":"lib","build-by-default":true}]},{"pkg-name":"ghc-boot-th","pkg-version":"9.6.4","component-name":"lib","available":[{"id":"ghc-boot-th-9.6.4","component-name":"lib","build-by-default":true}]},{"pkg-name":"ghc-platform","pkg-version":"0.1.0.0","component-name":"lib","available":[{"id":"ghc-platform-0.1.0.0-inplace","component-name":"lib","build-by-default":true}]},{"pkg-name":"ghc-prim","pkg-version":"0.10.0","component-name":"lib","available":[{"id":"ghc-prim-0.10.0","component-name":"lib","build-by-default":true}]},{"pkg-name":"ghc-toolchain","pkg-version":"0.1.0.0","component-name":"lib","available":[{"id":"ghc-toolchain-0.1.0.0-inplace","component-name":"lib","build-by-default":true}]},{"pkg-name":"hadrian","pkg-version":"0.1.0.0","component-name":"exe:hadrian","available":[{"id":"hadrian-0.1.0.0-inplace-hadrian","component-name":"exe:hadrian","build-by-default":true}]},{"pkg-name":"hashable","pkg-version":"1.5.0.0","component-name":"lib","available":[{"id":"hashable-1.5.0.0-0ac0785933877296ccb7501af740625424a60e762d9e13c3f7fb819fa7014b88","component-name":"lib","build-by-default":true}]},{"pkg-name":"hashable","pkg-version":"1.5.0.0","component-name":"test:hashable-examples","available":["TargetNotLocal"]},{"pkg-name":"hashable","pkg-version":"1.5.0.0","component-name":"test:hashable-tests","available":["TargetNotLocal"]},{"pkg-name":"hashable","pkg-version":"1.5.0.0","component-name":"test:xxhash-tests","available":["TargetNotLocal"]},{"pkg-name":"heaps","pkg-version":"0.4","component-name":"lib","available":[{"id":"heaps-0.4-582bc0f356369f4ac6a9badb439391d1ff82a6d0d7a4a55fe3db91d6d1a32875","component-name":"lib","build-by-default":true}]},{"pkg-name":"js-dgtable","pkg-version":"0.5.2","component-name":"lib","available":[{"id":"js-dgtable-0.5.2-40721bc9982faf5e0f71e3119e01102f429fefca9219230921535f5382e177f7","component-name":"lib","build-by-default":true}]},{"pkg-name":"js-dgtable","pkg-version":"0.5.2","component-name":"test:js-dgtable-test","available":["TargetNotLocal"]},{"pkg-name":"js-flot","pkg-version":"0.8.3","component-name":"lib","available":[{"id":"js-flot-0.8.3-fadd4ccb467ede662552cdc382e02fb02027d8181620f296bae75d1f76774b0b","component-name":"lib","build-by-default":true}]},{"pkg-name":"js-flot","pkg-version":"0.8.3","component-name":"test:js-flot-test","available":["TargetNotLocal"]},{"pkg-name":"js-jquery","pkg-version":"3.3.1","component-name":"lib","available":[{"id":"js-jquery-3.3.1-6a8cc1e84fc203e099644c71b32217b6615b055459038eb73f1b008db4b2f236","component-name":"lib","build-by-default":true}]},{"pkg-name":"js-jquery","pkg-version":"3.3.1","component-name":"test:js-jquery-test","available":["TargetNotLocal"]},{"pkg-name":"mtl","pkg-version":"2.3.1","component-name":"lib","available":[{"id":"mtl-2.3.1","component-name":"lib","build-by-default":true}]},{"pkg-name":"os-string","pkg-version":"2.0.6","component-name":"lib","available":[{"id":"os-string-2.0.6-01e3c1e4563fbed004a4ac273e2beea9dfd497789ab9039e09b96161f470a497","component-name":"lib","build-by-default":true}]},{"pkg-name":"os-string","pkg-version":"2.0.6","component-name":"test:bytestring-tests","available":["TargetNotLocal"]},{"pkg-name":"os-string","pkg-version":"2.0.6","component-name":"test:encoding-tests","available":["TargetNotLocal"]},{"pkg-name":"os-string","pkg-version":"2.0.6","component-name":"bench:bench","available":["TargetNotLocal"]},{"pkg-name":"parsec","pkg-version":"3.1.16.1","component-name":"lib","available":[{"id":"parsec-3.1.16.1","component-name":"lib","build-by-default":true}]},{"pkg-name":"pretty","pkg-version":"1.1.3.6","component-name":"lib","available":[{"id":"pretty-1.1.3.6","component-name":"lib","build-by-default":true}]},{"pkg-name":"primitive","pkg-version":"0.9.0.0","component-name":"lib","available":[{"id":"primitive-0.9.0.0-b327a6c8ea4577ea7938607770d363048048a528efdff4bc67a582b5feac66fc","component-name":"lib","build-by-default":true}]},{"pkg-name":"primitive","pkg-version":"0.9.0.0","component-name":"test:test-qc","available":["TargetNotLocal"]},{"pkg-name":"primitive","pkg-version":"0.9.0.0","component-name":"bench:bench","available":["TargetNotLocal"]},{"pkg-name":"process","pkg-version":"1.6.17.0","component-name":"lib","available":[{"id":"process-1.6.17.0","component-name":"lib","build-by-default":true}]},{"pkg-name":"random","pkg-version":"1.2.1.2","component-name":"lib","available":[{"id":"random-1.2.1.2-ccb717c59af131f21dfc040f6185e9cbf4f0b5a3f6de1b3b376d50859a348586","component-name":"lib","build-by-default":true}]},{"pkg-name":"random","pkg-version":"1.2.1.2","component-name":"test:doctests","available":["TargetNotLocal"]},{"pkg-name":"random","pkg-version":"1.2.1.2","component-name":"test:legacy-test","available":["TargetNotLocal"]},{"pkg-name":"random","pkg-version":"1.2.1.2","component-name":"test:spec","available":["TargetNotLocal"]},{"pkg-name":"random","pkg-version":"1.2.1.2","component-name":"test:spec-inspection","available":["TargetNotLocal"]},{"pkg-name":"random","pkg-version":"1.2.1.2","component-name":"bench:bench","available":["TargetNotLocal"]},{"pkg-name":"random","pkg-version":"1.2.1.2","component-name":"bench:legacy-bench","available":["TargetNotLocal"]},{"pkg-name":"shake","pkg-version":"0.19.8","component-name":"lib","available":[{"id":"shake-0.19.8-0ddb83d9db09621c7b8f326abc494d14323dc5751be6943ac5b5e19c9347d5c3","component-name":"lib","build-by-default":true}]},{"pkg-name":"shake","pkg-version":"0.19.8","component-name":"exe:shake","available":[{"id":"shake-0.19.8-e-shake-7559c7ff704c4f74648b4baa6b6f1b1db1f99fa251704d87397a432f656a4846","component-name":"exe:shake","build-by-default":true}]},{"pkg-name":"shake","pkg-version":"0.19.8","component-name":"test:shake-test","available":["TargetNotLocal"]},{"pkg-name":"splitmix","pkg-version":"0.1.0.5","component-name":"lib","available":[{"id":"splitmix-0.1.0.5-232d2b1a4ce5cacd620dd2472d411c8d63e777af17182b5d56b631942f729187","component-name":"lib","build-by-default":true}]},{"pkg-name":"splitmix","pkg-version":"0.1.0.5","component-name":"test:examples","available":["TargetNotLocal"]},{"pkg-name":"splitmix","pkg-version":"0.1.0.5","component-name":"test:initialization","available":["TargetNotLocal"]},{"pkg-name":"splitmix","pkg-version":"0.1.0.5","component-name":"test:montecarlo-pi","available":["TargetNotLocal"]},{"pkg-name":"splitmix","pkg-version":"0.1.0.5","component-name":"test:montecarlo-pi-32","available":["TargetNotLocal"]},{"pkg-name":"splitmix","pkg-version":"0.1.0.5","component-name":"test:splitmix-dieharder","available":["TargetNotLocal"]},{"pkg-name":"splitmix","pkg-version":"0.1.0.5","component-name":"test:splitmix-tests","available":["TargetNotLocal"]},{"pkg-name":"splitmix","pkg-version":"0.1.0.5","component-name":"test:splitmix-testu01","available":["TargetNotLocal"]},{"pkg-name":"splitmix","pkg-version":"0.1.0.5","component-name":"bench:comparison","available":["TargetNotLocal"]},{"pkg-name":"splitmix","pkg-version":"0.1.0.5","component-name":"bench:range","available":["TargetNotLocal"]},{"pkg-name":"splitmix","pkg-version":"0.1.0.5","component-name":"bench:simple-sum","available":["TargetNotLocal"]},{"pkg-name":"stm","pkg-version":"2.5.1.0","component-name":"lib","available":[{"id":"stm-2.5.1.0","component-name":"lib","build-by-default":true}]},{"pkg-name":"system-cxx-std-lib","pkg-version":"1.0","component-name":"lib","available":[{"id":"system-cxx-std-lib-1.0","component-name":"lib","build-by-default":true}]},{"pkg-name":"template-haskell","pkg-version":"2.20.0.0","component-name":"lib","available":[{"id":"template-haskell-2.20.0.0","component-name":"lib","build-by-default":true}]},{"pkg-name":"text","pkg-version":"2.0.2","component-name":"lib","available":[{"id":"text-2.0.2","component-name":"lib","build-by-default":true}]},{"pkg-name":"time","pkg-version":"1.12.2","component-name":"lib","available":[{"id":"time-1.12.2","component-name":"lib","build-by-default":true}]},{"pkg-name":"transformers","pkg-version":"0.6.1.0","component-name":"lib","available":[{"id":"transformers-0.6.1.0","component-name":"lib","build-by-default":true}]},{"pkg-name":"unix","pkg-version":"2.8.4.0","component-name":"lib","available":[{"id":"unix-2.8.4.0","component-name":"lib","build-by-default":true}]},{"pkg-name":"unordered-containers","pkg-version":"0.2.20","component-name":"lib","available":[{"id":"unordered-containers-0.2.20-0a8211d6220ec0e6694f219bbea9da08528b897266f5898f98f4d6e1ab6fd737","component-name":"lib","build-by-default":true}]},{"pkg-name":"unordered-containers","pkg-version":"0.2.20","component-name":"test:unordered-containers-tests","available":["TargetNotLocal"]},{"pkg-name":"unordered-containers","pkg-version":"0.2.20","component-name":"bench:benchmarks","available":["TargetNotLocal"]},{"pkg-name":"utf8-string","pkg-version":"1.0.2","component-name":"lib","available":[{"id":"utf8-string-1.0.2-134849f72bdb35a6754bed838d5c0f0412c3ca2863338b599b4cd9b0af070e05","component-name":"lib","build-by-default":true}]},{"pkg-name":"utf8-string","pkg-version":"1.0.2","component-name":"test:unit-tests","available":["TargetNotLocal"]}]} \ No newline at end of file diff --git a/materialized/ghc964/hadrian-ghc96/hadrian/cabal-files/extra.nix b/materialized/ghc964/hadrian-ghc96/hadrian/cabal-files/extra.nix index 41668cf6bc..26ff289717 100644 --- a/materialized/ghc964/hadrian-ghc96/hadrian/cabal-files/extra.nix +++ b/materialized/ghc964/hadrian-ghc96/hadrian/cabal-files/extra.nix @@ -11,9 +11,9 @@ flags = {}; package = { specVersion = "1.18"; - identifier = { name = "extra"; version = "1.7.14"; }; + identifier = { name = "extra"; version = "1.7.16"; }; license = "BSD-3-Clause"; - copyright = "Neil Mitchell 2014-2023"; + copyright = "Neil Mitchell 2014-2024"; maintainer = "Neil Mitchell "; author = "Neil Mitchell "; homepage = "https://github.com/ndmitchell/extra#readme"; @@ -50,9 +50,9 @@ }; } // { src = pkgs.lib.mkDefault (pkgs.fetchurl { - url = "http://hackage.haskell.org/package/extra-1.7.14.tar.gz"; - sha256 = "b6a909f8f0e4b8076a1653b4d34815a782f0a8c1e83d5267f4d00496471ef567"; + url = "http://hackage.haskell.org/package/extra-1.7.16.tar.gz"; + sha256 = "250c6d43c30b2c71f2cf498a10e69e43ac035974d3819529385d99e42ce77c70"; }); }) // { - package-description-override = "cabal-version: 1.18\nbuild-type: Simple\nname: extra\nversion: 1.7.14\nlicense: BSD3\nlicense-file: LICENSE\ncategory: Development\nauthor: Neil Mitchell \nmaintainer: Neil Mitchell \ncopyright: Neil Mitchell 2014-2023\nsynopsis: Extra functions I use.\ndescription:\n A library of extra functions for the standard Haskell libraries. Most functions are simple additions, filling out missing functionality. A few functions are available in later versions of GHC, but this package makes them available back to GHC 7.2.\n .\n The module \"Extra\" documents all functions provided by this library. Modules such as \"Data.List.Extra\" provide extra functions over \"Data.List\" and also reexport \"Data.List\". Users are recommended to replace \"Data.List\" imports with \"Data.List.Extra\" if they need the extra functionality.\nhomepage: https://github.com/ndmitchell/extra#readme\nbug-reports: https://github.com/ndmitchell/extra/issues\ntested-with: GHC==9.6, GHC==9.4, GHC==9.2, GHC==9.0, GHC==8.10, GHC==8.8\n\nextra-doc-files:\n CHANGES.txt\n README.md\nextra-source-files:\n Generate.hs\n\nsource-repository head\n type: git\n location: https://github.com/ndmitchell/extra.git\n\nlibrary\n default-language: Haskell2010\n hs-source-dirs: src\n build-depends:\n base >= 4.9 && < 5,\n directory,\n filepath,\n process,\n clock >= 0.7,\n time\n if !os(windows)\n build-depends: unix\n\n other-modules:\n Partial\n exposed-modules:\n Extra\n Control.Concurrent.Extra\n Control.Exception.Extra\n Control.Monad.Extra\n Data.Foldable.Extra\n Data.Either.Extra\n Data.IORef.Extra\n Data.List.Extra\n Data.List.NonEmpty.Extra\n Data.Monoid.Extra\n Data.Tuple.Extra\n Data.Typeable.Extra\n Data.Version.Extra\n Numeric.Extra\n System.Directory.Extra\n System.Environment.Extra\n System.Info.Extra\n System.IO.Extra\n System.Process.Extra\n System.Time.Extra\n Text.Read.Extra\n\ntest-suite extra-test\n type: exitcode-stdio-1.0\n default-language: Haskell2010\n build-depends:\n base == 4.*,\n directory,\n filepath,\n extra,\n QuickCheck >= 2.10,\n quickcheck-instances >= 0.3.17\n if !os(windows)\n build-depends: unix\n hs-source-dirs: test\n ghc-options: -main-is Test -threaded \"-with-rtsopts=-N4 -K1K\"\n main-is: Test.hs\n other-modules:\n TestCustom\n TestGen\n TestUtil\n"; + package-description-override = "cabal-version: 1.18\nbuild-type: Simple\nname: extra\nversion: 1.7.16\nlicense: BSD3\nlicense-file: LICENSE\ncategory: Development\nauthor: Neil Mitchell \nmaintainer: Neil Mitchell \ncopyright: Neil Mitchell 2014-2024\nsynopsis: Extra functions I use.\ndescription:\n A library of extra functions for the standard Haskell libraries. Most functions are simple additions, filling out missing functionality. A few functions are available in later versions of GHC, but this package makes them available back to GHC 7.2.\n .\n The module \"Extra\" documents all functions provided by this library. Modules such as \"Data.List.Extra\" provide extra functions over \"Data.List\" and also reexport \"Data.List\". Users are recommended to replace \"Data.List\" imports with \"Data.List.Extra\" if they need the extra functionality.\nhomepage: https://github.com/ndmitchell/extra#readme\nbug-reports: https://github.com/ndmitchell/extra/issues\ntested-with: GHC==9.8, GHC==9.6, GHC==9.4, GHC==9.2, GHC==9.0, GHC==8.10, GHC==8.8\n\nextra-doc-files:\n CHANGES.txt\n README.md\nextra-source-files:\n Generate.hs\n\nsource-repository head\n type: git\n location: https://github.com/ndmitchell/extra.git\n\nlibrary\n default-language: Haskell2010\n hs-source-dirs: src\n build-depends:\n base >= 4.9 && < 5,\n directory,\n filepath,\n process,\n clock >= 0.7,\n time\n if !os(windows)\n build-depends: unix\n\n other-modules:\n Partial\n exposed-modules:\n Extra\n Control.Concurrent.Extra\n Control.Exception.Extra\n Control.Monad.Extra\n Data.Foldable.Extra\n Data.Either.Extra\n Data.IORef.Extra\n Data.List.Extra\n Data.List.NonEmpty.Extra\n Data.Monoid.Extra\n Data.Tuple.Extra\n Data.Typeable.Extra\n Data.Version.Extra\n Numeric.Extra\n System.Directory.Extra\n System.Environment.Extra\n System.Info.Extra\n System.IO.Extra\n System.Process.Extra\n System.Time.Extra\n Text.Read.Extra\n\ntest-suite extra-test\n type: exitcode-stdio-1.0\n default-language: Haskell2010\n build-depends:\n base == 4.*,\n directory,\n filepath,\n extra,\n QuickCheck >= 2.10,\n quickcheck-instances >= 0.3.17\n if !os(windows)\n build-depends: unix\n hs-source-dirs: test\n ghc-options: -main-is Test -threaded \"-with-rtsopts=-N4 -K1K\"\n main-is: Test.hs\n other-modules:\n TestCustom\n TestGen\n TestUtil\n"; } \ No newline at end of file diff --git a/materialized/ghc964/hadrian-ghc96/hadrian/cabal-files/hashable.nix b/materialized/ghc964/hadrian-ghc96/hadrian/cabal-files/hashable.nix index 4b125fa0bc..68ae273859 100644 --- a/materialized/ghc964/hadrian-ghc96/hadrian/cabal-files/hashable.nix +++ b/materialized/ghc964/hadrian-ghc96/hadrian/cabal-files/hashable.nix @@ -8,10 +8,10 @@ , config , ... }: ({ - flags = { integer-gmp = true; random-initial-seed = false; }; + flags = { arch-native = false; random-initial-seed = false; }; package = { - specVersion = "1.12"; - identifier = { name = "hashable"; version = "1.4.3.0"; }; + specVersion = "2.2"; + identifier = { name = "hashable"; version = "1.5.0.0"; }; license = "BSD-3-Clause"; copyright = ""; maintainer = "Oleg Grenrus "; @@ -19,47 +19,51 @@ homepage = "http://github.com/haskell-unordered-containers/hashable"; url = ""; synopsis = "A class for types that can be converted to a hash value"; - description = "This package defines a class, 'Hashable', for types that\ncan be converted to a hash value. This class\nexists for the benefit of hashing-based data\nstructures. The package provides instances for\nbasic types and a way to combine hash values.\n\nThe 'Hashable' 'hash' values are not guaranteed to be stable across library versions, operating systems or architectures. For stable hashing use named hashes: SHA256, CRC32 etc."; + description = "This package defines a class, 'Hashable', for types that can be converted to a hash value.\nThis class exists for the benefit of hashing-based data structures.\nThe package provides instances for basic types and a way to combine hash values.\n\n'Hashable' is intended exclusively for use in in-memory data structures.\n\n'Hashable' does /not/ have a fixed standard.\nThis allows it to improve over time.\n\nBecause it does not have a fixed standard, different computers or computers on different versions of the code will observe different hash values.\nAs such, 'hashable' is not recommended for use other than in-memory datastructures.\nSpecifically, 'hashable' is not intended for network use or in applications which persist hashed values.\nFor stable hashing use named hashes: sha256, crc32, xxhash etc."; buildType = "Simple"; }; components = { "library" = { - depends = (([ + depends = [ (hsPkgs."base" or (errorHandler.buildDepError "base")) (hsPkgs."bytestring" or (errorHandler.buildDepError "bytestring")) (hsPkgs."containers" or (errorHandler.buildDepError "containers")) (hsPkgs."deepseq" or (errorHandler.buildDepError "deepseq")) - (hsPkgs."filepath" or (errorHandler.buildDepError "filepath")) (hsPkgs."ghc-prim" or (errorHandler.buildDepError "ghc-prim")) (hsPkgs."text" or (errorHandler.buildDepError "text")) - ] ++ pkgs.lib.optional (!(compiler.isGhc && compiler.version.ge "9.2")) (hsPkgs."base-orphans" or (errorHandler.buildDepError "base-orphans"))) ++ pkgs.lib.optional (!(compiler.isGhc && compiler.version.ge "9.4")) (hsPkgs."data-array-byte" or (errorHandler.buildDepError "data-array-byte"))) ++ (if compiler.isGhc && compiler.version.ge "9" - then [ - (hsPkgs."ghc-bignum" or (errorHandler.buildDepError "ghc-bignum")) - ] ++ pkgs.lib.optional (!(compiler.isGhc && compiler.version.ge "9.0.2")) (hsPkgs."ghc-bignum-orphans" or (errorHandler.buildDepError "ghc-bignum-orphans")) - else if flags.integer-gmp - then [ - (hsPkgs."integer-gmp" or (errorHandler.buildDepError "integer-gmp")) - ] - else [ - (hsPkgs."integer-simple" or (errorHandler.buildDepError "integer-simple")) - ]); + (hsPkgs."os-string" or (errorHandler.buildDepError "os-string")) + (hsPkgs."filepath" or (errorHandler.buildDepError "filepath")) + (hsPkgs."ghc-bignum" or (errorHandler.buildDepError "ghc-bignum")) + ]; buildable = true; }; tests = { "hashable-tests" = { - depends = [ + depends = ([ (hsPkgs."base" or (errorHandler.buildDepError "base")) (hsPkgs."bytestring" or (errorHandler.buildDepError "bytestring")) + (hsPkgs."filepath" or (errorHandler.buildDepError "filepath")) (hsPkgs."ghc-prim" or (errorHandler.buildDepError "ghc-prim")) (hsPkgs."hashable" or (errorHandler.buildDepError "hashable")) (hsPkgs."HUnit" or (errorHandler.buildDepError "HUnit")) (hsPkgs."QuickCheck" or (errorHandler.buildDepError "QuickCheck")) (hsPkgs."random" or (errorHandler.buildDepError "random")) - (hsPkgs."test-framework" or (errorHandler.buildDepError "test-framework")) - (hsPkgs."test-framework-hunit" or (errorHandler.buildDepError "test-framework-hunit")) - (hsPkgs."test-framework-quickcheck2" or (errorHandler.buildDepError "test-framework-quickcheck2")) + (hsPkgs."tasty" or (errorHandler.buildDepError "tasty")) + (hsPkgs."tasty-hunit" or (errorHandler.buildDepError "tasty-hunit")) + (hsPkgs."tasty-quickcheck" or (errorHandler.buildDepError "tasty-quickcheck")) (hsPkgs."text" or (errorHandler.buildDepError "text")) - ] ++ pkgs.lib.optional (!system.isWindows) (hsPkgs."unix" or (errorHandler.buildDepError "unix")); + ] ++ pkgs.lib.optional (compiler.isGhc && compiler.version.ge "9.2") (hsPkgs."os-string" or (errorHandler.buildDepError "os-string"))) ++ pkgs.lib.optional (!system.isWindows) (hsPkgs."unix" or (errorHandler.buildDepError "unix")); + buildable = true; + }; + "xxhash-tests" = { + depends = [ + (hsPkgs."base" or (errorHandler.buildDepError "base")) + (hsPkgs."bytestring" or (errorHandler.buildDepError "bytestring")) + (hsPkgs."primitive" or (errorHandler.buildDepError "primitive")) + (hsPkgs."tasty" or (errorHandler.buildDepError "tasty")) + (hsPkgs."tasty-hunit" or (errorHandler.buildDepError "tasty-hunit")) + (hsPkgs."tasty-quickcheck" or (errorHandler.buildDepError "tasty-quickcheck")) + ] ++ pkgs.lib.optional (!(compiler.isGhc && compiler.version.ge "9.4")) (hsPkgs."data-array-byte" or (errorHandler.buildDepError "data-array-byte")); buildable = true; }; "hashable-examples" = { @@ -74,9 +78,9 @@ }; } // { src = pkgs.lib.mkDefault (pkgs.fetchurl { - url = "http://hackage.haskell.org/package/hashable-1.4.3.0.tar.gz"; - sha256 = "32efb16c2891786209b7cbe5c39df9b3a9ae51e836f1a54f646bc4602b7ab0f5"; + url = "http://hackage.haskell.org/package/hashable-1.5.0.0.tar.gz"; + sha256 = "e58b3a8e18da5f6cd7e937e5fd683e500bb1f8276b3768269759119ca0cddb6a"; }); }) // { - package-description-override = "cabal-version: 1.12\nname: hashable\nversion: 1.4.3.0\nx-revision: 1\nsynopsis: A class for types that can be converted to a hash value\ndescription:\n This package defines a class, 'Hashable', for types that\n can be converted to a hash value. This class\n exists for the benefit of hashing-based data\n structures. The package provides instances for\n basic types and a way to combine hash values.\n .\n The 'Hashable' 'hash' values are not guaranteed to be stable across library versions, operating systems or architectures. For stable hashing use named hashes: SHA256, CRC32 etc.\n\nhomepage: http://github.com/haskell-unordered-containers/hashable\n\n-- SPDX-License-Identifier : BSD-3-Clause\nlicense: BSD3\nlicense-file: LICENSE\nauthor:\n Milan Straka \n Johan Tibell \n\nmaintainer: Oleg Grenrus \nbug-reports:\n https://github.com/haskell-unordered-containers/hashable/issues\n\nstability: Provisional\ncategory: Data\nbuild-type: Simple\ntested-with:\n GHC ==8.2.2\n || ==8.4.4\n || ==8.6.5\n || ==8.8.3\n || ==8.10.4\n || ==8.10.7\n || ==9.0.1\n || ==9.0.2\n || ==9.2.8\n || ==9.4.7\n || ==9.6.3\n || ==9.8.1\n\nextra-source-files:\n CHANGES.md\n include/HsHashable.h\n README.md\n\nflag integer-gmp\n description:\n Are we using @integer-gmp@ to provide fast Integer instances? No effect on GHC-9.0 or later.\n\n manual: False\n default: True\n\nflag random-initial-seed\n description:\n Randomly initialize the initial seed on each final executable invocation\n This is useful for catching cases when you rely on (non-existent)\n stability of hashable's hash functions.\n This is not a security feature.\n\n manual: True\n default: False\n\nlibrary\n exposed-modules:\n Data.Hashable\n Data.Hashable.Generic\n Data.Hashable.Lifted\n\n other-modules:\n Data.Hashable.Class\n Data.Hashable.Generic.Instances\n Data.Hashable.Imports\n Data.Hashable.LowLevel\n\n c-sources: cbits/fnv.c\n include-dirs: include\n hs-source-dirs: src\n build-depends:\n base >=4.10.1.0 && <4.20\n , bytestring >=0.10.8.2 && <0.13\n , containers >=0.5.10.2 && <0.7\n , deepseq >=1.4.3.0 && <1.6\n , filepath >=1.4.1.2 && <1.5\n , ghc-prim\n , text >=1.2.3.0 && <1.3 || >=2.0 && <2.2\n\n if !impl(ghc >=9.2)\n build-depends: base-orphans >=0.8.6 && <0.10\n\n if !impl(ghc >=9.4)\n build-depends: data-array-byte >=0.1.0.1 && <0.2\n\n -- Integer internals\n if impl(ghc >=9)\n build-depends: ghc-bignum >=1.0 && <1.4\n\n if !impl(ghc >=9.0.2)\n build-depends: ghc-bignum-orphans >=0.1 && <0.2\n\n else\n if flag(integer-gmp)\n build-depends: integer-gmp >=0.4 && <1.1\n\n else\n -- this is needed for the automatic flag to be well-balanced\n build-depends: integer-simple\n\n if (flag(random-initial-seed) && impl(ghc))\n cpp-options: -DHASHABLE_RANDOM_SEED=1\n\n if os(windows)\n c-sources: cbits-win/init.c\n\n else\n c-sources: cbits-unix/init.c\n\n default-language: Haskell2010\n other-extensions:\n BangPatterns\n CPP\n DeriveDataTypeable\n FlexibleContexts\n FlexibleInstances\n GADTs\n KindSignatures\n MagicHash\n MultiParamTypeClasses\n ScopedTypeVariables\n Trustworthy\n TypeOperators\n UnliftedFFITypes\n\n ghc-options: -Wall -fwarn-tabs\n\n if impl(ghc >=9.0)\n -- these flags may abort compilation with GHC-8.10\n -- https://gitlab.haskell.org/ghc/ghc/-/merge_requests/3295\n ghc-options: -Winferred-safe-imports -Wmissing-safe-haskell-mode\n\ntest-suite hashable-tests\n type: exitcode-stdio-1.0\n hs-source-dirs: tests\n main-is: Main.hs\n other-modules:\n Properties\n Regress\n\n build-depends:\n base\n , bytestring\n , ghc-prim\n , hashable\n , HUnit\n , QuickCheck >=2.4.0.1\n , random >=1.0 && <1.3\n , test-framework >=0.3.3\n , test-framework-hunit\n , test-framework-quickcheck2 >=0.2.9\n , text >=0.11.0.5\n\n if !os(windows)\n build-depends: unix\n cpp-options: -DHAVE_MMAP\n other-modules: Regress.Mmap\n other-extensions: CApiFFI\n\n ghc-options: -Wall -fno-warn-orphans\n default-language: Haskell2010\n\ntest-suite hashable-examples\n type: exitcode-stdio-1.0\n build-depends:\n base\n , ghc-prim\n , hashable\n\n hs-source-dirs: examples\n main-is: Main.hs\n default-language: Haskell2010\n\nsource-repository head\n type: git\n location:\n https://github.com/haskell-unordered-containers/hashable.git\n"; + package-description-override = "cabal-version: 2.2\nname: hashable\nversion: 1.5.0.0\nsynopsis: A class for types that can be converted to a hash value\ndescription:\n This package defines a class, 'Hashable', for types that can be converted to a hash value.\n This class exists for the benefit of hashing-based data structures.\n The package provides instances for basic types and a way to combine hash values.\n .\n 'Hashable' is intended exclusively for use in in-memory data structures.\n .\n 'Hashable' does /not/ have a fixed standard.\n This allows it to improve over time.\n .\n Because it does not have a fixed standard, different computers or computers on different versions of the code will observe different hash values.\n As such, 'hashable' is not recommended for use other than in-memory datastructures.\n Specifically, 'hashable' is not intended for network use or in applications which persist hashed values.\n For stable hashing use named hashes: sha256, crc32, xxhash etc.\n\nhomepage: http://github.com/haskell-unordered-containers/hashable\nlicense: BSD-3-Clause\nlicense-file: LICENSE\nauthor:\n Milan Straka \n Johan Tibell \n\nmaintainer: Oleg Grenrus \nbug-reports:\n https://github.com/haskell-unordered-containers/hashable/issues\n\nstability: Provisional\ncategory: Data\nbuild-type: Simple\ntested-with: GHC ==9.6.5 || ==9.8.2 || ==9.10.1\nextra-source-files:\n CHANGES.md\n include/HsHashable.h\n include/HsXXHash.h\n README.md\n xxHash-0.8.2/xxhash.h\n\nflag arch-native\n description:\n Use @-march=native@ when compiling C sources.\n Portable implementation is 15-50% slower.\n Consider enabling this flag if hashing performance is important.\n\n manual: True\n default: False\n\nflag random-initial-seed\n description:\n Randomly initialize the initial seed on each final executable invocation\n This is useful for catching cases when you rely on (non-existent)\n stability of hashable's hash functions.\n This is not a security feature.\n\n manual: True\n default: False\n\nlibrary\n exposed-modules:\n Data.Hashable\n Data.Hashable.Generic\n Data.Hashable.Lifted\n\n other-modules:\n Data.Hashable.Class\n Data.Hashable.FFI\n Data.Hashable.Generic.Instances\n Data.Hashable.Imports\n Data.Hashable.LowLevel\n Data.Hashable.Mix\n Data.Hashable.XXH3\n\n include-dirs: include xxHash-0.8.2\n includes:\n HsHashable.h\n HsXXHash.h\n xxhash.h\n\n hs-source-dirs: src\n build-depends:\n , base >=4.18.0.0 && <4.21\n , bytestring >=0.11.5.3 && <0.13\n , containers >=0.6.7 && <0.8\n , deepseq >=1.4.8.1 && <1.6\n , ghc-prim\n , text >=2.0.2 && <2.2\n\n -- depend on os-string on newer GHCs only.\n -- os-string has tight lower bound on bytestring, which prevents\n -- using bundled version on older GHCs.\n build-depends: os-string >=2.0.2 && <2.1\n\n -- we also ensure that we can get filepath-1.5 only with GHC-9.2\n -- therefore there is else-branch with stricter upper bound.\n build-depends: filepath >=1.4.200.1 && <1.6\n\n -- Integer internals\n build-depends: ghc-bignum >=1.3 && <1.4\n\n if (flag(random-initial-seed) && impl(ghc))\n cpp-options: -DHASHABLE_RANDOM_SEED=1\n\n if os(windows)\n c-sources: cbits-win/init.c\n\n else\n c-sources: cbits-unix/init.c\n\n default-language: Haskell2010\n other-extensions:\n BangPatterns\n CPP\n DeriveDataTypeable\n FlexibleContexts\n FlexibleInstances\n GADTs\n KindSignatures\n MagicHash\n MultiParamTypeClasses\n QuantifiedConstraints\n ScopedTypeVariables\n Trustworthy\n TypeOperators\n UnliftedFFITypes\n\n ghc-options: -Wall\n\n if flag(arch-native)\n -- Cabal doesn't pass cc-options to \"ordinary\" Haskell source compilation\n -- https://github.com/haskell/cabal/issues/9801\n ghc-options: -optc=-march=native -optc-mtune=native\n\n if impl(ghc >=9.0)\n -- these flags may abort compilation with GHC-8.10\n -- https://gitlab.haskell.org/ghc/ghc/-/merge_requests/3295\n ghc-options: -Winferred-safe-imports -Wmissing-safe-haskell-mode\n\ntest-suite hashable-tests\n type: exitcode-stdio-1.0\n hs-source-dirs: tests\n main-is: Main.hs\n other-modules:\n Properties\n Regress\n\n build-depends:\n , base\n , bytestring\n , filepath\n , ghc-prim\n , hashable\n , HUnit\n , QuickCheck >=2.15\n , random >=1.0 && <1.3\n , tasty ^>=1.5\n , tasty-hunit ^>=0.10.1\n , tasty-quickcheck ^>=0.10.3\n , text >=0.11.0.5\n\n if impl(ghc >=9.2)\n build-depends: os-string\n\n if !os(windows)\n build-depends: unix\n cpp-options: -DHAVE_MMAP\n other-modules: Regress.Mmap\n other-extensions: CApiFFI\n\n ghc-options: -Wall -fno-warn-orphans\n default-language: Haskell2010\n\ntest-suite xxhash-tests\n type: exitcode-stdio-1.0\n hs-source-dirs: tests src\n main-is: xxhash-tests.hs\n other-modules:\n Data.Hashable.FFI\n Data.Hashable.XXH3\n\n default-language: Haskell2010\n build-depends:\n , base\n , bytestring\n , primitive ^>=0.9.0.0\n , tasty ^>=1.5\n , tasty-hunit ^>=0.10.1\n , tasty-quickcheck ^>=0.10.3\n\n include-dirs: include xxHash-0.8.2\n includes:\n HsXXHash.h\n xxhash.h\n\n if !impl(ghc >=9.4)\n build-depends: data-array-byte >=0.1.0.1 && <0.2\n\ntest-suite hashable-examples\n type: exitcode-stdio-1.0\n build-depends:\n , base\n , ghc-prim\n , hashable\n\n hs-source-dirs: examples\n main-is: Main.hs\n default-language: Haskell2010\n\nsource-repository head\n type: git\n location:\n https://github.com/haskell-unordered-containers/hashable.git\n"; } \ No newline at end of file diff --git a/materialized/ghc964/hadrian-ghc96/hadrian/cabal-files/os-string.nix b/materialized/ghc964/hadrian-ghc96/hadrian/cabal-files/os-string.nix new file mode 100644 index 0000000000..761c0cf7ee --- /dev/null +++ b/materialized/ghc964/hadrian-ghc96/hadrian/cabal-files/os-string.nix @@ -0,0 +1,79 @@ +{ system + , compiler + , flags + , pkgs + , hsPkgs + , pkgconfPkgs + , errorHandler + , config + , ... }: + ({ + flags = {}; + package = { + specVersion = "2.2"; + identifier = { name = "os-string"; version = "2.0.6"; }; + license = "BSD-3-Clause"; + copyright = "Julain Ospald 2021-2023"; + maintainer = "Julian Ospald "; + author = "Julian Ospald "; + homepage = "https://github.com/haskell/os-string/blob/master/README.md"; + url = ""; + synopsis = "Library for manipulating Operating system strings."; + description = "This package provides functionality for manipulating @OsString@ values, and is shipped with ."; + buildType = "Simple"; + }; + components = { + "library" = { + depends = [ + (hsPkgs."base" or (errorHandler.buildDepError "base")) + (hsPkgs."bytestring" or (errorHandler.buildDepError "bytestring")) + (hsPkgs."deepseq" or (errorHandler.buildDepError "deepseq")) + (hsPkgs."exceptions" or (errorHandler.buildDepError "exceptions")) + (hsPkgs."template-haskell" or (errorHandler.buildDepError "template-haskell")) + ]; + buildable = true; + }; + tests = { + "bytestring-tests" = { + depends = [ + (hsPkgs."base" or (errorHandler.buildDepError "base")) + (hsPkgs."bytestring" or (errorHandler.buildDepError "bytestring")) + (hsPkgs."os-string" or (errorHandler.buildDepError "os-string")) + (hsPkgs."QuickCheck" or (errorHandler.buildDepError "QuickCheck")) + ]; + buildable = true; + }; + "encoding-tests" = { + depends = [ + (hsPkgs."base" or (errorHandler.buildDepError "base")) + (hsPkgs."bytestring" or (errorHandler.buildDepError "bytestring")) + (hsPkgs."deepseq" or (errorHandler.buildDepError "deepseq")) + (hsPkgs."os-string" or (errorHandler.buildDepError "os-string")) + (hsPkgs."QuickCheck" or (errorHandler.buildDepError "QuickCheck")) + (hsPkgs."quickcheck-classes-base" or (errorHandler.buildDepError "quickcheck-classes-base")) + ]; + buildable = true; + }; + }; + benchmarks = { + "bench" = { + depends = [ + (hsPkgs."base" or (errorHandler.buildDepError "base")) + (hsPkgs."bytestring" or (errorHandler.buildDepError "bytestring")) + (hsPkgs."os-string" or (errorHandler.buildDepError "os-string")) + (hsPkgs."deepseq" or (errorHandler.buildDepError "deepseq")) + (hsPkgs."tasty-bench" or (errorHandler.buildDepError "tasty-bench")) + (hsPkgs."random" or (errorHandler.buildDepError "random")) + ]; + buildable = true; + }; + }; + }; + } // { + src = pkgs.lib.mkDefault (pkgs.fetchurl { + url = "http://hackage.haskell.org/package/os-string-2.0.6.tar.gz"; + sha256 = "22fcc7d5fc66676b5dfc57b714d2caf93cce2d5a79d242168352f9eb0fe2f18a"; + }); + }) // { + package-description-override = "cabal-version: 2.2\nname: os-string\nversion: 2.0.6\n\n-- NOTE: Don't forget to update ./changelog.md\nlicense: BSD-3-Clause\nlicense-file: LICENSE\nauthor: Julian Ospald \nmaintainer: Julian Ospald \ncopyright: Julain Ospald 2021-2023\nbug-reports: https://github.com/haskell/os-string/issues\nhomepage:\n https://github.com/haskell/os-string/blob/master/README.md\n\ncategory: System\nbuild-type: Simple\nsynopsis: Library for manipulating Operating system strings.\ntested-with:\n GHC ==8.6.5\n || ==8.8.4\n || ==8.10.7\n || ==9.0.2\n || ==9.2.8\n || ==9.4.8\n || ==9.6.3\n || ==9.8.1\n\ndescription:\n This package provides functionality for manipulating @OsString@ values, and is shipped with .\n\nextra-source-files:\n System/OsString/Common.hs\n tests/bytestring-tests/Properties/Common.hs\n bench/Common.hs\n\nextra-doc-files:\n changelog.md\n README.md\n\nsource-repository head\n type: git\n location: https://github.com/haskell/os-string\n\nlibrary\n exposed-modules:\n System.OsString.Data.ByteString.Short\n System.OsString.Data.ByteString.Short.Internal\n System.OsString.Data.ByteString.Short.Word16\n System.OsString.Encoding\n System.OsString.Encoding.Internal\n System.OsString\n System.OsString.Internal\n System.OsString.Internal.Types\n System.OsString.Posix\n System.OsString.Windows\n\n other-extensions:\n CPP\n PatternGuards\n\n if impl(ghc >=7.2)\n other-extensions: Safe\n\n default-language: Haskell2010\n build-depends:\n , base >=4.12.0.0 && <4.21\n , bytestring >=0.11.3.0\n , deepseq\n , exceptions\n , template-haskell\n\n ghc-options: -Wall\n\ntest-suite bytestring-tests\n default-language: Haskell2010\n ghc-options: -Wall\n type: exitcode-stdio-1.0\n main-is: Main.hs\n hs-source-dirs: tests tests/bytestring-tests\n other-modules:\n Properties.ShortByteString\n Properties.WindowsString\n Properties.PosixString\n Properties.OsString\n Properties.ShortByteString.Word16\n TestUtil\n\n build-depends:\n , base\n , bytestring >=0.11.3.0\n , os-string\n , QuickCheck >=2.7 && <2.16\n\ntest-suite encoding-tests\n default-language: Haskell2010\n ghc-options: -Wall\n type: exitcode-stdio-1.0\n main-is: Main.hs\n hs-source-dirs: tests tests/encoding\n other-modules:\n Arbitrary\n EncodingSpec\n TestUtil\n\n build-depends:\n , base\n , bytestring >=0.11.3.0\n , deepseq\n , os-string\n , QuickCheck >=2.7 && <2.16\n , quickcheck-classes-base ^>=0.6.2\n\nbenchmark bench\n main-is: Bench.hs\n other-modules: BenchOsString\n BenchPosixString\n BenchWindowsString\n type: exitcode-stdio-1.0\n hs-source-dirs: bench\n default-language: Haskell2010\n ghc-options: -O2 \"-with-rtsopts=-A32m\"\n if impl(ghc >= 8.6)\n ghc-options: -fproc-alignment=64\n build-depends: base,\n bytestring,\n os-string,\n deepseq,\n tasty-bench,\n random\n"; + } \ No newline at end of file diff --git a/materialized/ghc964/hadrian-ghc96/hadrian/cabal-files/primitive.nix b/materialized/ghc964/hadrian-ghc96/hadrian/cabal-files/primitive.nix index b5683f2c83..bbba6b670f 100644 --- a/materialized/ghc964/hadrian-ghc96/hadrian/cabal-files/primitive.nix +++ b/materialized/ghc964/hadrian-ghc96/hadrian/cabal-files/primitive.nix @@ -69,5 +69,5 @@ sha256 = "696d4bd291c94d736142d6182117dca4258d3ef28bfefdb649ac8b5ecd0999c7"; }); }) // { - package-description-override = "Cabal-Version: 2.0\nName: primitive\nVersion: 0.9.0.0\nLicense: BSD3\nLicense-File: LICENSE\n\nAuthor: Roman Leshchinskiy \nMaintainer: libraries@haskell.org\nCopyright: (c) Roman Leshchinskiy 2009-2012\nHomepage: https://github.com/haskell/primitive\nBug-Reports: https://github.com/haskell/primitive/issues\nCategory: Data\nSynopsis: Primitive memory-related operations\nBuild-Type: Simple\nDescription: This package provides various primitive memory-related operations.\n\nExtra-Source-Files: changelog.md\n test/*.hs\n test/LICENSE\n\nTested-With:\n GHC == 8.0.2\n GHC == 8.2.2\n GHC == 8.4.4\n GHC == 8.6.5\n GHC == 8.8.4\n GHC == 8.10.7\n GHC == 9.0.2\n GHC == 9.2.5\n GHC == 9.4.4\n\nLibrary\n Default-Language: Haskell2010\n Default-Extensions:\n TypeOperators\n Other-Extensions:\n BangPatterns, CPP, DeriveDataTypeable,\n MagicHash, TypeFamilies, UnboxedTuples, UnliftedFFITypes\n\n Exposed-Modules:\n Control.Monad.Primitive\n Data.Primitive\n Data.Primitive.MachDeps\n Data.Primitive.Types\n Data.Primitive.Array\n Data.Primitive.ByteArray\n Data.Primitive.PrimArray\n Data.Primitive.SmallArray\n Data.Primitive.Ptr\n Data.Primitive.MutVar\n Data.Primitive.MVar\n Data.Primitive.PrimVar\n\n Other-Modules:\n Data.Primitive.Internal.Operations\n Data.Primitive.Internal.Read\n\n Build-Depends: base >= 4.9 && < 4.20\n , deepseq >= 1.1 && < 1.6\n , transformers >= 0.5 && < 0.7\n , template-haskell >= 2.11\n\n if impl(ghc >= 9.2)\n cpp-options: -DHAVE_KEEPALIVE\n\n if impl(ghc < 9.4)\n build-depends: data-array-byte >= 0.1 && < 0.1.1\n\n Ghc-Options: -O2\n\n Include-Dirs: cbits\n Install-Includes: primitive-memops.h\n includes: primitive-memops.h\n c-sources: cbits/primitive-memops.c\n if !os(solaris)\n cc-options: -ftree-vectorize\n if arch(i386) || arch(x86_64)\n cc-options: -msse2\n\ntest-suite test-qc\n Default-Language: Haskell2010\n hs-source-dirs: test\n test/src\n main-is: Main.hs\n Other-Modules: PrimLaws\n type: exitcode-stdio-1.0\n build-depends: base\n , base-orphans\n , ghc-prim\n , primitive\n , quickcheck-classes-base >= 0.6 && <0.7\n , QuickCheck >= 2.13 && < 2.15\n , tasty ^>= 1.2 || ^>= 1.3 || ^>= 1.4\n , tasty-quickcheck\n , tagged\n , transformers >= 0.5\n , transformers-compat\n\n cpp-options: -DHAVE_UNARY_LAWS\n ghc-options: -O2\n\nbenchmark bench\n Default-Language: Haskell2010\n hs-source-dirs: bench\n main-is: main.hs\n type: exitcode-stdio-1.0\n ghc-options: -O2\n other-modules:\n Array.Traverse.Closure\n Array.Traverse.Unsafe\n ByteArray.Compare\n PrimArray.Compare\n PrimArray.Traverse\n build-depends:\n base\n , primitive\n , deepseq\n , tasty-bench\n , transformers >= 0.5\n\nsource-repository head\n type: git\n location: https://github.com/haskell/primitive\n"; + package-description-override = "Cabal-Version: 2.0\nName: primitive\nVersion: 0.9.0.0\nx-revision: 1\nLicense: BSD3\nLicense-File: LICENSE\n\nAuthor: Roman Leshchinskiy \nMaintainer: libraries@haskell.org\nCopyright: (c) Roman Leshchinskiy 2009-2012\nHomepage: https://github.com/haskell/primitive\nBug-Reports: https://github.com/haskell/primitive/issues\nCategory: Data\nSynopsis: Primitive memory-related operations\nBuild-Type: Simple\nDescription: This package provides various primitive memory-related operations.\n\nExtra-Source-Files: changelog.md\n test/*.hs\n test/LICENSE\n\nTested-With:\n GHC == 8.0.2\n GHC == 8.2.2\n GHC == 8.4.4\n GHC == 8.6.5\n GHC == 8.8.4\n GHC == 8.10.7\n GHC == 9.0.2\n GHC == 9.2.8\n GHC == 9.4.8\n GHC == 9.6.4\n GHC == 9.8.2\n\nLibrary\n Default-Language: Haskell2010\n Default-Extensions:\n TypeOperators\n Other-Extensions:\n BangPatterns, CPP, DeriveDataTypeable,\n MagicHash, TypeFamilies, UnboxedTuples, UnliftedFFITypes\n\n Exposed-Modules:\n Control.Monad.Primitive\n Data.Primitive\n Data.Primitive.MachDeps\n Data.Primitive.Types\n Data.Primitive.Array\n Data.Primitive.ByteArray\n Data.Primitive.PrimArray\n Data.Primitive.SmallArray\n Data.Primitive.Ptr\n Data.Primitive.MutVar\n Data.Primitive.MVar\n Data.Primitive.PrimVar\n\n Other-Modules:\n Data.Primitive.Internal.Operations\n Data.Primitive.Internal.Read\n\n Build-Depends: base >= 4.9 && < 4.21\n , deepseq >= 1.1 && < 1.6\n , transformers >= 0.5 && < 0.7\n , template-haskell >= 2.11\n\n if impl(ghc >= 9.2)\n cpp-options: -DHAVE_KEEPALIVE\n\n if impl(ghc < 9.4)\n build-depends: data-array-byte >= 0.1 && < 0.1.1\n\n Ghc-Options: -O2\n\n Include-Dirs: cbits\n Install-Includes: primitive-memops.h\n includes: primitive-memops.h\n c-sources: cbits/primitive-memops.c\n if !os(solaris)\n cc-options: -ftree-vectorize\n if arch(i386) || arch(x86_64)\n cc-options: -msse2\n\ntest-suite test-qc\n Default-Language: Haskell2010\n hs-source-dirs: test\n test/src\n main-is: Main.hs\n Other-Modules: PrimLaws\n type: exitcode-stdio-1.0\n build-depends: base\n , base-orphans\n , ghc-prim\n , primitive\n , quickcheck-classes-base >= 0.6 && <0.7\n , QuickCheck >= 2.13 && < 2.15\n , tasty >= 1.2 && < 1.6\n , tasty-quickcheck\n , tagged\n , transformers >= 0.5\n , transformers-compat\n\n cpp-options: -DHAVE_UNARY_LAWS\n ghc-options: -O2\n\nbenchmark bench\n Default-Language: Haskell2010\n hs-source-dirs: bench\n main-is: main.hs\n type: exitcode-stdio-1.0\n ghc-options: -O2\n other-modules:\n Array.Traverse.Closure\n Array.Traverse.Unsafe\n ByteArray.Compare\n PrimArray.Compare\n PrimArray.Traverse\n build-depends:\n base\n , primitive\n , deepseq\n , tasty-bench\n , transformers >= 0.5\n\nsource-repository head\n type: git\n location: https://github.com/haskell/primitive\n"; } \ No newline at end of file diff --git a/materialized/ghc964/hadrian-ghc96/hadrian/cabal-files/random.nix b/materialized/ghc964/hadrian-ghc96/hadrian/cabal-files/random.nix index 0dbaf8b099..2d04734f5b 100644 --- a/materialized/ghc964/hadrian-ghc96/hadrian/cabal-files/random.nix +++ b/materialized/ghc964/hadrian-ghc96/hadrian/cabal-files/random.nix @@ -11,7 +11,7 @@ flags = {}; package = { specVersion = "1.10"; - identifier = { name = "random"; version = "1.2.1.1"; }; + identifier = { name = "random"; version = "1.2.1.2"; }; license = "BSD-3-Clause"; copyright = ""; maintainer = "core-libraries-committee@haskell.org"; @@ -105,9 +105,9 @@ }; } // { src = pkgs.lib.mkDefault (pkgs.fetchurl { - url = "http://hackage.haskell.org/package/random-1.2.1.1.tar.gz"; - sha256 = "3e1272f7ed6a4d7bd1712b90143ec326fee9b225789222379fea20a9c90c9b76"; + url = "http://hackage.haskell.org/package/random-1.2.1.2.tar.gz"; + sha256 = "790f4dc2d2327c453ff6aac7bf15399fd123d55e927935f68f84b5df42d9a4b4"; }); }) // { - package-description-override = "cabal-version: >=1.10\r\nname: random\r\nversion: 1.2.1.1\r\nx-revision: 1\r\nlicense: BSD3\r\nlicense-file: LICENSE\r\nmaintainer: core-libraries-committee@haskell.org\r\nbug-reports: https://github.com/haskell/random/issues\r\nsynopsis: Pseudo-random number generation\r\ndescription:\r\n This package provides basic pseudo-random number generation, including the\r\n ability to split random number generators.\r\n .\r\n == \"System.Random\": pure pseudo-random number interface\r\n .\r\n In pure code, use 'System.Random.uniform' and 'System.Random.uniformR' from\r\n \"System.Random\" to generate pseudo-random numbers with a pure pseudo-random\r\n number generator like 'System.Random.StdGen'.\r\n .\r\n As an example, here is how you can simulate rolls of a six-sided die using\r\n 'System.Random.uniformR':\r\n .\r\n >>> let roll = uniformR (1, 6) :: RandomGen g => g -> (Word, g)\r\n >>> let rolls = unfoldr (Just . roll) :: RandomGen g => g -> [Word]\r\n >>> let pureGen = mkStdGen 42\r\n >>> take 10 (rolls pureGen) :: [Word]\r\n [1,1,3,2,4,5,3,4,6,2]\r\n .\r\n See \"System.Random\" for more details.\r\n .\r\n == \"System.Random.Stateful\": monadic pseudo-random number interface\r\n .\r\n In monadic code, use 'System.Random.Stateful.uniformM' and\r\n 'System.Random.Stateful.uniformRM' from \"System.Random.Stateful\" to generate\r\n pseudo-random numbers with a monadic pseudo-random number generator, or\r\n using a monadic adapter.\r\n .\r\n As an example, here is how you can simulate rolls of a six-sided die using\r\n 'System.Random.Stateful.uniformRM':\r\n .\r\n >>> let rollM = uniformRM (1, 6) :: StatefulGen g m => g -> m Word\r\n >>> let pureGen = mkStdGen 42\r\n >>> runStateGen_ pureGen (replicateM 10 . rollM) :: [Word]\r\n [1,1,3,2,4,5,3,4,6,2]\r\n .\r\n The monadic adapter 'System.Random.Stateful.runStateGen_' is used here to lift\r\n the pure pseudo-random number generator @pureGen@ into the\r\n 'System.Random.Stateful.StatefulGen' context.\r\n .\r\n The monadic interface can also be used with existing monadic pseudo-random\r\n number generators. In this example, we use the one provided in the\r\n package:\r\n .\r\n >>> import System.Random.MWC as MWC\r\n >>> let rollM = uniformRM (1, 6) :: StatefulGen g m => g -> m Word\r\n >>> monadicGen <- MWC.create\r\n >>> replicateM 10 (rollM monadicGen) :: IO [Word]\r\n [2,3,6,6,4,4,3,1,5,4]\r\n .\r\n See \"System.Random.Stateful\" for more details.\r\n\r\ncategory: System\r\nbuild-type: Simple\r\nextra-source-files:\r\n README.md\r\n CHANGELOG.md\r\ntested-with: GHC == 7.10.2\r\n , GHC == 7.10.3\r\n , GHC == 8.0.2\r\n , GHC == 8.2.2\r\n , GHC == 8.4.3\r\n , GHC == 8.4.4\r\n , GHC == 8.6.3\r\n , GHC == 8.6.4\r\n , GHC == 8.6.5\r\n , GHC == 8.8.1\r\n , GHC == 8.8.2\r\n , GHC == 8.10.1\r\n\r\nsource-repository head\r\n type: git\r\n location: https://github.com/haskell/random.git\r\n\r\n\r\nlibrary\r\n exposed-modules:\r\n System.Random\r\n System.Random.Internal\r\n System.Random.Stateful\r\n other-modules:\r\n System.Random.GFinite\r\n\r\n hs-source-dirs: src\r\n default-language: Haskell2010\r\n ghc-options:\r\n -Wall\r\n if impl(ghc >= 8.0)\r\n ghc-options:\r\n -Wincomplete-record-updates -Wincomplete-uni-patterns\r\n\r\n build-depends:\r\n base >=4.8 && <5,\r\n bytestring >=0.10.4 && <0.13,\r\n deepseq >=1.1 && <2,\r\n mtl >=2.2 && <2.4,\r\n splitmix >=0.1 && <0.2\r\n if impl(ghc < 8.0)\r\n build-depends:\r\n transformers\r\n\r\ntest-suite legacy-test\r\n type: exitcode-stdio-1.0\r\n main-is: Legacy.hs\r\n hs-source-dirs: test-legacy\r\n other-modules:\r\n T7936\r\n TestRandomIOs\r\n TestRandomRs\r\n Random1283\r\n RangeTest\r\n\r\n default-language: Haskell2010\r\n ghc-options: -with-rtsopts=-M8M\r\n if impl(ghc >= 8.0)\r\n ghc-options:\r\n -Wno-deprecations\r\n build-depends:\r\n base,\r\n containers >=0.5 && <0.7,\r\n random\r\n\r\ntest-suite doctests\r\n type: exitcode-stdio-1.0\r\n main-is: doctests.hs\r\n hs-source-dirs: test\r\n default-language: Haskell2010\r\n build-depends:\r\n base,\r\n doctest >=0.15 && <0.21\r\n if impl(ghc >= 8.2) && impl(ghc < 8.10)\r\n build-depends:\r\n mwc-random >=0.13 && <0.16,\r\n primitive >=0.6 && <0.8,\r\n random,\r\n stm,\r\n unliftio >=0.2 && <0.3,\r\n vector >= 0.10 && <0.14\r\n\r\ntest-suite spec\r\n type: exitcode-stdio-1.0\r\n main-is: Spec.hs\r\n hs-source-dirs: test\r\n other-modules:\r\n Spec.Range\r\n Spec.Run\r\n Spec.Stateful\r\n\r\n default-language: Haskell2010\r\n ghc-options: -Wall\r\n build-depends:\r\n base,\r\n bytestring,\r\n random,\r\n smallcheck >=1.2 && <1.3,\r\n stm,\r\n tasty >=1.0 && <1.5,\r\n tasty-smallcheck >=0.8 && <0.9,\r\n tasty-hunit >=0.10 && <0.11,\r\n transformers\r\n\r\n-- Note. Fails when compiled with coverage:\r\n-- https://github.com/haskell/random/issues/107\r\ntest-suite spec-inspection\r\n type: exitcode-stdio-1.0\r\n main-is: Spec.hs\r\n hs-source-dirs: test-inspection\r\n build-depends:\r\n\r\n default-language: Haskell2010\r\n ghc-options: -Wall\r\n build-depends:\r\n base,\r\n random,\r\n tasty >=1.0 && <1.5\r\n if impl(ghc >= 8.0)\r\n build-depends:\r\n tasty-inspection-testing\r\n other-modules:\r\n Spec.Inspection\r\n\r\nbenchmark legacy-bench\r\n type: exitcode-stdio-1.0\r\n main-is: SimpleRNGBench.hs\r\n hs-source-dirs: bench-legacy\r\n other-modules: BinSearch\r\n default-language: Haskell2010\r\n ghc-options:\r\n -Wall -O2 -threaded -rtsopts -with-rtsopts=-N\r\n if impl(ghc >= 8.0)\r\n ghc-options:\r\n -Wno-deprecations\r\n\r\n build-depends:\r\n base,\r\n random,\r\n rdtsc,\r\n split >=0.2 && <0.3,\r\n time >=1.4 && <1.13\r\n\r\nbenchmark bench\r\n type: exitcode-stdio-1.0\r\n main-is: Main.hs\r\n hs-source-dirs: bench\r\n default-language: Haskell2010\r\n ghc-options: -Wall -O2\r\n build-depends:\r\n base,\r\n mtl,\r\n primitive >= 0.7.1,\r\n random,\r\n splitmix >=0.1 && <0.2,\r\n tasty-bench\r\n"; + package-description-override = "cabal-version: >=1.10\nname: random\nversion: 1.2.1.2\nlicense: BSD3\nlicense-file: LICENSE\nmaintainer: core-libraries-committee@haskell.org\nbug-reports: https://github.com/haskell/random/issues\nsynopsis: Pseudo-random number generation\ndescription:\n This package provides basic pseudo-random number generation, including the\n ability to split random number generators.\n .\n == \"System.Random\": pure pseudo-random number interface\n .\n In pure code, use 'System.Random.uniform' and 'System.Random.uniformR' from\n \"System.Random\" to generate pseudo-random numbers with a pure pseudo-random\n number generator like 'System.Random.StdGen'.\n .\n As an example, here is how you can simulate rolls of a six-sided die using\n 'System.Random.uniformR':\n .\n >>> let roll = uniformR (1, 6) :: RandomGen g => g -> (Word, g)\n >>> let rolls = unfoldr (Just . roll) :: RandomGen g => g -> [Word]\n >>> let pureGen = mkStdGen 42\n >>> take 10 (rolls pureGen) :: [Word]\n [1,1,3,2,4,5,3,4,6,2]\n .\n See \"System.Random\" for more details.\n .\n == \"System.Random.Stateful\": monadic pseudo-random number interface\n .\n In monadic code, use 'System.Random.Stateful.uniformM' and\n 'System.Random.Stateful.uniformRM' from \"System.Random.Stateful\" to generate\n pseudo-random numbers with a monadic pseudo-random number generator, or\n using a monadic adapter.\n .\n As an example, here is how you can simulate rolls of a six-sided die using\n 'System.Random.Stateful.uniformRM':\n .\n >>> let rollM = uniformRM (1, 6) :: StatefulGen g m => g -> m Word\n >>> let pureGen = mkStdGen 42\n >>> runStateGen_ pureGen (replicateM 10 . rollM) :: [Word]\n [1,1,3,2,4,5,3,4,6,2]\n .\n The monadic adapter 'System.Random.Stateful.runStateGen_' is used here to lift\n the pure pseudo-random number generator @pureGen@ into the\n 'System.Random.Stateful.StatefulGen' context.\n .\n The monadic interface can also be used with existing monadic pseudo-random\n number generators. In this example, we use the one provided in the\n package:\n .\n >>> import System.Random.MWC as MWC\n >>> let rollM = uniformRM (1, 6) :: StatefulGen g m => g -> m Word\n >>> monadicGen <- MWC.create\n >>> replicateM 10 (rollM monadicGen) :: IO [Word]\n [2,3,6,6,4,4,3,1,5,4]\n .\n See \"System.Random.Stateful\" for more details.\n\ncategory: System\nbuild-type: Simple\nextra-source-files:\n README.md\n CHANGELOG.md\ntested-with: GHC == 8.0.2\n , GHC == 8.2.2\n , GHC == 8.4.3\n , GHC == 8.4.4\n , GHC == 8.6.3\n , GHC == 8.6.4\n , GHC == 8.6.5\n , GHC == 8.8.1\n , GHC == 8.8.2\n , GHC == 8.10.1\n\nsource-repository head\n type: git\n location: https://github.com/haskell/random.git\n\n\nlibrary\n exposed-modules:\n System.Random\n System.Random.Internal\n System.Random.Stateful\n other-modules:\n System.Random.GFinite\n\n hs-source-dirs: src\n default-language: Haskell2010\n ghc-options:\n -Wall\n if impl(ghc >= 8.0)\n ghc-options:\n -Wincomplete-record-updates -Wincomplete-uni-patterns\n\n build-depends:\n base >=4.8 && <5,\n bytestring >=0.10.4 && <0.13,\n deepseq >=1.1 && <2,\n mtl >=2.2 && <2.4,\n splitmix >=0.1 && <0.2\n if impl(ghc < 8.0)\n build-depends:\n transformers\n\ntest-suite legacy-test\n type: exitcode-stdio-1.0\n main-is: Legacy.hs\n hs-source-dirs: test-legacy\n other-modules:\n T7936\n TestRandomIOs\n TestRandomRs\n Random1283\n RangeTest\n\n default-language: Haskell2010\n ghc-options: -rtsopts -with-rtsopts=-M9M\n if impl(ghc >= 8.0)\n ghc-options:\n -Wno-deprecations\n build-depends:\n base,\n containers >=0.5 && <0.7,\n random\n\ntest-suite doctests\n type: exitcode-stdio-1.0\n main-is: doctests.hs\n hs-source-dirs: test\n default-language: Haskell2010\n build-depends:\n base,\n doctest >=0.15 && <0.23\n if impl(ghc >= 8.2) && impl(ghc < 8.10)\n build-depends:\n mwc-random >=0.13 && <0.16,\n primitive >=0.6 && <0.8,\n random,\n stm,\n unliftio >=0.2 && <0.3,\n vector >= 0.10 && <0.14\n\ntest-suite spec\n type: exitcode-stdio-1.0\n main-is: Spec.hs\n hs-source-dirs: test\n other-modules:\n Spec.Range\n Spec.Run\n Spec.Stateful\n\n default-language: Haskell2010\n ghc-options: -Wall\n build-depends:\n base,\n bytestring,\n random,\n smallcheck >=1.2 && <1.3,\n stm,\n tasty >=1.0 && <1.6,\n tasty-smallcheck >=0.8 && <0.9,\n tasty-hunit >=0.10 && <0.11,\n transformers\n\n-- Note. Fails when compiled with coverage:\n-- https://github.com/haskell/random/issues/107\ntest-suite spec-inspection\n type: exitcode-stdio-1.0\n main-is: Spec.hs\n hs-source-dirs: test-inspection\n default-language: Haskell2010\n ghc-options: -Wall\n build-depends:\n base,\n random,\n tasty >=1.0 && <1.6\n if impl(ghc >= 8.0)\n build-depends:\n tasty-inspection-testing\n other-modules:\n Spec.Inspection\n\nbenchmark legacy-bench\n type: exitcode-stdio-1.0\n main-is: SimpleRNGBench.hs\n hs-source-dirs: bench-legacy\n other-modules: BinSearch\n default-language: Haskell2010\n ghc-options:\n -Wall -O2 -threaded -rtsopts -with-rtsopts=-N\n if impl(ghc >= 8.0)\n ghc-options:\n -Wno-deprecations\n\n build-depends:\n base,\n random,\n rdtsc,\n split >=0.2 && <0.3,\n time >=1.4 && <1.13\n\nbenchmark bench\n type: exitcode-stdio-1.0\n main-is: Main.hs\n hs-source-dirs: bench\n default-language: Haskell2010\n ghc-options: -Wall -O2\n build-depends:\n base,\n mtl,\n primitive >= 0.7.1,\n random,\n splitmix >=0.1 && <0.2,\n tasty-bench\n"; } \ No newline at end of file diff --git a/materialized/ghc964/hadrian-ghc96/hadrian/cabal-files/shake.nix b/materialized/ghc964/hadrian-ghc96/hadrian/cabal-files/shake.nix index d40c2a8bbc..d643f68037 100644 --- a/materialized/ghc964/hadrian-ghc96/hadrian/cabal-files/shake.nix +++ b/materialized/ghc964/hadrian-ghc96/hadrian/cabal-files/shake.nix @@ -8,12 +8,17 @@ , config , ... }: ({ - flags = { portable = false; cloud = false; embed-files = false; }; + flags = { + portable = false; + cloud = false; + embed-files = false; + threaded = true; + }; package = { specVersion = "1.18"; - identifier = { name = "shake"; version = "0.19.7"; }; + identifier = { name = "shake"; version = "0.19.8"; }; license = "BSD-3-Clause"; - copyright = "Neil Mitchell 2011-2022"; + copyright = "Neil Mitchell 2011-2024"; maintainer = "Neil Mitchell "; author = "Neil Mitchell "; homepage = "https://shakebuild.com"; @@ -124,9 +129,9 @@ }; } // { src = pkgs.lib.mkDefault (pkgs.fetchurl { - url = "http://hackage.haskell.org/package/shake-0.19.7.tar.gz"; - sha256 = "352a56af12f70b50d564dcb61131555577281957ee196f1702a3723c0a3699d1"; + url = "http://hackage.haskell.org/package/shake-0.19.8.tar.gz"; + sha256 = "6384e33a26a2590bf33719e88881076b899ac4b5340c1c9271e4caa37e9d6535"; }); }) // { - package-description-override = "cabal-version: 1.18\nbuild-type: Simple\nname: shake\nversion: 0.19.7\nx-revision: 1\nlicense: BSD3\nlicense-file: LICENSE\ncategory: Development, Shake\nauthor: Neil Mitchell \nmaintainer: Neil Mitchell \ncopyright: Neil Mitchell 2011-2022\nsynopsis: Build system library, like Make, but more accurate dependencies.\ndescription:\n Shake is a Haskell library for writing build systems - designed as a\n replacement for @make@. See \"Development.Shake\" for an introduction,\n including an example. The homepage contains links to a user\n manual, an academic paper and further information:\n \n .\n To use Shake the user writes a Haskell program\n that imports \"Development.Shake\", defines some build rules, and calls\n the 'Development.Shake.shakeArgs' function. Thanks to do notation and infix\n operators, a simple Shake build system\n is not too dissimilar from a simple Makefile. However, as build systems\n get more complex, Shake is able to take advantage of the excellent\n abstraction facilities offered by Haskell and easily support much larger\n projects. The Shake library provides all the standard features available in other\n build systems, including automatic parallelism and minimal rebuilds.\n Shake also provides more accurate dependency tracking, including seamless\n support for generated files, and dependencies on system information\n (e.g. compiler version).\nhomepage: https://shakebuild.com\nbug-reports: https://github.com/ndmitchell/shake/issues\ntested-with: GHC==9.0, GHC==8.10, GHC==8.8, GHC==8.6\nextra-doc-files:\n CHANGES.txt\n README.md\n docs/Manual.md\n docs/shake-progress.png\nextra-source-files:\n src/Paths.hs\n src/Test/C/constants.c\n src/Test/C/constants.h\n src/Test/C/main.c\n src/Test/Ninja/*.ninja\n src/Test/Ninja/*.output\n src/Test/Ninja/subdir/*.ninja\n src/Test/Progress/*.prog\n src/Test/Tar/list.txt\n src/Test/Tup/hello.c\n src/Test/Tup/newmath/root.cfg\n src/Test/Tup/newmath/square.c\n src/Test/Tup/newmath/square.h\n src/Test/Tup/root.cfg\ndata-files:\n docs/manual/build.bat\n docs/manual/Shakefile.hs\n docs/manual/build.sh\n docs/manual/constants.c\n docs/manual/constants.h\n docs/manual/main.c\n html/profile.html\n html/progress.html\n html/shake.js\n\nsource-repository head\n type: git\n location: https://github.com/ndmitchell/shake.git\n\nflag portable\n default: False\n manual: True\n description: Obtain FileTime using portable functions\n\nflag cloud\n default: False\n manual: True\n description: Enable cloud build features\n\nflag embed-files\n default: False\n manual: True\n description: Embed data files into the shake library\n\nlibrary\n default-language: Haskell2010\n hs-source-dirs: src\n build-depends:\n base >= 4.9,\n binary,\n bytestring,\n deepseq >= 1.1,\n directory >= 1.2.7.0,\n extra >= 1.6.19,\n filepath >= 1.4,\n filepattern,\n hashable >= 1.1.2.3,\n heaps >= 0.3.6.1,\n js-dgtable,\n js-flot,\n js-jquery,\n primitive,\n process >= 1.1,\n random,\n time,\n transformers >= 0.2,\n unordered-containers >= 0.2.7,\n utf8-string >= 0.3\n\n if flag(embed-files)\n cpp-options: -DFILE_EMBED\n build-depends:\n file-embed >= 0.0.11,\n template-haskell\n\n if flag(portable)\n cpp-options: -DPORTABLE\n else\n if !os(windows)\n build-depends: unix >= 2.5.1\n if !os(windows)\n build-depends: unix\n\n if flag(cloud)\n cpp-options: -DNETWORK\n build-depends: network, network-uri\n\n exposed-modules:\n Development.Shake\n Development.Shake.Classes\n Development.Shake.Command\n Development.Shake.Config\n Development.Shake.Database\n Development.Shake.FilePath\n Development.Shake.Forward\n Development.Shake.Rule\n Development.Shake.Util\n\n other-modules:\n Development.Ninja.Env\n Development.Ninja.Lexer\n Development.Ninja.Parse\n Development.Ninja.Type\n Development.Shake.Internal.Args\n Development.Shake.Internal.CmdOption\n Development.Shake.Internal.CompactUI\n Development.Shake.Internal.Core.Action\n Development.Shake.Internal.Core.Build\n Development.Shake.Internal.Core.Database\n Development.Shake.Internal.History.Shared\n Development.Shake.Internal.History.Symlink\n Development.Shake.Internal.History.Bloom\n Development.Shake.Internal.History.Cloud\n Development.Shake.Internal.History.Network\n Development.Shake.Internal.History.Server\n Development.Shake.Internal.History.Serialise\n Development.Shake.Internal.History.Types\n Development.Shake.Internal.Core.Monad\n Development.Shake.Internal.Core.Pool\n Development.Shake.Internal.Core.Rules\n Development.Shake.Internal.Core.Run\n Development.Shake.Internal.Core.Storage\n Development.Shake.Internal.Core.Types\n Development.Shake.Internal.Demo\n Development.Shake.Internal.Derived\n Development.Shake.Internal.Errors\n Development.Shake.Internal.FileInfo\n Development.Shake.Internal.FileName\n Development.Shake.Internal.FilePattern\n Development.Shake.Internal.Options\n Development.Shake.Internal.Paths\n Development.Shake.Internal.Profile\n Development.Shake.Internal.Progress\n Development.Shake.Internal.Resource\n Development.Shake.Internal.Rules.Default\n Development.Shake.Internal.Rules.Directory\n Development.Shake.Internal.Rules.File\n Development.Shake.Internal.Rules.Files\n Development.Shake.Internal.Rules.Oracle\n Development.Shake.Internal.Rules.OrderOnly\n Development.Shake.Internal.Rules.Rerun\n Development.Shake.Internal.Value\n General.Bilist\n General.Binary\n General.Chunks\n General.Cleanup\n General.Fence\n General.EscCodes\n General.Extra\n General.FileLock\n General.GetOpt\n General.Ids\n General.Intern\n General.ListBuilder\n General.Makefile\n General.Pool\n General.Process\n General.Template\n General.Thread\n General.Timing\n General.TypeMap\n General.Wait\n Paths_shake\n\n\nexecutable shake\n default-language: Haskell2010\n hs-source-dirs: src\n ghc-options: -main-is Run.main -rtsopts -threaded \"-with-rtsopts=-I0 -qg\"\n main-is: Run.hs\n build-depends:\n base == 4.*,\n binary,\n bytestring,\n deepseq >= 1.1,\n directory,\n extra >= 1.6.19,\n filepath,\n filepattern,\n hashable >= 1.1.2.3,\n heaps >= 0.3.6.1,\n js-dgtable,\n js-flot,\n js-jquery,\n primitive,\n process >= 1.1,\n random,\n time,\n transformers >= 0.2,\n unordered-containers >= 0.2.7,\n utf8-string >= 0.3\n\n if flag(embed-files)\n cpp-options: -DFILE_EMBED\n build-depends:\n file-embed >= 0.0.11,\n template-haskell\n\n if flag(portable)\n cpp-options: -DPORTABLE\n else\n if !os(windows)\n build-depends: unix >= 2.5.1\n if !os(windows)\n build-depends: unix\n\n if flag(cloud)\n cpp-options: -DNETWORK\n build-depends: network, network-uri\n\n if impl(ghc < 8.0)\n build-depends: semigroups >= 0.18\n\n other-modules:\n Development.Ninja.All\n Development.Ninja.Env\n Development.Ninja.Lexer\n Development.Ninja.Parse\n Development.Ninja.Type\n Development.Shake\n Development.Shake.Classes\n Development.Shake.Command\n Development.Shake.Database\n Development.Shake.FilePath\n Development.Shake.Internal.Args\n Development.Shake.Internal.CmdOption\n Development.Shake.Internal.CompactUI\n Development.Shake.Internal.Core.Action\n Development.Shake.Internal.Core.Build\n Development.Shake.Internal.Core.Database\n Development.Shake.Internal.History.Shared\n Development.Shake.Internal.History.Symlink\n Development.Shake.Internal.History.Bloom\n Development.Shake.Internal.History.Cloud\n Development.Shake.Internal.History.Network\n Development.Shake.Internal.History.Server\n Development.Shake.Internal.History.Serialise\n Development.Shake.Internal.History.Types\n Development.Shake.Internal.Core.Monad\n Development.Shake.Internal.Core.Pool\n Development.Shake.Internal.Core.Rules\n Development.Shake.Internal.Core.Run\n Development.Shake.Internal.Core.Storage\n Development.Shake.Internal.Core.Types\n Development.Shake.Internal.Demo\n Development.Shake.Internal.Derived\n Development.Shake.Internal.Errors\n Development.Shake.Internal.FileInfo\n Development.Shake.Internal.FileName\n Development.Shake.Internal.FilePattern\n Development.Shake.Internal.Options\n Development.Shake.Internal.Paths\n Development.Shake.Internal.Profile\n Development.Shake.Internal.Progress\n Development.Shake.Internal.Resource\n Development.Shake.Internal.Rules.Default\n Development.Shake.Internal.Rules.Directory\n Development.Shake.Internal.Rules.File\n Development.Shake.Internal.Rules.Files\n Development.Shake.Internal.Rules.Oracle\n Development.Shake.Internal.Rules.OrderOnly\n Development.Shake.Internal.Rules.Rerun\n Development.Shake.Internal.Value\n General.Bilist\n General.Binary\n General.Chunks\n General.Cleanup\n General.Fence\n General.EscCodes\n General.Extra\n General.FileLock\n General.GetOpt\n General.Ids\n General.Intern\n General.ListBuilder\n General.Makefile\n General.Pool\n General.Process\n General.Template\n General.Thread\n General.Timing\n General.TypeMap\n General.Wait\n Paths_shake\n\n\ntest-suite shake-test\n default-language: Haskell2010\n type: exitcode-stdio-1.0\n main-is: Test.hs\n hs-source-dirs: src\n ghc-options: -main-is Test.main -rtsopts -with-rtsopts=-K1K -threaded\n\n build-depends:\n base == 4.*,\n binary,\n bytestring,\n deepseq >= 1.1,\n directory,\n extra >= 1.6.19,\n filepath,\n filepattern,\n hashable >= 1.1.2.3,\n heaps >= 0.3.6.1,\n js-dgtable,\n js-flot,\n js-jquery,\n primitive,\n process >= 1.1,\n QuickCheck >= 2.0,\n random,\n time,\n transformers >= 0.2,\n unordered-containers >= 0.2.7,\n utf8-string >= 0.3\n\n if flag(embed-files)\n cpp-options: -DFILE_EMBED\n build-depends:\n file-embed >= 0.0.11,\n template-haskell\n\n if flag(portable)\n cpp-options: -DPORTABLE\n else\n if !os(windows)\n build-depends: unix >= 2.5.1\n if !os(windows)\n build-depends: unix\n\n if flag(cloud)\n cpp-options: -DNETWORK\n build-depends: network, network-uri\n\n if impl(ghc < 8.0)\n build-depends: semigroups >= 0.18\n\n other-modules:\n Development.Ninja.All\n Development.Ninja.Env\n Development.Ninja.Lexer\n Development.Ninja.Parse\n Development.Ninja.Type\n Development.Shake\n Development.Shake.Classes\n Development.Shake.Command\n Development.Shake.Config\n Development.Shake.Database\n Development.Shake.FilePath\n Development.Shake.Forward\n Development.Shake.Internal.Args\n Development.Shake.Internal.CmdOption\n Development.Shake.Internal.CompactUI\n Development.Shake.Internal.Core.Action\n Development.Shake.Internal.Core.Build\n Development.Shake.Internal.Core.Database\n Development.Shake.Internal.History.Shared\n Development.Shake.Internal.History.Symlink\n Development.Shake.Internal.History.Bloom\n Development.Shake.Internal.History.Cloud\n Development.Shake.Internal.History.Network\n Development.Shake.Internal.History.Server\n Development.Shake.Internal.History.Serialise\n Development.Shake.Internal.History.Types\n Development.Shake.Internal.Core.Monad\n Development.Shake.Internal.Core.Pool\n Development.Shake.Internal.Core.Rules\n Development.Shake.Internal.Core.Run\n Development.Shake.Internal.Core.Storage\n Development.Shake.Internal.Core.Types\n Development.Shake.Internal.Demo\n Development.Shake.Internal.Derived\n Development.Shake.Internal.Errors\n Development.Shake.Internal.FileInfo\n Development.Shake.Internal.FileName\n Development.Shake.Internal.FilePattern\n Development.Shake.Internal.Options\n Development.Shake.Internal.Paths\n Development.Shake.Internal.Profile\n Development.Shake.Internal.Progress\n Development.Shake.Internal.Resource\n Development.Shake.Internal.Rules.Default\n Development.Shake.Internal.Rules.Directory\n Development.Shake.Internal.Rules.File\n Development.Shake.Internal.Rules.Files\n Development.Shake.Internal.Rules.Oracle\n Development.Shake.Internal.Rules.OrderOnly\n Development.Shake.Internal.Rules.Rerun\n Development.Shake.Internal.Value\n Development.Shake.Rule\n Development.Shake.Util\n General.Bilist\n General.Binary\n General.Chunks\n General.Cleanup\n General.Fence\n General.EscCodes\n General.Extra\n General.FileLock\n General.GetOpt\n General.Ids\n General.Intern\n General.ListBuilder\n General.Makefile\n General.Pool\n General.Process\n General.Template\n General.Thread\n General.Timing\n General.TypeMap\n General.Wait\n Paths_shake\n Run\n Test.Basic\n Test.Batch\n Test.Benchmark\n Test.Builtin\n Test.BuiltinOverride\n Test.C\n Test.Cache\n Test.Cleanup\n Test.CloseFileHandles\n Test.Command\n Test.Config\n Test.Database\n Test.Digest\n Test.Directory\n Test.Docs\n Test.Errors\n Test.Existence\n Test.FileLock\n Test.FilePath\n Test.FilePattern\n Test.Files\n Test.Forward\n Test.History\n Test.Journal\n Test.Lint\n Test.Live\n Test.Manual\n Test.Match\n Test.Monad\n Test.Ninja\n Test.Oracle\n Test.OrderOnly\n Test.Parallel\n Test.Pool\n Test.Progress\n Test.Random\n Test.Rebuild\n Test.Reschedule\n Test.Resources\n Test.Self\n Test.SelfMake\n Test.Tar\n Test.Targets\n Test.Thread\n Test.Tup\n Test.Type\n Test.Unicode\n Test.Util\n Test.Verbosity\n Test.Version\n"; + package-description-override = "cabal-version: 1.18\nbuild-type: Simple\nname: shake\nversion: 0.19.8\nlicense: BSD3\nlicense-file: LICENSE\ncategory: Development, Shake\nauthor: Neil Mitchell \nmaintainer: Neil Mitchell \ncopyright: Neil Mitchell 2011-2024\nsynopsis: Build system library, like Make, but more accurate dependencies.\ndescription:\n Shake is a Haskell library for writing build systems - designed as a\n replacement for @make@. See \"Development.Shake\" for an introduction,\n including an example. The homepage contains links to a user\n manual, an academic paper and further information:\n \n .\n To use Shake the user writes a Haskell program\n that imports \"Development.Shake\", defines some build rules, and calls\n the 'Development.Shake.shakeArgs' function. Thanks to do notation and infix\n operators, a simple Shake build system\n is not too dissimilar from a simple Makefile. However, as build systems\n get more complex, Shake is able to take advantage of the excellent\n abstraction facilities offered by Haskell and easily support much larger\n projects. The Shake library provides all the standard features available in other\n build systems, including automatic parallelism and minimal rebuilds.\n Shake also provides more accurate dependency tracking, including seamless\n support for generated files, and dependencies on system information\n (e.g. compiler version).\nhomepage: https://shakebuild.com\nbug-reports: https://github.com/ndmitchell/shake/issues\ntested-with: GHC==9.8, GHC==9.6, GHC==9.4, GHC==9.2, GHC==9.0, GHC==8.10, GHC==8.8\nextra-doc-files:\n CHANGES.txt\n README.md\n docs/Manual.md\n docs/shake-progress.png\nextra-source-files:\n src/Paths.hs\n src/Test/C/constants.c\n src/Test/C/constants.h\n src/Test/C/main.c\n src/Test/Ninja/*.ninja\n src/Test/Ninja/*.output\n src/Test/Ninja/subdir/*.ninja\n src/Test/Progress/*.prog\n src/Test/Tar/list.txt\n src/Test/Tup/hello.c\n src/Test/Tup/newmath/root.cfg\n src/Test/Tup/newmath/square.c\n src/Test/Tup/newmath/square.h\n src/Test/Tup/root.cfg\ndata-files:\n docs/manual/build.bat\n docs/manual/Shakefile.hs\n docs/manual/build.sh\n docs/manual/constants.c\n docs/manual/constants.h\n docs/manual/main.c\n html/profile.html\n html/progress.html\n html/shake.js\n\nsource-repository head\n type: git\n location: https://github.com/ndmitchell/shake.git\n\nflag portable\n default: False\n manual: True\n description: Obtain FileTime using portable functions\n\nflag cloud\n default: False\n manual: True\n description: Enable cloud build features\n\nflag embed-files\n default: False\n manual: True\n description: Embed data files into the shake library\n\nflag threaded\n default: True\n manual: True\n description: Build shake with the threaded RTS\n\nlibrary\n default-language: Haskell2010\n hs-source-dirs: src\n build-depends:\n base >= 4.9,\n binary,\n bytestring,\n deepseq >= 1.1,\n directory >= 1.2.7.0,\n extra >= 1.6.19,\n filepath >= 1.4,\n filepattern,\n hashable >= 1.1.2.3,\n heaps >= 0.3.6.1,\n js-dgtable,\n js-flot,\n js-jquery,\n primitive,\n process >= 1.1,\n random,\n time,\n transformers >= 0.2,\n unordered-containers >= 0.2.7,\n utf8-string >= 0.3\n\n if flag(embed-files)\n cpp-options: -DFILE_EMBED\n build-depends:\n file-embed >= 0.0.11,\n template-haskell\n\n if flag(portable)\n cpp-options: -DPORTABLE\n else\n if !os(windows)\n build-depends: unix >= 2.5.1\n if !os(windows)\n build-depends: unix\n\n if flag(cloud)\n cpp-options: -DNETWORK\n build-depends: network, network-uri\n\n exposed-modules:\n Development.Shake\n Development.Shake.Classes\n Development.Shake.Command\n Development.Shake.Config\n Development.Shake.Database\n Development.Shake.FilePath\n Development.Shake.Forward\n Development.Shake.Rule\n Development.Shake.Util\n\n other-modules:\n Development.Ninja.Env\n Development.Ninja.Lexer\n Development.Ninja.Parse\n Development.Ninja.Type\n Development.Shake.Internal.Args\n Development.Shake.Internal.CmdOption\n Development.Shake.Internal.CompactUI\n Development.Shake.Internal.Core.Action\n Development.Shake.Internal.Core.Build\n Development.Shake.Internal.Core.Database\n Development.Shake.Internal.History.Shared\n Development.Shake.Internal.History.Symlink\n Development.Shake.Internal.History.Bloom\n Development.Shake.Internal.History.Cloud\n Development.Shake.Internal.History.Network\n Development.Shake.Internal.History.Server\n Development.Shake.Internal.History.Serialise\n Development.Shake.Internal.History.Types\n Development.Shake.Internal.Core.Monad\n Development.Shake.Internal.Core.Pool\n Development.Shake.Internal.Core.Rules\n Development.Shake.Internal.Core.Run\n Development.Shake.Internal.Core.Storage\n Development.Shake.Internal.Core.Types\n Development.Shake.Internal.Demo\n Development.Shake.Internal.Derived\n Development.Shake.Internal.Errors\n Development.Shake.Internal.FileInfo\n Development.Shake.Internal.FileName\n Development.Shake.Internal.FilePattern\n Development.Shake.Internal.Options\n Development.Shake.Internal.Paths\n Development.Shake.Internal.Profile\n Development.Shake.Internal.Progress\n Development.Shake.Internal.Resource\n Development.Shake.Internal.Rules.Default\n Development.Shake.Internal.Rules.Directory\n Development.Shake.Internal.Rules.File\n Development.Shake.Internal.Rules.Files\n Development.Shake.Internal.Rules.Oracle\n Development.Shake.Internal.Rules.OrderOnly\n Development.Shake.Internal.Rules.Rerun\n Development.Shake.Internal.Value\n General.Bilist\n General.Binary\n General.Chunks\n General.Cleanup\n General.Fence\n General.EscCodes\n General.Extra\n General.FileLock\n General.GetOpt\n General.Ids\n General.Intern\n General.ListBuilder\n General.Makefile\n General.Pool\n General.Process\n General.Template\n General.Thread\n General.Timing\n General.TypeMap\n General.Wait\n Paths_shake\n\n\nexecutable shake\n default-language: Haskell2010\n hs-source-dirs: src\n ghc-options: -main-is Run.main -rtsopts\n if flag(threaded)\n ghc-options: -threaded \"-with-rtsopts=-I0 -qg\"\n main-is: Run.hs\n build-depends:\n base == 4.*,\n binary,\n bytestring,\n deepseq >= 1.1,\n directory,\n extra >= 1.6.19,\n filepath,\n filepattern,\n hashable >= 1.1.2.3,\n heaps >= 0.3.6.1,\n js-dgtable,\n js-flot,\n js-jquery,\n primitive,\n process >= 1.1,\n random,\n time,\n transformers >= 0.2,\n unordered-containers >= 0.2.7,\n utf8-string >= 0.3\n\n if flag(embed-files)\n cpp-options: -DFILE_EMBED\n build-depends:\n file-embed >= 0.0.11,\n template-haskell\n\n if flag(portable)\n cpp-options: -DPORTABLE\n else\n if !os(windows)\n build-depends: unix >= 2.5.1\n if !os(windows)\n build-depends: unix\n\n if flag(cloud)\n cpp-options: -DNETWORK\n build-depends: network, network-uri\n\n if impl(ghc < 8.0)\n build-depends: semigroups >= 0.18\n\n other-modules:\n Development.Ninja.All\n Development.Ninja.Env\n Development.Ninja.Lexer\n Development.Ninja.Parse\n Development.Ninja.Type\n Development.Shake\n Development.Shake.Classes\n Development.Shake.Command\n Development.Shake.Database\n Development.Shake.FilePath\n Development.Shake.Internal.Args\n Development.Shake.Internal.CmdOption\n Development.Shake.Internal.CompactUI\n Development.Shake.Internal.Core.Action\n Development.Shake.Internal.Core.Build\n Development.Shake.Internal.Core.Database\n Development.Shake.Internal.History.Shared\n Development.Shake.Internal.History.Symlink\n Development.Shake.Internal.History.Bloom\n Development.Shake.Internal.History.Cloud\n Development.Shake.Internal.History.Network\n Development.Shake.Internal.History.Server\n Development.Shake.Internal.History.Serialise\n Development.Shake.Internal.History.Types\n Development.Shake.Internal.Core.Monad\n Development.Shake.Internal.Core.Pool\n Development.Shake.Internal.Core.Rules\n Development.Shake.Internal.Core.Run\n Development.Shake.Internal.Core.Storage\n Development.Shake.Internal.Core.Types\n Development.Shake.Internal.Demo\n Development.Shake.Internal.Derived\n Development.Shake.Internal.Errors\n Development.Shake.Internal.FileInfo\n Development.Shake.Internal.FileName\n Development.Shake.Internal.FilePattern\n Development.Shake.Internal.Options\n Development.Shake.Internal.Paths\n Development.Shake.Internal.Profile\n Development.Shake.Internal.Progress\n Development.Shake.Internal.Resource\n Development.Shake.Internal.Rules.Default\n Development.Shake.Internal.Rules.Directory\n Development.Shake.Internal.Rules.File\n Development.Shake.Internal.Rules.Files\n Development.Shake.Internal.Rules.Oracle\n Development.Shake.Internal.Rules.OrderOnly\n Development.Shake.Internal.Rules.Rerun\n Development.Shake.Internal.Value\n General.Bilist\n General.Binary\n General.Chunks\n General.Cleanup\n General.Fence\n General.EscCodes\n General.Extra\n General.FileLock\n General.GetOpt\n General.Ids\n General.Intern\n General.ListBuilder\n General.Makefile\n General.Pool\n General.Process\n General.Template\n General.Thread\n General.Timing\n General.TypeMap\n General.Wait\n Paths_shake\n\n\ntest-suite shake-test\n default-language: Haskell2010\n type: exitcode-stdio-1.0\n main-is: Test.hs\n hs-source-dirs: src\n ghc-options: -main-is Test.main -rtsopts -with-rtsopts=-K1K\n if flag(threaded)\n ghc-options: -threaded\n\n build-depends:\n base == 4.*,\n binary,\n bytestring,\n deepseq >= 1.1,\n directory,\n extra >= 1.6.19,\n filepath,\n filepattern,\n hashable >= 1.1.2.3,\n heaps >= 0.3.6.1,\n js-dgtable,\n js-flot,\n js-jquery,\n primitive,\n process >= 1.1,\n QuickCheck >= 2.0,\n random,\n time,\n transformers >= 0.2,\n unordered-containers >= 0.2.7,\n utf8-string >= 0.3\n\n if flag(embed-files)\n cpp-options: -DFILE_EMBED\n build-depends:\n file-embed >= 0.0.11,\n template-haskell\n\n if flag(portable)\n cpp-options: -DPORTABLE\n else\n if !os(windows)\n build-depends: unix >= 2.5.1\n if !os(windows)\n build-depends: unix\n\n if flag(cloud)\n cpp-options: -DNETWORK\n build-depends: network, network-uri\n\n if impl(ghc < 8.0)\n build-depends: semigroups >= 0.18\n\n other-modules:\n Development.Ninja.All\n Development.Ninja.Env\n Development.Ninja.Lexer\n Development.Ninja.Parse\n Development.Ninja.Type\n Development.Shake\n Development.Shake.Classes\n Development.Shake.Command\n Development.Shake.Config\n Development.Shake.Database\n Development.Shake.FilePath\n Development.Shake.Forward\n Development.Shake.Internal.Args\n Development.Shake.Internal.CmdOption\n Development.Shake.Internal.CompactUI\n Development.Shake.Internal.Core.Action\n Development.Shake.Internal.Core.Build\n Development.Shake.Internal.Core.Database\n Development.Shake.Internal.History.Shared\n Development.Shake.Internal.History.Symlink\n Development.Shake.Internal.History.Bloom\n Development.Shake.Internal.History.Cloud\n Development.Shake.Internal.History.Network\n Development.Shake.Internal.History.Server\n Development.Shake.Internal.History.Serialise\n Development.Shake.Internal.History.Types\n Development.Shake.Internal.Core.Monad\n Development.Shake.Internal.Core.Pool\n Development.Shake.Internal.Core.Rules\n Development.Shake.Internal.Core.Run\n Development.Shake.Internal.Core.Storage\n Development.Shake.Internal.Core.Types\n Development.Shake.Internal.Demo\n Development.Shake.Internal.Derived\n Development.Shake.Internal.Errors\n Development.Shake.Internal.FileInfo\n Development.Shake.Internal.FileName\n Development.Shake.Internal.FilePattern\n Development.Shake.Internal.Options\n Development.Shake.Internal.Paths\n Development.Shake.Internal.Profile\n Development.Shake.Internal.Progress\n Development.Shake.Internal.Resource\n Development.Shake.Internal.Rules.Default\n Development.Shake.Internal.Rules.Directory\n Development.Shake.Internal.Rules.File\n Development.Shake.Internal.Rules.Files\n Development.Shake.Internal.Rules.Oracle\n Development.Shake.Internal.Rules.OrderOnly\n Development.Shake.Internal.Rules.Rerun\n Development.Shake.Internal.Value\n Development.Shake.Rule\n Development.Shake.Util\n General.Bilist\n General.Binary\n General.Chunks\n General.Cleanup\n General.Fence\n General.EscCodes\n General.Extra\n General.FileLock\n General.GetOpt\n General.Ids\n General.Intern\n General.ListBuilder\n General.Makefile\n General.Pool\n General.Process\n General.Template\n General.Thread\n General.Timing\n General.TypeMap\n General.Wait\n Paths_shake\n Run\n Test.Basic\n Test.Batch\n Test.Benchmark\n Test.Builtin\n Test.BuiltinOverride\n Test.C\n Test.Cache\n Test.Cleanup\n Test.CloseFileHandles\n Test.Command\n Test.Config\n Test.Database\n Test.Digest\n Test.Directory\n Test.Docs\n Test.Errors\n Test.Existence\n Test.FileLock\n Test.FilePath\n Test.FilePattern\n Test.Files\n Test.Forward\n Test.History\n Test.Journal\n Test.Lint\n Test.Live\n Test.Manual\n Test.Match\n Test.Monad\n Test.Ninja\n Test.Oracle\n Test.OrderOnly\n Test.Parallel\n Test.Pool\n Test.Progress\n Test.Random\n Test.Rebuild\n Test.Reschedule\n Test.Resources\n Test.Self\n Test.SelfMake\n Test.Tar\n Test.Targets\n Test.Thread\n Test.Tup\n Test.Type\n Test.Unicode\n Test.Util\n Test.Verbosity\n Test.Version\n"; } \ No newline at end of file diff --git a/materialized/ghc964/hadrian-ghc96/hadrian/cabal-files/splitmix.nix b/materialized/ghc964/hadrian-ghc96/hadrian/cabal-files/splitmix.nix index aa0dd88d31..633d8e112a 100644 --- a/materialized/ghc964/hadrian-ghc96/hadrian/cabal-files/splitmix.nix +++ b/materialized/ghc964/hadrian-ghc96/hadrian/cabal-files/splitmix.nix @@ -135,5 +135,5 @@ sha256 = "9df07a9611ef45f1b1258a0b412f4d02c920248f69d2e2ce8ccda328f7e13002"; }); }) // { - package-description-override = "cabal-version: >=1.10\nname: splitmix\nversion: 0.1.0.5\nsynopsis: Fast Splittable PRNG\ndescription:\n Pure Haskell implementation of SplitMix described in\n .\n Guy L. Steele, Jr., Doug Lea, and Christine H. Flood. 2014.\n Fast splittable pseudorandom number generators. In Proceedings\n of the 2014 ACM International Conference on Object Oriented\n Programming Systems Languages & Applications (OOPSLA '14). ACM,\n New York, NY, USA, 453-472. DOI:\n \n .\n The paper describes a new algorithm /SplitMix/ for /splittable/\n pseudorandom number generator that is quite fast: 9 64 bit arithmetic/logical\n operations per 64 bits generated.\n .\n /SplitMix/ is tested with two standard statistical test suites (DieHarder and\n TestU01, this implementation only using the former) and it appears to be\n adequate for \"everyday\" use, such as Monte Carlo algorithms and randomized\n data structures where speed is important.\n .\n In particular, it __should not be used for cryptographic or security applications__,\n because generated sequences of pseudorandom values are too predictable\n (the mixing functions are easily inverted, and two successive outputs\n suffice to reconstruct the internal state).\n\nlicense: BSD3\nlicense-file: LICENSE\nmaintainer: Oleg Grenrus \nbug-reports: https://github.com/haskellari/splitmix/issues\ncategory: System, Random\nbuild-type: Simple\ntested-with:\n GHC ==7.0.4\n || ==7.2.2\n || ==7.4.2\n || ==7.6.3\n || ==7.8.4\n || ==7.10.3\n || ==8.0.2\n || ==8.2.2\n || ==8.4.4\n || ==8.6.5\n || ==8.8.4\n || ==8.10.4\n || ==9.0.2\n || ==9.2.8\n || ==9.4.7\n || ==9.6.3\n || ==9.8.1\n , GHCJS ==8.4\n\nextra-source-files:\n Changelog.md\n make-hugs.sh\n README.md\n test-hugs.sh\n\nflag optimised-mixer\n description: Use JavaScript for mix32\n manual: True\n default: False\n\nlibrary\n default-language: Haskell2010\n ghc-options: -Wall\n hs-source-dirs: src src-compat\n exposed-modules:\n System.Random.SplitMix\n System.Random.SplitMix32\n\n other-modules:\n Data.Bits.Compat\n System.Random.SplitMix.Init\n\n -- dump-core\n -- build-depends: dump-core\n -- ghc-options: -fplugin=DumpCore -fplugin-opt DumpCore:core-html\n\n build-depends:\n base >=4.3 && <4.20\n , deepseq >=1.3.0.0 && <1.6\n\n if flag(optimised-mixer)\n cpp-options: -DOPTIMISED_MIX32=1\n\n -- We don't want to depend on time, nor unix or Win32 packages\n -- because it's valuable that splitmix and QuickCheck doesn't\n -- depend on about anything\n\n if impl(ghcjs)\n cpp-options: -DSPLITMIX_INIT_GHCJS=1\n\n else\n if impl(ghc)\n cpp-options: -DSPLITMIX_INIT_C=1\n\n if os(windows)\n c-sources: cbits-win/init.c\n\n else\n c-sources: cbits-unix/init.c\n\n else\n cpp-options: -DSPLITMIX_INIT_COMPAT=1\n build-depends: time >=1.2.0.3 && <1.13\n\nsource-repository head\n type: git\n location: https://github.com/haskellari/splitmix.git\n\nbenchmark comparison\n type: exitcode-stdio-1.0\n default-language: Haskell2010\n ghc-options: -Wall\n hs-source-dirs: bench\n main-is: Bench.hs\n build-depends:\n base\n , containers >=0.4.2.1 && <0.7\n , criterion >=1.1.0.0 && <1.7\n , random\n , splitmix\n , tf-random >=0.5 && <0.6\n\nbenchmark simple-sum\n type: exitcode-stdio-1.0\n default-language: Haskell2010\n ghc-options: -Wall\n hs-source-dirs: bench\n main-is: SimpleSum.hs\n build-depends:\n base\n , random\n , splitmix\n\nbenchmark range\n type: exitcode-stdio-1.0\n default-language: Haskell2010\n ghc-options: -Wall\n hs-source-dirs: bench src-compat\n main-is: Range.hs\n other-modules: Data.Bits.Compat\n build-depends:\n base\n , random\n , splitmix\n\n if !impl(ghcjs)\n build-depends: clock >=0.8 && <0.9\n\ntest-suite examples\n type: exitcode-stdio-1.0\n default-language: Haskell2010\n ghc-options: -Wall\n hs-source-dirs: tests\n main-is: Examples.hs\n build-depends:\n base\n , HUnit ==1.3.1.2 || >=1.6.0.0 && <1.7\n , splitmix\n\ntest-suite splitmix-tests\n type: exitcode-stdio-1.0\n default-language: Haskell2010\n ghc-options: -Wall\n hs-source-dirs: tests\n main-is: Tests.hs\n other-modules:\n MiniQC\n Uniformity\n\n build-depends:\n base\n , base-compat >=0.11.1 && <0.14\n , containers >=0.4.0.0 && <0.7\n , HUnit ==1.3.1.2 || >=1.6.0.0 && <1.7\n , math-functions ==0.1.7.0 || >=0.3.3.0 && <0.4\n , splitmix\n , test-framework >=0.8.2.0 && <0.9\n , test-framework-hunit >=0.3.0.2 && <0.4\n\ntest-suite montecarlo-pi\n type: exitcode-stdio-1.0\n default-language: Haskell2010\n ghc-options: -Wall\n hs-source-dirs: tests\n main-is: SplitMixPi.hs\n build-depends:\n base\n , splitmix\n\ntest-suite montecarlo-pi-32\n type: exitcode-stdio-1.0\n default-language: Haskell2010\n ghc-options: -Wall\n hs-source-dirs: tests\n main-is: SplitMixPi32.hs\n build-depends:\n base\n , splitmix\n\ntest-suite splitmix-dieharder\n default-language: Haskell2010\n type: exitcode-stdio-1.0\n ghc-options: -Wall -threaded -rtsopts\n hs-source-dirs: tests\n main-is: Dieharder.hs\n build-depends:\n async >=2.2.1 && <2.3\n , base\n , base-compat-batteries >=0.10.5 && <0.14\n , bytestring >=0.9.1.8 && <0.13\n , deepseq\n , process >=1.0.1.5 && <1.7\n , random\n , splitmix\n , tf-random >=0.5 && <0.6\n , vector >=0.11.0.0 && <0.14\n\ntest-suite splitmix-testu01\n if !os(linux)\n buildable: False\n\n default-language: Haskell2010\n type: exitcode-stdio-1.0\n ghc-options: -Wall -threaded -rtsopts\n hs-source-dirs: tests\n main-is: TestU01.hs\n c-sources: tests/cbits/testu01.c\n extra-libraries: testu01\n build-depends:\n base\n , base-compat-batteries >=0.10.5 && <0.14\n , splitmix\n\ntest-suite initialization\n default-language: Haskell2010\n type: exitcode-stdio-1.0\n ghc-options: -Wall -threaded -rtsopts\n hs-source-dirs: tests\n main-is: Initialization.hs\n build-depends:\n base\n , HUnit ==1.3.1.2 || >=1.6.0.0 && <1.7\n , splitmix\n"; + package-description-override = "cabal-version: >=1.10\nname: splitmix\nversion: 0.1.0.5\nx-revision: 1\nsynopsis: Fast Splittable PRNG\ndescription:\n Pure Haskell implementation of SplitMix described in\n .\n Guy L. Steele, Jr., Doug Lea, and Christine H. Flood. 2014.\n Fast splittable pseudorandom number generators. In Proceedings\n of the 2014 ACM International Conference on Object Oriented\n Programming Systems Languages & Applications (OOPSLA '14). ACM,\n New York, NY, USA, 453-472. DOI:\n \n .\n The paper describes a new algorithm /SplitMix/ for /splittable/\n pseudorandom number generator that is quite fast: 9 64 bit arithmetic/logical\n operations per 64 bits generated.\n .\n /SplitMix/ is tested with two standard statistical test suites (DieHarder and\n TestU01, this implementation only using the former) and it appears to be\n adequate for \"everyday\" use, such as Monte Carlo algorithms and randomized\n data structures where speed is important.\n .\n In particular, it __should not be used for cryptographic or security applications__,\n because generated sequences of pseudorandom values are too predictable\n (the mixing functions are easily inverted, and two successive outputs\n suffice to reconstruct the internal state).\n\nlicense: BSD3\nlicense-file: LICENSE\nmaintainer: Oleg Grenrus \nbug-reports: https://github.com/haskellari/splitmix/issues\ncategory: System, Random\nbuild-type: Simple\ntested-with:\n GHC ==7.0.4\n || ==7.2.2\n || ==7.4.2\n || ==7.6.3\n || ==7.8.4\n || ==7.10.3\n || ==8.0.2\n || ==8.2.2\n || ==8.4.4\n || ==8.6.5\n || ==8.8.4\n || ==8.10.4\n || ==9.0.2\n || ==9.2.8\n || ==9.4.8\n || ==9.6.4\n || ==9.8.2\n || ==9.10.1\n , GHCJS ==8.4\n\nextra-source-files:\n Changelog.md\n make-hugs.sh\n README.md\n test-hugs.sh\n\nflag optimised-mixer\n description: Use JavaScript for mix32\n manual: True\n default: False\n\nlibrary\n default-language: Haskell2010\n ghc-options: -Wall\n hs-source-dirs: src src-compat\n exposed-modules:\n System.Random.SplitMix\n System.Random.SplitMix32\n\n other-modules:\n Data.Bits.Compat\n System.Random.SplitMix.Init\n\n -- dump-core\n -- build-depends: dump-core\n -- ghc-options: -fplugin=DumpCore -fplugin-opt DumpCore:core-html\n\n build-depends:\n base >=4.3 && <4.21\n , deepseq >=1.3.0.0 && <1.6\n\n if flag(optimised-mixer)\n cpp-options: -DOPTIMISED_MIX32=1\n\n -- We don't want to depend on time, nor unix or Win32 packages\n -- because it's valuable that splitmix and QuickCheck doesn't\n -- depend on about anything\n\n if impl(ghcjs)\n cpp-options: -DSPLITMIX_INIT_GHCJS=1\n\n else\n if impl(ghc)\n cpp-options: -DSPLITMIX_INIT_C=1\n\n if os(windows)\n c-sources: cbits-win/init.c\n\n else\n c-sources: cbits-unix/init.c\n\n else\n cpp-options: -DSPLITMIX_INIT_COMPAT=1\n build-depends: time >=1.2.0.3 && <1.13\n\nsource-repository head\n type: git\n location: https://github.com/haskellari/splitmix.git\n\nbenchmark comparison\n type: exitcode-stdio-1.0\n default-language: Haskell2010\n ghc-options: -Wall\n hs-source-dirs: bench\n main-is: Bench.hs\n build-depends:\n base\n , containers >=0.4.2.1 && <0.8\n , criterion >=1.1.0.0 && <1.7\n , random\n , splitmix\n , tf-random >=0.5 && <0.6\n\nbenchmark simple-sum\n type: exitcode-stdio-1.0\n default-language: Haskell2010\n ghc-options: -Wall\n hs-source-dirs: bench\n main-is: SimpleSum.hs\n build-depends:\n base\n , random\n , splitmix\n\nbenchmark range\n type: exitcode-stdio-1.0\n default-language: Haskell2010\n ghc-options: -Wall\n hs-source-dirs: bench src-compat\n main-is: Range.hs\n other-modules: Data.Bits.Compat\n build-depends:\n base\n , random\n , splitmix\n\n if !impl(ghcjs)\n build-depends: clock >=0.8 && <0.9\n\ntest-suite examples\n type: exitcode-stdio-1.0\n default-language: Haskell2010\n ghc-options: -Wall\n hs-source-dirs: tests\n main-is: Examples.hs\n build-depends:\n base\n , HUnit ==1.3.1.2 || >=1.6.0.0 && <1.7\n , splitmix\n\ntest-suite splitmix-tests\n type: exitcode-stdio-1.0\n default-language: Haskell2010\n ghc-options: -Wall\n hs-source-dirs: tests\n main-is: Tests.hs\n other-modules:\n MiniQC\n Uniformity\n\n build-depends:\n base\n , base-compat >=0.11.1 && <0.14\n , containers >=0.4.0.0 && <0.8\n , HUnit ==1.3.1.2 || >=1.6.0.0 && <1.7\n , math-functions ==0.1.7.0 || >=0.3.3.0 && <0.4\n , splitmix\n , test-framework >=0.8.2.0 && <0.9\n , test-framework-hunit >=0.3.0.2 && <0.4\n\ntest-suite montecarlo-pi\n type: exitcode-stdio-1.0\n default-language: Haskell2010\n ghc-options: -Wall\n hs-source-dirs: tests\n main-is: SplitMixPi.hs\n build-depends:\n base\n , splitmix\n\ntest-suite montecarlo-pi-32\n type: exitcode-stdio-1.0\n default-language: Haskell2010\n ghc-options: -Wall\n hs-source-dirs: tests\n main-is: SplitMixPi32.hs\n build-depends:\n base\n , splitmix\n\ntest-suite splitmix-dieharder\n default-language: Haskell2010\n type: exitcode-stdio-1.0\n ghc-options: -Wall -threaded -rtsopts\n hs-source-dirs: tests\n main-is: Dieharder.hs\n build-depends:\n async >=2.2.1 && <2.3\n , base\n , base-compat-batteries >=0.10.5 && <0.14\n , bytestring >=0.9.1.8 && <0.13\n , deepseq\n , process >=1.0.1.5 && <1.7\n , random\n , splitmix\n , tf-random >=0.5 && <0.6\n , vector >=0.11.0.0 && <0.14\n\ntest-suite splitmix-testu01\n if !os(linux)\n buildable: False\n\n default-language: Haskell2010\n type: exitcode-stdio-1.0\n ghc-options: -Wall -threaded -rtsopts\n hs-source-dirs: tests\n main-is: TestU01.hs\n c-sources: tests/cbits/testu01.c\n extra-libraries: testu01\n build-depends:\n base\n , base-compat-batteries >=0.10.5 && <0.14\n , splitmix\n\ntest-suite initialization\n default-language: Haskell2010\n type: exitcode-stdio-1.0\n ghc-options: -Wall -threaded -rtsopts\n hs-source-dirs: tests\n main-is: Initialization.hs\n build-depends:\n base\n , HUnit ==1.3.1.2 || >=1.6.0.0 && <1.7\n , splitmix\n"; } \ No newline at end of file diff --git a/materialized/ghc964/hadrian-ghc96/hadrian/cabal-files/unordered-containers.nix b/materialized/ghc964/hadrian-ghc96/hadrian/cabal-files/unordered-containers.nix index 0aeaccb277..816666c80f 100644 --- a/materialized/ghc964/hadrian-ghc96/hadrian/cabal-files/unordered-containers.nix +++ b/materialized/ghc964/hadrian-ghc96/hadrian/cabal-files/unordered-containers.nix @@ -11,7 +11,7 @@ flags = { debug = false; }; package = { specVersion = "1.10"; - identifier = { name = "unordered-containers"; version = "0.2.19.1"; }; + identifier = { name = "unordered-containers"; version = "0.2.20"; }; license = "BSD-3-Clause"; copyright = "2010-2014 Johan Tibell\n2010 Edward Z. Yang"; maintainer = "simon.jakobi@gmail.com, David.Feuer@gmail.com"; @@ -70,9 +70,9 @@ }; } // { src = pkgs.lib.mkDefault (pkgs.fetchurl { - url = "http://hackage.haskell.org/package/unordered-containers-0.2.19.1.tar.gz"; - sha256 = "1b27bec5e0d522b27a6029ebf4c4a6d40acbc083c787008e32fb55c4b1d128d2"; + url = "http://hackage.haskell.org/package/unordered-containers-0.2.20.tar.gz"; + sha256 = "d9cfb287cf00592d39dc9c3cac8b99627ea08f2c01798e70130fc39f7c90f11d"; }); }) // { - package-description-override = "name: unordered-containers\nversion: 0.2.19.1\nx-revision: 3\nsynopsis: Efficient hashing-based container types\ndescription:\n Efficient hashing-based container types. The containers have been\n optimized for performance critical use, both in terms of large data\n quantities and high speed.\n .\n The declared cost of each operation is either worst-case or\n amortized, but remains valid even if structures are shared.\n .\n /Security/\n .\n This package currently provides no defenses against hash collision attacks\n such as HashDoS.\n Users who need to store input from untrusted sources are advised to use\n @Data.Map@ or @Data.Set@ from the @containers@ package instead.\nlicense: BSD3\nlicense-file: LICENSE\nauthor: Johan Tibell\nmaintainer: simon.jakobi@gmail.com, David.Feuer@gmail.com\nHomepage: https://github.com/haskell-unordered-containers/unordered-containers\nbug-reports: https://github.com/haskell-unordered-containers/unordered-containers/issues\ncopyright: 2010-2014 Johan Tibell\n 2010 Edward Z. Yang\ncategory: Data\nbuild-type: Simple\ncabal-version: >=1.10\nextra-source-files: CHANGES.md\n\ntested-with:\n GHC ==9.8.1\n || ==9.6.3\n || ==9.4.7\n || ==9.2.8\n || ==9.0.2\n || ==8.10.7\n || ==8.8.4\n || ==8.6.5\n || ==8.4.4\n || ==8.2.2\n\nflag debug\n description: Enable debug support\n default: False\n\nlibrary\n exposed-modules:\n Data.HashMap.Internal\n Data.HashMap.Internal.Array\n Data.HashMap.Internal.List\n Data.HashMap.Internal.Strict\n Data.HashMap.Lazy\n Data.HashMap.Strict\n Data.HashSet\n Data.HashSet.Internal\n\n build-depends:\n base >= 4.10 && < 5,\n deepseq >= 1.4.3,\n hashable >= 1.2.5 && < 1.5,\n template-haskell < 2.22\n\n default-language: Haskell2010\n\n other-extensions:\n RoleAnnotations,\n UnboxedTuples,\n ScopedTypeVariables,\n MagicHash,\n BangPatterns\n\n ghc-options: -Wall -O2 -fwarn-tabs -ferror-spans\n\n -- For dumping the generated code:\n -- ghc-options: -ddump-simpl -ddump-stg-final -ddump-cmm -ddump-asm -ddump-to-file\n -- ghc-options: -dsuppress-coercions -dsuppress-unfoldings -dsuppress-module-prefixes\n -- ghc-options: -dsuppress-uniques -dsuppress-timestamps\n\n if flag(debug)\n cpp-options: -DASSERTS\n\ntest-suite unordered-containers-tests\n hs-source-dirs: tests\n main-is: Main.hs\n type: exitcode-stdio-1.0\n other-modules:\n Regressions\n Properties\n Properties.HashMapLazy\n Properties.HashMapStrict\n Properties.HashSet\n Properties.List\n Strictness\n\n build-depends:\n base,\n ChasingBottoms,\n containers >= 0.5.8,\n hashable,\n HUnit,\n QuickCheck >= 2.4.0.1,\n random,\n tasty >= 1.4.0.3,\n tasty-hunit >= 0.10.0.3,\n tasty-quickcheck >= 0.10.1.2,\n unordered-containers\n\n if impl(ghc >= 8.6)\n build-depends:\n nothunks >= 0.1.3\n\n default-language: Haskell2010\n ghc-options: -Wall\n cpp-options: -DASSERTS\n\nbenchmark benchmarks\n hs-source-dirs: benchmarks\n main-is: Benchmarks.hs\n type: exitcode-stdio-1.0\n\n other-modules:\n Util.ByteString\n Util.String\n Util.Int\n\n build-depends:\n base >= 4.8.0,\n bytestring >= 0.10.0.0,\n containers,\n deepseq,\n hashable,\n hashmap,\n mtl,\n random,\n tasty-bench >= 0.3.1,\n unordered-containers\n\n default-language: Haskell2010\n ghc-options: -Wall -O2 -rtsopts -with-rtsopts=-A32m\n if impl(ghc >= 8.10)\n ghc-options: \"-with-rtsopts=-A32m --nonmoving-gc\"\n -- cpp-options: -DBENCH_containers_Map -DBENCH_containers_IntMap -DBENCH_hashmap_Map\n\nsource-repository head\n type: git\n location: https://github.com/haskell-unordered-containers/unordered-containers.git\n"; + package-description-override = "name: unordered-containers\r\nversion: 0.2.20\r\nx-revision: 3\r\nsynopsis: Efficient hashing-based container types\r\ndescription:\r\n Efficient hashing-based container types. The containers have been\r\n optimized for performance critical use, both in terms of large data\r\n quantities and high speed.\r\n .\r\n The declared cost of each operation is either worst-case or\r\n amortized, but remains valid even if structures are shared.\r\n .\r\n /Security/\r\n .\r\n This package currently provides no defenses against hash collision attacks\r\n such as HashDoS.\r\n Users who need to store input from untrusted sources are advised to use\r\n @Data.Map@ or @Data.Set@ from the @containers@ package instead.\r\nlicense: BSD3\r\nlicense-file: LICENSE\r\nauthor: Johan Tibell\r\nmaintainer: simon.jakobi@gmail.com, David.Feuer@gmail.com\r\nHomepage: https://github.com/haskell-unordered-containers/unordered-containers\r\nbug-reports: https://github.com/haskell-unordered-containers/unordered-containers/issues\r\ncopyright: 2010-2014 Johan Tibell\r\n 2010 Edward Z. Yang\r\ncategory: Data\r\nbuild-type: Simple\r\ncabal-version: >=1.10\r\nextra-source-files: CHANGES.md\r\n\r\ntested-with:\r\n GHC ==9.8.1\r\n || ==9.6.3\r\n || ==9.4.7\r\n || ==9.2.8\r\n || ==9.0.2\r\n || ==8.10.7\r\n || ==8.8.4\r\n || ==8.6.5\r\n || ==8.4.4\r\n || ==8.2.2\r\n\r\nflag debug\r\n description: Enable debug support\r\n default: False\r\n\r\nlibrary\r\n exposed-modules:\r\n Data.HashMap.Internal\r\n Data.HashMap.Internal.Array\r\n Data.HashMap.Internal.Debug\r\n Data.HashMap.Internal.List\r\n Data.HashMap.Internal.Strict\r\n Data.HashMap.Lazy\r\n Data.HashMap.Strict\r\n Data.HashSet\r\n Data.HashSet.Internal\r\n\r\n build-depends:\r\n base >= 4.10 && < 5,\r\n deepseq >= 1.4.3,\r\n hashable >= 1.4 && < 1.6,\r\n template-haskell < 2.23\r\n\r\n default-language: Haskell2010\r\n\r\n other-extensions:\r\n RoleAnnotations,\r\n UnboxedTuples,\r\n ScopedTypeVariables,\r\n MagicHash,\r\n BangPatterns\r\n\r\n ghc-options: -Wall -O2 -fwarn-tabs -ferror-spans\r\n\r\n -- For dumping the generated code:\r\n -- ghc-options: -ddump-simpl -ddump-stg-final -ddump-cmm -ddump-asm -ddump-to-file\r\n -- ghc-options: -dsuppress-coercions -dsuppress-unfoldings -dsuppress-module-prefixes\r\n -- ghc-options: -dsuppress-uniques -dsuppress-timestamps\r\n\r\n if flag(debug)\r\n cpp-options: -DASSERTS\r\n\r\ntest-suite unordered-containers-tests\r\n hs-source-dirs: tests\r\n main-is: Main.hs\r\n type: exitcode-stdio-1.0\r\n other-modules:\r\n Regressions\r\n Properties\r\n Properties.HashMapLazy\r\n Properties.HashMapStrict\r\n Properties.HashSet\r\n Properties.List\r\n Strictness\r\n Util.Key\r\n\r\n build-depends:\r\n base,\r\n ChasingBottoms,\r\n containers >= 0.5.8,\r\n hashable,\r\n HUnit,\r\n QuickCheck >= 2.4.0.1,\r\n random,\r\n tasty >= 1.4.0.3,\r\n tasty-hunit >= 0.10.0.3,\r\n tasty-quickcheck >= 0.10.1.2,\r\n unordered-containers\r\n\r\n if impl(ghc >= 8.6)\r\n build-depends:\r\n nothunks >= 0.1.3\r\n\r\n default-language: Haskell2010\r\n ghc-options: -Wall -threaded -rtsopts -with-rtsopts=-N\r\n cpp-options: -DASSERTS\r\n\r\nbenchmark benchmarks\r\n hs-source-dirs: benchmarks\r\n main-is: Benchmarks.hs\r\n type: exitcode-stdio-1.0\r\n\r\n other-modules:\r\n Util.ByteString\r\n Util.String\r\n Util.Int\r\n\r\n build-depends:\r\n base >= 4.8.0,\r\n bytestring >= 0.10.0.0,\r\n containers,\r\n deepseq,\r\n hashable,\r\n hashmap,\r\n mtl,\r\n random,\r\n tasty-bench >= 0.3.1,\r\n unordered-containers\r\n\r\n default-language: Haskell2010\r\n ghc-options: -Wall -O2 -rtsopts -with-rtsopts=-A32m\r\n if impl(ghc >= 8.10)\r\n ghc-options: \"-with-rtsopts=-A32m --nonmoving-gc\"\r\n -- cpp-options: -DBENCH_containers_Map -DBENCH_containers_IntMap -DBENCH_hashmap_Map\r\n\r\nsource-repository head\r\n type: git\r\n location: https://github.com/haskell-unordered-containers/unordered-containers.git\r\n"; } \ No newline at end of file diff --git a/materialized/ghc964/hadrian-ghc96/hadrian/default.nix b/materialized/ghc964/hadrian-ghc96/hadrian/default.nix index ca057a5d6b..8bd2488da9 100644 --- a/materialized/ghc964/hadrian-ghc96/hadrian/default.nix +++ b/materialized/ghc964/hadrian-ghc96/hadrian/default.nix @@ -17,7 +17,7 @@ pretty.revision = hackage.pretty."1.1.3.6".revisions.default; hashable.revision = import ./cabal-files/hashable.nix; hashable.flags.random-initial-seed = false; - hashable.flags.integer-gmp = true; + hashable.flags.arch-native = false; heaps.revision = import ./cabal-files/heaps.nix; Cabal-syntax.revision = import ./cabal-files/Cabal-syntax.nix; process.revision = hackage.process."1.6.17.0".revisions.default; @@ -30,6 +30,7 @@ deepseq.revision = hackage.deepseq."1.4.8.1".revisions.default; utf8-string.revision = import ./cabal-files/utf8-string.nix; js-jquery.revision = import ./cabal-files/js-jquery.nix; + os-string.revision = import ./cabal-files/os-string.nix; text.revision = hackage.text."2.0.2".revisions.default; QuickCheck.revision = import ./cabal-files/QuickCheck.nix; QuickCheck.flags.old-random = false; @@ -39,6 +40,7 @@ containers.revision = hackage.containers."0.6.7".revisions.default; array.revision = hackage.array."0.5.6.0".revisions.default; shake.revision = import ./cabal-files/shake.nix; + shake.flags.threaded = true; shake.flags.cloud = false; shake.flags.embed-files = false; shake.flags.portable = false; @@ -145,6 +147,7 @@ "hashable".components.library.planned = lib.mkOverride 900 true; "primitive".components.library.planned = lib.mkOverride 900 true; "Cabal-syntax".components.library.planned = lib.mkOverride 900 true; + "os-string".components.library.planned = lib.mkOverride 900 true; "QuickCheck".components.library.planned = lib.mkOverride 900 true; "js-jquery".components.library.planned = lib.mkOverride 900 true; "mtl".components.library.planned = lib.mkOverride 900 true; diff --git a/materialized/ghc964/hadrian-ghc96/plan.json b/materialized/ghc964/hadrian-ghc96/plan.json index 7610e57826..ba1bc64fe7 100644 --- a/materialized/ghc964/hadrian-ghc96/plan.json +++ b/materialized/ghc964/hadrian-ghc96/plan.json @@ -1 +1 @@ -{"cabal-version":"3.10.3.0","cabal-lib-version":"3.10.3.0","compiler-id":"ghc-9.6.4","os":"linux","arch":"x86_64","install-plan":[{"type":"configured","id":"Cabal-3.8.1.0-c668f818769193b477ca1a8b87e802e56126adbc7bed962d76bde34a01e8c306","pkg-name":"Cabal","pkg-version":"3.8.1.0","flags":{},"style":"global","pkg-src":{"type":"repo-tar","repo":{"type":"secure-repo","uri":"http://hackage.haskell.org/"}},"pkg-cabal-sha256":"77121d8e1aff14a0fd95684b751599db78a7dd26d55862d9fcef27c88b193e9d","pkg-src-sha256":"7464cbe6c2f3d7e5d0232023a1a7330621f8b24853cb259fc89a2af85b736608","depends":["Cabal-syntax-3.8.1.0-b99db30153f1d2c83dc6d34e637d577dc69cabe5825778a1e3462bcf8317b588","array-0.5.6.0","base-4.18.2.0","bytestring-0.11.5.3","containers-0.6.7","deepseq-1.4.8.1","directory-1.3.8.1","filepath-1.4.200.1","mtl-2.3.1","parsec-3.1.16.1","pretty-1.1.3.6","process-1.6.17.0","text-2.0.2","time-1.12.2","transformers-0.6.1.0","unix-2.8.4.0"],"exe-depends":[],"component-name":"lib"},{"type":"configured","id":"Cabal-syntax-3.8.1.0-b99db30153f1d2c83dc6d34e637d577dc69cabe5825778a1e3462bcf8317b588","pkg-name":"Cabal-syntax","pkg-version":"3.8.1.0","flags":{},"style":"global","pkg-src":{"type":"repo-tar","repo":{"type":"secure-repo","uri":"http://hackage.haskell.org/"}},"pkg-cabal-sha256":"ed2d937ba6c6a20b75850349eedd41374885fc42369ef152d69e2ba70f44f593","pkg-src-sha256":"07e8ddb19fe01781485f1522b6afc22aba680b0ab28ebe6bbfb84a2dd698ce0f","depends":["array-0.5.6.0","base-4.18.2.0","binary-0.8.9.1","bytestring-0.11.5.3","containers-0.6.7","deepseq-1.4.8.1","directory-1.3.8.1","filepath-1.4.200.1","mtl-2.3.1","parsec-3.1.16.1","pretty-1.1.3.6","text-2.0.2","time-1.12.2","transformers-0.6.1.0","unix-2.8.4.0"],"exe-depends":[],"component-name":"lib"},{"type":"configured","id":"QuickCheck-2.14.3-116702925e70e233df64507a5cae969ff9c69efe35b3cc35e56c87d47168ff11","pkg-name":"QuickCheck","pkg-version":"2.14.3","flags":{"old-random":false,"templatehaskell":true},"style":"global","pkg-src":{"type":"repo-tar","repo":{"type":"secure-repo","uri":"http://hackage.haskell.org/"}},"pkg-cabal-sha256":"f03d2f404d5ba465453d0fbc1944832789a759fe7c4f9bf8616bc1378a02fde4","pkg-src-sha256":"5c0f22b36b28a1a8fa110b3819818d3f29494a3b0dedbae299f064123ca70501","depends":["base-4.18.2.0","containers-0.6.7","deepseq-1.4.8.1","random-1.2.1.1-e2b8c23c50d3a2e2d7c30c46d2a3344a9c2a38bf319885311c62efb7342cb80b","splitmix-0.1.0.5-232d2b1a4ce5cacd620dd2472d411c8d63e777af17182b5d56b631942f729187","template-haskell-2.20.0.0","transformers-0.6.1.0"],"exe-depends":[],"component-name":"lib"},{"type":"pre-existing","id":"array-0.5.6.0","pkg-name":"array","pkg-version":"0.5.6.0","depends":["base-4.18.2.0"]},{"type":"pre-existing","id":"base-4.18.2.0","pkg-name":"base","pkg-version":"4.18.2.0","depends":["ghc-bignum-1.3","ghc-prim-0.10.0"]},{"type":"pre-existing","id":"binary-0.8.9.1","pkg-name":"binary","pkg-version":"0.8.9.1","depends":["array-0.5.6.0","base-4.18.2.0","bytestring-0.11.5.3","containers-0.6.7","ghc-prim-0.10.0"]},{"type":"pre-existing","id":"bytestring-0.11.5.3","pkg-name":"bytestring","pkg-version":"0.11.5.3","depends":["base-4.18.2.0","deepseq-1.4.8.1","ghc-prim-0.10.0","template-haskell-2.20.0.0"]},{"type":"configured","id":"clock-0.8.4-b6af39fafa1fb93e9520050c562fc2d9803a08bc83cda5d8b8d907beefe150aa","pkg-name":"clock","pkg-version":"0.8.4","flags":{"llvm":false},"style":"global","pkg-src":{"type":"repo-tar","repo":{"type":"secure-repo","uri":"http://hackage.haskell.org/"}},"pkg-cabal-sha256":"b938655b00cf204ce69abfff946021bed111d2609a9f7a9c22e28a1a202e9115","pkg-src-sha256":"6ae9898afe788a5e334cd5fad5d18a3c2e8e59fa09aaf7b957dbb38a4767df2e","depends":["base-4.18.2.0"],"exe-depends":[],"component-name":"lib"},{"type":"pre-existing","id":"containers-0.6.7","pkg-name":"containers","pkg-version":"0.6.7","depends":["array-0.5.6.0","base-4.18.2.0","deepseq-1.4.8.1","template-haskell-2.20.0.0"]},{"type":"pre-existing","id":"deepseq-1.4.8.1","pkg-name":"deepseq","pkg-version":"1.4.8.1","depends":["array-0.5.6.0","base-4.18.2.0","ghc-prim-0.10.0"]},{"type":"pre-existing","id":"directory-1.3.8.1","pkg-name":"directory","pkg-version":"1.3.8.1","depends":["base-4.18.2.0","filepath-1.4.200.1","time-1.12.2","unix-2.8.4.0"]},{"type":"pre-existing","id":"exceptions-0.10.7","pkg-name":"exceptions","pkg-version":"0.10.7","depends":["base-4.18.2.0","mtl-2.3.1","stm-2.5.1.0","template-haskell-2.20.0.0","transformers-0.6.1.0"]},{"type":"configured","id":"extra-1.7.14-5b3875febb50e86e1fd0471cb61fc83c08afae84f74dd82e3fe23bdc226bd3c9","pkg-name":"extra","pkg-version":"1.7.14","flags":{},"style":"global","pkg-src":{"type":"repo-tar","repo":{"type":"secure-repo","uri":"http://hackage.haskell.org/"}},"pkg-cabal-sha256":"e3d3ce1dc7746b1132930e48c59fb5e8c51a09e92e0c031316be031067a273fb","pkg-src-sha256":"b6a909f8f0e4b8076a1653b4d34815a782f0a8c1e83d5267f4d00496471ef567","depends":["base-4.18.2.0","clock-0.8.4-b6af39fafa1fb93e9520050c562fc2d9803a08bc83cda5d8b8d907beefe150aa","directory-1.3.8.1","filepath-1.4.200.1","process-1.6.17.0","time-1.12.2","unix-2.8.4.0"],"exe-depends":[],"component-name":"lib"},{"type":"pre-existing","id":"filepath-1.4.200.1","pkg-name":"filepath","pkg-version":"1.4.200.1","depends":["base-4.18.2.0","bytestring-0.11.5.3","deepseq-1.4.8.1","exceptions-0.10.7","template-haskell-2.20.0.0"]},{"type":"configured","id":"filepattern-0.1.3-e0b05225cb586afea88cbd5fba3b81dbc7d8925b44e8dd467cfd9ed208da351b","pkg-name":"filepattern","pkg-version":"0.1.3","flags":{},"style":"global","pkg-src":{"type":"repo-tar","repo":{"type":"secure-repo","uri":"http://hackage.haskell.org/"}},"pkg-cabal-sha256":"372c1733d83b90045eb29da9f010fed79bfef8771ce65eb126a1d83ecc54a9a2","pkg-src-sha256":"cc445d439ea2f65cac7604d3578aa2c3a62e5a91dc989f4ce5b3390db9e59636","depends":["base-4.18.2.0","directory-1.3.8.1","extra-1.7.14-5b3875febb50e86e1fd0471cb61fc83c08afae84f74dd82e3fe23bdc226bd3c9","filepath-1.4.200.1"],"exe-depends":[],"component-name":"lib"},{"type":"pre-existing","id":"ghc-bignum-1.3","pkg-name":"ghc-bignum","pkg-version":"1.3","depends":["ghc-prim-0.10.0"]},{"type":"pre-existing","id":"ghc-boot-th-9.6.4","pkg-name":"ghc-boot-th","pkg-version":"9.6.4","depends":["base-4.18.2.0"]},{"type":"pre-existing","id":"ghc-prim-0.10.0","pkg-name":"ghc-prim","pkg-version":"0.10.0","depends":[]},{"type":"configured","id":"hadrian-0.1.0.0-inplace-hadrian","pkg-name":"hadrian","pkg-version":"0.1.0.0","flags":{"selftest":true,"threaded":true},"style":"local","pkg-src":{"type":"local","path":"./hadrian/."},"dist-dir":"./hadrian/dist-newstyle/build/x86_64-linux/ghc-9.6.4/hadrian-0.1.0.0/x/hadrian","build-info":"./hadrian/dist-newstyle/build/x86_64-linux/ghc-9.6.4/hadrian-0.1.0.0/x/hadrian/build-info.json","depends":["Cabal-3.8.1.0-c668f818769193b477ca1a8b87e802e56126adbc7bed962d76bde34a01e8c306","QuickCheck-2.14.3-116702925e70e233df64507a5cae969ff9c69efe35b3cc35e56c87d47168ff11","base-4.18.2.0","bytestring-0.11.5.3","containers-0.6.7","directory-1.3.8.1","extra-1.7.14-5b3875febb50e86e1fd0471cb61fc83c08afae84f74dd82e3fe23bdc226bd3c9","filepath-1.4.200.1","mtl-2.3.1","parsec-3.1.16.1","shake-0.19.7-9369313762a66f683383a6b11b819b9aafcd8f0d518c176b2cb1f5a198ccf8cd","text-2.0.2","time-1.12.2","transformers-0.6.1.0","unordered-containers-0.2.19.1-0eb0d95c2f270578763e7cbc938fd7d57fa65a8f3c10aa64b616bc79bbf6b993"],"exe-depends":[],"component-name":"exe:hadrian","bin-file":"./hadrian/dist-newstyle/build/x86_64-linux/ghc-9.6.4/hadrian-0.1.0.0/x/hadrian/build/hadrian/hadrian"},{"type":"configured","id":"hashable-1.4.3.0-cf03199beb9180bbbb9b383e3088c03deb3be32037dd08933c3d3ba08171d03e","pkg-name":"hashable","pkg-version":"1.4.3.0","flags":{"integer-gmp":true,"random-initial-seed":false},"style":"global","pkg-src":{"type":"repo-tar","repo":{"type":"secure-repo","uri":"http://hackage.haskell.org/"}},"pkg-cabal-sha256":"f3bf68acfa0df7a064a378ef2cdcfeb55e6fb96100675f4c593556dcbf3d7194","pkg-src-sha256":"32efb16c2891786209b7cbe5c39df9b3a9ae51e836f1a54f646bc4602b7ab0f5","depends":["base-4.18.2.0","bytestring-0.11.5.3","containers-0.6.7","deepseq-1.4.8.1","filepath-1.4.200.1","ghc-bignum-1.3","ghc-prim-0.10.0","text-2.0.2"],"exe-depends":[],"component-name":"lib"},{"type":"configured","id":"heaps-0.4-582bc0f356369f4ac6a9badb439391d1ff82a6d0d7a4a55fe3db91d6d1a32875","pkg-name":"heaps","pkg-version":"0.4","flags":{},"style":"global","pkg-src":{"type":"repo-tar","repo":{"type":"secure-repo","uri":"http://hackage.haskell.org/"}},"pkg-cabal-sha256":"66b19fcd813b0e4db3e0bac541bd46606c3b13d3d081d9f9666f4be0f5ff14b8","pkg-src-sha256":"89329df8b95ae99ef272e41e7a2d0fe2f1bb7eacfcc34bc01664414b33067cfd","depends":["base-4.18.2.0"],"exe-depends":[],"component-name":"lib"},{"type":"configured","id":"js-dgtable-0.5.2-40721bc9982faf5e0f71e3119e01102f429fefca9219230921535f5382e177f7","pkg-name":"js-dgtable","pkg-version":"0.5.2","flags":{},"style":"global","pkg-src":{"type":"repo-tar","repo":{"type":"secure-repo","uri":"http://hackage.haskell.org/"}},"pkg-cabal-sha256":"f75cb4fa53c88c65794becdd48eb0d3b2b8abd89a3d5c19e87af91f5225c15e4","pkg-src-sha256":"e28dd65bee8083b17210134e22e01c6349dc33c3b7bd17705973cd014e9f20ac","depends":["base-4.18.2.0"],"exe-depends":[],"component-name":"lib"},{"type":"configured","id":"js-flot-0.8.3-fadd4ccb467ede662552cdc382e02fb02027d8181620f296bae75d1f76774b0b","pkg-name":"js-flot","pkg-version":"0.8.3","flags":{},"style":"global","pkg-src":{"type":"repo-tar","repo":{"type":"secure-repo","uri":"http://hackage.haskell.org/"}},"pkg-cabal-sha256":"4c1c447a9a2fba0adba6d30678302a30c32b9dfde9e7aa9e9156483e1545096d","pkg-src-sha256":"1ba2f2a6b8d85da76c41f526c98903cbb107f8642e506c072c1e7e3c20fe5e7a","depends":["base-4.18.2.0"],"exe-depends":[],"component-name":"lib"},{"type":"configured","id":"js-jquery-3.3.1-6a8cc1e84fc203e099644c71b32217b6615b055459038eb73f1b008db4b2f236","pkg-name":"js-jquery","pkg-version":"3.3.1","flags":{},"style":"global","pkg-src":{"type":"repo-tar","repo":{"type":"secure-repo","uri":"http://hackage.haskell.org/"}},"pkg-cabal-sha256":"59ab6c79159549ef94b584abce8e6d3b336014c2cce1337b59a8f637e2856df5","pkg-src-sha256":"e0e0681f0da1130ede4e03a051630ea439c458cb97216cdb01771ebdbe44069b","depends":["base-4.18.2.0"],"exe-depends":[],"component-name":"lib"},{"type":"pre-existing","id":"mtl-2.3.1","pkg-name":"mtl","pkg-version":"2.3.1","depends":["base-4.18.2.0","transformers-0.6.1.0"]},{"type":"pre-existing","id":"parsec-3.1.16.1","pkg-name":"parsec","pkg-version":"3.1.16.1","depends":["base-4.18.2.0","bytestring-0.11.5.3","mtl-2.3.1","text-2.0.2"]},{"type":"pre-existing","id":"pretty-1.1.3.6","pkg-name":"pretty","pkg-version":"1.1.3.6","depends":["base-4.18.2.0","deepseq-1.4.8.1","ghc-prim-0.10.0"]},{"type":"configured","id":"primitive-0.9.0.0-b327a6c8ea4577ea7938607770d363048048a528efdff4bc67a582b5feac66fc","pkg-name":"primitive","pkg-version":"0.9.0.0","flags":{},"style":"global","pkg-src":{"type":"repo-tar","repo":{"type":"secure-repo","uri":"http://hackage.haskell.org/"}},"pkg-cabal-sha256":"1ceb39f67c0e614180f2992a6d30f26603ab2cd23c4f8e25b30213f98807f6f1","pkg-src-sha256":"696d4bd291c94d736142d6182117dca4258d3ef28bfefdb649ac8b5ecd0999c7","depends":["base-4.18.2.0","deepseq-1.4.8.1","template-haskell-2.20.0.0","transformers-0.6.1.0"],"exe-depends":[],"component-name":"lib"},{"type":"pre-existing","id":"process-1.6.17.0","pkg-name":"process","pkg-version":"1.6.17.0","depends":["base-4.18.2.0","deepseq-1.4.8.1","directory-1.3.8.1","filepath-1.4.200.1","unix-2.8.4.0"]},{"type":"configured","id":"random-1.2.1.1-e2b8c23c50d3a2e2d7c30c46d2a3344a9c2a38bf319885311c62efb7342cb80b","pkg-name":"random","pkg-version":"1.2.1.1","flags":{},"style":"global","pkg-src":{"type":"repo-tar","repo":{"type":"secure-repo","uri":"http://hackage.haskell.org/"}},"pkg-cabal-sha256":"e7c1f881159d5cc788619c9ee8b8f340ba2ff0db571cdf3d1a1968ebc5108789","pkg-src-sha256":"3e1272f7ed6a4d7bd1712b90143ec326fee9b225789222379fea20a9c90c9b76","depends":["base-4.18.2.0","bytestring-0.11.5.3","deepseq-1.4.8.1","mtl-2.3.1","splitmix-0.1.0.5-232d2b1a4ce5cacd620dd2472d411c8d63e777af17182b5d56b631942f729187"],"exe-depends":[],"component-name":"lib"},{"type":"configured","id":"shake-0.19.7-9369313762a66f683383a6b11b819b9aafcd8f0d518c176b2cb1f5a198ccf8cd","pkg-name":"shake","pkg-version":"0.19.7","flags":{"cloud":false,"embed-files":false,"portable":false},"style":"global","pkg-src":{"type":"repo-tar","repo":{"type":"secure-repo","uri":"http://hackage.haskell.org/"}},"pkg-cabal-sha256":"3cb5814cce210b9756fa9246ff1b2a1e1b86be46fdc4c5e2baacdc5bf83ce5c3","pkg-src-sha256":"352a56af12f70b50d564dcb61131555577281957ee196f1702a3723c0a3699d1","depends":["base-4.18.2.0","binary-0.8.9.1","bytestring-0.11.5.3","deepseq-1.4.8.1","directory-1.3.8.1","extra-1.7.14-5b3875febb50e86e1fd0471cb61fc83c08afae84f74dd82e3fe23bdc226bd3c9","filepath-1.4.200.1","filepattern-0.1.3-e0b05225cb586afea88cbd5fba3b81dbc7d8925b44e8dd467cfd9ed208da351b","hashable-1.4.3.0-cf03199beb9180bbbb9b383e3088c03deb3be32037dd08933c3d3ba08171d03e","heaps-0.4-582bc0f356369f4ac6a9badb439391d1ff82a6d0d7a4a55fe3db91d6d1a32875","js-dgtable-0.5.2-40721bc9982faf5e0f71e3119e01102f429fefca9219230921535f5382e177f7","js-flot-0.8.3-fadd4ccb467ede662552cdc382e02fb02027d8181620f296bae75d1f76774b0b","js-jquery-3.3.1-6a8cc1e84fc203e099644c71b32217b6615b055459038eb73f1b008db4b2f236","primitive-0.9.0.0-b327a6c8ea4577ea7938607770d363048048a528efdff4bc67a582b5feac66fc","process-1.6.17.0","random-1.2.1.1-e2b8c23c50d3a2e2d7c30c46d2a3344a9c2a38bf319885311c62efb7342cb80b","time-1.12.2","transformers-0.6.1.0","unix-2.8.4.0","unordered-containers-0.2.19.1-0eb0d95c2f270578763e7cbc938fd7d57fa65a8f3c10aa64b616bc79bbf6b993","utf8-string-1.0.2-134849f72bdb35a6754bed838d5c0f0412c3ca2863338b599b4cd9b0af070e05"],"exe-depends":[],"component-name":"lib"},{"type":"configured","id":"shake-0.19.7-e-shake-74d898c5705f61c05a8a7aee14d32e6ef38e5584b58da7af7f06efe4c3c36716","pkg-name":"shake","pkg-version":"0.19.7","flags":{"cloud":false,"embed-files":false,"portable":false},"style":"global","pkg-src":{"type":"repo-tar","repo":{"type":"secure-repo","uri":"http://hackage.haskell.org/"}},"pkg-cabal-sha256":"3cb5814cce210b9756fa9246ff1b2a1e1b86be46fdc4c5e2baacdc5bf83ce5c3","pkg-src-sha256":"352a56af12f70b50d564dcb61131555577281957ee196f1702a3723c0a3699d1","depends":["base-4.18.2.0","binary-0.8.9.1","bytestring-0.11.5.3","deepseq-1.4.8.1","directory-1.3.8.1","extra-1.7.14-5b3875febb50e86e1fd0471cb61fc83c08afae84f74dd82e3fe23bdc226bd3c9","filepath-1.4.200.1","filepattern-0.1.3-e0b05225cb586afea88cbd5fba3b81dbc7d8925b44e8dd467cfd9ed208da351b","hashable-1.4.3.0-cf03199beb9180bbbb9b383e3088c03deb3be32037dd08933c3d3ba08171d03e","heaps-0.4-582bc0f356369f4ac6a9badb439391d1ff82a6d0d7a4a55fe3db91d6d1a32875","js-dgtable-0.5.2-40721bc9982faf5e0f71e3119e01102f429fefca9219230921535f5382e177f7","js-flot-0.8.3-fadd4ccb467ede662552cdc382e02fb02027d8181620f296bae75d1f76774b0b","js-jquery-3.3.1-6a8cc1e84fc203e099644c71b32217b6615b055459038eb73f1b008db4b2f236","primitive-0.9.0.0-b327a6c8ea4577ea7938607770d363048048a528efdff4bc67a582b5feac66fc","process-1.6.17.0","random-1.2.1.1-e2b8c23c50d3a2e2d7c30c46d2a3344a9c2a38bf319885311c62efb7342cb80b","time-1.12.2","transformers-0.6.1.0","unix-2.8.4.0","unordered-containers-0.2.19.1-0eb0d95c2f270578763e7cbc938fd7d57fa65a8f3c10aa64b616bc79bbf6b993","utf8-string-1.0.2-134849f72bdb35a6754bed838d5c0f0412c3ca2863338b599b4cd9b0af070e05"],"exe-depends":[],"component-name":"exe:shake","bin-file":"/store/ghc-9.6.4/shake-0.19.7-e-shake-74d898c5705f61c05a8a7aee14d32e6ef38e5584b58da7af7f06efe4c3c36716/bin/shake"},{"type":"configured","id":"splitmix-0.1.0.5-232d2b1a4ce5cacd620dd2472d411c8d63e777af17182b5d56b631942f729187","pkg-name":"splitmix","pkg-version":"0.1.0.5","flags":{"optimised-mixer":false},"style":"global","pkg-src":{"type":"repo-tar","repo":{"type":"secure-repo","uri":"http://hackage.haskell.org/"}},"pkg-cabal-sha256":"bac0ae8d46a04e410666b0c8081cff63f060f29157983b569ca86ddb6e6e0dc6","pkg-src-sha256":"9df07a9611ef45f1b1258a0b412f4d02c920248f69d2e2ce8ccda328f7e13002","depends":["base-4.18.2.0","deepseq-1.4.8.1"],"exe-depends":[],"component-name":"lib"},{"type":"pre-existing","id":"stm-2.5.1.0","pkg-name":"stm","pkg-version":"2.5.1.0","depends":["array-0.5.6.0","base-4.18.2.0"]},{"type":"pre-existing","id":"system-cxx-std-lib-1.0","pkg-name":"system-cxx-std-lib","pkg-version":"1.0","depends":[]},{"type":"pre-existing","id":"template-haskell-2.20.0.0","pkg-name":"template-haskell","pkg-version":"2.20.0.0","depends":["base-4.18.2.0","ghc-boot-th-9.6.4","ghc-prim-0.10.0","pretty-1.1.3.6"]},{"type":"pre-existing","id":"text-2.0.2","pkg-name":"text","pkg-version":"2.0.2","depends":["array-0.5.6.0","base-4.18.2.0","binary-0.8.9.1","bytestring-0.11.5.3","deepseq-1.4.8.1","ghc-prim-0.10.0","system-cxx-std-lib-1.0","template-haskell-2.20.0.0"]},{"type":"pre-existing","id":"time-1.12.2","pkg-name":"time","pkg-version":"1.12.2","depends":["base-4.18.2.0","deepseq-1.4.8.1"]},{"type":"pre-existing","id":"transformers-0.6.1.0","pkg-name":"transformers","pkg-version":"0.6.1.0","depends":["base-4.18.2.0","ghc-prim-0.10.0"]},{"type":"pre-existing","id":"unix-2.8.4.0","pkg-name":"unix","pkg-version":"2.8.4.0","depends":["base-4.18.2.0","bytestring-0.11.5.3","filepath-1.4.200.1","time-1.12.2"]},{"type":"configured","id":"unordered-containers-0.2.19.1-0eb0d95c2f270578763e7cbc938fd7d57fa65a8f3c10aa64b616bc79bbf6b993","pkg-name":"unordered-containers","pkg-version":"0.2.19.1","flags":{"debug":false},"style":"global","pkg-src":{"type":"repo-tar","repo":{"type":"secure-repo","uri":"http://hackage.haskell.org/"}},"pkg-cabal-sha256":"1c28ca429e3960de0330908579a427ccacddd700cb84ec1969e2bbe576152add","pkg-src-sha256":"1b27bec5e0d522b27a6029ebf4c4a6d40acbc083c787008e32fb55c4b1d128d2","depends":["base-4.18.2.0","deepseq-1.4.8.1","hashable-1.4.3.0-cf03199beb9180bbbb9b383e3088c03deb3be32037dd08933c3d3ba08171d03e","template-haskell-2.20.0.0"],"exe-depends":[],"component-name":"lib"},{"type":"configured","id":"utf8-string-1.0.2-134849f72bdb35a6754bed838d5c0f0412c3ca2863338b599b4cd9b0af070e05","pkg-name":"utf8-string","pkg-version":"1.0.2","flags":{},"style":"global","pkg-src":{"type":"repo-tar","repo":{"type":"secure-repo","uri":"http://hackage.haskell.org/"}},"pkg-cabal-sha256":"79416292186feeaf1f60e49ac5a1ffae9bf1b120e040a74bf0e81ca7f1d31d3f","pkg-src-sha256":"ee48deada7600370728c4156cb002441de770d0121ae33a68139a9ed9c19b09a","depends":["base-4.18.2.0","bytestring-0.11.5.3"],"exe-depends":[],"component-name":"lib"}],"targets":[{"pkg-name":"Cabal","pkg-version":"3.8.1.0","component-name":"lib","available":[{"id":"Cabal-3.8.1.0-c668f818769193b477ca1a8b87e802e56126adbc7bed962d76bde34a01e8c306","component-name":"lib","build-by-default":true}]},{"pkg-name":"Cabal-syntax","pkg-version":"3.8.1.0","component-name":"lib","available":[{"id":"Cabal-syntax-3.8.1.0-b99db30153f1d2c83dc6d34e637d577dc69cabe5825778a1e3462bcf8317b588","component-name":"lib","build-by-default":true}]},{"pkg-name":"QuickCheck","pkg-version":"2.14.3","component-name":"lib","available":[{"id":"QuickCheck-2.14.3-116702925e70e233df64507a5cae969ff9c69efe35b3cc35e56c87d47168ff11","component-name":"lib","build-by-default":true}]},{"pkg-name":"QuickCheck","pkg-version":"2.14.3","component-name":"test:test-quickcheck","available":["TargetNotLocal"]},{"pkg-name":"QuickCheck","pkg-version":"2.14.3","component-name":"test:test-quickcheck-gcoarbitrary","available":["TargetNotLocal"]},{"pkg-name":"QuickCheck","pkg-version":"2.14.3","component-name":"test:test-quickcheck-generators","available":["TargetNotLocal"]},{"pkg-name":"QuickCheck","pkg-version":"2.14.3","component-name":"test:test-quickcheck-gshrink","available":["TargetNotLocal"]},{"pkg-name":"QuickCheck","pkg-version":"2.14.3","component-name":"test:test-quickcheck-misc","available":["TargetNotLocal"]},{"pkg-name":"QuickCheck","pkg-version":"2.14.3","component-name":"test:test-quickcheck-monadfix","available":["TargetNotLocal"]},{"pkg-name":"QuickCheck","pkg-version":"2.14.3","component-name":"test:test-quickcheck-split","available":["TargetNotLocal"]},{"pkg-name":"QuickCheck","pkg-version":"2.14.3","component-name":"test:test-quickcheck-terminal","available":["TargetNotLocal"]},{"pkg-name":"array","pkg-version":"0.5.6.0","component-name":"lib","available":[{"id":"array-0.5.6.0","component-name":"lib","build-by-default":true}]},{"pkg-name":"base","pkg-version":"4.18.2.0","component-name":"lib","available":[{"id":"base-4.18.2.0","component-name":"lib","build-by-default":true}]},{"pkg-name":"binary","pkg-version":"0.8.9.1","component-name":"lib","available":[{"id":"binary-0.8.9.1","component-name":"lib","build-by-default":true}]},{"pkg-name":"bytestring","pkg-version":"0.11.5.3","component-name":"lib","available":[{"id":"bytestring-0.11.5.3","component-name":"lib","build-by-default":true}]},{"pkg-name":"clock","pkg-version":"0.8.4","component-name":"lib","available":[{"id":"clock-0.8.4-b6af39fafa1fb93e9520050c562fc2d9803a08bc83cda5d8b8d907beefe150aa","component-name":"lib","build-by-default":true}]},{"pkg-name":"clock","pkg-version":"0.8.4","component-name":"test:test","available":["TargetNotLocal"]},{"pkg-name":"clock","pkg-version":"0.8.4","component-name":"bench:benchmarks","available":["TargetNotLocal"]},{"pkg-name":"containers","pkg-version":"0.6.7","component-name":"lib","available":[{"id":"containers-0.6.7","component-name":"lib","build-by-default":true}]},{"pkg-name":"deepseq","pkg-version":"1.4.8.1","component-name":"lib","available":[{"id":"deepseq-1.4.8.1","component-name":"lib","build-by-default":true}]},{"pkg-name":"directory","pkg-version":"1.3.8.1","component-name":"lib","available":[{"id":"directory-1.3.8.1","component-name":"lib","build-by-default":true}]},{"pkg-name":"exceptions","pkg-version":"0.10.7","component-name":"lib","available":[{"id":"exceptions-0.10.7","component-name":"lib","build-by-default":true}]},{"pkg-name":"extra","pkg-version":"1.7.14","component-name":"lib","available":[{"id":"extra-1.7.14-5b3875febb50e86e1fd0471cb61fc83c08afae84f74dd82e3fe23bdc226bd3c9","component-name":"lib","build-by-default":true}]},{"pkg-name":"extra","pkg-version":"1.7.14","component-name":"test:extra-test","available":["TargetNotLocal"]},{"pkg-name":"filepath","pkg-version":"1.4.200.1","component-name":"lib","available":[{"id":"filepath-1.4.200.1","component-name":"lib","build-by-default":true}]},{"pkg-name":"filepattern","pkg-version":"0.1.3","component-name":"lib","available":[{"id":"filepattern-0.1.3-e0b05225cb586afea88cbd5fba3b81dbc7d8925b44e8dd467cfd9ed208da351b","component-name":"lib","build-by-default":true}]},{"pkg-name":"filepattern","pkg-version":"0.1.3","component-name":"test:filepattern-test","available":["TargetNotLocal"]},{"pkg-name":"ghc-bignum","pkg-version":"1.3","component-name":"lib","available":[{"id":"ghc-bignum-1.3","component-name":"lib","build-by-default":true}]},{"pkg-name":"ghc-boot-th","pkg-version":"9.6.4","component-name":"lib","available":[{"id":"ghc-boot-th-9.6.4","component-name":"lib","build-by-default":true}]},{"pkg-name":"ghc-prim","pkg-version":"0.10.0","component-name":"lib","available":[{"id":"ghc-prim-0.10.0","component-name":"lib","build-by-default":true}]},{"pkg-name":"hadrian","pkg-version":"0.1.0.0","component-name":"exe:hadrian","available":[{"id":"hadrian-0.1.0.0-inplace-hadrian","component-name":"exe:hadrian","build-by-default":true}]},{"pkg-name":"hashable","pkg-version":"1.4.3.0","component-name":"lib","available":[{"id":"hashable-1.4.3.0-cf03199beb9180bbbb9b383e3088c03deb3be32037dd08933c3d3ba08171d03e","component-name":"lib","build-by-default":true}]},{"pkg-name":"hashable","pkg-version":"1.4.3.0","component-name":"test:hashable-examples","available":["TargetNotLocal"]},{"pkg-name":"hashable","pkg-version":"1.4.3.0","component-name":"test:hashable-tests","available":["TargetNotLocal"]},{"pkg-name":"heaps","pkg-version":"0.4","component-name":"lib","available":[{"id":"heaps-0.4-582bc0f356369f4ac6a9badb439391d1ff82a6d0d7a4a55fe3db91d6d1a32875","component-name":"lib","build-by-default":true}]},{"pkg-name":"js-dgtable","pkg-version":"0.5.2","component-name":"lib","available":[{"id":"js-dgtable-0.5.2-40721bc9982faf5e0f71e3119e01102f429fefca9219230921535f5382e177f7","component-name":"lib","build-by-default":true}]},{"pkg-name":"js-dgtable","pkg-version":"0.5.2","component-name":"test:js-dgtable-test","available":["TargetNotLocal"]},{"pkg-name":"js-flot","pkg-version":"0.8.3","component-name":"lib","available":[{"id":"js-flot-0.8.3-fadd4ccb467ede662552cdc382e02fb02027d8181620f296bae75d1f76774b0b","component-name":"lib","build-by-default":true}]},{"pkg-name":"js-flot","pkg-version":"0.8.3","component-name":"test:js-flot-test","available":["TargetNotLocal"]},{"pkg-name":"js-jquery","pkg-version":"3.3.1","component-name":"lib","available":[{"id":"js-jquery-3.3.1-6a8cc1e84fc203e099644c71b32217b6615b055459038eb73f1b008db4b2f236","component-name":"lib","build-by-default":true}]},{"pkg-name":"js-jquery","pkg-version":"3.3.1","component-name":"test:js-jquery-test","available":["TargetNotLocal"]},{"pkg-name":"mtl","pkg-version":"2.3.1","component-name":"lib","available":[{"id":"mtl-2.3.1","component-name":"lib","build-by-default":true}]},{"pkg-name":"parsec","pkg-version":"3.1.16.1","component-name":"lib","available":[{"id":"parsec-3.1.16.1","component-name":"lib","build-by-default":true}]},{"pkg-name":"pretty","pkg-version":"1.1.3.6","component-name":"lib","available":[{"id":"pretty-1.1.3.6","component-name":"lib","build-by-default":true}]},{"pkg-name":"primitive","pkg-version":"0.9.0.0","component-name":"lib","available":[{"id":"primitive-0.9.0.0-b327a6c8ea4577ea7938607770d363048048a528efdff4bc67a582b5feac66fc","component-name":"lib","build-by-default":true}]},{"pkg-name":"primitive","pkg-version":"0.9.0.0","component-name":"test:test-qc","available":["TargetNotLocal"]},{"pkg-name":"primitive","pkg-version":"0.9.0.0","component-name":"bench:bench","available":["TargetNotLocal"]},{"pkg-name":"process","pkg-version":"1.6.17.0","component-name":"lib","available":[{"id":"process-1.6.17.0","component-name":"lib","build-by-default":true}]},{"pkg-name":"random","pkg-version":"1.2.1.1","component-name":"lib","available":[{"id":"random-1.2.1.1-e2b8c23c50d3a2e2d7c30c46d2a3344a9c2a38bf319885311c62efb7342cb80b","component-name":"lib","build-by-default":true}]},{"pkg-name":"random","pkg-version":"1.2.1.1","component-name":"test:doctests","available":["TargetNotLocal"]},{"pkg-name":"random","pkg-version":"1.2.1.1","component-name":"test:legacy-test","available":["TargetNotLocal"]},{"pkg-name":"random","pkg-version":"1.2.1.1","component-name":"test:spec","available":["TargetNotLocal"]},{"pkg-name":"random","pkg-version":"1.2.1.1","component-name":"test:spec-inspection","available":["TargetNotLocal"]},{"pkg-name":"random","pkg-version":"1.2.1.1","component-name":"bench:bench","available":["TargetNotLocal"]},{"pkg-name":"random","pkg-version":"1.2.1.1","component-name":"bench:legacy-bench","available":["TargetNotLocal"]},{"pkg-name":"shake","pkg-version":"0.19.7","component-name":"lib","available":[{"id":"shake-0.19.7-9369313762a66f683383a6b11b819b9aafcd8f0d518c176b2cb1f5a198ccf8cd","component-name":"lib","build-by-default":true}]},{"pkg-name":"shake","pkg-version":"0.19.7","component-name":"exe:shake","available":[{"id":"shake-0.19.7-e-shake-74d898c5705f61c05a8a7aee14d32e6ef38e5584b58da7af7f06efe4c3c36716","component-name":"exe:shake","build-by-default":true}]},{"pkg-name":"shake","pkg-version":"0.19.7","component-name":"test:shake-test","available":["TargetNotLocal"]},{"pkg-name":"splitmix","pkg-version":"0.1.0.5","component-name":"lib","available":[{"id":"splitmix-0.1.0.5-232d2b1a4ce5cacd620dd2472d411c8d63e777af17182b5d56b631942f729187","component-name":"lib","build-by-default":true}]},{"pkg-name":"splitmix","pkg-version":"0.1.0.5","component-name":"test:examples","available":["TargetNotLocal"]},{"pkg-name":"splitmix","pkg-version":"0.1.0.5","component-name":"test:initialization","available":["TargetNotLocal"]},{"pkg-name":"splitmix","pkg-version":"0.1.0.5","component-name":"test:montecarlo-pi","available":["TargetNotLocal"]},{"pkg-name":"splitmix","pkg-version":"0.1.0.5","component-name":"test:montecarlo-pi-32","available":["TargetNotLocal"]},{"pkg-name":"splitmix","pkg-version":"0.1.0.5","component-name":"test:splitmix-dieharder","available":["TargetNotLocal"]},{"pkg-name":"splitmix","pkg-version":"0.1.0.5","component-name":"test:splitmix-tests","available":["TargetNotLocal"]},{"pkg-name":"splitmix","pkg-version":"0.1.0.5","component-name":"test:splitmix-testu01","available":["TargetNotLocal"]},{"pkg-name":"splitmix","pkg-version":"0.1.0.5","component-name":"bench:comparison","available":["TargetNotLocal"]},{"pkg-name":"splitmix","pkg-version":"0.1.0.5","component-name":"bench:range","available":["TargetNotLocal"]},{"pkg-name":"splitmix","pkg-version":"0.1.0.5","component-name":"bench:simple-sum","available":["TargetNotLocal"]},{"pkg-name":"stm","pkg-version":"2.5.1.0","component-name":"lib","available":[{"id":"stm-2.5.1.0","component-name":"lib","build-by-default":true}]},{"pkg-name":"system-cxx-std-lib","pkg-version":"1.0","component-name":"lib","available":[{"id":"system-cxx-std-lib-1.0","component-name":"lib","build-by-default":true}]},{"pkg-name":"template-haskell","pkg-version":"2.20.0.0","component-name":"lib","available":[{"id":"template-haskell-2.20.0.0","component-name":"lib","build-by-default":true}]},{"pkg-name":"text","pkg-version":"2.0.2","component-name":"lib","available":[{"id":"text-2.0.2","component-name":"lib","build-by-default":true}]},{"pkg-name":"time","pkg-version":"1.12.2","component-name":"lib","available":[{"id":"time-1.12.2","component-name":"lib","build-by-default":true}]},{"pkg-name":"transformers","pkg-version":"0.6.1.0","component-name":"lib","available":[{"id":"transformers-0.6.1.0","component-name":"lib","build-by-default":true}]},{"pkg-name":"unix","pkg-version":"2.8.4.0","component-name":"lib","available":[{"id":"unix-2.8.4.0","component-name":"lib","build-by-default":true}]},{"pkg-name":"unordered-containers","pkg-version":"0.2.19.1","component-name":"lib","available":[{"id":"unordered-containers-0.2.19.1-0eb0d95c2f270578763e7cbc938fd7d57fa65a8f3c10aa64b616bc79bbf6b993","component-name":"lib","build-by-default":true}]},{"pkg-name":"unordered-containers","pkg-version":"0.2.19.1","component-name":"test:unordered-containers-tests","available":["TargetNotLocal"]},{"pkg-name":"unordered-containers","pkg-version":"0.2.19.1","component-name":"bench:benchmarks","available":["TargetNotLocal"]},{"pkg-name":"utf8-string","pkg-version":"1.0.2","component-name":"lib","available":[{"id":"utf8-string-1.0.2-134849f72bdb35a6754bed838d5c0f0412c3ca2863338b599b4cd9b0af070e05","component-name":"lib","build-by-default":true}]},{"pkg-name":"utf8-string","pkg-version":"1.0.2","component-name":"test:unit-tests","available":["TargetNotLocal"]}]} \ No newline at end of file +{"cabal-version":"3.10.3.0","cabal-lib-version":"3.10.3.0","compiler-id":"ghc-9.6.4","os":"linux","arch":"x86_64","install-plan":[{"type":"configured","id":"Cabal-3.8.1.0-c668f818769193b477ca1a8b87e802e56126adbc7bed962d76bde34a01e8c306","pkg-name":"Cabal","pkg-version":"3.8.1.0","flags":{},"style":"global","pkg-src":{"type":"repo-tar","repo":{"type":"secure-repo","uri":"http://hackage.haskell.org/"}},"pkg-cabal-sha256":"77121d8e1aff14a0fd95684b751599db78a7dd26d55862d9fcef27c88b193e9d","pkg-src-sha256":"7464cbe6c2f3d7e5d0232023a1a7330621f8b24853cb259fc89a2af85b736608","depends":["Cabal-syntax-3.8.1.0-b99db30153f1d2c83dc6d34e637d577dc69cabe5825778a1e3462bcf8317b588","array-0.5.6.0","base-4.18.2.0","bytestring-0.11.5.3","containers-0.6.7","deepseq-1.4.8.1","directory-1.3.8.1","filepath-1.4.200.1","mtl-2.3.1","parsec-3.1.16.1","pretty-1.1.3.6","process-1.6.17.0","text-2.0.2","time-1.12.2","transformers-0.6.1.0","unix-2.8.4.0"],"exe-depends":[],"component-name":"lib"},{"type":"configured","id":"Cabal-syntax-3.8.1.0-b99db30153f1d2c83dc6d34e637d577dc69cabe5825778a1e3462bcf8317b588","pkg-name":"Cabal-syntax","pkg-version":"3.8.1.0","flags":{},"style":"global","pkg-src":{"type":"repo-tar","repo":{"type":"secure-repo","uri":"http://hackage.haskell.org/"}},"pkg-cabal-sha256":"ed2d937ba6c6a20b75850349eedd41374885fc42369ef152d69e2ba70f44f593","pkg-src-sha256":"07e8ddb19fe01781485f1522b6afc22aba680b0ab28ebe6bbfb84a2dd698ce0f","depends":["array-0.5.6.0","base-4.18.2.0","binary-0.8.9.1","bytestring-0.11.5.3","containers-0.6.7","deepseq-1.4.8.1","directory-1.3.8.1","filepath-1.4.200.1","mtl-2.3.1","parsec-3.1.16.1","pretty-1.1.3.6","text-2.0.2","time-1.12.2","transformers-0.6.1.0","unix-2.8.4.0"],"exe-depends":[],"component-name":"lib"},{"type":"configured","id":"QuickCheck-2.14.3-12660abe9f5c6a28f87584c784112e82267cee7f5b9b5a1823ce30f9270ebf1a","pkg-name":"QuickCheck","pkg-version":"2.14.3","flags":{"old-random":false,"templatehaskell":true},"style":"global","pkg-src":{"type":"repo-tar","repo":{"type":"secure-repo","uri":"http://hackage.haskell.org/"}},"pkg-cabal-sha256":"f03d2f404d5ba465453d0fbc1944832789a759fe7c4f9bf8616bc1378a02fde4","pkg-src-sha256":"5c0f22b36b28a1a8fa110b3819818d3f29494a3b0dedbae299f064123ca70501","depends":["base-4.18.2.0","containers-0.6.7","deepseq-1.4.8.1","random-1.2.1.2-ccb717c59af131f21dfc040f6185e9cbf4f0b5a3f6de1b3b376d50859a348586","splitmix-0.1.0.5-232d2b1a4ce5cacd620dd2472d411c8d63e777af17182b5d56b631942f729187","template-haskell-2.20.0.0","transformers-0.6.1.0"],"exe-depends":[],"component-name":"lib"},{"type":"pre-existing","id":"array-0.5.6.0","pkg-name":"array","pkg-version":"0.5.6.0","depends":["base-4.18.2.0"]},{"type":"pre-existing","id":"base-4.18.2.0","pkg-name":"base","pkg-version":"4.18.2.0","depends":["ghc-bignum-1.3","ghc-prim-0.10.0"]},{"type":"pre-existing","id":"binary-0.8.9.1","pkg-name":"binary","pkg-version":"0.8.9.1","depends":["array-0.5.6.0","base-4.18.2.0","bytestring-0.11.5.3","containers-0.6.7","ghc-prim-0.10.0"]},{"type":"pre-existing","id":"bytestring-0.11.5.3","pkg-name":"bytestring","pkg-version":"0.11.5.3","depends":["base-4.18.2.0","deepseq-1.4.8.1","ghc-prim-0.10.0","template-haskell-2.20.0.0"]},{"type":"configured","id":"clock-0.8.4-b6af39fafa1fb93e9520050c562fc2d9803a08bc83cda5d8b8d907beefe150aa","pkg-name":"clock","pkg-version":"0.8.4","flags":{"llvm":false},"style":"global","pkg-src":{"type":"repo-tar","repo":{"type":"secure-repo","uri":"http://hackage.haskell.org/"}},"pkg-cabal-sha256":"b938655b00cf204ce69abfff946021bed111d2609a9f7a9c22e28a1a202e9115","pkg-src-sha256":"6ae9898afe788a5e334cd5fad5d18a3c2e8e59fa09aaf7b957dbb38a4767df2e","depends":["base-4.18.2.0"],"exe-depends":[],"component-name":"lib"},{"type":"pre-existing","id":"containers-0.6.7","pkg-name":"containers","pkg-version":"0.6.7","depends":["array-0.5.6.0","base-4.18.2.0","deepseq-1.4.8.1","template-haskell-2.20.0.0"]},{"type":"pre-existing","id":"deepseq-1.4.8.1","pkg-name":"deepseq","pkg-version":"1.4.8.1","depends":["array-0.5.6.0","base-4.18.2.0","ghc-prim-0.10.0"]},{"type":"pre-existing","id":"directory-1.3.8.1","pkg-name":"directory","pkg-version":"1.3.8.1","depends":["base-4.18.2.0","filepath-1.4.200.1","time-1.12.2","unix-2.8.4.0"]},{"type":"pre-existing","id":"exceptions-0.10.7","pkg-name":"exceptions","pkg-version":"0.10.7","depends":["base-4.18.2.0","mtl-2.3.1","stm-2.5.1.0","template-haskell-2.20.0.0","transformers-0.6.1.0"]},{"type":"configured","id":"extra-1.7.16-dc63228cbe6629bad55bc0268aff37cd1d9389acb03be20763ed611a10fe3efc","pkg-name":"extra","pkg-version":"1.7.16","flags":{},"style":"global","pkg-src":{"type":"repo-tar","repo":{"type":"secure-repo","uri":"http://hackage.haskell.org/"}},"pkg-cabal-sha256":"edd191f77adf31acb1b53960b4d1ca9fca925ac28345a396c614414cb7bfa7ec","pkg-src-sha256":"250c6d43c30b2c71f2cf498a10e69e43ac035974d3819529385d99e42ce77c70","depends":["base-4.18.2.0","clock-0.8.4-b6af39fafa1fb93e9520050c562fc2d9803a08bc83cda5d8b8d907beefe150aa","directory-1.3.8.1","filepath-1.4.200.1","process-1.6.17.0","time-1.12.2","unix-2.8.4.0"],"exe-depends":[],"component-name":"lib"},{"type":"pre-existing","id":"filepath-1.4.200.1","pkg-name":"filepath","pkg-version":"1.4.200.1","depends":["base-4.18.2.0","bytestring-0.11.5.3","deepseq-1.4.8.1","exceptions-0.10.7","template-haskell-2.20.0.0"]},{"type":"configured","id":"filepattern-0.1.3-c45690bc0b4b5c677f6943e7896ddd599d085687db6e459293ba6fa381af7c6e","pkg-name":"filepattern","pkg-version":"0.1.3","flags":{},"style":"global","pkg-src":{"type":"repo-tar","repo":{"type":"secure-repo","uri":"http://hackage.haskell.org/"}},"pkg-cabal-sha256":"372c1733d83b90045eb29da9f010fed79bfef8771ce65eb126a1d83ecc54a9a2","pkg-src-sha256":"cc445d439ea2f65cac7604d3578aa2c3a62e5a91dc989f4ce5b3390db9e59636","depends":["base-4.18.2.0","directory-1.3.8.1","extra-1.7.16-dc63228cbe6629bad55bc0268aff37cd1d9389acb03be20763ed611a10fe3efc","filepath-1.4.200.1"],"exe-depends":[],"component-name":"lib"},{"type":"pre-existing","id":"ghc-bignum-1.3","pkg-name":"ghc-bignum","pkg-version":"1.3","depends":["ghc-prim-0.10.0"]},{"type":"pre-existing","id":"ghc-boot-th-9.6.4","pkg-name":"ghc-boot-th","pkg-version":"9.6.4","depends":["base-4.18.2.0"]},{"type":"pre-existing","id":"ghc-prim-0.10.0","pkg-name":"ghc-prim","pkg-version":"0.10.0","depends":[]},{"type":"configured","id":"hadrian-0.1.0.0-inplace-hadrian","pkg-name":"hadrian","pkg-version":"0.1.0.0","flags":{"selftest":true,"threaded":true},"style":"local","pkg-src":{"type":"local","path":"./hadrian/."},"dist-dir":"./hadrian/dist-newstyle/build/x86_64-linux/ghc-9.6.4/hadrian-0.1.0.0/x/hadrian","build-info":"./hadrian/dist-newstyle/build/x86_64-linux/ghc-9.6.4/hadrian-0.1.0.0/x/hadrian/build-info.json","depends":["Cabal-3.8.1.0-c668f818769193b477ca1a8b87e802e56126adbc7bed962d76bde34a01e8c306","QuickCheck-2.14.3-12660abe9f5c6a28f87584c784112e82267cee7f5b9b5a1823ce30f9270ebf1a","base-4.18.2.0","bytestring-0.11.5.3","containers-0.6.7","directory-1.3.8.1","extra-1.7.16-dc63228cbe6629bad55bc0268aff37cd1d9389acb03be20763ed611a10fe3efc","filepath-1.4.200.1","mtl-2.3.1","parsec-3.1.16.1","shake-0.19.8-0ddb83d9db09621c7b8f326abc494d14323dc5751be6943ac5b5e19c9347d5c3","text-2.0.2","time-1.12.2","transformers-0.6.1.0","unordered-containers-0.2.20-0a8211d6220ec0e6694f219bbea9da08528b897266f5898f98f4d6e1ab6fd737"],"exe-depends":[],"component-name":"exe:hadrian","bin-file":"./hadrian/dist-newstyle/build/x86_64-linux/ghc-9.6.4/hadrian-0.1.0.0/x/hadrian/build/hadrian/hadrian"},{"type":"configured","id":"hashable-1.5.0.0-0ac0785933877296ccb7501af740625424a60e762d9e13c3f7fb819fa7014b88","pkg-name":"hashable","pkg-version":"1.5.0.0","flags":{"arch-native":false,"random-initial-seed":false},"style":"global","pkg-src":{"type":"repo-tar","repo":{"type":"secure-repo","uri":"http://hackage.haskell.org/"}},"pkg-cabal-sha256":"fc68b07d957ade5a0a0beadd560a8d093ceac30b2f35c85eed3bcf7889a25975","pkg-src-sha256":"e58b3a8e18da5f6cd7e937e5fd683e500bb1f8276b3768269759119ca0cddb6a","depends":["base-4.18.2.0","bytestring-0.11.5.3","containers-0.6.7","deepseq-1.4.8.1","filepath-1.4.200.1","ghc-bignum-1.3","ghc-prim-0.10.0","os-string-2.0.6-01e3c1e4563fbed004a4ac273e2beea9dfd497789ab9039e09b96161f470a497","text-2.0.2"],"exe-depends":[],"component-name":"lib"},{"type":"configured","id":"heaps-0.4-582bc0f356369f4ac6a9badb439391d1ff82a6d0d7a4a55fe3db91d6d1a32875","pkg-name":"heaps","pkg-version":"0.4","flags":{},"style":"global","pkg-src":{"type":"repo-tar","repo":{"type":"secure-repo","uri":"http://hackage.haskell.org/"}},"pkg-cabal-sha256":"66b19fcd813b0e4db3e0bac541bd46606c3b13d3d081d9f9666f4be0f5ff14b8","pkg-src-sha256":"89329df8b95ae99ef272e41e7a2d0fe2f1bb7eacfcc34bc01664414b33067cfd","depends":["base-4.18.2.0"],"exe-depends":[],"component-name":"lib"},{"type":"configured","id":"js-dgtable-0.5.2-40721bc9982faf5e0f71e3119e01102f429fefca9219230921535f5382e177f7","pkg-name":"js-dgtable","pkg-version":"0.5.2","flags":{},"style":"global","pkg-src":{"type":"repo-tar","repo":{"type":"secure-repo","uri":"http://hackage.haskell.org/"}},"pkg-cabal-sha256":"f75cb4fa53c88c65794becdd48eb0d3b2b8abd89a3d5c19e87af91f5225c15e4","pkg-src-sha256":"e28dd65bee8083b17210134e22e01c6349dc33c3b7bd17705973cd014e9f20ac","depends":["base-4.18.2.0"],"exe-depends":[],"component-name":"lib"},{"type":"configured","id":"js-flot-0.8.3-fadd4ccb467ede662552cdc382e02fb02027d8181620f296bae75d1f76774b0b","pkg-name":"js-flot","pkg-version":"0.8.3","flags":{},"style":"global","pkg-src":{"type":"repo-tar","repo":{"type":"secure-repo","uri":"http://hackage.haskell.org/"}},"pkg-cabal-sha256":"4c1c447a9a2fba0adba6d30678302a30c32b9dfde9e7aa9e9156483e1545096d","pkg-src-sha256":"1ba2f2a6b8d85da76c41f526c98903cbb107f8642e506c072c1e7e3c20fe5e7a","depends":["base-4.18.2.0"],"exe-depends":[],"component-name":"lib"},{"type":"configured","id":"js-jquery-3.3.1-6a8cc1e84fc203e099644c71b32217b6615b055459038eb73f1b008db4b2f236","pkg-name":"js-jquery","pkg-version":"3.3.1","flags":{},"style":"global","pkg-src":{"type":"repo-tar","repo":{"type":"secure-repo","uri":"http://hackage.haskell.org/"}},"pkg-cabal-sha256":"59ab6c79159549ef94b584abce8e6d3b336014c2cce1337b59a8f637e2856df5","pkg-src-sha256":"e0e0681f0da1130ede4e03a051630ea439c458cb97216cdb01771ebdbe44069b","depends":["base-4.18.2.0"],"exe-depends":[],"component-name":"lib"},{"type":"pre-existing","id":"mtl-2.3.1","pkg-name":"mtl","pkg-version":"2.3.1","depends":["base-4.18.2.0","transformers-0.6.1.0"]},{"type":"configured","id":"os-string-2.0.6-01e3c1e4563fbed004a4ac273e2beea9dfd497789ab9039e09b96161f470a497","pkg-name":"os-string","pkg-version":"2.0.6","flags":{},"style":"global","pkg-src":{"type":"repo-tar","repo":{"type":"secure-repo","uri":"http://hackage.haskell.org/"}},"pkg-cabal-sha256":"7699e7ae9bf74d056a62f384ceef8dfb2aa660f3f7c8016e9703f3b995e5e030","pkg-src-sha256":"22fcc7d5fc66676b5dfc57b714d2caf93cce2d5a79d242168352f9eb0fe2f18a","depends":["base-4.18.2.0","bytestring-0.11.5.3","deepseq-1.4.8.1","exceptions-0.10.7","template-haskell-2.20.0.0"],"exe-depends":[],"component-name":"lib"},{"type":"pre-existing","id":"parsec-3.1.16.1","pkg-name":"parsec","pkg-version":"3.1.16.1","depends":["base-4.18.2.0","bytestring-0.11.5.3","mtl-2.3.1","text-2.0.2"]},{"type":"pre-existing","id":"pretty-1.1.3.6","pkg-name":"pretty","pkg-version":"1.1.3.6","depends":["base-4.18.2.0","deepseq-1.4.8.1","ghc-prim-0.10.0"]},{"type":"configured","id":"primitive-0.9.0.0-b327a6c8ea4577ea7938607770d363048048a528efdff4bc67a582b5feac66fc","pkg-name":"primitive","pkg-version":"0.9.0.0","flags":{},"style":"global","pkg-src":{"type":"repo-tar","repo":{"type":"secure-repo","uri":"http://hackage.haskell.org/"}},"pkg-cabal-sha256":"2e08c5409e3559c7f1669ef50e9a0d9a397e68ecf51110d5e2cedf05cdd7d93c","pkg-src-sha256":"696d4bd291c94d736142d6182117dca4258d3ef28bfefdb649ac8b5ecd0999c7","depends":["base-4.18.2.0","deepseq-1.4.8.1","template-haskell-2.20.0.0","transformers-0.6.1.0"],"exe-depends":[],"component-name":"lib"},{"type":"pre-existing","id":"process-1.6.17.0","pkg-name":"process","pkg-version":"1.6.17.0","depends":["base-4.18.2.0","deepseq-1.4.8.1","directory-1.3.8.1","filepath-1.4.200.1","unix-2.8.4.0"]},{"type":"configured","id":"random-1.2.1.2-ccb717c59af131f21dfc040f6185e9cbf4f0b5a3f6de1b3b376d50859a348586","pkg-name":"random","pkg-version":"1.2.1.2","flags":{},"style":"global","pkg-src":{"type":"repo-tar","repo":{"type":"secure-repo","uri":"http://hackage.haskell.org/"}},"pkg-cabal-sha256":"32397de181e20ccaacf806ec70de9308cf044f089a2be37c936f3f8967bde867","pkg-src-sha256":"790f4dc2d2327c453ff6aac7bf15399fd123d55e927935f68f84b5df42d9a4b4","depends":["base-4.18.2.0","bytestring-0.11.5.3","deepseq-1.4.8.1","mtl-2.3.1","splitmix-0.1.0.5-232d2b1a4ce5cacd620dd2472d411c8d63e777af17182b5d56b631942f729187"],"exe-depends":[],"component-name":"lib"},{"type":"configured","id":"shake-0.19.8-0ddb83d9db09621c7b8f326abc494d14323dc5751be6943ac5b5e19c9347d5c3","pkg-name":"shake","pkg-version":"0.19.8","flags":{"cloud":false,"embed-files":false,"portable":false,"threaded":true},"style":"global","pkg-src":{"type":"repo-tar","repo":{"type":"secure-repo","uri":"http://hackage.haskell.org/"}},"pkg-cabal-sha256":"03c8f06de478e07ad6fde95984c9206920106d0d8432ecb7ab825ef108d45382","pkg-src-sha256":"6384e33a26a2590bf33719e88881076b899ac4b5340c1c9271e4caa37e9d6535","depends":["base-4.18.2.0","binary-0.8.9.1","bytestring-0.11.5.3","deepseq-1.4.8.1","directory-1.3.8.1","extra-1.7.16-dc63228cbe6629bad55bc0268aff37cd1d9389acb03be20763ed611a10fe3efc","filepath-1.4.200.1","filepattern-0.1.3-c45690bc0b4b5c677f6943e7896ddd599d085687db6e459293ba6fa381af7c6e","hashable-1.5.0.0-0ac0785933877296ccb7501af740625424a60e762d9e13c3f7fb819fa7014b88","heaps-0.4-582bc0f356369f4ac6a9badb439391d1ff82a6d0d7a4a55fe3db91d6d1a32875","js-dgtable-0.5.2-40721bc9982faf5e0f71e3119e01102f429fefca9219230921535f5382e177f7","js-flot-0.8.3-fadd4ccb467ede662552cdc382e02fb02027d8181620f296bae75d1f76774b0b","js-jquery-3.3.1-6a8cc1e84fc203e099644c71b32217b6615b055459038eb73f1b008db4b2f236","primitive-0.9.0.0-b327a6c8ea4577ea7938607770d363048048a528efdff4bc67a582b5feac66fc","process-1.6.17.0","random-1.2.1.2-ccb717c59af131f21dfc040f6185e9cbf4f0b5a3f6de1b3b376d50859a348586","time-1.12.2","transformers-0.6.1.0","unix-2.8.4.0","unordered-containers-0.2.20-0a8211d6220ec0e6694f219bbea9da08528b897266f5898f98f4d6e1ab6fd737","utf8-string-1.0.2-134849f72bdb35a6754bed838d5c0f0412c3ca2863338b599b4cd9b0af070e05"],"exe-depends":[],"component-name":"lib"},{"type":"configured","id":"shake-0.19.8-e-shake-7559c7ff704c4f74648b4baa6b6f1b1db1f99fa251704d87397a432f656a4846","pkg-name":"shake","pkg-version":"0.19.8","flags":{"cloud":false,"embed-files":false,"portable":false,"threaded":true},"style":"global","pkg-src":{"type":"repo-tar","repo":{"type":"secure-repo","uri":"http://hackage.haskell.org/"}},"pkg-cabal-sha256":"03c8f06de478e07ad6fde95984c9206920106d0d8432ecb7ab825ef108d45382","pkg-src-sha256":"6384e33a26a2590bf33719e88881076b899ac4b5340c1c9271e4caa37e9d6535","depends":["base-4.18.2.0","binary-0.8.9.1","bytestring-0.11.5.3","deepseq-1.4.8.1","directory-1.3.8.1","extra-1.7.16-dc63228cbe6629bad55bc0268aff37cd1d9389acb03be20763ed611a10fe3efc","filepath-1.4.200.1","filepattern-0.1.3-c45690bc0b4b5c677f6943e7896ddd599d085687db6e459293ba6fa381af7c6e","hashable-1.5.0.0-0ac0785933877296ccb7501af740625424a60e762d9e13c3f7fb819fa7014b88","heaps-0.4-582bc0f356369f4ac6a9badb439391d1ff82a6d0d7a4a55fe3db91d6d1a32875","js-dgtable-0.5.2-40721bc9982faf5e0f71e3119e01102f429fefca9219230921535f5382e177f7","js-flot-0.8.3-fadd4ccb467ede662552cdc382e02fb02027d8181620f296bae75d1f76774b0b","js-jquery-3.3.1-6a8cc1e84fc203e099644c71b32217b6615b055459038eb73f1b008db4b2f236","primitive-0.9.0.0-b327a6c8ea4577ea7938607770d363048048a528efdff4bc67a582b5feac66fc","process-1.6.17.0","random-1.2.1.2-ccb717c59af131f21dfc040f6185e9cbf4f0b5a3f6de1b3b376d50859a348586","time-1.12.2","transformers-0.6.1.0","unix-2.8.4.0","unordered-containers-0.2.20-0a8211d6220ec0e6694f219bbea9da08528b897266f5898f98f4d6e1ab6fd737","utf8-string-1.0.2-134849f72bdb35a6754bed838d5c0f0412c3ca2863338b599b4cd9b0af070e05"],"exe-depends":[],"component-name":"exe:shake","bin-file":"/store/ghc-9.6.4/shake-0.19.8-e-shake-7559c7ff704c4f74648b4baa6b6f1b1db1f99fa251704d87397a432f656a4846/bin/shake"},{"type":"configured","id":"splitmix-0.1.0.5-232d2b1a4ce5cacd620dd2472d411c8d63e777af17182b5d56b631942f729187","pkg-name":"splitmix","pkg-version":"0.1.0.5","flags":{"optimised-mixer":false},"style":"global","pkg-src":{"type":"repo-tar","repo":{"type":"secure-repo","uri":"http://hackage.haskell.org/"}},"pkg-cabal-sha256":"caa9b4a92abf1496c7f6a3c0f4e357426a54880077cb9f04e260a8bfa034b77b","pkg-src-sha256":"9df07a9611ef45f1b1258a0b412f4d02c920248f69d2e2ce8ccda328f7e13002","depends":["base-4.18.2.0","deepseq-1.4.8.1"],"exe-depends":[],"component-name":"lib"},{"type":"pre-existing","id":"stm-2.5.1.0","pkg-name":"stm","pkg-version":"2.5.1.0","depends":["array-0.5.6.0","base-4.18.2.0"]},{"type":"pre-existing","id":"system-cxx-std-lib-1.0","pkg-name":"system-cxx-std-lib","pkg-version":"1.0","depends":[]},{"type":"pre-existing","id":"template-haskell-2.20.0.0","pkg-name":"template-haskell","pkg-version":"2.20.0.0","depends":["base-4.18.2.0","ghc-boot-th-9.6.4","ghc-prim-0.10.0","pretty-1.1.3.6"]},{"type":"pre-existing","id":"text-2.0.2","pkg-name":"text","pkg-version":"2.0.2","depends":["array-0.5.6.0","base-4.18.2.0","binary-0.8.9.1","bytestring-0.11.5.3","deepseq-1.4.8.1","ghc-prim-0.10.0","system-cxx-std-lib-1.0","template-haskell-2.20.0.0"]},{"type":"pre-existing","id":"time-1.12.2","pkg-name":"time","pkg-version":"1.12.2","depends":["base-4.18.2.0","deepseq-1.4.8.1"]},{"type":"pre-existing","id":"transformers-0.6.1.0","pkg-name":"transformers","pkg-version":"0.6.1.0","depends":["base-4.18.2.0","ghc-prim-0.10.0"]},{"type":"pre-existing","id":"unix-2.8.4.0","pkg-name":"unix","pkg-version":"2.8.4.0","depends":["base-4.18.2.0","bytestring-0.11.5.3","filepath-1.4.200.1","time-1.12.2"]},{"type":"configured","id":"unordered-containers-0.2.20-0a8211d6220ec0e6694f219bbea9da08528b897266f5898f98f4d6e1ab6fd737","pkg-name":"unordered-containers","pkg-version":"0.2.20","flags":{"debug":false},"style":"global","pkg-src":{"type":"repo-tar","repo":{"type":"secure-repo","uri":"http://hackage.haskell.org/"}},"pkg-cabal-sha256":"c7fe9cba405ed9905e12d89c7add3b3eb9868dfba7975e70ba0cdd64b7b11abc","pkg-src-sha256":"d9cfb287cf00592d39dc9c3cac8b99627ea08f2c01798e70130fc39f7c90f11d","depends":["base-4.18.2.0","deepseq-1.4.8.1","hashable-1.5.0.0-0ac0785933877296ccb7501af740625424a60e762d9e13c3f7fb819fa7014b88","template-haskell-2.20.0.0"],"exe-depends":[],"component-name":"lib"},{"type":"configured","id":"utf8-string-1.0.2-134849f72bdb35a6754bed838d5c0f0412c3ca2863338b599b4cd9b0af070e05","pkg-name":"utf8-string","pkg-version":"1.0.2","flags":{},"style":"global","pkg-src":{"type":"repo-tar","repo":{"type":"secure-repo","uri":"http://hackage.haskell.org/"}},"pkg-cabal-sha256":"79416292186feeaf1f60e49ac5a1ffae9bf1b120e040a74bf0e81ca7f1d31d3f","pkg-src-sha256":"ee48deada7600370728c4156cb002441de770d0121ae33a68139a9ed9c19b09a","depends":["base-4.18.2.0","bytestring-0.11.5.3"],"exe-depends":[],"component-name":"lib"}],"targets":[{"pkg-name":"Cabal","pkg-version":"3.8.1.0","component-name":"lib","available":[{"id":"Cabal-3.8.1.0-c668f818769193b477ca1a8b87e802e56126adbc7bed962d76bde34a01e8c306","component-name":"lib","build-by-default":true}]},{"pkg-name":"Cabal-syntax","pkg-version":"3.8.1.0","component-name":"lib","available":[{"id":"Cabal-syntax-3.8.1.0-b99db30153f1d2c83dc6d34e637d577dc69cabe5825778a1e3462bcf8317b588","component-name":"lib","build-by-default":true}]},{"pkg-name":"QuickCheck","pkg-version":"2.14.3","component-name":"lib","available":[{"id":"QuickCheck-2.14.3-12660abe9f5c6a28f87584c784112e82267cee7f5b9b5a1823ce30f9270ebf1a","component-name":"lib","build-by-default":true}]},{"pkg-name":"QuickCheck","pkg-version":"2.14.3","component-name":"test:test-quickcheck","available":["TargetNotLocal"]},{"pkg-name":"QuickCheck","pkg-version":"2.14.3","component-name":"test:test-quickcheck-gcoarbitrary","available":["TargetNotLocal"]},{"pkg-name":"QuickCheck","pkg-version":"2.14.3","component-name":"test:test-quickcheck-generators","available":["TargetNotLocal"]},{"pkg-name":"QuickCheck","pkg-version":"2.14.3","component-name":"test:test-quickcheck-gshrink","available":["TargetNotLocal"]},{"pkg-name":"QuickCheck","pkg-version":"2.14.3","component-name":"test:test-quickcheck-misc","available":["TargetNotLocal"]},{"pkg-name":"QuickCheck","pkg-version":"2.14.3","component-name":"test:test-quickcheck-monadfix","available":["TargetNotLocal"]},{"pkg-name":"QuickCheck","pkg-version":"2.14.3","component-name":"test:test-quickcheck-split","available":["TargetNotLocal"]},{"pkg-name":"QuickCheck","pkg-version":"2.14.3","component-name":"test:test-quickcheck-terminal","available":["TargetNotLocal"]},{"pkg-name":"array","pkg-version":"0.5.6.0","component-name":"lib","available":[{"id":"array-0.5.6.0","component-name":"lib","build-by-default":true}]},{"pkg-name":"base","pkg-version":"4.18.2.0","component-name":"lib","available":[{"id":"base-4.18.2.0","component-name":"lib","build-by-default":true}]},{"pkg-name":"binary","pkg-version":"0.8.9.1","component-name":"lib","available":[{"id":"binary-0.8.9.1","component-name":"lib","build-by-default":true}]},{"pkg-name":"bytestring","pkg-version":"0.11.5.3","component-name":"lib","available":[{"id":"bytestring-0.11.5.3","component-name":"lib","build-by-default":true}]},{"pkg-name":"clock","pkg-version":"0.8.4","component-name":"lib","available":[{"id":"clock-0.8.4-b6af39fafa1fb93e9520050c562fc2d9803a08bc83cda5d8b8d907beefe150aa","component-name":"lib","build-by-default":true}]},{"pkg-name":"clock","pkg-version":"0.8.4","component-name":"test:test","available":["TargetNotLocal"]},{"pkg-name":"clock","pkg-version":"0.8.4","component-name":"bench:benchmarks","available":["TargetNotLocal"]},{"pkg-name":"containers","pkg-version":"0.6.7","component-name":"lib","available":[{"id":"containers-0.6.7","component-name":"lib","build-by-default":true}]},{"pkg-name":"deepseq","pkg-version":"1.4.8.1","component-name":"lib","available":[{"id":"deepseq-1.4.8.1","component-name":"lib","build-by-default":true}]},{"pkg-name":"directory","pkg-version":"1.3.8.1","component-name":"lib","available":[{"id":"directory-1.3.8.1","component-name":"lib","build-by-default":true}]},{"pkg-name":"exceptions","pkg-version":"0.10.7","component-name":"lib","available":[{"id":"exceptions-0.10.7","component-name":"lib","build-by-default":true}]},{"pkg-name":"extra","pkg-version":"1.7.16","component-name":"lib","available":[{"id":"extra-1.7.16-dc63228cbe6629bad55bc0268aff37cd1d9389acb03be20763ed611a10fe3efc","component-name":"lib","build-by-default":true}]},{"pkg-name":"extra","pkg-version":"1.7.16","component-name":"test:extra-test","available":["TargetNotLocal"]},{"pkg-name":"filepath","pkg-version":"1.4.200.1","component-name":"lib","available":[{"id":"filepath-1.4.200.1","component-name":"lib","build-by-default":true}]},{"pkg-name":"filepattern","pkg-version":"0.1.3","component-name":"lib","available":[{"id":"filepattern-0.1.3-c45690bc0b4b5c677f6943e7896ddd599d085687db6e459293ba6fa381af7c6e","component-name":"lib","build-by-default":true}]},{"pkg-name":"filepattern","pkg-version":"0.1.3","component-name":"test:filepattern-test","available":["TargetNotLocal"]},{"pkg-name":"ghc-bignum","pkg-version":"1.3","component-name":"lib","available":[{"id":"ghc-bignum-1.3","component-name":"lib","build-by-default":true}]},{"pkg-name":"ghc-boot-th","pkg-version":"9.6.4","component-name":"lib","available":[{"id":"ghc-boot-th-9.6.4","component-name":"lib","build-by-default":true}]},{"pkg-name":"ghc-prim","pkg-version":"0.10.0","component-name":"lib","available":[{"id":"ghc-prim-0.10.0","component-name":"lib","build-by-default":true}]},{"pkg-name":"hadrian","pkg-version":"0.1.0.0","component-name":"exe:hadrian","available":[{"id":"hadrian-0.1.0.0-inplace-hadrian","component-name":"exe:hadrian","build-by-default":true}]},{"pkg-name":"hashable","pkg-version":"1.5.0.0","component-name":"lib","available":[{"id":"hashable-1.5.0.0-0ac0785933877296ccb7501af740625424a60e762d9e13c3f7fb819fa7014b88","component-name":"lib","build-by-default":true}]},{"pkg-name":"hashable","pkg-version":"1.5.0.0","component-name":"test:hashable-examples","available":["TargetNotLocal"]},{"pkg-name":"hashable","pkg-version":"1.5.0.0","component-name":"test:hashable-tests","available":["TargetNotLocal"]},{"pkg-name":"hashable","pkg-version":"1.5.0.0","component-name":"test:xxhash-tests","available":["TargetNotLocal"]},{"pkg-name":"heaps","pkg-version":"0.4","component-name":"lib","available":[{"id":"heaps-0.4-582bc0f356369f4ac6a9badb439391d1ff82a6d0d7a4a55fe3db91d6d1a32875","component-name":"lib","build-by-default":true}]},{"pkg-name":"js-dgtable","pkg-version":"0.5.2","component-name":"lib","available":[{"id":"js-dgtable-0.5.2-40721bc9982faf5e0f71e3119e01102f429fefca9219230921535f5382e177f7","component-name":"lib","build-by-default":true}]},{"pkg-name":"js-dgtable","pkg-version":"0.5.2","component-name":"test:js-dgtable-test","available":["TargetNotLocal"]},{"pkg-name":"js-flot","pkg-version":"0.8.3","component-name":"lib","available":[{"id":"js-flot-0.8.3-fadd4ccb467ede662552cdc382e02fb02027d8181620f296bae75d1f76774b0b","component-name":"lib","build-by-default":true}]},{"pkg-name":"js-flot","pkg-version":"0.8.3","component-name":"test:js-flot-test","available":["TargetNotLocal"]},{"pkg-name":"js-jquery","pkg-version":"3.3.1","component-name":"lib","available":[{"id":"js-jquery-3.3.1-6a8cc1e84fc203e099644c71b32217b6615b055459038eb73f1b008db4b2f236","component-name":"lib","build-by-default":true}]},{"pkg-name":"js-jquery","pkg-version":"3.3.1","component-name":"test:js-jquery-test","available":["TargetNotLocal"]},{"pkg-name":"mtl","pkg-version":"2.3.1","component-name":"lib","available":[{"id":"mtl-2.3.1","component-name":"lib","build-by-default":true}]},{"pkg-name":"os-string","pkg-version":"2.0.6","component-name":"lib","available":[{"id":"os-string-2.0.6-01e3c1e4563fbed004a4ac273e2beea9dfd497789ab9039e09b96161f470a497","component-name":"lib","build-by-default":true}]},{"pkg-name":"os-string","pkg-version":"2.0.6","component-name":"test:bytestring-tests","available":["TargetNotLocal"]},{"pkg-name":"os-string","pkg-version":"2.0.6","component-name":"test:encoding-tests","available":["TargetNotLocal"]},{"pkg-name":"os-string","pkg-version":"2.0.6","component-name":"bench:bench","available":["TargetNotLocal"]},{"pkg-name":"parsec","pkg-version":"3.1.16.1","component-name":"lib","available":[{"id":"parsec-3.1.16.1","component-name":"lib","build-by-default":true}]},{"pkg-name":"pretty","pkg-version":"1.1.3.6","component-name":"lib","available":[{"id":"pretty-1.1.3.6","component-name":"lib","build-by-default":true}]},{"pkg-name":"primitive","pkg-version":"0.9.0.0","component-name":"lib","available":[{"id":"primitive-0.9.0.0-b327a6c8ea4577ea7938607770d363048048a528efdff4bc67a582b5feac66fc","component-name":"lib","build-by-default":true}]},{"pkg-name":"primitive","pkg-version":"0.9.0.0","component-name":"test:test-qc","available":["TargetNotLocal"]},{"pkg-name":"primitive","pkg-version":"0.9.0.0","component-name":"bench:bench","available":["TargetNotLocal"]},{"pkg-name":"process","pkg-version":"1.6.17.0","component-name":"lib","available":[{"id":"process-1.6.17.0","component-name":"lib","build-by-default":true}]},{"pkg-name":"random","pkg-version":"1.2.1.2","component-name":"lib","available":[{"id":"random-1.2.1.2-ccb717c59af131f21dfc040f6185e9cbf4f0b5a3f6de1b3b376d50859a348586","component-name":"lib","build-by-default":true}]},{"pkg-name":"random","pkg-version":"1.2.1.2","component-name":"test:doctests","available":["TargetNotLocal"]},{"pkg-name":"random","pkg-version":"1.2.1.2","component-name":"test:legacy-test","available":["TargetNotLocal"]},{"pkg-name":"random","pkg-version":"1.2.1.2","component-name":"test:spec","available":["TargetNotLocal"]},{"pkg-name":"random","pkg-version":"1.2.1.2","component-name":"test:spec-inspection","available":["TargetNotLocal"]},{"pkg-name":"random","pkg-version":"1.2.1.2","component-name":"bench:bench","available":["TargetNotLocal"]},{"pkg-name":"random","pkg-version":"1.2.1.2","component-name":"bench:legacy-bench","available":["TargetNotLocal"]},{"pkg-name":"shake","pkg-version":"0.19.8","component-name":"lib","available":[{"id":"shake-0.19.8-0ddb83d9db09621c7b8f326abc494d14323dc5751be6943ac5b5e19c9347d5c3","component-name":"lib","build-by-default":true}]},{"pkg-name":"shake","pkg-version":"0.19.8","component-name":"exe:shake","available":[{"id":"shake-0.19.8-e-shake-7559c7ff704c4f74648b4baa6b6f1b1db1f99fa251704d87397a432f656a4846","component-name":"exe:shake","build-by-default":true}]},{"pkg-name":"shake","pkg-version":"0.19.8","component-name":"test:shake-test","available":["TargetNotLocal"]},{"pkg-name":"splitmix","pkg-version":"0.1.0.5","component-name":"lib","available":[{"id":"splitmix-0.1.0.5-232d2b1a4ce5cacd620dd2472d411c8d63e777af17182b5d56b631942f729187","component-name":"lib","build-by-default":true}]},{"pkg-name":"splitmix","pkg-version":"0.1.0.5","component-name":"test:examples","available":["TargetNotLocal"]},{"pkg-name":"splitmix","pkg-version":"0.1.0.5","component-name":"test:initialization","available":["TargetNotLocal"]},{"pkg-name":"splitmix","pkg-version":"0.1.0.5","component-name":"test:montecarlo-pi","available":["TargetNotLocal"]},{"pkg-name":"splitmix","pkg-version":"0.1.0.5","component-name":"test:montecarlo-pi-32","available":["TargetNotLocal"]},{"pkg-name":"splitmix","pkg-version":"0.1.0.5","component-name":"test:splitmix-dieharder","available":["TargetNotLocal"]},{"pkg-name":"splitmix","pkg-version":"0.1.0.5","component-name":"test:splitmix-tests","available":["TargetNotLocal"]},{"pkg-name":"splitmix","pkg-version":"0.1.0.5","component-name":"test:splitmix-testu01","available":["TargetNotLocal"]},{"pkg-name":"splitmix","pkg-version":"0.1.0.5","component-name":"bench:comparison","available":["TargetNotLocal"]},{"pkg-name":"splitmix","pkg-version":"0.1.0.5","component-name":"bench:range","available":["TargetNotLocal"]},{"pkg-name":"splitmix","pkg-version":"0.1.0.5","component-name":"bench:simple-sum","available":["TargetNotLocal"]},{"pkg-name":"stm","pkg-version":"2.5.1.0","component-name":"lib","available":[{"id":"stm-2.5.1.0","component-name":"lib","build-by-default":true}]},{"pkg-name":"system-cxx-std-lib","pkg-version":"1.0","component-name":"lib","available":[{"id":"system-cxx-std-lib-1.0","component-name":"lib","build-by-default":true}]},{"pkg-name":"template-haskell","pkg-version":"2.20.0.0","component-name":"lib","available":[{"id":"template-haskell-2.20.0.0","component-name":"lib","build-by-default":true}]},{"pkg-name":"text","pkg-version":"2.0.2","component-name":"lib","available":[{"id":"text-2.0.2","component-name":"lib","build-by-default":true}]},{"pkg-name":"time","pkg-version":"1.12.2","component-name":"lib","available":[{"id":"time-1.12.2","component-name":"lib","build-by-default":true}]},{"pkg-name":"transformers","pkg-version":"0.6.1.0","component-name":"lib","available":[{"id":"transformers-0.6.1.0","component-name":"lib","build-by-default":true}]},{"pkg-name":"unix","pkg-version":"2.8.4.0","component-name":"lib","available":[{"id":"unix-2.8.4.0","component-name":"lib","build-by-default":true}]},{"pkg-name":"unordered-containers","pkg-version":"0.2.20","component-name":"lib","available":[{"id":"unordered-containers-0.2.20-0a8211d6220ec0e6694f219bbea9da08528b897266f5898f98f4d6e1ab6fd737","component-name":"lib","build-by-default":true}]},{"pkg-name":"unordered-containers","pkg-version":"0.2.20","component-name":"test:unordered-containers-tests","available":["TargetNotLocal"]},{"pkg-name":"unordered-containers","pkg-version":"0.2.20","component-name":"bench:benchmarks","available":["TargetNotLocal"]},{"pkg-name":"utf8-string","pkg-version":"1.0.2","component-name":"lib","available":[{"id":"utf8-string-1.0.2-134849f72bdb35a6754bed838d5c0f0412c3ca2863338b599b4cd9b0af070e05","component-name":"lib","build-by-default":true}]},{"pkg-name":"utf8-string","pkg-version":"1.0.2","component-name":"test:unit-tests","available":["TargetNotLocal"]}]} \ No newline at end of file diff --git a/materialized/ghc964/hadrian-ghc98/hadrian/cabal-files/Cabal-syntax.nix b/materialized/ghc964/hadrian-ghc98/hadrian/cabal-files/Cabal-syntax.nix deleted file mode 100644 index dabbcbdee8..0000000000 --- a/materialized/ghc964/hadrian-ghc98/hadrian/cabal-files/Cabal-syntax.nix +++ /dev/null @@ -1,55 +0,0 @@ -{ system - , compiler - , flags - , pkgs - , hsPkgs - , pkgconfPkgs - , errorHandler - , config - , ... }: - ({ - flags = {}; - package = { - specVersion = "1.22"; - identifier = { name = "Cabal-syntax"; version = "3.8.1.0"; }; - license = "BSD-3-Clause"; - copyright = "2003-2022, Cabal Development Team (see AUTHORS file)"; - maintainer = "cabal-devel@haskell.org"; - author = "Cabal Development Team "; - homepage = "http://www.haskell.org/cabal/"; - url = ""; - synopsis = "A library for working with .cabal files"; - description = "This library provides tools for reading and manipulating the .cabal file\nformat."; - buildType = "Simple"; - }; - components = { - "library" = { - depends = [ - (hsPkgs."array" or (errorHandler.buildDepError "array")) - (hsPkgs."base" or (errorHandler.buildDepError "base")) - (hsPkgs."binary" or (errorHandler.buildDepError "binary")) - (hsPkgs."bytestring" or (errorHandler.buildDepError "bytestring")) - (hsPkgs."containers" or (errorHandler.buildDepError "containers")) - (hsPkgs."deepseq" or (errorHandler.buildDepError "deepseq")) - (hsPkgs."directory" or (errorHandler.buildDepError "directory")) - (hsPkgs."filepath" or (errorHandler.buildDepError "filepath")) - (hsPkgs."mtl" or (errorHandler.buildDepError "mtl")) - (hsPkgs."parsec" or (errorHandler.buildDepError "parsec")) - (hsPkgs."pretty" or (errorHandler.buildDepError "pretty")) - (hsPkgs."text" or (errorHandler.buildDepError "text")) - (hsPkgs."time" or (errorHandler.buildDepError "time")) - (hsPkgs."transformers" or (errorHandler.buildDepError "transformers")) - ] ++ (if system.isWindows - then [ (hsPkgs."Win32" or (errorHandler.buildDepError "Win32")) ] - else [ (hsPkgs."unix" or (errorHandler.buildDepError "unix")) ]); - buildable = true; - }; - }; - } // { - src = pkgs.lib.mkDefault (pkgs.fetchurl { - url = "http://hackage.haskell.org/package/Cabal-syntax-3.8.1.0.tar.gz"; - sha256 = "07e8ddb19fe01781485f1522b6afc22aba680b0ab28ebe6bbfb84a2dd698ce0f"; - }); - }) // { - package-description-override = "cabal-version: 1.22\r\nname: Cabal-syntax\r\nversion: 3.8.1.0\r\nx-revision: 3\r\ncopyright: 2003-2022, Cabal Development Team (see AUTHORS file)\r\nlicense: BSD3\r\nlicense-file: LICENSE\r\nauthor: Cabal Development Team \r\nmaintainer: cabal-devel@haskell.org\r\nhomepage: http://www.haskell.org/cabal/\r\nbug-reports: https://github.com/haskell/cabal/issues\r\nsynopsis: A library for working with .cabal files\r\ndescription:\r\n This library provides tools for reading and manipulating the .cabal file\r\n format.\r\ncategory: Distribution\r\nbuild-type: Simple\r\n\r\nextra-source-files:\r\n README.md ChangeLog.md\r\n\r\nsource-repository head\r\n type: git\r\n location: https://github.com/haskell/cabal/\r\n subdir: Cabal-syntax\r\n\r\nlibrary\r\n default-language: Haskell2010\r\n hs-source-dirs: src\r\n\r\n build-depends:\r\n array >= 0.4.0.1 && < 0.6,\r\n base >= 4.9 && < 5,\r\n binary >= 0.7 && < 0.9,\r\n bytestring >= 0.10.0.0 && < 0.12,\r\n containers >= 0.5.0.0 && < 0.7,\r\n deepseq >= 1.3.0.1 && < 1.5,\r\n directory >= 1.2 && < 1.4,\r\n filepath >= 1.3.0.1 && < 1.5,\r\n mtl >= 2.1 && < 2.4,\r\n parsec >= 3.1.13.0 && < 3.2,\r\n pretty >= 1.1.1 && < 1.2,\r\n text (>= 1.2.3.0 && < 1.3) || (>= 2.0 && < 2.1),\r\n time >= 1.4.0.1 && < 1.13,\r\n -- transformers-0.4.0.0 doesn't have record syntax e.g. for Identity\r\n -- See also https://github.com/ekmett/transformers-compat/issues/35\r\n transformers (>= 0.3 && < 0.4) || (>=0.4.1.0 && <0.7)\r\n\r\n if os(windows)\r\n build-depends: Win32 >= 2.3.0.0 && < 2.14\r\n else\r\n build-depends: unix >= 2.6.0.0 && < 2.9\r\n\r\n ghc-options: -Wall -fno-ignore-asserts -fwarn-tabs -fwarn-incomplete-uni-patterns -fwarn-incomplete-record-updates\r\n ghc-options: -Wcompat -Wnoncanonical-monad-instances\r\n\r\n if impl(ghc < 8.8)\r\n ghc-options: -Wnoncanonical-monadfail-instances\r\n\r\n exposed-modules:\r\n Distribution.Backpack\r\n Distribution.CabalSpecVersion\r\n Distribution.Compat.Binary\r\n Distribution.Compat.CharParsing\r\n Distribution.Compat.DList\r\n Distribution.Compat.Exception\r\n Distribution.Compat.Graph\r\n Distribution.Compat.Lens\r\n Distribution.Compat.MonadFail\r\n Distribution.Compat.Newtype\r\n Distribution.Compat.NonEmptySet\r\n Distribution.Compat.Parsing\r\n Distribution.Compat.Prelude\r\n Distribution.Compat.Semigroup\r\n Distribution.Compat.Typeable\r\n Distribution.Compiler\r\n Distribution.FieldGrammar\r\n Distribution.FieldGrammar.Class\r\n Distribution.FieldGrammar.FieldDescrs\r\n Distribution.FieldGrammar.Newtypes\r\n Distribution.FieldGrammar.Parsec\r\n Distribution.FieldGrammar.Pretty\r\n Distribution.Fields\r\n Distribution.Fields.ConfVar\r\n Distribution.Fields.Field\r\n Distribution.Fields.Lexer\r\n Distribution.Fields.LexerMonad\r\n Distribution.Fields.ParseResult\r\n Distribution.Fields.Parser\r\n Distribution.Fields.Pretty\r\n Distribution.InstalledPackageInfo\r\n Distribution.License\r\n Distribution.ModuleName\r\n Distribution.Package\r\n Distribution.PackageDescription\r\n Distribution.PackageDescription.Configuration\r\n Distribution.PackageDescription.FieldGrammar\r\n Distribution.PackageDescription.Parsec\r\n Distribution.PackageDescription.PrettyPrint\r\n Distribution.PackageDescription.Quirks\r\n Distribution.PackageDescription.Utils\r\n Distribution.Parsec\r\n Distribution.Parsec.Error\r\n Distribution.Parsec.FieldLineStream\r\n Distribution.Parsec.Position\r\n Distribution.Parsec.Warning\r\n Distribution.Pretty\r\n Distribution.SPDX\r\n Distribution.SPDX.License\r\n Distribution.SPDX.LicenseExceptionId\r\n Distribution.SPDX.LicenseExpression\r\n Distribution.SPDX.LicenseId\r\n Distribution.SPDX.LicenseListVersion\r\n Distribution.SPDX.LicenseReference\r\n Distribution.System\r\n Distribution.Text\r\n Distribution.Types.AbiDependency\r\n Distribution.Types.AbiHash\r\n Distribution.Types.Benchmark\r\n Distribution.Types.Benchmark.Lens\r\n Distribution.Types.BenchmarkInterface\r\n Distribution.Types.BenchmarkType\r\n Distribution.Types.BuildInfo\r\n Distribution.Types.BuildInfo.Lens\r\n Distribution.Types.BuildType\r\n Distribution.Types.Component\r\n Distribution.Types.ComponentId\r\n Distribution.Types.ComponentName\r\n Distribution.Types.ComponentRequestedSpec\r\n Distribution.Types.CondTree\r\n Distribution.Types.Condition\r\n Distribution.Types.ConfVar\r\n Distribution.Types.Dependency\r\n Distribution.Types.DependencyMap\r\n Distribution.Types.ExeDependency\r\n Distribution.Types.Executable\r\n Distribution.Types.Executable.Lens\r\n Distribution.Types.ExecutableScope\r\n Distribution.Types.ExposedModule\r\n Distribution.Types.Flag\r\n Distribution.Types.ForeignLib\r\n Distribution.Types.ForeignLib.Lens\r\n Distribution.Types.ForeignLibOption\r\n Distribution.Types.ForeignLibType\r\n Distribution.Types.GenericPackageDescription\r\n Distribution.Types.GenericPackageDescription.Lens\r\n Distribution.Types.HookedBuildInfo\r\n Distribution.Types.IncludeRenaming\r\n Distribution.Types.InstalledPackageInfo\r\n Distribution.Types.InstalledPackageInfo.Lens\r\n Distribution.Types.InstalledPackageInfo.FieldGrammar\r\n Distribution.Types.LegacyExeDependency\r\n Distribution.Types.Lens\r\n Distribution.Types.Library\r\n Distribution.Types.Library.Lens\r\n Distribution.Types.LibraryName\r\n Distribution.Types.LibraryVisibility\r\n Distribution.Types.Mixin\r\n Distribution.Types.Module\r\n Distribution.Types.ModuleReexport\r\n Distribution.Types.ModuleRenaming\r\n Distribution.Types.MungedPackageId\r\n Distribution.Types.MungedPackageName\r\n Distribution.Types.PackageDescription\r\n Distribution.Types.PackageDescription.Lens\r\n Distribution.Types.PackageId\r\n Distribution.Types.PackageId.Lens\r\n Distribution.Types.PackageName\r\n Distribution.Types.PackageVersionConstraint\r\n Distribution.Types.PkgconfigDependency\r\n Distribution.Types.PkgconfigName\r\n Distribution.Types.PkgconfigVersion\r\n Distribution.Types.PkgconfigVersionRange\r\n Distribution.Types.SetupBuildInfo\r\n Distribution.Types.SetupBuildInfo.Lens\r\n Distribution.Types.SourceRepo\r\n Distribution.Types.SourceRepo.Lens\r\n Distribution.Types.TestSuite\r\n Distribution.Types.TestSuite.Lens\r\n Distribution.Types.TestSuiteInterface\r\n Distribution.Types.TestType\r\n Distribution.Types.UnitId\r\n Distribution.Types.UnqualComponentName\r\n Distribution.Types.Version\r\n Distribution.Types.VersionInterval\r\n Distribution.Types.VersionInterval.Legacy\r\n Distribution.Types.VersionRange\r\n Distribution.Types.VersionRange.Internal\r\n Distribution.Utils.Base62\r\n Distribution.Utils.Generic\r\n Distribution.Utils.MD5\r\n Distribution.Utils.Path\r\n Distribution.Utils.ShortText\r\n Distribution.Utils.String\r\n Distribution.Utils.Structured\r\n Distribution.Version\r\n Language.Haskell.Extension\r\n\r\n other-extensions:\r\n BangPatterns\r\n CPP\r\n DefaultSignatures\r\n DeriveDataTypeable\r\n DeriveFoldable\r\n DeriveFunctor\r\n DeriveGeneric\r\n DeriveTraversable\r\n ExistentialQuantification\r\n FlexibleContexts\r\n FlexibleInstances\r\n GeneralizedNewtypeDeriving\r\n ImplicitParams\r\n KindSignatures\r\n NondecreasingIndentation\r\n OverloadedStrings\r\n PatternSynonyms\r\n RankNTypes\r\n RecordWildCards\r\n ScopedTypeVariables\r\n StandaloneDeriving\r\n Trustworthy\r\n TypeFamilies\r\n TypeOperators\r\n TypeSynonymInstances\r\n UndecidableInstances\r\n"; - } \ No newline at end of file diff --git a/materialized/ghc964/hadrian-ghc98/hadrian/cabal-files/Cabal.nix b/materialized/ghc964/hadrian-ghc98/hadrian/cabal-files/Cabal.nix deleted file mode 100644 index be0b5019d9..0000000000 --- a/materialized/ghc964/hadrian-ghc98/hadrian/cabal-files/Cabal.nix +++ /dev/null @@ -1,56 +0,0 @@ -{ system - , compiler - , flags - , pkgs - , hsPkgs - , pkgconfPkgs - , errorHandler - , config - , ... }: - ({ - flags = {}; - package = { - specVersion = "1.22"; - identifier = { name = "Cabal"; version = "3.8.1.0"; }; - license = "BSD-3-Clause"; - copyright = "2003-2022, Cabal Development Team (see AUTHORS file)"; - maintainer = "cabal-devel@haskell.org"; - author = "Cabal Development Team "; - homepage = "http://www.haskell.org/cabal/"; - url = ""; - synopsis = "A framework for packaging Haskell software"; - description = "The Haskell Common Architecture for Building Applications and\nLibraries: a framework defining a common interface for authors to more\neasily build their Haskell applications in a portable way.\n\nThe Haskell Cabal is part of a larger infrastructure for distributing,\norganizing, and cataloging Haskell libraries and tools."; - buildType = "Simple"; - }; - components = { - "library" = { - depends = ([ - (hsPkgs."Cabal-syntax" or (errorHandler.buildDepError "Cabal-syntax")) - (hsPkgs."array" or (errorHandler.buildDepError "array")) - (hsPkgs."base" or (errorHandler.buildDepError "base")) - (hsPkgs."bytestring" or (errorHandler.buildDepError "bytestring")) - (hsPkgs."containers" or (errorHandler.buildDepError "containers")) - (hsPkgs."deepseq" or (errorHandler.buildDepError "deepseq")) - (hsPkgs."directory" or (errorHandler.buildDepError "directory")) - (hsPkgs."filepath" or (errorHandler.buildDepError "filepath")) - (hsPkgs."pretty" or (errorHandler.buildDepError "pretty")) - (hsPkgs."process" or (errorHandler.buildDepError "process")) - (hsPkgs."time" or (errorHandler.buildDepError "time")) - (hsPkgs."transformers" or (errorHandler.buildDepError "transformers")) - (hsPkgs."mtl" or (errorHandler.buildDepError "mtl")) - (hsPkgs."text" or (errorHandler.buildDepError "text")) - (hsPkgs."parsec" or (errorHandler.buildDepError "parsec")) - ] ++ pkgs.lib.optional (compiler.isGhc && compiler.version.ge "8.2") (hsPkgs."process" or (errorHandler.buildDepError "process"))) ++ (if system.isWindows - then [ (hsPkgs."Win32" or (errorHandler.buildDepError "Win32")) ] - else [ (hsPkgs."unix" or (errorHandler.buildDepError "unix")) ]); - buildable = true; - }; - }; - } // { - src = pkgs.lib.mkDefault (pkgs.fetchurl { - url = "http://hackage.haskell.org/package/Cabal-3.8.1.0.tar.gz"; - sha256 = "7464cbe6c2f3d7e5d0232023a1a7330621f8b24853cb259fc89a2af85b736608"; - }); - }) // { - package-description-override = "cabal-version: 1.22\r\nname: Cabal\r\nversion: 3.8.1.0\r\nx-revision: 2\r\ncopyright: 2003-2022, Cabal Development Team (see AUTHORS file)\r\nlicense: BSD3\r\nlicense-file: LICENSE\r\nauthor: Cabal Development Team \r\nmaintainer: cabal-devel@haskell.org\r\nhomepage: http://www.haskell.org/cabal/\r\nbug-reports: https://github.com/haskell/cabal/issues\r\nsynopsis: A framework for packaging Haskell software\r\ndescription:\r\n The Haskell Common Architecture for Building Applications and\r\n Libraries: a framework defining a common interface for authors to more\r\n easily build their Haskell applications in a portable way.\r\n .\r\n The Haskell Cabal is part of a larger infrastructure for distributing,\r\n organizing, and cataloging Haskell libraries and tools.\r\ncategory: Distribution\r\nbuild-type: Simple\r\n-- If we use a new Cabal feature, this needs to be changed to Custom so\r\n-- we can bootstrap.\r\n\r\nextra-source-files:\r\n README.md ChangeLog.md\r\n\r\nsource-repository head\r\n type: git\r\n location: https://github.com/haskell/cabal/\r\n subdir: Cabal\r\n\r\nlibrary\r\n default-language: Haskell2010\r\n hs-source-dirs: src\r\n\r\n build-depends:\r\n Cabal-syntax >= 3.8 && < 3.9,\r\n array >= 0.4.0.1 && < 0.6,\r\n base >= 4.6 && < 5,\r\n bytestring >= 0.10.0.0 && < 0.12,\r\n containers >= 0.5.0.0 && < 0.7,\r\n deepseq >= 1.3.0.1 && < 1.5,\r\n directory >= 1.2 && < 1.4,\r\n filepath >= 1.3.0.1 && < 1.5,\r\n pretty >= 1.1.1 && < 1.2,\r\n process >= 1.2.1.0 && < 1.7,\r\n time >= 1.4.0.1 && < 1.13\r\n\r\n -- PR #8802: moved conditional process lower bound to cabal-install package\r\n if impl(ghc >=8.2)\r\n build-depends: process >= 1.2.1.0\r\n\r\n if os(windows)\r\n build-depends: Win32 >= 2.3.0.0 && < 2.14\r\n else\r\n build-depends: unix >= 2.6.0.0 && < 2.9\r\n\r\n ghc-options: -Wall -fno-ignore-asserts -fwarn-tabs -fwarn-incomplete-uni-patterns -fwarn-incomplete-record-updates\r\n ghc-options: -Wcompat -Wnoncanonical-monad-instances\r\n\r\n if impl(ghc <8.8)\r\n ghc-options: -Wnoncanonical-monadfail-instances\r\n\r\n exposed-modules:\r\n Distribution.Backpack.Configure\r\n Distribution.Backpack.ComponentsGraph\r\n Distribution.Backpack.ConfiguredComponent\r\n Distribution.Backpack.DescribeUnitId\r\n Distribution.Backpack.FullUnitId\r\n Distribution.Backpack.LinkedComponent\r\n Distribution.Backpack.ModSubst\r\n Distribution.Backpack.ModuleShape\r\n Distribution.Backpack.PreModuleShape\r\n Distribution.Utils.IOData\r\n Distribution.Utils.LogProgress\r\n Distribution.Utils.MapAccum\r\n Distribution.Compat.CreatePipe\r\n Distribution.Compat.Directory\r\n Distribution.Compat.Environment\r\n Distribution.Compat.FilePath\r\n Distribution.Compat.Internal.TempFile\r\n Distribution.Compat.ResponseFile\r\n Distribution.Compat.Prelude.Internal\r\n Distribution.Compat.Process\r\n Distribution.Compat.Stack\r\n Distribution.Compat.Time\r\n Distribution.Make\r\n Distribution.PackageDescription.Check\r\n Distribution.ReadE\r\n Distribution.Simple\r\n Distribution.Simple.Bench\r\n Distribution.Simple.Build\r\n Distribution.Simple.Build.Macros\r\n Distribution.Simple.Build.PathsModule\r\n Distribution.Simple.BuildPaths\r\n Distribution.Simple.BuildTarget\r\n Distribution.Simple.BuildToolDepends\r\n Distribution.Simple.CCompiler\r\n Distribution.Simple.Command\r\n Distribution.Simple.Compiler\r\n Distribution.Simple.Configure\r\n Distribution.Simple.Flag\r\n Distribution.Simple.GHC\r\n Distribution.Simple.GHCJS\r\n Distribution.Simple.Haddock\r\n Distribution.Simple.Glob\r\n Distribution.Simple.HaskellSuite\r\n Distribution.Simple.Hpc\r\n Distribution.Simple.Install\r\n Distribution.Simple.InstallDirs\r\n Distribution.Simple.InstallDirs.Internal\r\n Distribution.Simple.LocalBuildInfo\r\n Distribution.Simple.PackageDescription\r\n Distribution.Simple.PackageIndex\r\n Distribution.Simple.PreProcess\r\n Distribution.Simple.PreProcess.Unlit\r\n Distribution.Simple.Program\r\n Distribution.Simple.Program.Ar\r\n Distribution.Simple.Program.Builtin\r\n Distribution.Simple.Program.Db\r\n Distribution.Simple.Program.Find\r\n Distribution.Simple.Program.GHC\r\n Distribution.Simple.Program.HcPkg\r\n Distribution.Simple.Program.Hpc\r\n Distribution.Simple.Program.Internal\r\n Distribution.Simple.Program.Ld\r\n Distribution.Simple.Program.ResponseFile\r\n Distribution.Simple.Program.Run\r\n Distribution.Simple.Program.Script\r\n Distribution.Simple.Program.Strip\r\n Distribution.Simple.Program.Types\r\n Distribution.Simple.Register\r\n Distribution.Simple.Setup\r\n Distribution.Simple.ShowBuildInfo\r\n Distribution.Simple.SrcDist\r\n Distribution.Simple.Test\r\n Distribution.Simple.Test.ExeV10\r\n Distribution.Simple.Test.LibV09\r\n Distribution.Simple.Test.Log\r\n Distribution.Simple.UHC\r\n Distribution.Simple.UserHooks\r\n Distribution.Simple.Utils\r\n Distribution.TestSuite\r\n Distribution.Types.AnnotatedId\r\n Distribution.Types.ComponentInclude\r\n Distribution.Types.DumpBuildInfo\r\n Distribution.Types.PackageName.Magic\r\n Distribution.Types.ComponentLocalBuildInfo\r\n Distribution.Types.LocalBuildInfo\r\n Distribution.Types.TargetInfo\r\n Distribution.Types.GivenComponent\r\n Distribution.Utils.Json\r\n Distribution.Utils.NubList\r\n Distribution.Utils.Progress\r\n Distribution.Verbosity\r\n Distribution.Verbosity.Internal\r\n\r\n -- We reexport all of Cabal-syntax to aid in compatibility for downstream\r\n -- users. In the future we may opt to deprecate some or all of these exports.\r\n -- See haskell/Cabal#7974.\r\n reexported-modules:\r\n Distribution.Backpack,\r\n Distribution.CabalSpecVersion,\r\n Distribution.Compat.Binary,\r\n Distribution.Compat.CharParsing,\r\n Distribution.Compat.DList,\r\n Distribution.Compat.Exception,\r\n Distribution.Compat.Graph,\r\n Distribution.Compat.Lens,\r\n Distribution.Compat.MonadFail,\r\n Distribution.Compat.Newtype,\r\n Distribution.Compat.NonEmptySet,\r\n Distribution.Compat.Parsing,\r\n Distribution.Compat.Prelude,\r\n Distribution.Compat.Semigroup,\r\n Distribution.Compat.Typeable,\r\n Distribution.Compiler,\r\n Distribution.FieldGrammar,\r\n Distribution.FieldGrammar.Class,\r\n Distribution.FieldGrammar.FieldDescrs,\r\n Distribution.FieldGrammar.Newtypes,\r\n Distribution.FieldGrammar.Parsec,\r\n Distribution.FieldGrammar.Pretty,\r\n Distribution.Fields,\r\n Distribution.Fields.ConfVar,\r\n Distribution.Fields.Field,\r\n Distribution.Fields.Lexer,\r\n Distribution.Fields.LexerMonad,\r\n Distribution.Fields.ParseResult,\r\n Distribution.Fields.Parser,\r\n Distribution.Fields.Pretty,\r\n Distribution.InstalledPackageInfo,\r\n Distribution.License,\r\n Distribution.ModuleName,\r\n Distribution.Package,\r\n Distribution.PackageDescription,\r\n Distribution.PackageDescription.Configuration,\r\n Distribution.PackageDescription.FieldGrammar,\r\n Distribution.PackageDescription.Parsec,\r\n Distribution.PackageDescription.PrettyPrint,\r\n Distribution.PackageDescription.Quirks,\r\n Distribution.PackageDescription.Utils,\r\n Distribution.Parsec,\r\n Distribution.Parsec.Error,\r\n Distribution.Parsec.FieldLineStream,\r\n Distribution.Parsec.Position,\r\n Distribution.Parsec.Warning,\r\n Distribution.Pretty,\r\n Distribution.SPDX,\r\n Distribution.SPDX.License,\r\n Distribution.SPDX.LicenseExceptionId,\r\n Distribution.SPDX.LicenseExpression,\r\n Distribution.SPDX.LicenseId,\r\n Distribution.SPDX.LicenseListVersion,\r\n Distribution.SPDX.LicenseReference,\r\n Distribution.System,\r\n Distribution.Text,\r\n Distribution.Types.AbiDependency,\r\n Distribution.Types.AbiHash,\r\n Distribution.Types.Benchmark,\r\n Distribution.Types.Benchmark.Lens,\r\n Distribution.Types.BenchmarkInterface,\r\n Distribution.Types.BenchmarkType,\r\n Distribution.Types.BuildInfo,\r\n Distribution.Types.BuildInfo.Lens,\r\n Distribution.Types.BuildType,\r\n Distribution.Types.Component,\r\n Distribution.Types.ComponentId,\r\n Distribution.Types.ComponentName,\r\n Distribution.Types.ComponentRequestedSpec,\r\n Distribution.Types.CondTree,\r\n Distribution.Types.Condition,\r\n Distribution.Types.ConfVar,\r\n Distribution.Types.Dependency,\r\n Distribution.Types.DependencyMap,\r\n Distribution.Types.ExeDependency,\r\n Distribution.Types.Executable,\r\n Distribution.Types.Executable.Lens,\r\n Distribution.Types.ExecutableScope,\r\n Distribution.Types.ExposedModule,\r\n Distribution.Types.Flag,\r\n Distribution.Types.ForeignLib,\r\n Distribution.Types.ForeignLib.Lens,\r\n Distribution.Types.ForeignLibOption,\r\n Distribution.Types.ForeignLibType,\r\n Distribution.Types.GenericPackageDescription,\r\n Distribution.Types.GenericPackageDescription.Lens,\r\n Distribution.Types.HookedBuildInfo,\r\n Distribution.Types.IncludeRenaming,\r\n Distribution.Types.InstalledPackageInfo,\r\n Distribution.Types.InstalledPackageInfo.Lens,\r\n Distribution.Types.InstalledPackageInfo.FieldGrammar,\r\n Distribution.Types.LegacyExeDependency,\r\n Distribution.Types.Lens,\r\n Distribution.Types.Library,\r\n Distribution.Types.Library.Lens,\r\n Distribution.Types.LibraryName,\r\n Distribution.Types.LibraryVisibility,\r\n Distribution.Types.Mixin,\r\n Distribution.Types.Module,\r\n Distribution.Types.ModuleReexport,\r\n Distribution.Types.ModuleRenaming,\r\n Distribution.Types.MungedPackageId,\r\n Distribution.Types.MungedPackageName,\r\n Distribution.Types.PackageDescription,\r\n Distribution.Types.PackageDescription.Lens,\r\n Distribution.Types.PackageId,\r\n Distribution.Types.PackageId.Lens,\r\n Distribution.Types.PackageName,\r\n Distribution.Types.PackageVersionConstraint,\r\n Distribution.Types.PkgconfigDependency,\r\n Distribution.Types.PkgconfigName,\r\n Distribution.Types.PkgconfigVersion,\r\n Distribution.Types.PkgconfigVersionRange,\r\n Distribution.Types.SetupBuildInfo,\r\n Distribution.Types.SetupBuildInfo.Lens,\r\n Distribution.Types.SourceRepo,\r\n Distribution.Types.SourceRepo.Lens,\r\n Distribution.Types.TestSuite,\r\n Distribution.Types.TestSuite.Lens,\r\n Distribution.Types.TestSuiteInterface,\r\n Distribution.Types.TestType,\r\n Distribution.Types.UnitId,\r\n Distribution.Types.UnqualComponentName,\r\n Distribution.Types.Version,\r\n Distribution.Types.VersionInterval,\r\n Distribution.Types.VersionInterval.Legacy,\r\n Distribution.Types.VersionRange,\r\n Distribution.Types.VersionRange.Internal,\r\n Distribution.Utils.Base62,\r\n Distribution.Utils.Generic,\r\n Distribution.Utils.MD5,\r\n Distribution.Utils.Path,\r\n Distribution.Utils.ShortText,\r\n Distribution.Utils.String,\r\n Distribution.Utils.Structured,\r\n Distribution.Version,\r\n Language.Haskell.Extension\r\n\r\n -- Parsec parser-related modules\r\n build-depends:\r\n -- transformers-0.4.0.0 doesn't have record syntax e.g. for Identity\r\n -- See also https://github.com/ekmett/transformers-compat/issues/35\r\n transformers (>= 0.3 && < 0.4) || (>=0.4.1.0 && <0.7),\r\n mtl >= 2.1 && < 2.4,\r\n text (>= 1.2.3.0 && < 1.3) || (>= 2.0 && < 2.1),\r\n parsec >= 3.1.13.0 && < 3.2\r\n\r\n other-modules:\r\n Distribution.Backpack.PreExistingComponent\r\n Distribution.Backpack.ReadyComponent\r\n Distribution.Backpack.MixLink\r\n Distribution.Backpack.ModuleScope\r\n Distribution.Backpack.UnifyM\r\n Distribution.Backpack.Id\r\n Distribution.Utils.UnionFind\r\n Distribution.Compat.Async\r\n Distribution.Compat.CopyFile\r\n Distribution.Compat.GetShortPathName\r\n Distribution.Compat.SnocList\r\n Distribution.GetOpt\r\n Distribution.Lex\r\n Distribution.Simple.Build.Macros.Z\r\n Distribution.Simple.Build.PathsModule.Z\r\n Distribution.Simple.GHC.EnvironmentParser\r\n Distribution.Simple.GHC.Internal\r\n Distribution.Simple.GHC.ImplInfo\r\n Distribution.ZinzaPrelude\r\n Paths_Cabal\r\n\r\n other-extensions:\r\n BangPatterns\r\n CPP\r\n DefaultSignatures\r\n DeriveDataTypeable\r\n DeriveFoldable\r\n DeriveFunctor\r\n DeriveGeneric\r\n DeriveTraversable\r\n ExistentialQuantification\r\n FlexibleContexts\r\n FlexibleInstances\r\n GeneralizedNewtypeDeriving\r\n ImplicitParams\r\n KindSignatures\r\n LambdaCase\r\n NondecreasingIndentation\r\n OverloadedStrings\r\n PatternSynonyms\r\n RankNTypes\r\n RecordWildCards\r\n ScopedTypeVariables\r\n StandaloneDeriving\r\n Trustworthy\r\n TypeFamilies\r\n TypeOperators\r\n TypeSynonymInstances\r\n UndecidableInstances\r\n"; - } \ No newline at end of file diff --git a/materialized/ghc964/hadrian-ghc98/hadrian/cabal-files/cryptohash-sha256.nix b/materialized/ghc964/hadrian-ghc98/hadrian/cabal-files/cryptohash-sha256.nix index 7fe8a112a9..e7efd5f428 100644 --- a/materialized/ghc964/hadrian-ghc98/hadrian/cabal-files/cryptohash-sha256.nix +++ b/materialized/ghc964/hadrian-ghc98/hadrian/cabal-files/cryptohash-sha256.nix @@ -16,7 +16,7 @@ copyright = "Vincent Hanquez, Herbert Valerio Riedel"; maintainer = "Herbert Valerio Riedel "; author = ""; - homepage = "https://github.com/hvr/cryptohash-sha256"; + homepage = "https://github.com/haskell-hvr/cryptohash-sha256"; url = ""; synopsis = "Fast, pure and practical SHA-256 implementation"; description = "A practical incremental and one-pass, pure API to\nthe [SHA-256 cryptographic hash algorithm](https://en.wikipedia.org/wiki/SHA-2) according\nto [FIPS 180-4](http://dx.doi.org/10.6028/NIST.FIPS.180-4)\nwith performance close to the fastest implementations available in other languages.\n\nThe core SHA-256 algorithm is implemented in C and is thus expected\nto be as fast as the standard [sha256sum(1) tool](https://linux.die.net/man/1/sha256sum);\nfor instance, on an /Intel Core i7-3770/ at 3.40GHz this implementation can\ncompute a SHA-256 hash over 230 MiB of data in under one second.\n(If, instead, you require a pure Haskell implementation and performance is secondary, please refer to the [SHA package](https://hackage.haskell.org/package/SHA).)\n\n\nAdditionally, this package provides support for\n\n- HMAC-SHA-256: SHA-256-based [Hashed Message Authentication Codes](https://en.wikipedia.org/wiki/HMAC) (HMAC)\n- HKDF-SHA-256: [HMAC-SHA-256-based Key Derivation Function](https://en.wikipedia.org/wiki/HKDF) (HKDF)\n\nconforming to [RFC6234](https://tools.ietf.org/html/rfc6234), [RFC4231](https://tools.ietf.org/html/rfc4231), [RFC5869](https://tools.ietf.org/html/rfc5869), et al..\n\n=== Relationship to the @cryptohash@ package and its API\n\nThis package has been originally a fork of @cryptohash-0.11.7@ because the @cryptohash@\npackage had been deprecated and so this package continues to satisfy the need for a\nlightweight package providing the SHA-256 hash algorithm without any dependencies on packages\nother than @base@ and @bytestring@. The API exposed by @cryptohash-sha256-0.11.*@'s\n\"Crypto.Hash.SHA256\" module is guaranteed to remain a compatible superset of the API provided\nby the @cryptohash-0.11.7@'s module of the same name.\n\nConsequently, this package is designed to be used as a drop-in replacement for @cryptohash-0.11.7@'s\n\"Crypto.Hash.SHA256\" module, though with\na [clearly smaller footprint by almost 3 orders of magnitude](https://www.reddit.com/r/haskell/comments/5lxv75/psa_please_use_unique_module_names_when_uploading/dbzegx3/)."; @@ -80,5 +80,5 @@ sha256 = "73a7dc7163871a80837495039a099967b11f5c4fe70a118277842f7a713c6bf6"; }); }) // { - package-description-override = "cabal-version: 2.0\nname: cryptohash-sha256\nversion: 0.11.102.1\nx-revision: 3\n\nsynopsis: Fast, pure and practical SHA-256 implementation\ndescription: {\n\nA practical incremental and one-pass, pure API to\nthe [SHA-256 cryptographic hash algorithm](https://en.wikipedia.org/wiki/SHA-2) according\nto [FIPS 180-4](http://dx.doi.org/10.6028/NIST.FIPS.180-4)\nwith performance close to the fastest implementations available in other languages.\n.\nThe core SHA-256 algorithm is implemented in C and is thus expected\nto be as fast as the standard [sha256sum(1) tool](https://linux.die.net/man/1/sha256sum);\nfor instance, on an /Intel Core i7-3770/ at 3.40GHz this implementation can\ncompute a SHA-256 hash over 230 MiB of data in under one second.\n(If, instead, you require a pure Haskell implementation and performance is secondary, please refer to the [SHA package](https://hackage.haskell.org/package/SHA).)\n.\n\n.\nAdditionally, this package provides support for\n.\n- HMAC-SHA-256: SHA-256-based [Hashed Message Authentication Codes](https://en.wikipedia.org/wiki/HMAC) (HMAC)\n- HKDF-SHA-256: [HMAC-SHA-256-based Key Derivation Function](https://en.wikipedia.org/wiki/HKDF) (HKDF)\n.\nconforming to [RFC6234](https://tools.ietf.org/html/rfc6234), [RFC4231](https://tools.ietf.org/html/rfc4231), [RFC5869](https://tools.ietf.org/html/rfc5869), et al..\n.\n=== Relationship to the @cryptohash@ package and its API\n.\nThis package has been originally a fork of @cryptohash-0.11.7@ because the @cryptohash@\npackage had been deprecated and so this package continues to satisfy the need for a\nlightweight package providing the SHA-256 hash algorithm without any dependencies on packages\nother than @base@ and @bytestring@. The API exposed by @cryptohash-sha256-0.11.*@'s\n\"Crypto.Hash.SHA256\" module is guaranteed to remain a compatible superset of the API provided\nby the @cryptohash-0.11.7@'s module of the same name.\n.\nConsequently, this package is designed to be used as a drop-in replacement for @cryptohash-0.11.7@'s\n\"Crypto.Hash.SHA256\" module, though with\na [clearly smaller footprint by almost 3 orders of magnitude](https://www.reddit.com/r/haskell/comments/5lxv75/psa_please_use_unique_module_names_when_uploading/dbzegx3/).\n\n}\n\nlicense: BSD3\nlicense-file: LICENSE\ncopyright: Vincent Hanquez, Herbert Valerio Riedel\nmaintainer: Herbert Valerio Riedel \nhomepage: https://github.com/hvr/cryptohash-sha256\nbug-reports: https://github.com/hvr/cryptohash-sha256/issues\ncategory: Data, Cryptography\nbuild-type: Simple\n\ntested-with:\n GHC == 9.8.0\n GHC == 9.6.2\n GHC == 9.4.7\n GHC == 9.2.8\n GHC == 9.0.2\n GHC == 8.10.7\n GHC == 8.8.4\n GHC == 8.6.5\n GHC == 8.4.4\n GHC == 8.2.2\n GHC == 8.0.2\n GHC == 7.10.3\n\nextra-source-files: cbits/hs_sha256.h\n changelog.md\n\nsource-repository head\n type: git\n location: https://github.com/hvr/cryptohash-sha256.git\n\nflag exe\n description: Enable building @sha256sum@ executable\n manual: True\n default: False\n\nflag use-cbits\n description: Use fast optimized C routines via FFI; if flag is disabled falls back to non-FFI Haskell optimized implementation.\n manual: True\n default: True\n\nlibrary\n default-language: Haskell2010\n\n ghc-options: -Wall\n\n build-depends: base >= 4.5 && < 4.20\n\n exposed-modules: Crypto.Hash.SHA256\n\n if flag(use-cbits)\n build-depends: bytestring ^>= 0.9.2.0 || ^>= 0.10.0.0 || ^>= 0.11.0.0 || ^>= 0.12.0.2\n\n other-extensions: BangPatterns\n CApiFFI\n CPP\n Trustworthy\n Unsafe\n\n hs-source-dirs: src\n other-modules: Crypto.Hash.SHA256.FFI\n Compat\n include-dirs: cbits\n else\n hs-source-dirs: src-pure\n build-depends: cryptohash-sha256-pure ^>= 0.1.0\n\nexecutable sha256sum\n default-language: Haskell2010\n hs-source-dirs: src-exe\n main-is: sha256sum.hs\n ghc-options: -Wall -threaded\n if flag(exe)\n other-extensions: RecordWildCards\n build-depends: cryptohash-sha256\n , base\n , bytestring\n\n , base16-bytestring ^>= 0.1.1 || ^>= 1.0.0\n else\n buildable: False\n\ntest-suite test-sha256\n default-language: Haskell2010\n other-extensions: OverloadedStrings\n type: exitcode-stdio-1.0\n hs-source-dirs: src-tests\n main-is: test-sha256.hs\n ghc-options: -Wall -threaded\n build-depends: cryptohash-sha256\n , base\n , bytestring\n\n , base16-bytestring ^>= 0.1.1 || ^>= 1.0.0\n , SHA ^>= 1.6.4\n , tasty ^>= 1.4 || ^>= 1.5\n , tasty-quickcheck ^>= 0.10\n , tasty-hunit ^>= 0.10\n\nbenchmark bench-sha256\n default-language: Haskell2010\n other-extensions: BangPatterns\n type: exitcode-stdio-1.0\n main-is: bench-sha256.hs\n hs-source-dirs: src-bench\n build-depends: cryptohash-sha256\n , SHA ^>= 1.6.4\n , base\n , bytestring\n , criterion ^>= 1.5 || ^>=1.6\n\n -- not yet public\n -- build-depends: cryptohash-sha256-pure ^>= 0.1.0\n"; + package-description-override = "cabal-version: 2.0\nname: cryptohash-sha256\nversion: 0.11.102.1\nx-revision: 5\n\nsynopsis: Fast, pure and practical SHA-256 implementation\ndescription: {\n\nA practical incremental and one-pass, pure API to\nthe [SHA-256 cryptographic hash algorithm](https://en.wikipedia.org/wiki/SHA-2) according\nto [FIPS 180-4](http://dx.doi.org/10.6028/NIST.FIPS.180-4)\nwith performance close to the fastest implementations available in other languages.\n.\nThe core SHA-256 algorithm is implemented in C and is thus expected\nto be as fast as the standard [sha256sum(1) tool](https://linux.die.net/man/1/sha256sum);\nfor instance, on an /Intel Core i7-3770/ at 3.40GHz this implementation can\ncompute a SHA-256 hash over 230 MiB of data in under one second.\n(If, instead, you require a pure Haskell implementation and performance is secondary, please refer to the [SHA package](https://hackage.haskell.org/package/SHA).)\n.\n\n.\nAdditionally, this package provides support for\n.\n- HMAC-SHA-256: SHA-256-based [Hashed Message Authentication Codes](https://en.wikipedia.org/wiki/HMAC) (HMAC)\n- HKDF-SHA-256: [HMAC-SHA-256-based Key Derivation Function](https://en.wikipedia.org/wiki/HKDF) (HKDF)\n.\nconforming to [RFC6234](https://tools.ietf.org/html/rfc6234), [RFC4231](https://tools.ietf.org/html/rfc4231), [RFC5869](https://tools.ietf.org/html/rfc5869), et al..\n.\n=== Relationship to the @cryptohash@ package and its API\n.\nThis package has been originally a fork of @cryptohash-0.11.7@ because the @cryptohash@\npackage had been deprecated and so this package continues to satisfy the need for a\nlightweight package providing the SHA-256 hash algorithm without any dependencies on packages\nother than @base@ and @bytestring@. The API exposed by @cryptohash-sha256-0.11.*@'s\n\"Crypto.Hash.SHA256\" module is guaranteed to remain a compatible superset of the API provided\nby the @cryptohash-0.11.7@'s module of the same name.\n.\nConsequently, this package is designed to be used as a drop-in replacement for @cryptohash-0.11.7@'s\n\"Crypto.Hash.SHA256\" module, though with\na [clearly smaller footprint by almost 3 orders of magnitude](https://www.reddit.com/r/haskell/comments/5lxv75/psa_please_use_unique_module_names_when_uploading/dbzegx3/).\n\n}\n\nlicense: BSD3\nlicense-file: LICENSE\ncopyright: Vincent Hanquez, Herbert Valerio Riedel\nmaintainer: Herbert Valerio Riedel \nhomepage: https://github.com/haskell-hvr/cryptohash-sha256\nbug-reports: https://github.com/haskell-hvr/cryptohash-sha256/issues\ncategory: Data, Cryptography\nbuild-type: Simple\n\ntested-with:\n GHC == 9.10.1\n GHC == 9.8.2\n GHC == 9.6.5\n GHC == 9.4.8\n GHC == 9.2.8\n GHC == 9.0.2\n GHC == 8.10.7\n GHC == 8.8.4\n GHC == 8.6.5\n GHC == 8.4.4\n GHC == 8.2.2\n GHC == 8.0.2\n\nextra-source-files: cbits/hs_sha256.h\n changelog.md\n\nsource-repository head\n type: git\n location: https://github.com/haskell-hvr/cryptohash-sha256.git\n\nflag exe\n description: Enable building @sha256sum@ executable\n manual: True\n default: False\n\nflag use-cbits\n description: Use fast optimized C routines via FFI; if flag is disabled falls back to non-FFI Haskell optimized implementation.\n manual: True\n default: True\n\nlibrary\n default-language: Haskell2010\n\n ghc-options: -Wall\n\n build-depends: base >= 4.5 && < 4.21\n\n exposed-modules: Crypto.Hash.SHA256\n\n if flag(use-cbits)\n build-depends: bytestring ^>= 0.9.2.0 || ^>= 0.10.0.0 || ^>= 0.11.0.0 || ^>= 0.12.0.2\n\n other-extensions: BangPatterns\n CApiFFI\n CPP\n Trustworthy\n Unsafe\n\n hs-source-dirs: src\n other-modules: Crypto.Hash.SHA256.FFI\n Compat\n include-dirs: cbits\n else\n hs-source-dirs: src-pure\n build-depends: cryptohash-sha256-pure ^>= 0.1.0\n\nexecutable sha256sum\n default-language: Haskell2010\n hs-source-dirs: src-exe\n main-is: sha256sum.hs\n ghc-options: -Wall -threaded\n if flag(exe)\n other-extensions: RecordWildCards\n build-depends: cryptohash-sha256\n , base\n , bytestring\n\n , base16-bytestring ^>= 0.1.1 || ^>= 1.0.0\n else\n buildable: False\n\ntest-suite test-sha256\n default-language: Haskell2010\n other-extensions: OverloadedStrings\n type: exitcode-stdio-1.0\n hs-source-dirs: src-tests\n main-is: test-sha256.hs\n ghc-options: -Wall -threaded\n build-depends: cryptohash-sha256\n , base\n , bytestring\n\n , base16-bytestring ^>= 0.1.1 || ^>= 1.0.0\n , SHA ^>= 1.6.4\n , tasty ^>= 1.4 || ^>= 1.5\n , tasty-quickcheck >= 0.10 && < 1\n , tasty-hunit ^>= 0.10\n\nbenchmark bench-sha256\n default-language: Haskell2010\n other-extensions: BangPatterns\n type: exitcode-stdio-1.0\n main-is: bench-sha256.hs\n hs-source-dirs: src-bench\n build-depends: cryptohash-sha256\n , SHA ^>= 1.6.4\n , base\n , bytestring\n , criterion ^>= 1.5 || ^>=1.6\n\n -- not yet public\n -- build-depends: cryptohash-sha256-pure ^>= 0.1.0\n"; } \ No newline at end of file diff --git a/materialized/ghc964/hadrian-ghc98/hadrian/cabal-files/extra.nix b/materialized/ghc964/hadrian-ghc98/hadrian/cabal-files/extra.nix index 41668cf6bc..26ff289717 100644 --- a/materialized/ghc964/hadrian-ghc98/hadrian/cabal-files/extra.nix +++ b/materialized/ghc964/hadrian-ghc98/hadrian/cabal-files/extra.nix @@ -11,9 +11,9 @@ flags = {}; package = { specVersion = "1.18"; - identifier = { name = "extra"; version = "1.7.14"; }; + identifier = { name = "extra"; version = "1.7.16"; }; license = "BSD-3-Clause"; - copyright = "Neil Mitchell 2014-2023"; + copyright = "Neil Mitchell 2014-2024"; maintainer = "Neil Mitchell "; author = "Neil Mitchell "; homepage = "https://github.com/ndmitchell/extra#readme"; @@ -50,9 +50,9 @@ }; } // { src = pkgs.lib.mkDefault (pkgs.fetchurl { - url = "http://hackage.haskell.org/package/extra-1.7.14.tar.gz"; - sha256 = "b6a909f8f0e4b8076a1653b4d34815a782f0a8c1e83d5267f4d00496471ef567"; + url = "http://hackage.haskell.org/package/extra-1.7.16.tar.gz"; + sha256 = "250c6d43c30b2c71f2cf498a10e69e43ac035974d3819529385d99e42ce77c70"; }); }) // { - package-description-override = "cabal-version: 1.18\nbuild-type: Simple\nname: extra\nversion: 1.7.14\nlicense: BSD3\nlicense-file: LICENSE\ncategory: Development\nauthor: Neil Mitchell \nmaintainer: Neil Mitchell \ncopyright: Neil Mitchell 2014-2023\nsynopsis: Extra functions I use.\ndescription:\n A library of extra functions for the standard Haskell libraries. Most functions are simple additions, filling out missing functionality. A few functions are available in later versions of GHC, but this package makes them available back to GHC 7.2.\n .\n The module \"Extra\" documents all functions provided by this library. Modules such as \"Data.List.Extra\" provide extra functions over \"Data.List\" and also reexport \"Data.List\". Users are recommended to replace \"Data.List\" imports with \"Data.List.Extra\" if they need the extra functionality.\nhomepage: https://github.com/ndmitchell/extra#readme\nbug-reports: https://github.com/ndmitchell/extra/issues\ntested-with: GHC==9.6, GHC==9.4, GHC==9.2, GHC==9.0, GHC==8.10, GHC==8.8\n\nextra-doc-files:\n CHANGES.txt\n README.md\nextra-source-files:\n Generate.hs\n\nsource-repository head\n type: git\n location: https://github.com/ndmitchell/extra.git\n\nlibrary\n default-language: Haskell2010\n hs-source-dirs: src\n build-depends:\n base >= 4.9 && < 5,\n directory,\n filepath,\n process,\n clock >= 0.7,\n time\n if !os(windows)\n build-depends: unix\n\n other-modules:\n Partial\n exposed-modules:\n Extra\n Control.Concurrent.Extra\n Control.Exception.Extra\n Control.Monad.Extra\n Data.Foldable.Extra\n Data.Either.Extra\n Data.IORef.Extra\n Data.List.Extra\n Data.List.NonEmpty.Extra\n Data.Monoid.Extra\n Data.Tuple.Extra\n Data.Typeable.Extra\n Data.Version.Extra\n Numeric.Extra\n System.Directory.Extra\n System.Environment.Extra\n System.Info.Extra\n System.IO.Extra\n System.Process.Extra\n System.Time.Extra\n Text.Read.Extra\n\ntest-suite extra-test\n type: exitcode-stdio-1.0\n default-language: Haskell2010\n build-depends:\n base == 4.*,\n directory,\n filepath,\n extra,\n QuickCheck >= 2.10,\n quickcheck-instances >= 0.3.17\n if !os(windows)\n build-depends: unix\n hs-source-dirs: test\n ghc-options: -main-is Test -threaded \"-with-rtsopts=-N4 -K1K\"\n main-is: Test.hs\n other-modules:\n TestCustom\n TestGen\n TestUtil\n"; + package-description-override = "cabal-version: 1.18\nbuild-type: Simple\nname: extra\nversion: 1.7.16\nlicense: BSD3\nlicense-file: LICENSE\ncategory: Development\nauthor: Neil Mitchell \nmaintainer: Neil Mitchell \ncopyright: Neil Mitchell 2014-2024\nsynopsis: Extra functions I use.\ndescription:\n A library of extra functions for the standard Haskell libraries. Most functions are simple additions, filling out missing functionality. A few functions are available in later versions of GHC, but this package makes them available back to GHC 7.2.\n .\n The module \"Extra\" documents all functions provided by this library. Modules such as \"Data.List.Extra\" provide extra functions over \"Data.List\" and also reexport \"Data.List\". Users are recommended to replace \"Data.List\" imports with \"Data.List.Extra\" if they need the extra functionality.\nhomepage: https://github.com/ndmitchell/extra#readme\nbug-reports: https://github.com/ndmitchell/extra/issues\ntested-with: GHC==9.8, GHC==9.6, GHC==9.4, GHC==9.2, GHC==9.0, GHC==8.10, GHC==8.8\n\nextra-doc-files:\n CHANGES.txt\n README.md\nextra-source-files:\n Generate.hs\n\nsource-repository head\n type: git\n location: https://github.com/ndmitchell/extra.git\n\nlibrary\n default-language: Haskell2010\n hs-source-dirs: src\n build-depends:\n base >= 4.9 && < 5,\n directory,\n filepath,\n process,\n clock >= 0.7,\n time\n if !os(windows)\n build-depends: unix\n\n other-modules:\n Partial\n exposed-modules:\n Extra\n Control.Concurrent.Extra\n Control.Exception.Extra\n Control.Monad.Extra\n Data.Foldable.Extra\n Data.Either.Extra\n Data.IORef.Extra\n Data.List.Extra\n Data.List.NonEmpty.Extra\n Data.Monoid.Extra\n Data.Tuple.Extra\n Data.Typeable.Extra\n Data.Version.Extra\n Numeric.Extra\n System.Directory.Extra\n System.Environment.Extra\n System.Info.Extra\n System.IO.Extra\n System.Process.Extra\n System.Time.Extra\n Text.Read.Extra\n\ntest-suite extra-test\n type: exitcode-stdio-1.0\n default-language: Haskell2010\n build-depends:\n base == 4.*,\n directory,\n filepath,\n extra,\n QuickCheck >= 2.10,\n quickcheck-instances >= 0.3.17\n if !os(windows)\n build-depends: unix\n hs-source-dirs: test\n ghc-options: -main-is Test -threaded \"-with-rtsopts=-N4 -K1K\"\n main-is: Test.hs\n other-modules:\n TestCustom\n TestGen\n TestUtil\n"; } \ No newline at end of file diff --git a/materialized/ghc964/hadrian-ghc98/hadrian/cabal-files/hashable.nix b/materialized/ghc964/hadrian-ghc98/hadrian/cabal-files/hashable.nix index 4b125fa0bc..68ae273859 100644 --- a/materialized/ghc964/hadrian-ghc98/hadrian/cabal-files/hashable.nix +++ b/materialized/ghc964/hadrian-ghc98/hadrian/cabal-files/hashable.nix @@ -8,10 +8,10 @@ , config , ... }: ({ - flags = { integer-gmp = true; random-initial-seed = false; }; + flags = { arch-native = false; random-initial-seed = false; }; package = { - specVersion = "1.12"; - identifier = { name = "hashable"; version = "1.4.3.0"; }; + specVersion = "2.2"; + identifier = { name = "hashable"; version = "1.5.0.0"; }; license = "BSD-3-Clause"; copyright = ""; maintainer = "Oleg Grenrus "; @@ -19,47 +19,51 @@ homepage = "http://github.com/haskell-unordered-containers/hashable"; url = ""; synopsis = "A class for types that can be converted to a hash value"; - description = "This package defines a class, 'Hashable', for types that\ncan be converted to a hash value. This class\nexists for the benefit of hashing-based data\nstructures. The package provides instances for\nbasic types and a way to combine hash values.\n\nThe 'Hashable' 'hash' values are not guaranteed to be stable across library versions, operating systems or architectures. For stable hashing use named hashes: SHA256, CRC32 etc."; + description = "This package defines a class, 'Hashable', for types that can be converted to a hash value.\nThis class exists for the benefit of hashing-based data structures.\nThe package provides instances for basic types and a way to combine hash values.\n\n'Hashable' is intended exclusively for use in in-memory data structures.\n\n'Hashable' does /not/ have a fixed standard.\nThis allows it to improve over time.\n\nBecause it does not have a fixed standard, different computers or computers on different versions of the code will observe different hash values.\nAs such, 'hashable' is not recommended for use other than in-memory datastructures.\nSpecifically, 'hashable' is not intended for network use or in applications which persist hashed values.\nFor stable hashing use named hashes: sha256, crc32, xxhash etc."; buildType = "Simple"; }; components = { "library" = { - depends = (([ + depends = [ (hsPkgs."base" or (errorHandler.buildDepError "base")) (hsPkgs."bytestring" or (errorHandler.buildDepError "bytestring")) (hsPkgs."containers" or (errorHandler.buildDepError "containers")) (hsPkgs."deepseq" or (errorHandler.buildDepError "deepseq")) - (hsPkgs."filepath" or (errorHandler.buildDepError "filepath")) (hsPkgs."ghc-prim" or (errorHandler.buildDepError "ghc-prim")) (hsPkgs."text" or (errorHandler.buildDepError "text")) - ] ++ pkgs.lib.optional (!(compiler.isGhc && compiler.version.ge "9.2")) (hsPkgs."base-orphans" or (errorHandler.buildDepError "base-orphans"))) ++ pkgs.lib.optional (!(compiler.isGhc && compiler.version.ge "9.4")) (hsPkgs."data-array-byte" or (errorHandler.buildDepError "data-array-byte"))) ++ (if compiler.isGhc && compiler.version.ge "9" - then [ - (hsPkgs."ghc-bignum" or (errorHandler.buildDepError "ghc-bignum")) - ] ++ pkgs.lib.optional (!(compiler.isGhc && compiler.version.ge "9.0.2")) (hsPkgs."ghc-bignum-orphans" or (errorHandler.buildDepError "ghc-bignum-orphans")) - else if flags.integer-gmp - then [ - (hsPkgs."integer-gmp" or (errorHandler.buildDepError "integer-gmp")) - ] - else [ - (hsPkgs."integer-simple" or (errorHandler.buildDepError "integer-simple")) - ]); + (hsPkgs."os-string" or (errorHandler.buildDepError "os-string")) + (hsPkgs."filepath" or (errorHandler.buildDepError "filepath")) + (hsPkgs."ghc-bignum" or (errorHandler.buildDepError "ghc-bignum")) + ]; buildable = true; }; tests = { "hashable-tests" = { - depends = [ + depends = ([ (hsPkgs."base" or (errorHandler.buildDepError "base")) (hsPkgs."bytestring" or (errorHandler.buildDepError "bytestring")) + (hsPkgs."filepath" or (errorHandler.buildDepError "filepath")) (hsPkgs."ghc-prim" or (errorHandler.buildDepError "ghc-prim")) (hsPkgs."hashable" or (errorHandler.buildDepError "hashable")) (hsPkgs."HUnit" or (errorHandler.buildDepError "HUnit")) (hsPkgs."QuickCheck" or (errorHandler.buildDepError "QuickCheck")) (hsPkgs."random" or (errorHandler.buildDepError "random")) - (hsPkgs."test-framework" or (errorHandler.buildDepError "test-framework")) - (hsPkgs."test-framework-hunit" or (errorHandler.buildDepError "test-framework-hunit")) - (hsPkgs."test-framework-quickcheck2" or (errorHandler.buildDepError "test-framework-quickcheck2")) + (hsPkgs."tasty" or (errorHandler.buildDepError "tasty")) + (hsPkgs."tasty-hunit" or (errorHandler.buildDepError "tasty-hunit")) + (hsPkgs."tasty-quickcheck" or (errorHandler.buildDepError "tasty-quickcheck")) (hsPkgs."text" or (errorHandler.buildDepError "text")) - ] ++ pkgs.lib.optional (!system.isWindows) (hsPkgs."unix" or (errorHandler.buildDepError "unix")); + ] ++ pkgs.lib.optional (compiler.isGhc && compiler.version.ge "9.2") (hsPkgs."os-string" or (errorHandler.buildDepError "os-string"))) ++ pkgs.lib.optional (!system.isWindows) (hsPkgs."unix" or (errorHandler.buildDepError "unix")); + buildable = true; + }; + "xxhash-tests" = { + depends = [ + (hsPkgs."base" or (errorHandler.buildDepError "base")) + (hsPkgs."bytestring" or (errorHandler.buildDepError "bytestring")) + (hsPkgs."primitive" or (errorHandler.buildDepError "primitive")) + (hsPkgs."tasty" or (errorHandler.buildDepError "tasty")) + (hsPkgs."tasty-hunit" or (errorHandler.buildDepError "tasty-hunit")) + (hsPkgs."tasty-quickcheck" or (errorHandler.buildDepError "tasty-quickcheck")) + ] ++ pkgs.lib.optional (!(compiler.isGhc && compiler.version.ge "9.4")) (hsPkgs."data-array-byte" or (errorHandler.buildDepError "data-array-byte")); buildable = true; }; "hashable-examples" = { @@ -74,9 +78,9 @@ }; } // { src = pkgs.lib.mkDefault (pkgs.fetchurl { - url = "http://hackage.haskell.org/package/hashable-1.4.3.0.tar.gz"; - sha256 = "32efb16c2891786209b7cbe5c39df9b3a9ae51e836f1a54f646bc4602b7ab0f5"; + url = "http://hackage.haskell.org/package/hashable-1.5.0.0.tar.gz"; + sha256 = "e58b3a8e18da5f6cd7e937e5fd683e500bb1f8276b3768269759119ca0cddb6a"; }); }) // { - package-description-override = "cabal-version: 1.12\nname: hashable\nversion: 1.4.3.0\nx-revision: 1\nsynopsis: A class for types that can be converted to a hash value\ndescription:\n This package defines a class, 'Hashable', for types that\n can be converted to a hash value. This class\n exists for the benefit of hashing-based data\n structures. The package provides instances for\n basic types and a way to combine hash values.\n .\n The 'Hashable' 'hash' values are not guaranteed to be stable across library versions, operating systems or architectures. For stable hashing use named hashes: SHA256, CRC32 etc.\n\nhomepage: http://github.com/haskell-unordered-containers/hashable\n\n-- SPDX-License-Identifier : BSD-3-Clause\nlicense: BSD3\nlicense-file: LICENSE\nauthor:\n Milan Straka \n Johan Tibell \n\nmaintainer: Oleg Grenrus \nbug-reports:\n https://github.com/haskell-unordered-containers/hashable/issues\n\nstability: Provisional\ncategory: Data\nbuild-type: Simple\ntested-with:\n GHC ==8.2.2\n || ==8.4.4\n || ==8.6.5\n || ==8.8.3\n || ==8.10.4\n || ==8.10.7\n || ==9.0.1\n || ==9.0.2\n || ==9.2.8\n || ==9.4.7\n || ==9.6.3\n || ==9.8.1\n\nextra-source-files:\n CHANGES.md\n include/HsHashable.h\n README.md\n\nflag integer-gmp\n description:\n Are we using @integer-gmp@ to provide fast Integer instances? No effect on GHC-9.0 or later.\n\n manual: False\n default: True\n\nflag random-initial-seed\n description:\n Randomly initialize the initial seed on each final executable invocation\n This is useful for catching cases when you rely on (non-existent)\n stability of hashable's hash functions.\n This is not a security feature.\n\n manual: True\n default: False\n\nlibrary\n exposed-modules:\n Data.Hashable\n Data.Hashable.Generic\n Data.Hashable.Lifted\n\n other-modules:\n Data.Hashable.Class\n Data.Hashable.Generic.Instances\n Data.Hashable.Imports\n Data.Hashable.LowLevel\n\n c-sources: cbits/fnv.c\n include-dirs: include\n hs-source-dirs: src\n build-depends:\n base >=4.10.1.0 && <4.20\n , bytestring >=0.10.8.2 && <0.13\n , containers >=0.5.10.2 && <0.7\n , deepseq >=1.4.3.0 && <1.6\n , filepath >=1.4.1.2 && <1.5\n , ghc-prim\n , text >=1.2.3.0 && <1.3 || >=2.0 && <2.2\n\n if !impl(ghc >=9.2)\n build-depends: base-orphans >=0.8.6 && <0.10\n\n if !impl(ghc >=9.4)\n build-depends: data-array-byte >=0.1.0.1 && <0.2\n\n -- Integer internals\n if impl(ghc >=9)\n build-depends: ghc-bignum >=1.0 && <1.4\n\n if !impl(ghc >=9.0.2)\n build-depends: ghc-bignum-orphans >=0.1 && <0.2\n\n else\n if flag(integer-gmp)\n build-depends: integer-gmp >=0.4 && <1.1\n\n else\n -- this is needed for the automatic flag to be well-balanced\n build-depends: integer-simple\n\n if (flag(random-initial-seed) && impl(ghc))\n cpp-options: -DHASHABLE_RANDOM_SEED=1\n\n if os(windows)\n c-sources: cbits-win/init.c\n\n else\n c-sources: cbits-unix/init.c\n\n default-language: Haskell2010\n other-extensions:\n BangPatterns\n CPP\n DeriveDataTypeable\n FlexibleContexts\n FlexibleInstances\n GADTs\n KindSignatures\n MagicHash\n MultiParamTypeClasses\n ScopedTypeVariables\n Trustworthy\n TypeOperators\n UnliftedFFITypes\n\n ghc-options: -Wall -fwarn-tabs\n\n if impl(ghc >=9.0)\n -- these flags may abort compilation with GHC-8.10\n -- https://gitlab.haskell.org/ghc/ghc/-/merge_requests/3295\n ghc-options: -Winferred-safe-imports -Wmissing-safe-haskell-mode\n\ntest-suite hashable-tests\n type: exitcode-stdio-1.0\n hs-source-dirs: tests\n main-is: Main.hs\n other-modules:\n Properties\n Regress\n\n build-depends:\n base\n , bytestring\n , ghc-prim\n , hashable\n , HUnit\n , QuickCheck >=2.4.0.1\n , random >=1.0 && <1.3\n , test-framework >=0.3.3\n , test-framework-hunit\n , test-framework-quickcheck2 >=0.2.9\n , text >=0.11.0.5\n\n if !os(windows)\n build-depends: unix\n cpp-options: -DHAVE_MMAP\n other-modules: Regress.Mmap\n other-extensions: CApiFFI\n\n ghc-options: -Wall -fno-warn-orphans\n default-language: Haskell2010\n\ntest-suite hashable-examples\n type: exitcode-stdio-1.0\n build-depends:\n base\n , ghc-prim\n , hashable\n\n hs-source-dirs: examples\n main-is: Main.hs\n default-language: Haskell2010\n\nsource-repository head\n type: git\n location:\n https://github.com/haskell-unordered-containers/hashable.git\n"; + package-description-override = "cabal-version: 2.2\nname: hashable\nversion: 1.5.0.0\nsynopsis: A class for types that can be converted to a hash value\ndescription:\n This package defines a class, 'Hashable', for types that can be converted to a hash value.\n This class exists for the benefit of hashing-based data structures.\n The package provides instances for basic types and a way to combine hash values.\n .\n 'Hashable' is intended exclusively for use in in-memory data structures.\n .\n 'Hashable' does /not/ have a fixed standard.\n This allows it to improve over time.\n .\n Because it does not have a fixed standard, different computers or computers on different versions of the code will observe different hash values.\n As such, 'hashable' is not recommended for use other than in-memory datastructures.\n Specifically, 'hashable' is not intended for network use or in applications which persist hashed values.\n For stable hashing use named hashes: sha256, crc32, xxhash etc.\n\nhomepage: http://github.com/haskell-unordered-containers/hashable\nlicense: BSD-3-Clause\nlicense-file: LICENSE\nauthor:\n Milan Straka \n Johan Tibell \n\nmaintainer: Oleg Grenrus \nbug-reports:\n https://github.com/haskell-unordered-containers/hashable/issues\n\nstability: Provisional\ncategory: Data\nbuild-type: Simple\ntested-with: GHC ==9.6.5 || ==9.8.2 || ==9.10.1\nextra-source-files:\n CHANGES.md\n include/HsHashable.h\n include/HsXXHash.h\n README.md\n xxHash-0.8.2/xxhash.h\n\nflag arch-native\n description:\n Use @-march=native@ when compiling C sources.\n Portable implementation is 15-50% slower.\n Consider enabling this flag if hashing performance is important.\n\n manual: True\n default: False\n\nflag random-initial-seed\n description:\n Randomly initialize the initial seed on each final executable invocation\n This is useful for catching cases when you rely on (non-existent)\n stability of hashable's hash functions.\n This is not a security feature.\n\n manual: True\n default: False\n\nlibrary\n exposed-modules:\n Data.Hashable\n Data.Hashable.Generic\n Data.Hashable.Lifted\n\n other-modules:\n Data.Hashable.Class\n Data.Hashable.FFI\n Data.Hashable.Generic.Instances\n Data.Hashable.Imports\n Data.Hashable.LowLevel\n Data.Hashable.Mix\n Data.Hashable.XXH3\n\n include-dirs: include xxHash-0.8.2\n includes:\n HsHashable.h\n HsXXHash.h\n xxhash.h\n\n hs-source-dirs: src\n build-depends:\n , base >=4.18.0.0 && <4.21\n , bytestring >=0.11.5.3 && <0.13\n , containers >=0.6.7 && <0.8\n , deepseq >=1.4.8.1 && <1.6\n , ghc-prim\n , text >=2.0.2 && <2.2\n\n -- depend on os-string on newer GHCs only.\n -- os-string has tight lower bound on bytestring, which prevents\n -- using bundled version on older GHCs.\n build-depends: os-string >=2.0.2 && <2.1\n\n -- we also ensure that we can get filepath-1.5 only with GHC-9.2\n -- therefore there is else-branch with stricter upper bound.\n build-depends: filepath >=1.4.200.1 && <1.6\n\n -- Integer internals\n build-depends: ghc-bignum >=1.3 && <1.4\n\n if (flag(random-initial-seed) && impl(ghc))\n cpp-options: -DHASHABLE_RANDOM_SEED=1\n\n if os(windows)\n c-sources: cbits-win/init.c\n\n else\n c-sources: cbits-unix/init.c\n\n default-language: Haskell2010\n other-extensions:\n BangPatterns\n CPP\n DeriveDataTypeable\n FlexibleContexts\n FlexibleInstances\n GADTs\n KindSignatures\n MagicHash\n MultiParamTypeClasses\n QuantifiedConstraints\n ScopedTypeVariables\n Trustworthy\n TypeOperators\n UnliftedFFITypes\n\n ghc-options: -Wall\n\n if flag(arch-native)\n -- Cabal doesn't pass cc-options to \"ordinary\" Haskell source compilation\n -- https://github.com/haskell/cabal/issues/9801\n ghc-options: -optc=-march=native -optc-mtune=native\n\n if impl(ghc >=9.0)\n -- these flags may abort compilation with GHC-8.10\n -- https://gitlab.haskell.org/ghc/ghc/-/merge_requests/3295\n ghc-options: -Winferred-safe-imports -Wmissing-safe-haskell-mode\n\ntest-suite hashable-tests\n type: exitcode-stdio-1.0\n hs-source-dirs: tests\n main-is: Main.hs\n other-modules:\n Properties\n Regress\n\n build-depends:\n , base\n , bytestring\n , filepath\n , ghc-prim\n , hashable\n , HUnit\n , QuickCheck >=2.15\n , random >=1.0 && <1.3\n , tasty ^>=1.5\n , tasty-hunit ^>=0.10.1\n , tasty-quickcheck ^>=0.10.3\n , text >=0.11.0.5\n\n if impl(ghc >=9.2)\n build-depends: os-string\n\n if !os(windows)\n build-depends: unix\n cpp-options: -DHAVE_MMAP\n other-modules: Regress.Mmap\n other-extensions: CApiFFI\n\n ghc-options: -Wall -fno-warn-orphans\n default-language: Haskell2010\n\ntest-suite xxhash-tests\n type: exitcode-stdio-1.0\n hs-source-dirs: tests src\n main-is: xxhash-tests.hs\n other-modules:\n Data.Hashable.FFI\n Data.Hashable.XXH3\n\n default-language: Haskell2010\n build-depends:\n , base\n , bytestring\n , primitive ^>=0.9.0.0\n , tasty ^>=1.5\n , tasty-hunit ^>=0.10.1\n , tasty-quickcheck ^>=0.10.3\n\n include-dirs: include xxHash-0.8.2\n includes:\n HsXXHash.h\n xxhash.h\n\n if !impl(ghc >=9.4)\n build-depends: data-array-byte >=0.1.0.1 && <0.2\n\ntest-suite hashable-examples\n type: exitcode-stdio-1.0\n build-depends:\n , base\n , ghc-prim\n , hashable\n\n hs-source-dirs: examples\n main-is: Main.hs\n default-language: Haskell2010\n\nsource-repository head\n type: git\n location:\n https://github.com/haskell-unordered-containers/hashable.git\n"; } \ No newline at end of file diff --git a/materialized/ghc964/hadrian-ghc98/hadrian/cabal-files/os-string.nix b/materialized/ghc964/hadrian-ghc98/hadrian/cabal-files/os-string.nix new file mode 100644 index 0000000000..761c0cf7ee --- /dev/null +++ b/materialized/ghc964/hadrian-ghc98/hadrian/cabal-files/os-string.nix @@ -0,0 +1,79 @@ +{ system + , compiler + , flags + , pkgs + , hsPkgs + , pkgconfPkgs + , errorHandler + , config + , ... }: + ({ + flags = {}; + package = { + specVersion = "2.2"; + identifier = { name = "os-string"; version = "2.0.6"; }; + license = "BSD-3-Clause"; + copyright = "Julain Ospald 2021-2023"; + maintainer = "Julian Ospald "; + author = "Julian Ospald "; + homepage = "https://github.com/haskell/os-string/blob/master/README.md"; + url = ""; + synopsis = "Library for manipulating Operating system strings."; + description = "This package provides functionality for manipulating @OsString@ values, and is shipped with ."; + buildType = "Simple"; + }; + components = { + "library" = { + depends = [ + (hsPkgs."base" or (errorHandler.buildDepError "base")) + (hsPkgs."bytestring" or (errorHandler.buildDepError "bytestring")) + (hsPkgs."deepseq" or (errorHandler.buildDepError "deepseq")) + (hsPkgs."exceptions" or (errorHandler.buildDepError "exceptions")) + (hsPkgs."template-haskell" or (errorHandler.buildDepError "template-haskell")) + ]; + buildable = true; + }; + tests = { + "bytestring-tests" = { + depends = [ + (hsPkgs."base" or (errorHandler.buildDepError "base")) + (hsPkgs."bytestring" or (errorHandler.buildDepError "bytestring")) + (hsPkgs."os-string" or (errorHandler.buildDepError "os-string")) + (hsPkgs."QuickCheck" or (errorHandler.buildDepError "QuickCheck")) + ]; + buildable = true; + }; + "encoding-tests" = { + depends = [ + (hsPkgs."base" or (errorHandler.buildDepError "base")) + (hsPkgs."bytestring" or (errorHandler.buildDepError "bytestring")) + (hsPkgs."deepseq" or (errorHandler.buildDepError "deepseq")) + (hsPkgs."os-string" or (errorHandler.buildDepError "os-string")) + (hsPkgs."QuickCheck" or (errorHandler.buildDepError "QuickCheck")) + (hsPkgs."quickcheck-classes-base" or (errorHandler.buildDepError "quickcheck-classes-base")) + ]; + buildable = true; + }; + }; + benchmarks = { + "bench" = { + depends = [ + (hsPkgs."base" or (errorHandler.buildDepError "base")) + (hsPkgs."bytestring" or (errorHandler.buildDepError "bytestring")) + (hsPkgs."os-string" or (errorHandler.buildDepError "os-string")) + (hsPkgs."deepseq" or (errorHandler.buildDepError "deepseq")) + (hsPkgs."tasty-bench" or (errorHandler.buildDepError "tasty-bench")) + (hsPkgs."random" or (errorHandler.buildDepError "random")) + ]; + buildable = true; + }; + }; + }; + } // { + src = pkgs.lib.mkDefault (pkgs.fetchurl { + url = "http://hackage.haskell.org/package/os-string-2.0.6.tar.gz"; + sha256 = "22fcc7d5fc66676b5dfc57b714d2caf93cce2d5a79d242168352f9eb0fe2f18a"; + }); + }) // { + package-description-override = "cabal-version: 2.2\nname: os-string\nversion: 2.0.6\n\n-- NOTE: Don't forget to update ./changelog.md\nlicense: BSD-3-Clause\nlicense-file: LICENSE\nauthor: Julian Ospald \nmaintainer: Julian Ospald \ncopyright: Julain Ospald 2021-2023\nbug-reports: https://github.com/haskell/os-string/issues\nhomepage:\n https://github.com/haskell/os-string/blob/master/README.md\n\ncategory: System\nbuild-type: Simple\nsynopsis: Library for manipulating Operating system strings.\ntested-with:\n GHC ==8.6.5\n || ==8.8.4\n || ==8.10.7\n || ==9.0.2\n || ==9.2.8\n || ==9.4.8\n || ==9.6.3\n || ==9.8.1\n\ndescription:\n This package provides functionality for manipulating @OsString@ values, and is shipped with .\n\nextra-source-files:\n System/OsString/Common.hs\n tests/bytestring-tests/Properties/Common.hs\n bench/Common.hs\n\nextra-doc-files:\n changelog.md\n README.md\n\nsource-repository head\n type: git\n location: https://github.com/haskell/os-string\n\nlibrary\n exposed-modules:\n System.OsString.Data.ByteString.Short\n System.OsString.Data.ByteString.Short.Internal\n System.OsString.Data.ByteString.Short.Word16\n System.OsString.Encoding\n System.OsString.Encoding.Internal\n System.OsString\n System.OsString.Internal\n System.OsString.Internal.Types\n System.OsString.Posix\n System.OsString.Windows\n\n other-extensions:\n CPP\n PatternGuards\n\n if impl(ghc >=7.2)\n other-extensions: Safe\n\n default-language: Haskell2010\n build-depends:\n , base >=4.12.0.0 && <4.21\n , bytestring >=0.11.3.0\n , deepseq\n , exceptions\n , template-haskell\n\n ghc-options: -Wall\n\ntest-suite bytestring-tests\n default-language: Haskell2010\n ghc-options: -Wall\n type: exitcode-stdio-1.0\n main-is: Main.hs\n hs-source-dirs: tests tests/bytestring-tests\n other-modules:\n Properties.ShortByteString\n Properties.WindowsString\n Properties.PosixString\n Properties.OsString\n Properties.ShortByteString.Word16\n TestUtil\n\n build-depends:\n , base\n , bytestring >=0.11.3.0\n , os-string\n , QuickCheck >=2.7 && <2.16\n\ntest-suite encoding-tests\n default-language: Haskell2010\n ghc-options: -Wall\n type: exitcode-stdio-1.0\n main-is: Main.hs\n hs-source-dirs: tests tests/encoding\n other-modules:\n Arbitrary\n EncodingSpec\n TestUtil\n\n build-depends:\n , base\n , bytestring >=0.11.3.0\n , deepseq\n , os-string\n , QuickCheck >=2.7 && <2.16\n , quickcheck-classes-base ^>=0.6.2\n\nbenchmark bench\n main-is: Bench.hs\n other-modules: BenchOsString\n BenchPosixString\n BenchWindowsString\n type: exitcode-stdio-1.0\n hs-source-dirs: bench\n default-language: Haskell2010\n ghc-options: -O2 \"-with-rtsopts=-A32m\"\n if impl(ghc >= 8.6)\n ghc-options: -fproc-alignment=64\n build-depends: base,\n bytestring,\n os-string,\n deepseq,\n tasty-bench,\n random\n"; + } \ No newline at end of file diff --git a/materialized/ghc964/hadrian-ghc98/hadrian/cabal-files/primitive.nix b/materialized/ghc964/hadrian-ghc98/hadrian/cabal-files/primitive.nix index b5683f2c83..bbba6b670f 100644 --- a/materialized/ghc964/hadrian-ghc98/hadrian/cabal-files/primitive.nix +++ b/materialized/ghc964/hadrian-ghc98/hadrian/cabal-files/primitive.nix @@ -69,5 +69,5 @@ sha256 = "696d4bd291c94d736142d6182117dca4258d3ef28bfefdb649ac8b5ecd0999c7"; }); }) // { - package-description-override = "Cabal-Version: 2.0\nName: primitive\nVersion: 0.9.0.0\nLicense: BSD3\nLicense-File: LICENSE\n\nAuthor: Roman Leshchinskiy \nMaintainer: libraries@haskell.org\nCopyright: (c) Roman Leshchinskiy 2009-2012\nHomepage: https://github.com/haskell/primitive\nBug-Reports: https://github.com/haskell/primitive/issues\nCategory: Data\nSynopsis: Primitive memory-related operations\nBuild-Type: Simple\nDescription: This package provides various primitive memory-related operations.\n\nExtra-Source-Files: changelog.md\n test/*.hs\n test/LICENSE\n\nTested-With:\n GHC == 8.0.2\n GHC == 8.2.2\n GHC == 8.4.4\n GHC == 8.6.5\n GHC == 8.8.4\n GHC == 8.10.7\n GHC == 9.0.2\n GHC == 9.2.5\n GHC == 9.4.4\n\nLibrary\n Default-Language: Haskell2010\n Default-Extensions:\n TypeOperators\n Other-Extensions:\n BangPatterns, CPP, DeriveDataTypeable,\n MagicHash, TypeFamilies, UnboxedTuples, UnliftedFFITypes\n\n Exposed-Modules:\n Control.Monad.Primitive\n Data.Primitive\n Data.Primitive.MachDeps\n Data.Primitive.Types\n Data.Primitive.Array\n Data.Primitive.ByteArray\n Data.Primitive.PrimArray\n Data.Primitive.SmallArray\n Data.Primitive.Ptr\n Data.Primitive.MutVar\n Data.Primitive.MVar\n Data.Primitive.PrimVar\n\n Other-Modules:\n Data.Primitive.Internal.Operations\n Data.Primitive.Internal.Read\n\n Build-Depends: base >= 4.9 && < 4.20\n , deepseq >= 1.1 && < 1.6\n , transformers >= 0.5 && < 0.7\n , template-haskell >= 2.11\n\n if impl(ghc >= 9.2)\n cpp-options: -DHAVE_KEEPALIVE\n\n if impl(ghc < 9.4)\n build-depends: data-array-byte >= 0.1 && < 0.1.1\n\n Ghc-Options: -O2\n\n Include-Dirs: cbits\n Install-Includes: primitive-memops.h\n includes: primitive-memops.h\n c-sources: cbits/primitive-memops.c\n if !os(solaris)\n cc-options: -ftree-vectorize\n if arch(i386) || arch(x86_64)\n cc-options: -msse2\n\ntest-suite test-qc\n Default-Language: Haskell2010\n hs-source-dirs: test\n test/src\n main-is: Main.hs\n Other-Modules: PrimLaws\n type: exitcode-stdio-1.0\n build-depends: base\n , base-orphans\n , ghc-prim\n , primitive\n , quickcheck-classes-base >= 0.6 && <0.7\n , QuickCheck >= 2.13 && < 2.15\n , tasty ^>= 1.2 || ^>= 1.3 || ^>= 1.4\n , tasty-quickcheck\n , tagged\n , transformers >= 0.5\n , transformers-compat\n\n cpp-options: -DHAVE_UNARY_LAWS\n ghc-options: -O2\n\nbenchmark bench\n Default-Language: Haskell2010\n hs-source-dirs: bench\n main-is: main.hs\n type: exitcode-stdio-1.0\n ghc-options: -O2\n other-modules:\n Array.Traverse.Closure\n Array.Traverse.Unsafe\n ByteArray.Compare\n PrimArray.Compare\n PrimArray.Traverse\n build-depends:\n base\n , primitive\n , deepseq\n , tasty-bench\n , transformers >= 0.5\n\nsource-repository head\n type: git\n location: https://github.com/haskell/primitive\n"; + package-description-override = "Cabal-Version: 2.0\nName: primitive\nVersion: 0.9.0.0\nx-revision: 1\nLicense: BSD3\nLicense-File: LICENSE\n\nAuthor: Roman Leshchinskiy \nMaintainer: libraries@haskell.org\nCopyright: (c) Roman Leshchinskiy 2009-2012\nHomepage: https://github.com/haskell/primitive\nBug-Reports: https://github.com/haskell/primitive/issues\nCategory: Data\nSynopsis: Primitive memory-related operations\nBuild-Type: Simple\nDescription: This package provides various primitive memory-related operations.\n\nExtra-Source-Files: changelog.md\n test/*.hs\n test/LICENSE\n\nTested-With:\n GHC == 8.0.2\n GHC == 8.2.2\n GHC == 8.4.4\n GHC == 8.6.5\n GHC == 8.8.4\n GHC == 8.10.7\n GHC == 9.0.2\n GHC == 9.2.8\n GHC == 9.4.8\n GHC == 9.6.4\n GHC == 9.8.2\n\nLibrary\n Default-Language: Haskell2010\n Default-Extensions:\n TypeOperators\n Other-Extensions:\n BangPatterns, CPP, DeriveDataTypeable,\n MagicHash, TypeFamilies, UnboxedTuples, UnliftedFFITypes\n\n Exposed-Modules:\n Control.Monad.Primitive\n Data.Primitive\n Data.Primitive.MachDeps\n Data.Primitive.Types\n Data.Primitive.Array\n Data.Primitive.ByteArray\n Data.Primitive.PrimArray\n Data.Primitive.SmallArray\n Data.Primitive.Ptr\n Data.Primitive.MutVar\n Data.Primitive.MVar\n Data.Primitive.PrimVar\n\n Other-Modules:\n Data.Primitive.Internal.Operations\n Data.Primitive.Internal.Read\n\n Build-Depends: base >= 4.9 && < 4.21\n , deepseq >= 1.1 && < 1.6\n , transformers >= 0.5 && < 0.7\n , template-haskell >= 2.11\n\n if impl(ghc >= 9.2)\n cpp-options: -DHAVE_KEEPALIVE\n\n if impl(ghc < 9.4)\n build-depends: data-array-byte >= 0.1 && < 0.1.1\n\n Ghc-Options: -O2\n\n Include-Dirs: cbits\n Install-Includes: primitive-memops.h\n includes: primitive-memops.h\n c-sources: cbits/primitive-memops.c\n if !os(solaris)\n cc-options: -ftree-vectorize\n if arch(i386) || arch(x86_64)\n cc-options: -msse2\n\ntest-suite test-qc\n Default-Language: Haskell2010\n hs-source-dirs: test\n test/src\n main-is: Main.hs\n Other-Modules: PrimLaws\n type: exitcode-stdio-1.0\n build-depends: base\n , base-orphans\n , ghc-prim\n , primitive\n , quickcheck-classes-base >= 0.6 && <0.7\n , QuickCheck >= 2.13 && < 2.15\n , tasty >= 1.2 && < 1.6\n , tasty-quickcheck\n , tagged\n , transformers >= 0.5\n , transformers-compat\n\n cpp-options: -DHAVE_UNARY_LAWS\n ghc-options: -O2\n\nbenchmark bench\n Default-Language: Haskell2010\n hs-source-dirs: bench\n main-is: main.hs\n type: exitcode-stdio-1.0\n ghc-options: -O2\n other-modules:\n Array.Traverse.Closure\n Array.Traverse.Unsafe\n ByteArray.Compare\n PrimArray.Compare\n PrimArray.Traverse\n build-depends:\n base\n , primitive\n , deepseq\n , tasty-bench\n , transformers >= 0.5\n\nsource-repository head\n type: git\n location: https://github.com/haskell/primitive\n"; } \ No newline at end of file diff --git a/materialized/ghc964/hadrian-ghc98/hadrian/cabal-files/random.nix b/materialized/ghc964/hadrian-ghc98/hadrian/cabal-files/random.nix index 0dbaf8b099..2d04734f5b 100644 --- a/materialized/ghc964/hadrian-ghc98/hadrian/cabal-files/random.nix +++ b/materialized/ghc964/hadrian-ghc98/hadrian/cabal-files/random.nix @@ -11,7 +11,7 @@ flags = {}; package = { specVersion = "1.10"; - identifier = { name = "random"; version = "1.2.1.1"; }; + identifier = { name = "random"; version = "1.2.1.2"; }; license = "BSD-3-Clause"; copyright = ""; maintainer = "core-libraries-committee@haskell.org"; @@ -105,9 +105,9 @@ }; } // { src = pkgs.lib.mkDefault (pkgs.fetchurl { - url = "http://hackage.haskell.org/package/random-1.2.1.1.tar.gz"; - sha256 = "3e1272f7ed6a4d7bd1712b90143ec326fee9b225789222379fea20a9c90c9b76"; + url = "http://hackage.haskell.org/package/random-1.2.1.2.tar.gz"; + sha256 = "790f4dc2d2327c453ff6aac7bf15399fd123d55e927935f68f84b5df42d9a4b4"; }); }) // { - package-description-override = "cabal-version: >=1.10\r\nname: random\r\nversion: 1.2.1.1\r\nx-revision: 1\r\nlicense: BSD3\r\nlicense-file: LICENSE\r\nmaintainer: core-libraries-committee@haskell.org\r\nbug-reports: https://github.com/haskell/random/issues\r\nsynopsis: Pseudo-random number generation\r\ndescription:\r\n This package provides basic pseudo-random number generation, including the\r\n ability to split random number generators.\r\n .\r\n == \"System.Random\": pure pseudo-random number interface\r\n .\r\n In pure code, use 'System.Random.uniform' and 'System.Random.uniformR' from\r\n \"System.Random\" to generate pseudo-random numbers with a pure pseudo-random\r\n number generator like 'System.Random.StdGen'.\r\n .\r\n As an example, here is how you can simulate rolls of a six-sided die using\r\n 'System.Random.uniformR':\r\n .\r\n >>> let roll = uniformR (1, 6) :: RandomGen g => g -> (Word, g)\r\n >>> let rolls = unfoldr (Just . roll) :: RandomGen g => g -> [Word]\r\n >>> let pureGen = mkStdGen 42\r\n >>> take 10 (rolls pureGen) :: [Word]\r\n [1,1,3,2,4,5,3,4,6,2]\r\n .\r\n See \"System.Random\" for more details.\r\n .\r\n == \"System.Random.Stateful\": monadic pseudo-random number interface\r\n .\r\n In monadic code, use 'System.Random.Stateful.uniformM' and\r\n 'System.Random.Stateful.uniformRM' from \"System.Random.Stateful\" to generate\r\n pseudo-random numbers with a monadic pseudo-random number generator, or\r\n using a monadic adapter.\r\n .\r\n As an example, here is how you can simulate rolls of a six-sided die using\r\n 'System.Random.Stateful.uniformRM':\r\n .\r\n >>> let rollM = uniformRM (1, 6) :: StatefulGen g m => g -> m Word\r\n >>> let pureGen = mkStdGen 42\r\n >>> runStateGen_ pureGen (replicateM 10 . rollM) :: [Word]\r\n [1,1,3,2,4,5,3,4,6,2]\r\n .\r\n The monadic adapter 'System.Random.Stateful.runStateGen_' is used here to lift\r\n the pure pseudo-random number generator @pureGen@ into the\r\n 'System.Random.Stateful.StatefulGen' context.\r\n .\r\n The monadic interface can also be used with existing monadic pseudo-random\r\n number generators. In this example, we use the one provided in the\r\n package:\r\n .\r\n >>> import System.Random.MWC as MWC\r\n >>> let rollM = uniformRM (1, 6) :: StatefulGen g m => g -> m Word\r\n >>> monadicGen <- MWC.create\r\n >>> replicateM 10 (rollM monadicGen) :: IO [Word]\r\n [2,3,6,6,4,4,3,1,5,4]\r\n .\r\n See \"System.Random.Stateful\" for more details.\r\n\r\ncategory: System\r\nbuild-type: Simple\r\nextra-source-files:\r\n README.md\r\n CHANGELOG.md\r\ntested-with: GHC == 7.10.2\r\n , GHC == 7.10.3\r\n , GHC == 8.0.2\r\n , GHC == 8.2.2\r\n , GHC == 8.4.3\r\n , GHC == 8.4.4\r\n , GHC == 8.6.3\r\n , GHC == 8.6.4\r\n , GHC == 8.6.5\r\n , GHC == 8.8.1\r\n , GHC == 8.8.2\r\n , GHC == 8.10.1\r\n\r\nsource-repository head\r\n type: git\r\n location: https://github.com/haskell/random.git\r\n\r\n\r\nlibrary\r\n exposed-modules:\r\n System.Random\r\n System.Random.Internal\r\n System.Random.Stateful\r\n other-modules:\r\n System.Random.GFinite\r\n\r\n hs-source-dirs: src\r\n default-language: Haskell2010\r\n ghc-options:\r\n -Wall\r\n if impl(ghc >= 8.0)\r\n ghc-options:\r\n -Wincomplete-record-updates -Wincomplete-uni-patterns\r\n\r\n build-depends:\r\n base >=4.8 && <5,\r\n bytestring >=0.10.4 && <0.13,\r\n deepseq >=1.1 && <2,\r\n mtl >=2.2 && <2.4,\r\n splitmix >=0.1 && <0.2\r\n if impl(ghc < 8.0)\r\n build-depends:\r\n transformers\r\n\r\ntest-suite legacy-test\r\n type: exitcode-stdio-1.0\r\n main-is: Legacy.hs\r\n hs-source-dirs: test-legacy\r\n other-modules:\r\n T7936\r\n TestRandomIOs\r\n TestRandomRs\r\n Random1283\r\n RangeTest\r\n\r\n default-language: Haskell2010\r\n ghc-options: -with-rtsopts=-M8M\r\n if impl(ghc >= 8.0)\r\n ghc-options:\r\n -Wno-deprecations\r\n build-depends:\r\n base,\r\n containers >=0.5 && <0.7,\r\n random\r\n\r\ntest-suite doctests\r\n type: exitcode-stdio-1.0\r\n main-is: doctests.hs\r\n hs-source-dirs: test\r\n default-language: Haskell2010\r\n build-depends:\r\n base,\r\n doctest >=0.15 && <0.21\r\n if impl(ghc >= 8.2) && impl(ghc < 8.10)\r\n build-depends:\r\n mwc-random >=0.13 && <0.16,\r\n primitive >=0.6 && <0.8,\r\n random,\r\n stm,\r\n unliftio >=0.2 && <0.3,\r\n vector >= 0.10 && <0.14\r\n\r\ntest-suite spec\r\n type: exitcode-stdio-1.0\r\n main-is: Spec.hs\r\n hs-source-dirs: test\r\n other-modules:\r\n Spec.Range\r\n Spec.Run\r\n Spec.Stateful\r\n\r\n default-language: Haskell2010\r\n ghc-options: -Wall\r\n build-depends:\r\n base,\r\n bytestring,\r\n random,\r\n smallcheck >=1.2 && <1.3,\r\n stm,\r\n tasty >=1.0 && <1.5,\r\n tasty-smallcheck >=0.8 && <0.9,\r\n tasty-hunit >=0.10 && <0.11,\r\n transformers\r\n\r\n-- Note. Fails when compiled with coverage:\r\n-- https://github.com/haskell/random/issues/107\r\ntest-suite spec-inspection\r\n type: exitcode-stdio-1.0\r\n main-is: Spec.hs\r\n hs-source-dirs: test-inspection\r\n build-depends:\r\n\r\n default-language: Haskell2010\r\n ghc-options: -Wall\r\n build-depends:\r\n base,\r\n random,\r\n tasty >=1.0 && <1.5\r\n if impl(ghc >= 8.0)\r\n build-depends:\r\n tasty-inspection-testing\r\n other-modules:\r\n Spec.Inspection\r\n\r\nbenchmark legacy-bench\r\n type: exitcode-stdio-1.0\r\n main-is: SimpleRNGBench.hs\r\n hs-source-dirs: bench-legacy\r\n other-modules: BinSearch\r\n default-language: Haskell2010\r\n ghc-options:\r\n -Wall -O2 -threaded -rtsopts -with-rtsopts=-N\r\n if impl(ghc >= 8.0)\r\n ghc-options:\r\n -Wno-deprecations\r\n\r\n build-depends:\r\n base,\r\n random,\r\n rdtsc,\r\n split >=0.2 && <0.3,\r\n time >=1.4 && <1.13\r\n\r\nbenchmark bench\r\n type: exitcode-stdio-1.0\r\n main-is: Main.hs\r\n hs-source-dirs: bench\r\n default-language: Haskell2010\r\n ghc-options: -Wall -O2\r\n build-depends:\r\n base,\r\n mtl,\r\n primitive >= 0.7.1,\r\n random,\r\n splitmix >=0.1 && <0.2,\r\n tasty-bench\r\n"; + package-description-override = "cabal-version: >=1.10\nname: random\nversion: 1.2.1.2\nlicense: BSD3\nlicense-file: LICENSE\nmaintainer: core-libraries-committee@haskell.org\nbug-reports: https://github.com/haskell/random/issues\nsynopsis: Pseudo-random number generation\ndescription:\n This package provides basic pseudo-random number generation, including the\n ability to split random number generators.\n .\n == \"System.Random\": pure pseudo-random number interface\n .\n In pure code, use 'System.Random.uniform' and 'System.Random.uniformR' from\n \"System.Random\" to generate pseudo-random numbers with a pure pseudo-random\n number generator like 'System.Random.StdGen'.\n .\n As an example, here is how you can simulate rolls of a six-sided die using\n 'System.Random.uniformR':\n .\n >>> let roll = uniformR (1, 6) :: RandomGen g => g -> (Word, g)\n >>> let rolls = unfoldr (Just . roll) :: RandomGen g => g -> [Word]\n >>> let pureGen = mkStdGen 42\n >>> take 10 (rolls pureGen) :: [Word]\n [1,1,3,2,4,5,3,4,6,2]\n .\n See \"System.Random\" for more details.\n .\n == \"System.Random.Stateful\": monadic pseudo-random number interface\n .\n In monadic code, use 'System.Random.Stateful.uniformM' and\n 'System.Random.Stateful.uniformRM' from \"System.Random.Stateful\" to generate\n pseudo-random numbers with a monadic pseudo-random number generator, or\n using a monadic adapter.\n .\n As an example, here is how you can simulate rolls of a six-sided die using\n 'System.Random.Stateful.uniformRM':\n .\n >>> let rollM = uniformRM (1, 6) :: StatefulGen g m => g -> m Word\n >>> let pureGen = mkStdGen 42\n >>> runStateGen_ pureGen (replicateM 10 . rollM) :: [Word]\n [1,1,3,2,4,5,3,4,6,2]\n .\n The monadic adapter 'System.Random.Stateful.runStateGen_' is used here to lift\n the pure pseudo-random number generator @pureGen@ into the\n 'System.Random.Stateful.StatefulGen' context.\n .\n The monadic interface can also be used with existing monadic pseudo-random\n number generators. In this example, we use the one provided in the\n package:\n .\n >>> import System.Random.MWC as MWC\n >>> let rollM = uniformRM (1, 6) :: StatefulGen g m => g -> m Word\n >>> monadicGen <- MWC.create\n >>> replicateM 10 (rollM monadicGen) :: IO [Word]\n [2,3,6,6,4,4,3,1,5,4]\n .\n See \"System.Random.Stateful\" for more details.\n\ncategory: System\nbuild-type: Simple\nextra-source-files:\n README.md\n CHANGELOG.md\ntested-with: GHC == 8.0.2\n , GHC == 8.2.2\n , GHC == 8.4.3\n , GHC == 8.4.4\n , GHC == 8.6.3\n , GHC == 8.6.4\n , GHC == 8.6.5\n , GHC == 8.8.1\n , GHC == 8.8.2\n , GHC == 8.10.1\n\nsource-repository head\n type: git\n location: https://github.com/haskell/random.git\n\n\nlibrary\n exposed-modules:\n System.Random\n System.Random.Internal\n System.Random.Stateful\n other-modules:\n System.Random.GFinite\n\n hs-source-dirs: src\n default-language: Haskell2010\n ghc-options:\n -Wall\n if impl(ghc >= 8.0)\n ghc-options:\n -Wincomplete-record-updates -Wincomplete-uni-patterns\n\n build-depends:\n base >=4.8 && <5,\n bytestring >=0.10.4 && <0.13,\n deepseq >=1.1 && <2,\n mtl >=2.2 && <2.4,\n splitmix >=0.1 && <0.2\n if impl(ghc < 8.0)\n build-depends:\n transformers\n\ntest-suite legacy-test\n type: exitcode-stdio-1.0\n main-is: Legacy.hs\n hs-source-dirs: test-legacy\n other-modules:\n T7936\n TestRandomIOs\n TestRandomRs\n Random1283\n RangeTest\n\n default-language: Haskell2010\n ghc-options: -rtsopts -with-rtsopts=-M9M\n if impl(ghc >= 8.0)\n ghc-options:\n -Wno-deprecations\n build-depends:\n base,\n containers >=0.5 && <0.7,\n random\n\ntest-suite doctests\n type: exitcode-stdio-1.0\n main-is: doctests.hs\n hs-source-dirs: test\n default-language: Haskell2010\n build-depends:\n base,\n doctest >=0.15 && <0.23\n if impl(ghc >= 8.2) && impl(ghc < 8.10)\n build-depends:\n mwc-random >=0.13 && <0.16,\n primitive >=0.6 && <0.8,\n random,\n stm,\n unliftio >=0.2 && <0.3,\n vector >= 0.10 && <0.14\n\ntest-suite spec\n type: exitcode-stdio-1.0\n main-is: Spec.hs\n hs-source-dirs: test\n other-modules:\n Spec.Range\n Spec.Run\n Spec.Stateful\n\n default-language: Haskell2010\n ghc-options: -Wall\n build-depends:\n base,\n bytestring,\n random,\n smallcheck >=1.2 && <1.3,\n stm,\n tasty >=1.0 && <1.6,\n tasty-smallcheck >=0.8 && <0.9,\n tasty-hunit >=0.10 && <0.11,\n transformers\n\n-- Note. Fails when compiled with coverage:\n-- https://github.com/haskell/random/issues/107\ntest-suite spec-inspection\n type: exitcode-stdio-1.0\n main-is: Spec.hs\n hs-source-dirs: test-inspection\n default-language: Haskell2010\n ghc-options: -Wall\n build-depends:\n base,\n random,\n tasty >=1.0 && <1.6\n if impl(ghc >= 8.0)\n build-depends:\n tasty-inspection-testing\n other-modules:\n Spec.Inspection\n\nbenchmark legacy-bench\n type: exitcode-stdio-1.0\n main-is: SimpleRNGBench.hs\n hs-source-dirs: bench-legacy\n other-modules: BinSearch\n default-language: Haskell2010\n ghc-options:\n -Wall -O2 -threaded -rtsopts -with-rtsopts=-N\n if impl(ghc >= 8.0)\n ghc-options:\n -Wno-deprecations\n\n build-depends:\n base,\n random,\n rdtsc,\n split >=0.2 && <0.3,\n time >=1.4 && <1.13\n\nbenchmark bench\n type: exitcode-stdio-1.0\n main-is: Main.hs\n hs-source-dirs: bench\n default-language: Haskell2010\n ghc-options: -Wall -O2\n build-depends:\n base,\n mtl,\n primitive >= 0.7.1,\n random,\n splitmix >=0.1 && <0.2,\n tasty-bench\n"; } \ No newline at end of file diff --git a/materialized/ghc964/hadrian-ghc98/hadrian/cabal-files/shake.nix b/materialized/ghc964/hadrian-ghc98/hadrian/cabal-files/shake.nix index d40c2a8bbc..d643f68037 100644 --- a/materialized/ghc964/hadrian-ghc98/hadrian/cabal-files/shake.nix +++ b/materialized/ghc964/hadrian-ghc98/hadrian/cabal-files/shake.nix @@ -8,12 +8,17 @@ , config , ... }: ({ - flags = { portable = false; cloud = false; embed-files = false; }; + flags = { + portable = false; + cloud = false; + embed-files = false; + threaded = true; + }; package = { specVersion = "1.18"; - identifier = { name = "shake"; version = "0.19.7"; }; + identifier = { name = "shake"; version = "0.19.8"; }; license = "BSD-3-Clause"; - copyright = "Neil Mitchell 2011-2022"; + copyright = "Neil Mitchell 2011-2024"; maintainer = "Neil Mitchell "; author = "Neil Mitchell "; homepage = "https://shakebuild.com"; @@ -124,9 +129,9 @@ }; } // { src = pkgs.lib.mkDefault (pkgs.fetchurl { - url = "http://hackage.haskell.org/package/shake-0.19.7.tar.gz"; - sha256 = "352a56af12f70b50d564dcb61131555577281957ee196f1702a3723c0a3699d1"; + url = "http://hackage.haskell.org/package/shake-0.19.8.tar.gz"; + sha256 = "6384e33a26a2590bf33719e88881076b899ac4b5340c1c9271e4caa37e9d6535"; }); }) // { - package-description-override = "cabal-version: 1.18\nbuild-type: Simple\nname: shake\nversion: 0.19.7\nx-revision: 1\nlicense: BSD3\nlicense-file: LICENSE\ncategory: Development, Shake\nauthor: Neil Mitchell \nmaintainer: Neil Mitchell \ncopyright: Neil Mitchell 2011-2022\nsynopsis: Build system library, like Make, but more accurate dependencies.\ndescription:\n Shake is a Haskell library for writing build systems - designed as a\n replacement for @make@. See \"Development.Shake\" for an introduction,\n including an example. The homepage contains links to a user\n manual, an academic paper and further information:\n \n .\n To use Shake the user writes a Haskell program\n that imports \"Development.Shake\", defines some build rules, and calls\n the 'Development.Shake.shakeArgs' function. Thanks to do notation and infix\n operators, a simple Shake build system\n is not too dissimilar from a simple Makefile. However, as build systems\n get more complex, Shake is able to take advantage of the excellent\n abstraction facilities offered by Haskell and easily support much larger\n projects. The Shake library provides all the standard features available in other\n build systems, including automatic parallelism and minimal rebuilds.\n Shake also provides more accurate dependency tracking, including seamless\n support for generated files, and dependencies on system information\n (e.g. compiler version).\nhomepage: https://shakebuild.com\nbug-reports: https://github.com/ndmitchell/shake/issues\ntested-with: GHC==9.0, GHC==8.10, GHC==8.8, GHC==8.6\nextra-doc-files:\n CHANGES.txt\n README.md\n docs/Manual.md\n docs/shake-progress.png\nextra-source-files:\n src/Paths.hs\n src/Test/C/constants.c\n src/Test/C/constants.h\n src/Test/C/main.c\n src/Test/Ninja/*.ninja\n src/Test/Ninja/*.output\n src/Test/Ninja/subdir/*.ninja\n src/Test/Progress/*.prog\n src/Test/Tar/list.txt\n src/Test/Tup/hello.c\n src/Test/Tup/newmath/root.cfg\n src/Test/Tup/newmath/square.c\n src/Test/Tup/newmath/square.h\n src/Test/Tup/root.cfg\ndata-files:\n docs/manual/build.bat\n docs/manual/Shakefile.hs\n docs/manual/build.sh\n docs/manual/constants.c\n docs/manual/constants.h\n docs/manual/main.c\n html/profile.html\n html/progress.html\n html/shake.js\n\nsource-repository head\n type: git\n location: https://github.com/ndmitchell/shake.git\n\nflag portable\n default: False\n manual: True\n description: Obtain FileTime using portable functions\n\nflag cloud\n default: False\n manual: True\n description: Enable cloud build features\n\nflag embed-files\n default: False\n manual: True\n description: Embed data files into the shake library\n\nlibrary\n default-language: Haskell2010\n hs-source-dirs: src\n build-depends:\n base >= 4.9,\n binary,\n bytestring,\n deepseq >= 1.1,\n directory >= 1.2.7.0,\n extra >= 1.6.19,\n filepath >= 1.4,\n filepattern,\n hashable >= 1.1.2.3,\n heaps >= 0.3.6.1,\n js-dgtable,\n js-flot,\n js-jquery,\n primitive,\n process >= 1.1,\n random,\n time,\n transformers >= 0.2,\n unordered-containers >= 0.2.7,\n utf8-string >= 0.3\n\n if flag(embed-files)\n cpp-options: -DFILE_EMBED\n build-depends:\n file-embed >= 0.0.11,\n template-haskell\n\n if flag(portable)\n cpp-options: -DPORTABLE\n else\n if !os(windows)\n build-depends: unix >= 2.5.1\n if !os(windows)\n build-depends: unix\n\n if flag(cloud)\n cpp-options: -DNETWORK\n build-depends: network, network-uri\n\n exposed-modules:\n Development.Shake\n Development.Shake.Classes\n Development.Shake.Command\n Development.Shake.Config\n Development.Shake.Database\n Development.Shake.FilePath\n Development.Shake.Forward\n Development.Shake.Rule\n Development.Shake.Util\n\n other-modules:\n Development.Ninja.Env\n Development.Ninja.Lexer\n Development.Ninja.Parse\n Development.Ninja.Type\n Development.Shake.Internal.Args\n Development.Shake.Internal.CmdOption\n Development.Shake.Internal.CompactUI\n Development.Shake.Internal.Core.Action\n Development.Shake.Internal.Core.Build\n Development.Shake.Internal.Core.Database\n Development.Shake.Internal.History.Shared\n Development.Shake.Internal.History.Symlink\n Development.Shake.Internal.History.Bloom\n Development.Shake.Internal.History.Cloud\n Development.Shake.Internal.History.Network\n Development.Shake.Internal.History.Server\n Development.Shake.Internal.History.Serialise\n Development.Shake.Internal.History.Types\n Development.Shake.Internal.Core.Monad\n Development.Shake.Internal.Core.Pool\n Development.Shake.Internal.Core.Rules\n Development.Shake.Internal.Core.Run\n Development.Shake.Internal.Core.Storage\n Development.Shake.Internal.Core.Types\n Development.Shake.Internal.Demo\n Development.Shake.Internal.Derived\n Development.Shake.Internal.Errors\n Development.Shake.Internal.FileInfo\n Development.Shake.Internal.FileName\n Development.Shake.Internal.FilePattern\n Development.Shake.Internal.Options\n Development.Shake.Internal.Paths\n Development.Shake.Internal.Profile\n Development.Shake.Internal.Progress\n Development.Shake.Internal.Resource\n Development.Shake.Internal.Rules.Default\n Development.Shake.Internal.Rules.Directory\n Development.Shake.Internal.Rules.File\n Development.Shake.Internal.Rules.Files\n Development.Shake.Internal.Rules.Oracle\n Development.Shake.Internal.Rules.OrderOnly\n Development.Shake.Internal.Rules.Rerun\n Development.Shake.Internal.Value\n General.Bilist\n General.Binary\n General.Chunks\n General.Cleanup\n General.Fence\n General.EscCodes\n General.Extra\n General.FileLock\n General.GetOpt\n General.Ids\n General.Intern\n General.ListBuilder\n General.Makefile\n General.Pool\n General.Process\n General.Template\n General.Thread\n General.Timing\n General.TypeMap\n General.Wait\n Paths_shake\n\n\nexecutable shake\n default-language: Haskell2010\n hs-source-dirs: src\n ghc-options: -main-is Run.main -rtsopts -threaded \"-with-rtsopts=-I0 -qg\"\n main-is: Run.hs\n build-depends:\n base == 4.*,\n binary,\n bytestring,\n deepseq >= 1.1,\n directory,\n extra >= 1.6.19,\n filepath,\n filepattern,\n hashable >= 1.1.2.3,\n heaps >= 0.3.6.1,\n js-dgtable,\n js-flot,\n js-jquery,\n primitive,\n process >= 1.1,\n random,\n time,\n transformers >= 0.2,\n unordered-containers >= 0.2.7,\n utf8-string >= 0.3\n\n if flag(embed-files)\n cpp-options: -DFILE_EMBED\n build-depends:\n file-embed >= 0.0.11,\n template-haskell\n\n if flag(portable)\n cpp-options: -DPORTABLE\n else\n if !os(windows)\n build-depends: unix >= 2.5.1\n if !os(windows)\n build-depends: unix\n\n if flag(cloud)\n cpp-options: -DNETWORK\n build-depends: network, network-uri\n\n if impl(ghc < 8.0)\n build-depends: semigroups >= 0.18\n\n other-modules:\n Development.Ninja.All\n Development.Ninja.Env\n Development.Ninja.Lexer\n Development.Ninja.Parse\n Development.Ninja.Type\n Development.Shake\n Development.Shake.Classes\n Development.Shake.Command\n Development.Shake.Database\n Development.Shake.FilePath\n Development.Shake.Internal.Args\n Development.Shake.Internal.CmdOption\n Development.Shake.Internal.CompactUI\n Development.Shake.Internal.Core.Action\n Development.Shake.Internal.Core.Build\n Development.Shake.Internal.Core.Database\n Development.Shake.Internal.History.Shared\n Development.Shake.Internal.History.Symlink\n Development.Shake.Internal.History.Bloom\n Development.Shake.Internal.History.Cloud\n Development.Shake.Internal.History.Network\n Development.Shake.Internal.History.Server\n Development.Shake.Internal.History.Serialise\n Development.Shake.Internal.History.Types\n Development.Shake.Internal.Core.Monad\n Development.Shake.Internal.Core.Pool\n Development.Shake.Internal.Core.Rules\n Development.Shake.Internal.Core.Run\n Development.Shake.Internal.Core.Storage\n Development.Shake.Internal.Core.Types\n Development.Shake.Internal.Demo\n Development.Shake.Internal.Derived\n Development.Shake.Internal.Errors\n Development.Shake.Internal.FileInfo\n Development.Shake.Internal.FileName\n Development.Shake.Internal.FilePattern\n Development.Shake.Internal.Options\n Development.Shake.Internal.Paths\n Development.Shake.Internal.Profile\n Development.Shake.Internal.Progress\n Development.Shake.Internal.Resource\n Development.Shake.Internal.Rules.Default\n Development.Shake.Internal.Rules.Directory\n Development.Shake.Internal.Rules.File\n Development.Shake.Internal.Rules.Files\n Development.Shake.Internal.Rules.Oracle\n Development.Shake.Internal.Rules.OrderOnly\n Development.Shake.Internal.Rules.Rerun\n Development.Shake.Internal.Value\n General.Bilist\n General.Binary\n General.Chunks\n General.Cleanup\n General.Fence\n General.EscCodes\n General.Extra\n General.FileLock\n General.GetOpt\n General.Ids\n General.Intern\n General.ListBuilder\n General.Makefile\n General.Pool\n General.Process\n General.Template\n General.Thread\n General.Timing\n General.TypeMap\n General.Wait\n Paths_shake\n\n\ntest-suite shake-test\n default-language: Haskell2010\n type: exitcode-stdio-1.0\n main-is: Test.hs\n hs-source-dirs: src\n ghc-options: -main-is Test.main -rtsopts -with-rtsopts=-K1K -threaded\n\n build-depends:\n base == 4.*,\n binary,\n bytestring,\n deepseq >= 1.1,\n directory,\n extra >= 1.6.19,\n filepath,\n filepattern,\n hashable >= 1.1.2.3,\n heaps >= 0.3.6.1,\n js-dgtable,\n js-flot,\n js-jquery,\n primitive,\n process >= 1.1,\n QuickCheck >= 2.0,\n random,\n time,\n transformers >= 0.2,\n unordered-containers >= 0.2.7,\n utf8-string >= 0.3\n\n if flag(embed-files)\n cpp-options: -DFILE_EMBED\n build-depends:\n file-embed >= 0.0.11,\n template-haskell\n\n if flag(portable)\n cpp-options: -DPORTABLE\n else\n if !os(windows)\n build-depends: unix >= 2.5.1\n if !os(windows)\n build-depends: unix\n\n if flag(cloud)\n cpp-options: -DNETWORK\n build-depends: network, network-uri\n\n if impl(ghc < 8.0)\n build-depends: semigroups >= 0.18\n\n other-modules:\n Development.Ninja.All\n Development.Ninja.Env\n Development.Ninja.Lexer\n Development.Ninja.Parse\n Development.Ninja.Type\n Development.Shake\n Development.Shake.Classes\n Development.Shake.Command\n Development.Shake.Config\n Development.Shake.Database\n Development.Shake.FilePath\n Development.Shake.Forward\n Development.Shake.Internal.Args\n Development.Shake.Internal.CmdOption\n Development.Shake.Internal.CompactUI\n Development.Shake.Internal.Core.Action\n Development.Shake.Internal.Core.Build\n Development.Shake.Internal.Core.Database\n Development.Shake.Internal.History.Shared\n Development.Shake.Internal.History.Symlink\n Development.Shake.Internal.History.Bloom\n Development.Shake.Internal.History.Cloud\n Development.Shake.Internal.History.Network\n Development.Shake.Internal.History.Server\n Development.Shake.Internal.History.Serialise\n Development.Shake.Internal.History.Types\n Development.Shake.Internal.Core.Monad\n Development.Shake.Internal.Core.Pool\n Development.Shake.Internal.Core.Rules\n Development.Shake.Internal.Core.Run\n Development.Shake.Internal.Core.Storage\n Development.Shake.Internal.Core.Types\n Development.Shake.Internal.Demo\n Development.Shake.Internal.Derived\n Development.Shake.Internal.Errors\n Development.Shake.Internal.FileInfo\n Development.Shake.Internal.FileName\n Development.Shake.Internal.FilePattern\n Development.Shake.Internal.Options\n Development.Shake.Internal.Paths\n Development.Shake.Internal.Profile\n Development.Shake.Internal.Progress\n Development.Shake.Internal.Resource\n Development.Shake.Internal.Rules.Default\n Development.Shake.Internal.Rules.Directory\n Development.Shake.Internal.Rules.File\n Development.Shake.Internal.Rules.Files\n Development.Shake.Internal.Rules.Oracle\n Development.Shake.Internal.Rules.OrderOnly\n Development.Shake.Internal.Rules.Rerun\n Development.Shake.Internal.Value\n Development.Shake.Rule\n Development.Shake.Util\n General.Bilist\n General.Binary\n General.Chunks\n General.Cleanup\n General.Fence\n General.EscCodes\n General.Extra\n General.FileLock\n General.GetOpt\n General.Ids\n General.Intern\n General.ListBuilder\n General.Makefile\n General.Pool\n General.Process\n General.Template\n General.Thread\n General.Timing\n General.TypeMap\n General.Wait\n Paths_shake\n Run\n Test.Basic\n Test.Batch\n Test.Benchmark\n Test.Builtin\n Test.BuiltinOverride\n Test.C\n Test.Cache\n Test.Cleanup\n Test.CloseFileHandles\n Test.Command\n Test.Config\n Test.Database\n Test.Digest\n Test.Directory\n Test.Docs\n Test.Errors\n Test.Existence\n Test.FileLock\n Test.FilePath\n Test.FilePattern\n Test.Files\n Test.Forward\n Test.History\n Test.Journal\n Test.Lint\n Test.Live\n Test.Manual\n Test.Match\n Test.Monad\n Test.Ninja\n Test.Oracle\n Test.OrderOnly\n Test.Parallel\n Test.Pool\n Test.Progress\n Test.Random\n Test.Rebuild\n Test.Reschedule\n Test.Resources\n Test.Self\n Test.SelfMake\n Test.Tar\n Test.Targets\n Test.Thread\n Test.Tup\n Test.Type\n Test.Unicode\n Test.Util\n Test.Verbosity\n Test.Version\n"; + package-description-override = "cabal-version: 1.18\nbuild-type: Simple\nname: shake\nversion: 0.19.8\nlicense: BSD3\nlicense-file: LICENSE\ncategory: Development, Shake\nauthor: Neil Mitchell \nmaintainer: Neil Mitchell \ncopyright: Neil Mitchell 2011-2024\nsynopsis: Build system library, like Make, but more accurate dependencies.\ndescription:\n Shake is a Haskell library for writing build systems - designed as a\n replacement for @make@. See \"Development.Shake\" for an introduction,\n including an example. The homepage contains links to a user\n manual, an academic paper and further information:\n \n .\n To use Shake the user writes a Haskell program\n that imports \"Development.Shake\", defines some build rules, and calls\n the 'Development.Shake.shakeArgs' function. Thanks to do notation and infix\n operators, a simple Shake build system\n is not too dissimilar from a simple Makefile. However, as build systems\n get more complex, Shake is able to take advantage of the excellent\n abstraction facilities offered by Haskell and easily support much larger\n projects. The Shake library provides all the standard features available in other\n build systems, including automatic parallelism and minimal rebuilds.\n Shake also provides more accurate dependency tracking, including seamless\n support for generated files, and dependencies on system information\n (e.g. compiler version).\nhomepage: https://shakebuild.com\nbug-reports: https://github.com/ndmitchell/shake/issues\ntested-with: GHC==9.8, GHC==9.6, GHC==9.4, GHC==9.2, GHC==9.0, GHC==8.10, GHC==8.8\nextra-doc-files:\n CHANGES.txt\n README.md\n docs/Manual.md\n docs/shake-progress.png\nextra-source-files:\n src/Paths.hs\n src/Test/C/constants.c\n src/Test/C/constants.h\n src/Test/C/main.c\n src/Test/Ninja/*.ninja\n src/Test/Ninja/*.output\n src/Test/Ninja/subdir/*.ninja\n src/Test/Progress/*.prog\n src/Test/Tar/list.txt\n src/Test/Tup/hello.c\n src/Test/Tup/newmath/root.cfg\n src/Test/Tup/newmath/square.c\n src/Test/Tup/newmath/square.h\n src/Test/Tup/root.cfg\ndata-files:\n docs/manual/build.bat\n docs/manual/Shakefile.hs\n docs/manual/build.sh\n docs/manual/constants.c\n docs/manual/constants.h\n docs/manual/main.c\n html/profile.html\n html/progress.html\n html/shake.js\n\nsource-repository head\n type: git\n location: https://github.com/ndmitchell/shake.git\n\nflag portable\n default: False\n manual: True\n description: Obtain FileTime using portable functions\n\nflag cloud\n default: False\n manual: True\n description: Enable cloud build features\n\nflag embed-files\n default: False\n manual: True\n description: Embed data files into the shake library\n\nflag threaded\n default: True\n manual: True\n description: Build shake with the threaded RTS\n\nlibrary\n default-language: Haskell2010\n hs-source-dirs: src\n build-depends:\n base >= 4.9,\n binary,\n bytestring,\n deepseq >= 1.1,\n directory >= 1.2.7.0,\n extra >= 1.6.19,\n filepath >= 1.4,\n filepattern,\n hashable >= 1.1.2.3,\n heaps >= 0.3.6.1,\n js-dgtable,\n js-flot,\n js-jquery,\n primitive,\n process >= 1.1,\n random,\n time,\n transformers >= 0.2,\n unordered-containers >= 0.2.7,\n utf8-string >= 0.3\n\n if flag(embed-files)\n cpp-options: -DFILE_EMBED\n build-depends:\n file-embed >= 0.0.11,\n template-haskell\n\n if flag(portable)\n cpp-options: -DPORTABLE\n else\n if !os(windows)\n build-depends: unix >= 2.5.1\n if !os(windows)\n build-depends: unix\n\n if flag(cloud)\n cpp-options: -DNETWORK\n build-depends: network, network-uri\n\n exposed-modules:\n Development.Shake\n Development.Shake.Classes\n Development.Shake.Command\n Development.Shake.Config\n Development.Shake.Database\n Development.Shake.FilePath\n Development.Shake.Forward\n Development.Shake.Rule\n Development.Shake.Util\n\n other-modules:\n Development.Ninja.Env\n Development.Ninja.Lexer\n Development.Ninja.Parse\n Development.Ninja.Type\n Development.Shake.Internal.Args\n Development.Shake.Internal.CmdOption\n Development.Shake.Internal.CompactUI\n Development.Shake.Internal.Core.Action\n Development.Shake.Internal.Core.Build\n Development.Shake.Internal.Core.Database\n Development.Shake.Internal.History.Shared\n Development.Shake.Internal.History.Symlink\n Development.Shake.Internal.History.Bloom\n Development.Shake.Internal.History.Cloud\n Development.Shake.Internal.History.Network\n Development.Shake.Internal.History.Server\n Development.Shake.Internal.History.Serialise\n Development.Shake.Internal.History.Types\n Development.Shake.Internal.Core.Monad\n Development.Shake.Internal.Core.Pool\n Development.Shake.Internal.Core.Rules\n Development.Shake.Internal.Core.Run\n Development.Shake.Internal.Core.Storage\n Development.Shake.Internal.Core.Types\n Development.Shake.Internal.Demo\n Development.Shake.Internal.Derived\n Development.Shake.Internal.Errors\n Development.Shake.Internal.FileInfo\n Development.Shake.Internal.FileName\n Development.Shake.Internal.FilePattern\n Development.Shake.Internal.Options\n Development.Shake.Internal.Paths\n Development.Shake.Internal.Profile\n Development.Shake.Internal.Progress\n Development.Shake.Internal.Resource\n Development.Shake.Internal.Rules.Default\n Development.Shake.Internal.Rules.Directory\n Development.Shake.Internal.Rules.File\n Development.Shake.Internal.Rules.Files\n Development.Shake.Internal.Rules.Oracle\n Development.Shake.Internal.Rules.OrderOnly\n Development.Shake.Internal.Rules.Rerun\n Development.Shake.Internal.Value\n General.Bilist\n General.Binary\n General.Chunks\n General.Cleanup\n General.Fence\n General.EscCodes\n General.Extra\n General.FileLock\n General.GetOpt\n General.Ids\n General.Intern\n General.ListBuilder\n General.Makefile\n General.Pool\n General.Process\n General.Template\n General.Thread\n General.Timing\n General.TypeMap\n General.Wait\n Paths_shake\n\n\nexecutable shake\n default-language: Haskell2010\n hs-source-dirs: src\n ghc-options: -main-is Run.main -rtsopts\n if flag(threaded)\n ghc-options: -threaded \"-with-rtsopts=-I0 -qg\"\n main-is: Run.hs\n build-depends:\n base == 4.*,\n binary,\n bytestring,\n deepseq >= 1.1,\n directory,\n extra >= 1.6.19,\n filepath,\n filepattern,\n hashable >= 1.1.2.3,\n heaps >= 0.3.6.1,\n js-dgtable,\n js-flot,\n js-jquery,\n primitive,\n process >= 1.1,\n random,\n time,\n transformers >= 0.2,\n unordered-containers >= 0.2.7,\n utf8-string >= 0.3\n\n if flag(embed-files)\n cpp-options: -DFILE_EMBED\n build-depends:\n file-embed >= 0.0.11,\n template-haskell\n\n if flag(portable)\n cpp-options: -DPORTABLE\n else\n if !os(windows)\n build-depends: unix >= 2.5.1\n if !os(windows)\n build-depends: unix\n\n if flag(cloud)\n cpp-options: -DNETWORK\n build-depends: network, network-uri\n\n if impl(ghc < 8.0)\n build-depends: semigroups >= 0.18\n\n other-modules:\n Development.Ninja.All\n Development.Ninja.Env\n Development.Ninja.Lexer\n Development.Ninja.Parse\n Development.Ninja.Type\n Development.Shake\n Development.Shake.Classes\n Development.Shake.Command\n Development.Shake.Database\n Development.Shake.FilePath\n Development.Shake.Internal.Args\n Development.Shake.Internal.CmdOption\n Development.Shake.Internal.CompactUI\n Development.Shake.Internal.Core.Action\n Development.Shake.Internal.Core.Build\n Development.Shake.Internal.Core.Database\n Development.Shake.Internal.History.Shared\n Development.Shake.Internal.History.Symlink\n Development.Shake.Internal.History.Bloom\n Development.Shake.Internal.History.Cloud\n Development.Shake.Internal.History.Network\n Development.Shake.Internal.History.Server\n Development.Shake.Internal.History.Serialise\n Development.Shake.Internal.History.Types\n Development.Shake.Internal.Core.Monad\n Development.Shake.Internal.Core.Pool\n Development.Shake.Internal.Core.Rules\n Development.Shake.Internal.Core.Run\n Development.Shake.Internal.Core.Storage\n Development.Shake.Internal.Core.Types\n Development.Shake.Internal.Demo\n Development.Shake.Internal.Derived\n Development.Shake.Internal.Errors\n Development.Shake.Internal.FileInfo\n Development.Shake.Internal.FileName\n Development.Shake.Internal.FilePattern\n Development.Shake.Internal.Options\n Development.Shake.Internal.Paths\n Development.Shake.Internal.Profile\n Development.Shake.Internal.Progress\n Development.Shake.Internal.Resource\n Development.Shake.Internal.Rules.Default\n Development.Shake.Internal.Rules.Directory\n Development.Shake.Internal.Rules.File\n Development.Shake.Internal.Rules.Files\n Development.Shake.Internal.Rules.Oracle\n Development.Shake.Internal.Rules.OrderOnly\n Development.Shake.Internal.Rules.Rerun\n Development.Shake.Internal.Value\n General.Bilist\n General.Binary\n General.Chunks\n General.Cleanup\n General.Fence\n General.EscCodes\n General.Extra\n General.FileLock\n General.GetOpt\n General.Ids\n General.Intern\n General.ListBuilder\n General.Makefile\n General.Pool\n General.Process\n General.Template\n General.Thread\n General.Timing\n General.TypeMap\n General.Wait\n Paths_shake\n\n\ntest-suite shake-test\n default-language: Haskell2010\n type: exitcode-stdio-1.0\n main-is: Test.hs\n hs-source-dirs: src\n ghc-options: -main-is Test.main -rtsopts -with-rtsopts=-K1K\n if flag(threaded)\n ghc-options: -threaded\n\n build-depends:\n base == 4.*,\n binary,\n bytestring,\n deepseq >= 1.1,\n directory,\n extra >= 1.6.19,\n filepath,\n filepattern,\n hashable >= 1.1.2.3,\n heaps >= 0.3.6.1,\n js-dgtable,\n js-flot,\n js-jquery,\n primitive,\n process >= 1.1,\n QuickCheck >= 2.0,\n random,\n time,\n transformers >= 0.2,\n unordered-containers >= 0.2.7,\n utf8-string >= 0.3\n\n if flag(embed-files)\n cpp-options: -DFILE_EMBED\n build-depends:\n file-embed >= 0.0.11,\n template-haskell\n\n if flag(portable)\n cpp-options: -DPORTABLE\n else\n if !os(windows)\n build-depends: unix >= 2.5.1\n if !os(windows)\n build-depends: unix\n\n if flag(cloud)\n cpp-options: -DNETWORK\n build-depends: network, network-uri\n\n if impl(ghc < 8.0)\n build-depends: semigroups >= 0.18\n\n other-modules:\n Development.Ninja.All\n Development.Ninja.Env\n Development.Ninja.Lexer\n Development.Ninja.Parse\n Development.Ninja.Type\n Development.Shake\n Development.Shake.Classes\n Development.Shake.Command\n Development.Shake.Config\n Development.Shake.Database\n Development.Shake.FilePath\n Development.Shake.Forward\n Development.Shake.Internal.Args\n Development.Shake.Internal.CmdOption\n Development.Shake.Internal.CompactUI\n Development.Shake.Internal.Core.Action\n Development.Shake.Internal.Core.Build\n Development.Shake.Internal.Core.Database\n Development.Shake.Internal.History.Shared\n Development.Shake.Internal.History.Symlink\n Development.Shake.Internal.History.Bloom\n Development.Shake.Internal.History.Cloud\n Development.Shake.Internal.History.Network\n Development.Shake.Internal.History.Server\n Development.Shake.Internal.History.Serialise\n Development.Shake.Internal.History.Types\n Development.Shake.Internal.Core.Monad\n Development.Shake.Internal.Core.Pool\n Development.Shake.Internal.Core.Rules\n Development.Shake.Internal.Core.Run\n Development.Shake.Internal.Core.Storage\n Development.Shake.Internal.Core.Types\n Development.Shake.Internal.Demo\n Development.Shake.Internal.Derived\n Development.Shake.Internal.Errors\n Development.Shake.Internal.FileInfo\n Development.Shake.Internal.FileName\n Development.Shake.Internal.FilePattern\n Development.Shake.Internal.Options\n Development.Shake.Internal.Paths\n Development.Shake.Internal.Profile\n Development.Shake.Internal.Progress\n Development.Shake.Internal.Resource\n Development.Shake.Internal.Rules.Default\n Development.Shake.Internal.Rules.Directory\n Development.Shake.Internal.Rules.File\n Development.Shake.Internal.Rules.Files\n Development.Shake.Internal.Rules.Oracle\n Development.Shake.Internal.Rules.OrderOnly\n Development.Shake.Internal.Rules.Rerun\n Development.Shake.Internal.Value\n Development.Shake.Rule\n Development.Shake.Util\n General.Bilist\n General.Binary\n General.Chunks\n General.Cleanup\n General.Fence\n General.EscCodes\n General.Extra\n General.FileLock\n General.GetOpt\n General.Ids\n General.Intern\n General.ListBuilder\n General.Makefile\n General.Pool\n General.Process\n General.Template\n General.Thread\n General.Timing\n General.TypeMap\n General.Wait\n Paths_shake\n Run\n Test.Basic\n Test.Batch\n Test.Benchmark\n Test.Builtin\n Test.BuiltinOverride\n Test.C\n Test.Cache\n Test.Cleanup\n Test.CloseFileHandles\n Test.Command\n Test.Config\n Test.Database\n Test.Digest\n Test.Directory\n Test.Docs\n Test.Errors\n Test.Existence\n Test.FileLock\n Test.FilePath\n Test.FilePattern\n Test.Files\n Test.Forward\n Test.History\n Test.Journal\n Test.Lint\n Test.Live\n Test.Manual\n Test.Match\n Test.Monad\n Test.Ninja\n Test.Oracle\n Test.OrderOnly\n Test.Parallel\n Test.Pool\n Test.Progress\n Test.Random\n Test.Rebuild\n Test.Reschedule\n Test.Resources\n Test.Self\n Test.SelfMake\n Test.Tar\n Test.Targets\n Test.Thread\n Test.Tup\n Test.Type\n Test.Unicode\n Test.Util\n Test.Verbosity\n Test.Version\n"; } \ No newline at end of file diff --git a/materialized/ghc964/hadrian-ghc98/hadrian/cabal-files/splitmix.nix b/materialized/ghc964/hadrian-ghc98/hadrian/cabal-files/splitmix.nix index aa0dd88d31..633d8e112a 100644 --- a/materialized/ghc964/hadrian-ghc98/hadrian/cabal-files/splitmix.nix +++ b/materialized/ghc964/hadrian-ghc98/hadrian/cabal-files/splitmix.nix @@ -135,5 +135,5 @@ sha256 = "9df07a9611ef45f1b1258a0b412f4d02c920248f69d2e2ce8ccda328f7e13002"; }); }) // { - package-description-override = "cabal-version: >=1.10\nname: splitmix\nversion: 0.1.0.5\nsynopsis: Fast Splittable PRNG\ndescription:\n Pure Haskell implementation of SplitMix described in\n .\n Guy L. Steele, Jr., Doug Lea, and Christine H. Flood. 2014.\n Fast splittable pseudorandom number generators. In Proceedings\n of the 2014 ACM International Conference on Object Oriented\n Programming Systems Languages & Applications (OOPSLA '14). ACM,\n New York, NY, USA, 453-472. DOI:\n \n .\n The paper describes a new algorithm /SplitMix/ for /splittable/\n pseudorandom number generator that is quite fast: 9 64 bit arithmetic/logical\n operations per 64 bits generated.\n .\n /SplitMix/ is tested with two standard statistical test suites (DieHarder and\n TestU01, this implementation only using the former) and it appears to be\n adequate for \"everyday\" use, such as Monte Carlo algorithms and randomized\n data structures where speed is important.\n .\n In particular, it __should not be used for cryptographic or security applications__,\n because generated sequences of pseudorandom values are too predictable\n (the mixing functions are easily inverted, and two successive outputs\n suffice to reconstruct the internal state).\n\nlicense: BSD3\nlicense-file: LICENSE\nmaintainer: Oleg Grenrus \nbug-reports: https://github.com/haskellari/splitmix/issues\ncategory: System, Random\nbuild-type: Simple\ntested-with:\n GHC ==7.0.4\n || ==7.2.2\n || ==7.4.2\n || ==7.6.3\n || ==7.8.4\n || ==7.10.3\n || ==8.0.2\n || ==8.2.2\n || ==8.4.4\n || ==8.6.5\n || ==8.8.4\n || ==8.10.4\n || ==9.0.2\n || ==9.2.8\n || ==9.4.7\n || ==9.6.3\n || ==9.8.1\n , GHCJS ==8.4\n\nextra-source-files:\n Changelog.md\n make-hugs.sh\n README.md\n test-hugs.sh\n\nflag optimised-mixer\n description: Use JavaScript for mix32\n manual: True\n default: False\n\nlibrary\n default-language: Haskell2010\n ghc-options: -Wall\n hs-source-dirs: src src-compat\n exposed-modules:\n System.Random.SplitMix\n System.Random.SplitMix32\n\n other-modules:\n Data.Bits.Compat\n System.Random.SplitMix.Init\n\n -- dump-core\n -- build-depends: dump-core\n -- ghc-options: -fplugin=DumpCore -fplugin-opt DumpCore:core-html\n\n build-depends:\n base >=4.3 && <4.20\n , deepseq >=1.3.0.0 && <1.6\n\n if flag(optimised-mixer)\n cpp-options: -DOPTIMISED_MIX32=1\n\n -- We don't want to depend on time, nor unix or Win32 packages\n -- because it's valuable that splitmix and QuickCheck doesn't\n -- depend on about anything\n\n if impl(ghcjs)\n cpp-options: -DSPLITMIX_INIT_GHCJS=1\n\n else\n if impl(ghc)\n cpp-options: -DSPLITMIX_INIT_C=1\n\n if os(windows)\n c-sources: cbits-win/init.c\n\n else\n c-sources: cbits-unix/init.c\n\n else\n cpp-options: -DSPLITMIX_INIT_COMPAT=1\n build-depends: time >=1.2.0.3 && <1.13\n\nsource-repository head\n type: git\n location: https://github.com/haskellari/splitmix.git\n\nbenchmark comparison\n type: exitcode-stdio-1.0\n default-language: Haskell2010\n ghc-options: -Wall\n hs-source-dirs: bench\n main-is: Bench.hs\n build-depends:\n base\n , containers >=0.4.2.1 && <0.7\n , criterion >=1.1.0.0 && <1.7\n , random\n , splitmix\n , tf-random >=0.5 && <0.6\n\nbenchmark simple-sum\n type: exitcode-stdio-1.0\n default-language: Haskell2010\n ghc-options: -Wall\n hs-source-dirs: bench\n main-is: SimpleSum.hs\n build-depends:\n base\n , random\n , splitmix\n\nbenchmark range\n type: exitcode-stdio-1.0\n default-language: Haskell2010\n ghc-options: -Wall\n hs-source-dirs: bench src-compat\n main-is: Range.hs\n other-modules: Data.Bits.Compat\n build-depends:\n base\n , random\n , splitmix\n\n if !impl(ghcjs)\n build-depends: clock >=0.8 && <0.9\n\ntest-suite examples\n type: exitcode-stdio-1.0\n default-language: Haskell2010\n ghc-options: -Wall\n hs-source-dirs: tests\n main-is: Examples.hs\n build-depends:\n base\n , HUnit ==1.3.1.2 || >=1.6.0.0 && <1.7\n , splitmix\n\ntest-suite splitmix-tests\n type: exitcode-stdio-1.0\n default-language: Haskell2010\n ghc-options: -Wall\n hs-source-dirs: tests\n main-is: Tests.hs\n other-modules:\n MiniQC\n Uniformity\n\n build-depends:\n base\n , base-compat >=0.11.1 && <0.14\n , containers >=0.4.0.0 && <0.7\n , HUnit ==1.3.1.2 || >=1.6.0.0 && <1.7\n , math-functions ==0.1.7.0 || >=0.3.3.0 && <0.4\n , splitmix\n , test-framework >=0.8.2.0 && <0.9\n , test-framework-hunit >=0.3.0.2 && <0.4\n\ntest-suite montecarlo-pi\n type: exitcode-stdio-1.0\n default-language: Haskell2010\n ghc-options: -Wall\n hs-source-dirs: tests\n main-is: SplitMixPi.hs\n build-depends:\n base\n , splitmix\n\ntest-suite montecarlo-pi-32\n type: exitcode-stdio-1.0\n default-language: Haskell2010\n ghc-options: -Wall\n hs-source-dirs: tests\n main-is: SplitMixPi32.hs\n build-depends:\n base\n , splitmix\n\ntest-suite splitmix-dieharder\n default-language: Haskell2010\n type: exitcode-stdio-1.0\n ghc-options: -Wall -threaded -rtsopts\n hs-source-dirs: tests\n main-is: Dieharder.hs\n build-depends:\n async >=2.2.1 && <2.3\n , base\n , base-compat-batteries >=0.10.5 && <0.14\n , bytestring >=0.9.1.8 && <0.13\n , deepseq\n , process >=1.0.1.5 && <1.7\n , random\n , splitmix\n , tf-random >=0.5 && <0.6\n , vector >=0.11.0.0 && <0.14\n\ntest-suite splitmix-testu01\n if !os(linux)\n buildable: False\n\n default-language: Haskell2010\n type: exitcode-stdio-1.0\n ghc-options: -Wall -threaded -rtsopts\n hs-source-dirs: tests\n main-is: TestU01.hs\n c-sources: tests/cbits/testu01.c\n extra-libraries: testu01\n build-depends:\n base\n , base-compat-batteries >=0.10.5 && <0.14\n , splitmix\n\ntest-suite initialization\n default-language: Haskell2010\n type: exitcode-stdio-1.0\n ghc-options: -Wall -threaded -rtsopts\n hs-source-dirs: tests\n main-is: Initialization.hs\n build-depends:\n base\n , HUnit ==1.3.1.2 || >=1.6.0.0 && <1.7\n , splitmix\n"; + package-description-override = "cabal-version: >=1.10\nname: splitmix\nversion: 0.1.0.5\nx-revision: 1\nsynopsis: Fast Splittable PRNG\ndescription:\n Pure Haskell implementation of SplitMix described in\n .\n Guy L. Steele, Jr., Doug Lea, and Christine H. Flood. 2014.\n Fast splittable pseudorandom number generators. In Proceedings\n of the 2014 ACM International Conference on Object Oriented\n Programming Systems Languages & Applications (OOPSLA '14). ACM,\n New York, NY, USA, 453-472. DOI:\n \n .\n The paper describes a new algorithm /SplitMix/ for /splittable/\n pseudorandom number generator that is quite fast: 9 64 bit arithmetic/logical\n operations per 64 bits generated.\n .\n /SplitMix/ is tested with two standard statistical test suites (DieHarder and\n TestU01, this implementation only using the former) and it appears to be\n adequate for \"everyday\" use, such as Monte Carlo algorithms and randomized\n data structures where speed is important.\n .\n In particular, it __should not be used for cryptographic or security applications__,\n because generated sequences of pseudorandom values are too predictable\n (the mixing functions are easily inverted, and two successive outputs\n suffice to reconstruct the internal state).\n\nlicense: BSD3\nlicense-file: LICENSE\nmaintainer: Oleg Grenrus \nbug-reports: https://github.com/haskellari/splitmix/issues\ncategory: System, Random\nbuild-type: Simple\ntested-with:\n GHC ==7.0.4\n || ==7.2.2\n || ==7.4.2\n || ==7.6.3\n || ==7.8.4\n || ==7.10.3\n || ==8.0.2\n || ==8.2.2\n || ==8.4.4\n || ==8.6.5\n || ==8.8.4\n || ==8.10.4\n || ==9.0.2\n || ==9.2.8\n || ==9.4.8\n || ==9.6.4\n || ==9.8.2\n || ==9.10.1\n , GHCJS ==8.4\n\nextra-source-files:\n Changelog.md\n make-hugs.sh\n README.md\n test-hugs.sh\n\nflag optimised-mixer\n description: Use JavaScript for mix32\n manual: True\n default: False\n\nlibrary\n default-language: Haskell2010\n ghc-options: -Wall\n hs-source-dirs: src src-compat\n exposed-modules:\n System.Random.SplitMix\n System.Random.SplitMix32\n\n other-modules:\n Data.Bits.Compat\n System.Random.SplitMix.Init\n\n -- dump-core\n -- build-depends: dump-core\n -- ghc-options: -fplugin=DumpCore -fplugin-opt DumpCore:core-html\n\n build-depends:\n base >=4.3 && <4.21\n , deepseq >=1.3.0.0 && <1.6\n\n if flag(optimised-mixer)\n cpp-options: -DOPTIMISED_MIX32=1\n\n -- We don't want to depend on time, nor unix or Win32 packages\n -- because it's valuable that splitmix and QuickCheck doesn't\n -- depend on about anything\n\n if impl(ghcjs)\n cpp-options: -DSPLITMIX_INIT_GHCJS=1\n\n else\n if impl(ghc)\n cpp-options: -DSPLITMIX_INIT_C=1\n\n if os(windows)\n c-sources: cbits-win/init.c\n\n else\n c-sources: cbits-unix/init.c\n\n else\n cpp-options: -DSPLITMIX_INIT_COMPAT=1\n build-depends: time >=1.2.0.3 && <1.13\n\nsource-repository head\n type: git\n location: https://github.com/haskellari/splitmix.git\n\nbenchmark comparison\n type: exitcode-stdio-1.0\n default-language: Haskell2010\n ghc-options: -Wall\n hs-source-dirs: bench\n main-is: Bench.hs\n build-depends:\n base\n , containers >=0.4.2.1 && <0.8\n , criterion >=1.1.0.0 && <1.7\n , random\n , splitmix\n , tf-random >=0.5 && <0.6\n\nbenchmark simple-sum\n type: exitcode-stdio-1.0\n default-language: Haskell2010\n ghc-options: -Wall\n hs-source-dirs: bench\n main-is: SimpleSum.hs\n build-depends:\n base\n , random\n , splitmix\n\nbenchmark range\n type: exitcode-stdio-1.0\n default-language: Haskell2010\n ghc-options: -Wall\n hs-source-dirs: bench src-compat\n main-is: Range.hs\n other-modules: Data.Bits.Compat\n build-depends:\n base\n , random\n , splitmix\n\n if !impl(ghcjs)\n build-depends: clock >=0.8 && <0.9\n\ntest-suite examples\n type: exitcode-stdio-1.0\n default-language: Haskell2010\n ghc-options: -Wall\n hs-source-dirs: tests\n main-is: Examples.hs\n build-depends:\n base\n , HUnit ==1.3.1.2 || >=1.6.0.0 && <1.7\n , splitmix\n\ntest-suite splitmix-tests\n type: exitcode-stdio-1.0\n default-language: Haskell2010\n ghc-options: -Wall\n hs-source-dirs: tests\n main-is: Tests.hs\n other-modules:\n MiniQC\n Uniformity\n\n build-depends:\n base\n , base-compat >=0.11.1 && <0.14\n , containers >=0.4.0.0 && <0.8\n , HUnit ==1.3.1.2 || >=1.6.0.0 && <1.7\n , math-functions ==0.1.7.0 || >=0.3.3.0 && <0.4\n , splitmix\n , test-framework >=0.8.2.0 && <0.9\n , test-framework-hunit >=0.3.0.2 && <0.4\n\ntest-suite montecarlo-pi\n type: exitcode-stdio-1.0\n default-language: Haskell2010\n ghc-options: -Wall\n hs-source-dirs: tests\n main-is: SplitMixPi.hs\n build-depends:\n base\n , splitmix\n\ntest-suite montecarlo-pi-32\n type: exitcode-stdio-1.0\n default-language: Haskell2010\n ghc-options: -Wall\n hs-source-dirs: tests\n main-is: SplitMixPi32.hs\n build-depends:\n base\n , splitmix\n\ntest-suite splitmix-dieharder\n default-language: Haskell2010\n type: exitcode-stdio-1.0\n ghc-options: -Wall -threaded -rtsopts\n hs-source-dirs: tests\n main-is: Dieharder.hs\n build-depends:\n async >=2.2.1 && <2.3\n , base\n , base-compat-batteries >=0.10.5 && <0.14\n , bytestring >=0.9.1.8 && <0.13\n , deepseq\n , process >=1.0.1.5 && <1.7\n , random\n , splitmix\n , tf-random >=0.5 && <0.6\n , vector >=0.11.0.0 && <0.14\n\ntest-suite splitmix-testu01\n if !os(linux)\n buildable: False\n\n default-language: Haskell2010\n type: exitcode-stdio-1.0\n ghc-options: -Wall -threaded -rtsopts\n hs-source-dirs: tests\n main-is: TestU01.hs\n c-sources: tests/cbits/testu01.c\n extra-libraries: testu01\n build-depends:\n base\n , base-compat-batteries >=0.10.5 && <0.14\n , splitmix\n\ntest-suite initialization\n default-language: Haskell2010\n type: exitcode-stdio-1.0\n ghc-options: -Wall -threaded -rtsopts\n hs-source-dirs: tests\n main-is: Initialization.hs\n build-depends:\n base\n , HUnit ==1.3.1.2 || >=1.6.0.0 && <1.7\n , splitmix\n"; } \ No newline at end of file diff --git a/materialized/ghc964/hadrian-ghc98/hadrian/cabal-files/unordered-containers.nix b/materialized/ghc964/hadrian-ghc98/hadrian/cabal-files/unordered-containers.nix index 0aeaccb277..816666c80f 100644 --- a/materialized/ghc964/hadrian-ghc98/hadrian/cabal-files/unordered-containers.nix +++ b/materialized/ghc964/hadrian-ghc98/hadrian/cabal-files/unordered-containers.nix @@ -11,7 +11,7 @@ flags = { debug = false; }; package = { specVersion = "1.10"; - identifier = { name = "unordered-containers"; version = "0.2.19.1"; }; + identifier = { name = "unordered-containers"; version = "0.2.20"; }; license = "BSD-3-Clause"; copyright = "2010-2014 Johan Tibell\n2010 Edward Z. Yang"; maintainer = "simon.jakobi@gmail.com, David.Feuer@gmail.com"; @@ -70,9 +70,9 @@ }; } // { src = pkgs.lib.mkDefault (pkgs.fetchurl { - url = "http://hackage.haskell.org/package/unordered-containers-0.2.19.1.tar.gz"; - sha256 = "1b27bec5e0d522b27a6029ebf4c4a6d40acbc083c787008e32fb55c4b1d128d2"; + url = "http://hackage.haskell.org/package/unordered-containers-0.2.20.tar.gz"; + sha256 = "d9cfb287cf00592d39dc9c3cac8b99627ea08f2c01798e70130fc39f7c90f11d"; }); }) // { - package-description-override = "name: unordered-containers\nversion: 0.2.19.1\nx-revision: 3\nsynopsis: Efficient hashing-based container types\ndescription:\n Efficient hashing-based container types. The containers have been\n optimized for performance critical use, both in terms of large data\n quantities and high speed.\n .\n The declared cost of each operation is either worst-case or\n amortized, but remains valid even if structures are shared.\n .\n /Security/\n .\n This package currently provides no defenses against hash collision attacks\n such as HashDoS.\n Users who need to store input from untrusted sources are advised to use\n @Data.Map@ or @Data.Set@ from the @containers@ package instead.\nlicense: BSD3\nlicense-file: LICENSE\nauthor: Johan Tibell\nmaintainer: simon.jakobi@gmail.com, David.Feuer@gmail.com\nHomepage: https://github.com/haskell-unordered-containers/unordered-containers\nbug-reports: https://github.com/haskell-unordered-containers/unordered-containers/issues\ncopyright: 2010-2014 Johan Tibell\n 2010 Edward Z. Yang\ncategory: Data\nbuild-type: Simple\ncabal-version: >=1.10\nextra-source-files: CHANGES.md\n\ntested-with:\n GHC ==9.8.1\n || ==9.6.3\n || ==9.4.7\n || ==9.2.8\n || ==9.0.2\n || ==8.10.7\n || ==8.8.4\n || ==8.6.5\n || ==8.4.4\n || ==8.2.2\n\nflag debug\n description: Enable debug support\n default: False\n\nlibrary\n exposed-modules:\n Data.HashMap.Internal\n Data.HashMap.Internal.Array\n Data.HashMap.Internal.List\n Data.HashMap.Internal.Strict\n Data.HashMap.Lazy\n Data.HashMap.Strict\n Data.HashSet\n Data.HashSet.Internal\n\n build-depends:\n base >= 4.10 && < 5,\n deepseq >= 1.4.3,\n hashable >= 1.2.5 && < 1.5,\n template-haskell < 2.22\n\n default-language: Haskell2010\n\n other-extensions:\n RoleAnnotations,\n UnboxedTuples,\n ScopedTypeVariables,\n MagicHash,\n BangPatterns\n\n ghc-options: -Wall -O2 -fwarn-tabs -ferror-spans\n\n -- For dumping the generated code:\n -- ghc-options: -ddump-simpl -ddump-stg-final -ddump-cmm -ddump-asm -ddump-to-file\n -- ghc-options: -dsuppress-coercions -dsuppress-unfoldings -dsuppress-module-prefixes\n -- ghc-options: -dsuppress-uniques -dsuppress-timestamps\n\n if flag(debug)\n cpp-options: -DASSERTS\n\ntest-suite unordered-containers-tests\n hs-source-dirs: tests\n main-is: Main.hs\n type: exitcode-stdio-1.0\n other-modules:\n Regressions\n Properties\n Properties.HashMapLazy\n Properties.HashMapStrict\n Properties.HashSet\n Properties.List\n Strictness\n\n build-depends:\n base,\n ChasingBottoms,\n containers >= 0.5.8,\n hashable,\n HUnit,\n QuickCheck >= 2.4.0.1,\n random,\n tasty >= 1.4.0.3,\n tasty-hunit >= 0.10.0.3,\n tasty-quickcheck >= 0.10.1.2,\n unordered-containers\n\n if impl(ghc >= 8.6)\n build-depends:\n nothunks >= 0.1.3\n\n default-language: Haskell2010\n ghc-options: -Wall\n cpp-options: -DASSERTS\n\nbenchmark benchmarks\n hs-source-dirs: benchmarks\n main-is: Benchmarks.hs\n type: exitcode-stdio-1.0\n\n other-modules:\n Util.ByteString\n Util.String\n Util.Int\n\n build-depends:\n base >= 4.8.0,\n bytestring >= 0.10.0.0,\n containers,\n deepseq,\n hashable,\n hashmap,\n mtl,\n random,\n tasty-bench >= 0.3.1,\n unordered-containers\n\n default-language: Haskell2010\n ghc-options: -Wall -O2 -rtsopts -with-rtsopts=-A32m\n if impl(ghc >= 8.10)\n ghc-options: \"-with-rtsopts=-A32m --nonmoving-gc\"\n -- cpp-options: -DBENCH_containers_Map -DBENCH_containers_IntMap -DBENCH_hashmap_Map\n\nsource-repository head\n type: git\n location: https://github.com/haskell-unordered-containers/unordered-containers.git\n"; + package-description-override = "name: unordered-containers\r\nversion: 0.2.20\r\nx-revision: 3\r\nsynopsis: Efficient hashing-based container types\r\ndescription:\r\n Efficient hashing-based container types. The containers have been\r\n optimized for performance critical use, both in terms of large data\r\n quantities and high speed.\r\n .\r\n The declared cost of each operation is either worst-case or\r\n amortized, but remains valid even if structures are shared.\r\n .\r\n /Security/\r\n .\r\n This package currently provides no defenses against hash collision attacks\r\n such as HashDoS.\r\n Users who need to store input from untrusted sources are advised to use\r\n @Data.Map@ or @Data.Set@ from the @containers@ package instead.\r\nlicense: BSD3\r\nlicense-file: LICENSE\r\nauthor: Johan Tibell\r\nmaintainer: simon.jakobi@gmail.com, David.Feuer@gmail.com\r\nHomepage: https://github.com/haskell-unordered-containers/unordered-containers\r\nbug-reports: https://github.com/haskell-unordered-containers/unordered-containers/issues\r\ncopyright: 2010-2014 Johan Tibell\r\n 2010 Edward Z. Yang\r\ncategory: Data\r\nbuild-type: Simple\r\ncabal-version: >=1.10\r\nextra-source-files: CHANGES.md\r\n\r\ntested-with:\r\n GHC ==9.8.1\r\n || ==9.6.3\r\n || ==9.4.7\r\n || ==9.2.8\r\n || ==9.0.2\r\n || ==8.10.7\r\n || ==8.8.4\r\n || ==8.6.5\r\n || ==8.4.4\r\n || ==8.2.2\r\n\r\nflag debug\r\n description: Enable debug support\r\n default: False\r\n\r\nlibrary\r\n exposed-modules:\r\n Data.HashMap.Internal\r\n Data.HashMap.Internal.Array\r\n Data.HashMap.Internal.Debug\r\n Data.HashMap.Internal.List\r\n Data.HashMap.Internal.Strict\r\n Data.HashMap.Lazy\r\n Data.HashMap.Strict\r\n Data.HashSet\r\n Data.HashSet.Internal\r\n\r\n build-depends:\r\n base >= 4.10 && < 5,\r\n deepseq >= 1.4.3,\r\n hashable >= 1.4 && < 1.6,\r\n template-haskell < 2.23\r\n\r\n default-language: Haskell2010\r\n\r\n other-extensions:\r\n RoleAnnotations,\r\n UnboxedTuples,\r\n ScopedTypeVariables,\r\n MagicHash,\r\n BangPatterns\r\n\r\n ghc-options: -Wall -O2 -fwarn-tabs -ferror-spans\r\n\r\n -- For dumping the generated code:\r\n -- ghc-options: -ddump-simpl -ddump-stg-final -ddump-cmm -ddump-asm -ddump-to-file\r\n -- ghc-options: -dsuppress-coercions -dsuppress-unfoldings -dsuppress-module-prefixes\r\n -- ghc-options: -dsuppress-uniques -dsuppress-timestamps\r\n\r\n if flag(debug)\r\n cpp-options: -DASSERTS\r\n\r\ntest-suite unordered-containers-tests\r\n hs-source-dirs: tests\r\n main-is: Main.hs\r\n type: exitcode-stdio-1.0\r\n other-modules:\r\n Regressions\r\n Properties\r\n Properties.HashMapLazy\r\n Properties.HashMapStrict\r\n Properties.HashSet\r\n Properties.List\r\n Strictness\r\n Util.Key\r\n\r\n build-depends:\r\n base,\r\n ChasingBottoms,\r\n containers >= 0.5.8,\r\n hashable,\r\n HUnit,\r\n QuickCheck >= 2.4.0.1,\r\n random,\r\n tasty >= 1.4.0.3,\r\n tasty-hunit >= 0.10.0.3,\r\n tasty-quickcheck >= 0.10.1.2,\r\n unordered-containers\r\n\r\n if impl(ghc >= 8.6)\r\n build-depends:\r\n nothunks >= 0.1.3\r\n\r\n default-language: Haskell2010\r\n ghc-options: -Wall -threaded -rtsopts -with-rtsopts=-N\r\n cpp-options: -DASSERTS\r\n\r\nbenchmark benchmarks\r\n hs-source-dirs: benchmarks\r\n main-is: Benchmarks.hs\r\n type: exitcode-stdio-1.0\r\n\r\n other-modules:\r\n Util.ByteString\r\n Util.String\r\n Util.Int\r\n\r\n build-depends:\r\n base >= 4.8.0,\r\n bytestring >= 0.10.0.0,\r\n containers,\r\n deepseq,\r\n hashable,\r\n hashmap,\r\n mtl,\r\n random,\r\n tasty-bench >= 0.3.1,\r\n unordered-containers\r\n\r\n default-language: Haskell2010\r\n ghc-options: -Wall -O2 -rtsopts -with-rtsopts=-A32m\r\n if impl(ghc >= 8.10)\r\n ghc-options: \"-with-rtsopts=-A32m --nonmoving-gc\"\r\n -- cpp-options: -DBENCH_containers_Map -DBENCH_containers_IntMap -DBENCH_hashmap_Map\r\n\r\nsource-repository head\r\n type: git\r\n location: https://github.com/haskell-unordered-containers/unordered-containers.git\r\n"; } \ No newline at end of file diff --git a/materialized/ghc964/hadrian-ghc98/hadrian/default.nix b/materialized/ghc964/hadrian-ghc98/hadrian/default.nix index 08f0ef6f72..1f822105bf 100644 --- a/materialized/ghc964/hadrian-ghc98/hadrian/default.nix +++ b/materialized/ghc964/hadrian-ghc98/hadrian/default.nix @@ -17,9 +17,9 @@ pretty.revision = hackage.pretty."1.1.3.6".revisions.default; hashable.revision = import ./cabal-files/hashable.nix; hashable.flags.random-initial-seed = false; - hashable.flags.integer-gmp = true; + hashable.flags.arch-native = false; heaps.revision = import ./cabal-files/heaps.nix; - Cabal-syntax.revision = import ./cabal-files/Cabal-syntax.nix; + Cabal-syntax.revision = hackage.Cabal-syntax."3.10.1.0".revisions.default; process.revision = hackage.process."1.6.17.0".revisions.default; primitive.revision = import ./cabal-files/primitive.nix; stm.revision = hackage.stm."2.5.1.0".revisions.default; @@ -31,6 +31,7 @@ deepseq.revision = hackage.deepseq."1.4.8.1".revisions.default; utf8-string.revision = import ./cabal-files/utf8-string.nix; js-jquery.revision = import ./cabal-files/js-jquery.nix; + os-string.revision = import ./cabal-files/os-string.nix; text.revision = hackage.text."2.0.2".revisions.default; QuickCheck.revision = import ./cabal-files/QuickCheck.nix; QuickCheck.flags.old-random = false; @@ -40,12 +41,13 @@ containers.revision = hackage.containers."0.6.7".revisions.default; array.revision = hackage.array."0.5.6.0".revisions.default; shake.revision = import ./cabal-files/shake.nix; + shake.flags.threaded = true; shake.flags.cloud = false; shake.flags.embed-files = false; shake.flags.portable = false; random.revision = import ./cabal-files/random.nix; bytestring.revision = hackage.bytestring."0.11.5.3".revisions.default; - Cabal.revision = import ./cabal-files/Cabal.nix; + Cabal.revision = hackage.Cabal."3.10.1.0".revisions.default; directory.revision = hackage.directory."1.3.8.1".revisions.default; js-flot.revision = import ./cabal-files/js-flot.nix; cryptohash-sha256.revision = import ./cabal-files/cryptohash-sha256.nix; @@ -69,10 +71,12 @@ "containers" = "0.6.7"; "ghc-prim" = "0.10.0"; "mtl" = "2.3.1"; + "Cabal" = "3.10.1.0"; "ghc-boot-th" = "9.6.4"; "base" = "4.18.2.0"; "time" = "1.12.2"; "stm" = "2.5.1.0"; + "Cabal-syntax" = "3.10.1.0"; "ghc-bignum" = "1.3"; "directory" = "1.3.8.1"; "template-haskell" = "2.20.0.0"; @@ -100,6 +104,7 @@ "ghc-boot-th" "mtl" "pretty" + "Cabal-syntax" "process" "stm" "template-haskell" @@ -111,6 +116,7 @@ "containers" "array" "bytestring" + "Cabal" "directory" "ghc-bignum" "binary" @@ -150,6 +156,7 @@ "hashable".components.library.planned = lib.mkOverride 900 true; "primitive".components.library.planned = lib.mkOverride 900 true; "Cabal-syntax".components.library.planned = lib.mkOverride 900 true; + "os-string".components.library.planned = lib.mkOverride 900 true; "QuickCheck".components.library.planned = lib.mkOverride 900 true; "js-jquery".components.library.planned = lib.mkOverride 900 true; "mtl".components.library.planned = lib.mkOverride 900 true; diff --git a/materialized/ghc964/hadrian-ghc98/plan.json b/materialized/ghc964/hadrian-ghc98/plan.json index eb5633aa5f..c9e8584dfd 100644 --- a/materialized/ghc964/hadrian-ghc98/plan.json +++ b/materialized/ghc964/hadrian-ghc98/plan.json @@ -1 +1 @@ -{"cabal-version":"3.10.3.0","cabal-lib-version":"3.10.3.0","compiler-id":"ghc-9.6.4","os":"linux","arch":"x86_64","install-plan":[{"type":"configured","id":"Cabal-3.8.1.0-c668f818769193b477ca1a8b87e802e56126adbc7bed962d76bde34a01e8c306","pkg-name":"Cabal","pkg-version":"3.8.1.0","flags":{},"style":"global","pkg-src":{"type":"repo-tar","repo":{"type":"secure-repo","uri":"http://hackage.haskell.org/"}},"pkg-cabal-sha256":"77121d8e1aff14a0fd95684b751599db78a7dd26d55862d9fcef27c88b193e9d","pkg-src-sha256":"7464cbe6c2f3d7e5d0232023a1a7330621f8b24853cb259fc89a2af85b736608","depends":["Cabal-syntax-3.8.1.0-b99db30153f1d2c83dc6d34e637d577dc69cabe5825778a1e3462bcf8317b588","array-0.5.6.0","base-4.18.2.0","bytestring-0.11.5.3","containers-0.6.7","deepseq-1.4.8.1","directory-1.3.8.1","filepath-1.4.200.1","mtl-2.3.1","parsec-3.1.16.1","pretty-1.1.3.6","process-1.6.17.0","text-2.0.2","time-1.12.2","transformers-0.6.1.0","unix-2.8.4.0"],"exe-depends":[],"component-name":"lib"},{"type":"configured","id":"Cabal-syntax-3.8.1.0-b99db30153f1d2c83dc6d34e637d577dc69cabe5825778a1e3462bcf8317b588","pkg-name":"Cabal-syntax","pkg-version":"3.8.1.0","flags":{},"style":"global","pkg-src":{"type":"repo-tar","repo":{"type":"secure-repo","uri":"http://hackage.haskell.org/"}},"pkg-cabal-sha256":"ed2d937ba6c6a20b75850349eedd41374885fc42369ef152d69e2ba70f44f593","pkg-src-sha256":"07e8ddb19fe01781485f1522b6afc22aba680b0ab28ebe6bbfb84a2dd698ce0f","depends":["array-0.5.6.0","base-4.18.2.0","binary-0.8.9.1","bytestring-0.11.5.3","containers-0.6.7","deepseq-1.4.8.1","directory-1.3.8.1","filepath-1.4.200.1","mtl-2.3.1","parsec-3.1.16.1","pretty-1.1.3.6","text-2.0.2","time-1.12.2","transformers-0.6.1.0","unix-2.8.4.0"],"exe-depends":[],"component-name":"lib"},{"type":"configured","id":"QuickCheck-2.14.3-116702925e70e233df64507a5cae969ff9c69efe35b3cc35e56c87d47168ff11","pkg-name":"QuickCheck","pkg-version":"2.14.3","flags":{"old-random":false,"templatehaskell":true},"style":"global","pkg-src":{"type":"repo-tar","repo":{"type":"secure-repo","uri":"http://hackage.haskell.org/"}},"pkg-cabal-sha256":"f03d2f404d5ba465453d0fbc1944832789a759fe7c4f9bf8616bc1378a02fde4","pkg-src-sha256":"5c0f22b36b28a1a8fa110b3819818d3f29494a3b0dedbae299f064123ca70501","depends":["base-4.18.2.0","containers-0.6.7","deepseq-1.4.8.1","random-1.2.1.1-e2b8c23c50d3a2e2d7c30c46d2a3344a9c2a38bf319885311c62efb7342cb80b","splitmix-0.1.0.5-232d2b1a4ce5cacd620dd2472d411c8d63e777af17182b5d56b631942f729187","template-haskell-2.20.0.0","transformers-0.6.1.0"],"exe-depends":[],"component-name":"lib"},{"type":"pre-existing","id":"array-0.5.6.0","pkg-name":"array","pkg-version":"0.5.6.0","depends":["base-4.18.2.0"]},{"type":"pre-existing","id":"base-4.18.2.0","pkg-name":"base","pkg-version":"4.18.2.0","depends":["ghc-bignum-1.3","ghc-prim-0.10.0"]},{"type":"configured","id":"base16-bytestring-1.0.2.0-48e234cd9d2674d718111ce6f52d0142cc28a3c5a0493618f8fb6a8b7f7dd1f7","pkg-name":"base16-bytestring","pkg-version":"1.0.2.0","flags":{},"style":"global","pkg-src":{"type":"repo-tar","repo":{"type":"secure-repo","uri":"http://hackage.haskell.org/"}},"pkg-cabal-sha256":"a694e88f9ec9fc79f0b03f233d3fea592b68f70a34aac2ddb5bcaecb6562e2fd","pkg-src-sha256":"1d5a91143ef0e22157536093ec8e59d226a68220ec89378d5dcaeea86472c784","depends":["base-4.18.2.0","bytestring-0.11.5.3"],"exe-depends":[],"component-name":"lib"},{"type":"pre-existing","id":"binary-0.8.9.1","pkg-name":"binary","pkg-version":"0.8.9.1","depends":["array-0.5.6.0","base-4.18.2.0","bytestring-0.11.5.3","containers-0.6.7","ghc-prim-0.10.0"]},{"type":"pre-existing","id":"bytestring-0.11.5.3","pkg-name":"bytestring","pkg-version":"0.11.5.3","depends":["base-4.18.2.0","deepseq-1.4.8.1","ghc-prim-0.10.0","template-haskell-2.20.0.0"]},{"type":"configured","id":"clock-0.8.4-b6af39fafa1fb93e9520050c562fc2d9803a08bc83cda5d8b8d907beefe150aa","pkg-name":"clock","pkg-version":"0.8.4","flags":{"llvm":false},"style":"global","pkg-src":{"type":"repo-tar","repo":{"type":"secure-repo","uri":"http://hackage.haskell.org/"}},"pkg-cabal-sha256":"b938655b00cf204ce69abfff946021bed111d2609a9f7a9c22e28a1a202e9115","pkg-src-sha256":"6ae9898afe788a5e334cd5fad5d18a3c2e8e59fa09aaf7b957dbb38a4767df2e","depends":["base-4.18.2.0"],"exe-depends":[],"component-name":"lib"},{"type":"pre-existing","id":"containers-0.6.7","pkg-name":"containers","pkg-version":"0.6.7","depends":["array-0.5.6.0","base-4.18.2.0","deepseq-1.4.8.1","template-haskell-2.20.0.0"]},{"type":"configured","id":"cryptohash-sha256-0.11.102.1-898616048405d66a1ac2538c4878965bc94c2902780e27b3e48e171cdfe34cf8","pkg-name":"cryptohash-sha256","pkg-version":"0.11.102.1","flags":{"exe":false,"use-cbits":true},"style":"global","pkg-src":{"type":"repo-tar","repo":{"type":"secure-repo","uri":"http://hackage.haskell.org/"}},"pkg-cabal-sha256":"03db065161987f614a3a2bbcd16264f78e47efe231fb5bd161be2043eaf20488","pkg-src-sha256":"73a7dc7163871a80837495039a099967b11f5c4fe70a118277842f7a713c6bf6","depends":["base-4.18.2.0","bytestring-0.11.5.3"],"exe-depends":[],"component-name":"lib"},{"type":"pre-existing","id":"deepseq-1.4.8.1","pkg-name":"deepseq","pkg-version":"1.4.8.1","depends":["array-0.5.6.0","base-4.18.2.0","ghc-prim-0.10.0"]},{"type":"pre-existing","id":"directory-1.3.8.1","pkg-name":"directory","pkg-version":"1.3.8.1","depends":["base-4.18.2.0","filepath-1.4.200.1","time-1.12.2","unix-2.8.4.0"]},{"type":"pre-existing","id":"exceptions-0.10.7","pkg-name":"exceptions","pkg-version":"0.10.7","depends":["base-4.18.2.0","mtl-2.3.1","stm-2.5.1.0","template-haskell-2.20.0.0","transformers-0.6.1.0"]},{"type":"configured","id":"extra-1.7.14-5b3875febb50e86e1fd0471cb61fc83c08afae84f74dd82e3fe23bdc226bd3c9","pkg-name":"extra","pkg-version":"1.7.14","flags":{},"style":"global","pkg-src":{"type":"repo-tar","repo":{"type":"secure-repo","uri":"http://hackage.haskell.org/"}},"pkg-cabal-sha256":"e3d3ce1dc7746b1132930e48c59fb5e8c51a09e92e0c031316be031067a273fb","pkg-src-sha256":"b6a909f8f0e4b8076a1653b4d34815a782f0a8c1e83d5267f4d00496471ef567","depends":["base-4.18.2.0","clock-0.8.4-b6af39fafa1fb93e9520050c562fc2d9803a08bc83cda5d8b8d907beefe150aa","directory-1.3.8.1","filepath-1.4.200.1","process-1.6.17.0","time-1.12.2","unix-2.8.4.0"],"exe-depends":[],"component-name":"lib"},{"type":"pre-existing","id":"filepath-1.4.200.1","pkg-name":"filepath","pkg-version":"1.4.200.1","depends":["base-4.18.2.0","bytestring-0.11.5.3","deepseq-1.4.8.1","exceptions-0.10.7","template-haskell-2.20.0.0"]},{"type":"configured","id":"filepattern-0.1.3-e0b05225cb586afea88cbd5fba3b81dbc7d8925b44e8dd467cfd9ed208da351b","pkg-name":"filepattern","pkg-version":"0.1.3","flags":{},"style":"global","pkg-src":{"type":"repo-tar","repo":{"type":"secure-repo","uri":"http://hackage.haskell.org/"}},"pkg-cabal-sha256":"372c1733d83b90045eb29da9f010fed79bfef8771ce65eb126a1d83ecc54a9a2","pkg-src-sha256":"cc445d439ea2f65cac7604d3578aa2c3a62e5a91dc989f4ce5b3390db9e59636","depends":["base-4.18.2.0","directory-1.3.8.1","extra-1.7.14-5b3875febb50e86e1fd0471cb61fc83c08afae84f74dd82e3fe23bdc226bd3c9","filepath-1.4.200.1"],"exe-depends":[],"component-name":"lib"},{"type":"pre-existing","id":"ghc-bignum-1.3","pkg-name":"ghc-bignum","pkg-version":"1.3","depends":["ghc-prim-0.10.0"]},{"type":"pre-existing","id":"ghc-boot-th-9.6.4","pkg-name":"ghc-boot-th","pkg-version":"9.6.4","depends":["base-4.18.2.0"]},{"type":"pre-existing","id":"ghc-prim-0.10.0","pkg-name":"ghc-prim","pkg-version":"0.10.0","depends":[]},{"type":"configured","id":"hadrian-0.1.0.0-inplace-hadrian","pkg-name":"hadrian","pkg-version":"0.1.0.0","flags":{"selftest":true,"threaded":true},"style":"local","pkg-src":{"type":"local","path":"./hadrian/."},"dist-dir":"./hadrian/dist-newstyle/build/x86_64-linux/ghc-9.6.4/hadrian-0.1.0.0/x/hadrian","build-info":"./hadrian/dist-newstyle/build/x86_64-linux/ghc-9.6.4/hadrian-0.1.0.0/x/hadrian/build-info.json","depends":["Cabal-3.8.1.0-c668f818769193b477ca1a8b87e802e56126adbc7bed962d76bde34a01e8c306","QuickCheck-2.14.3-116702925e70e233df64507a5cae969ff9c69efe35b3cc35e56c87d47168ff11","base-4.18.2.0","base16-bytestring-1.0.2.0-48e234cd9d2674d718111ce6f52d0142cc28a3c5a0493618f8fb6a8b7f7dd1f7","bytestring-0.11.5.3","containers-0.6.7","cryptohash-sha256-0.11.102.1-898616048405d66a1ac2538c4878965bc94c2902780e27b3e48e171cdfe34cf8","directory-1.3.8.1","extra-1.7.14-5b3875febb50e86e1fd0471cb61fc83c08afae84f74dd82e3fe23bdc226bd3c9","filepath-1.4.200.1","mtl-2.3.1","parsec-3.1.16.1","shake-0.19.7-9369313762a66f683383a6b11b819b9aafcd8f0d518c176b2cb1f5a198ccf8cd","text-2.0.2","time-1.12.2","transformers-0.6.1.0","unordered-containers-0.2.19.1-0eb0d95c2f270578763e7cbc938fd7d57fa65a8f3c10aa64b616bc79bbf6b993"],"exe-depends":[],"component-name":"exe:hadrian","bin-file":"./hadrian/dist-newstyle/build/x86_64-linux/ghc-9.6.4/hadrian-0.1.0.0/x/hadrian/build/hadrian/hadrian"},{"type":"configured","id":"hashable-1.4.3.0-cf03199beb9180bbbb9b383e3088c03deb3be32037dd08933c3d3ba08171d03e","pkg-name":"hashable","pkg-version":"1.4.3.0","flags":{"integer-gmp":true,"random-initial-seed":false},"style":"global","pkg-src":{"type":"repo-tar","repo":{"type":"secure-repo","uri":"http://hackage.haskell.org/"}},"pkg-cabal-sha256":"f3bf68acfa0df7a064a378ef2cdcfeb55e6fb96100675f4c593556dcbf3d7194","pkg-src-sha256":"32efb16c2891786209b7cbe5c39df9b3a9ae51e836f1a54f646bc4602b7ab0f5","depends":["base-4.18.2.0","bytestring-0.11.5.3","containers-0.6.7","deepseq-1.4.8.1","filepath-1.4.200.1","ghc-bignum-1.3","ghc-prim-0.10.0","text-2.0.2"],"exe-depends":[],"component-name":"lib"},{"type":"configured","id":"heaps-0.4-582bc0f356369f4ac6a9badb439391d1ff82a6d0d7a4a55fe3db91d6d1a32875","pkg-name":"heaps","pkg-version":"0.4","flags":{},"style":"global","pkg-src":{"type":"repo-tar","repo":{"type":"secure-repo","uri":"http://hackage.haskell.org/"}},"pkg-cabal-sha256":"66b19fcd813b0e4db3e0bac541bd46606c3b13d3d081d9f9666f4be0f5ff14b8","pkg-src-sha256":"89329df8b95ae99ef272e41e7a2d0fe2f1bb7eacfcc34bc01664414b33067cfd","depends":["base-4.18.2.0"],"exe-depends":[],"component-name":"lib"},{"type":"configured","id":"js-dgtable-0.5.2-40721bc9982faf5e0f71e3119e01102f429fefca9219230921535f5382e177f7","pkg-name":"js-dgtable","pkg-version":"0.5.2","flags":{},"style":"global","pkg-src":{"type":"repo-tar","repo":{"type":"secure-repo","uri":"http://hackage.haskell.org/"}},"pkg-cabal-sha256":"f75cb4fa53c88c65794becdd48eb0d3b2b8abd89a3d5c19e87af91f5225c15e4","pkg-src-sha256":"e28dd65bee8083b17210134e22e01c6349dc33c3b7bd17705973cd014e9f20ac","depends":["base-4.18.2.0"],"exe-depends":[],"component-name":"lib"},{"type":"configured","id":"js-flot-0.8.3-fadd4ccb467ede662552cdc382e02fb02027d8181620f296bae75d1f76774b0b","pkg-name":"js-flot","pkg-version":"0.8.3","flags":{},"style":"global","pkg-src":{"type":"repo-tar","repo":{"type":"secure-repo","uri":"http://hackage.haskell.org/"}},"pkg-cabal-sha256":"4c1c447a9a2fba0adba6d30678302a30c32b9dfde9e7aa9e9156483e1545096d","pkg-src-sha256":"1ba2f2a6b8d85da76c41f526c98903cbb107f8642e506c072c1e7e3c20fe5e7a","depends":["base-4.18.2.0"],"exe-depends":[],"component-name":"lib"},{"type":"configured","id":"js-jquery-3.3.1-6a8cc1e84fc203e099644c71b32217b6615b055459038eb73f1b008db4b2f236","pkg-name":"js-jquery","pkg-version":"3.3.1","flags":{},"style":"global","pkg-src":{"type":"repo-tar","repo":{"type":"secure-repo","uri":"http://hackage.haskell.org/"}},"pkg-cabal-sha256":"59ab6c79159549ef94b584abce8e6d3b336014c2cce1337b59a8f637e2856df5","pkg-src-sha256":"e0e0681f0da1130ede4e03a051630ea439c458cb97216cdb01771ebdbe44069b","depends":["base-4.18.2.0"],"exe-depends":[],"component-name":"lib"},{"type":"pre-existing","id":"mtl-2.3.1","pkg-name":"mtl","pkg-version":"2.3.1","depends":["base-4.18.2.0","transformers-0.6.1.0"]},{"type":"pre-existing","id":"parsec-3.1.16.1","pkg-name":"parsec","pkg-version":"3.1.16.1","depends":["base-4.18.2.0","bytestring-0.11.5.3","mtl-2.3.1","text-2.0.2"]},{"type":"pre-existing","id":"pretty-1.1.3.6","pkg-name":"pretty","pkg-version":"1.1.3.6","depends":["base-4.18.2.0","deepseq-1.4.8.1","ghc-prim-0.10.0"]},{"type":"configured","id":"primitive-0.9.0.0-b327a6c8ea4577ea7938607770d363048048a528efdff4bc67a582b5feac66fc","pkg-name":"primitive","pkg-version":"0.9.0.0","flags":{},"style":"global","pkg-src":{"type":"repo-tar","repo":{"type":"secure-repo","uri":"http://hackage.haskell.org/"}},"pkg-cabal-sha256":"1ceb39f67c0e614180f2992a6d30f26603ab2cd23c4f8e25b30213f98807f6f1","pkg-src-sha256":"696d4bd291c94d736142d6182117dca4258d3ef28bfefdb649ac8b5ecd0999c7","depends":["base-4.18.2.0","deepseq-1.4.8.1","template-haskell-2.20.0.0","transformers-0.6.1.0"],"exe-depends":[],"component-name":"lib"},{"type":"pre-existing","id":"process-1.6.17.0","pkg-name":"process","pkg-version":"1.6.17.0","depends":["base-4.18.2.0","deepseq-1.4.8.1","directory-1.3.8.1","filepath-1.4.200.1","unix-2.8.4.0"]},{"type":"configured","id":"random-1.2.1.1-e2b8c23c50d3a2e2d7c30c46d2a3344a9c2a38bf319885311c62efb7342cb80b","pkg-name":"random","pkg-version":"1.2.1.1","flags":{},"style":"global","pkg-src":{"type":"repo-tar","repo":{"type":"secure-repo","uri":"http://hackage.haskell.org/"}},"pkg-cabal-sha256":"e7c1f881159d5cc788619c9ee8b8f340ba2ff0db571cdf3d1a1968ebc5108789","pkg-src-sha256":"3e1272f7ed6a4d7bd1712b90143ec326fee9b225789222379fea20a9c90c9b76","depends":["base-4.18.2.0","bytestring-0.11.5.3","deepseq-1.4.8.1","mtl-2.3.1","splitmix-0.1.0.5-232d2b1a4ce5cacd620dd2472d411c8d63e777af17182b5d56b631942f729187"],"exe-depends":[],"component-name":"lib"},{"type":"configured","id":"shake-0.19.7-9369313762a66f683383a6b11b819b9aafcd8f0d518c176b2cb1f5a198ccf8cd","pkg-name":"shake","pkg-version":"0.19.7","flags":{"cloud":false,"embed-files":false,"portable":false},"style":"global","pkg-src":{"type":"repo-tar","repo":{"type":"secure-repo","uri":"http://hackage.haskell.org/"}},"pkg-cabal-sha256":"3cb5814cce210b9756fa9246ff1b2a1e1b86be46fdc4c5e2baacdc5bf83ce5c3","pkg-src-sha256":"352a56af12f70b50d564dcb61131555577281957ee196f1702a3723c0a3699d1","depends":["base-4.18.2.0","binary-0.8.9.1","bytestring-0.11.5.3","deepseq-1.4.8.1","directory-1.3.8.1","extra-1.7.14-5b3875febb50e86e1fd0471cb61fc83c08afae84f74dd82e3fe23bdc226bd3c9","filepath-1.4.200.1","filepattern-0.1.3-e0b05225cb586afea88cbd5fba3b81dbc7d8925b44e8dd467cfd9ed208da351b","hashable-1.4.3.0-cf03199beb9180bbbb9b383e3088c03deb3be32037dd08933c3d3ba08171d03e","heaps-0.4-582bc0f356369f4ac6a9badb439391d1ff82a6d0d7a4a55fe3db91d6d1a32875","js-dgtable-0.5.2-40721bc9982faf5e0f71e3119e01102f429fefca9219230921535f5382e177f7","js-flot-0.8.3-fadd4ccb467ede662552cdc382e02fb02027d8181620f296bae75d1f76774b0b","js-jquery-3.3.1-6a8cc1e84fc203e099644c71b32217b6615b055459038eb73f1b008db4b2f236","primitive-0.9.0.0-b327a6c8ea4577ea7938607770d363048048a528efdff4bc67a582b5feac66fc","process-1.6.17.0","random-1.2.1.1-e2b8c23c50d3a2e2d7c30c46d2a3344a9c2a38bf319885311c62efb7342cb80b","time-1.12.2","transformers-0.6.1.0","unix-2.8.4.0","unordered-containers-0.2.19.1-0eb0d95c2f270578763e7cbc938fd7d57fa65a8f3c10aa64b616bc79bbf6b993","utf8-string-1.0.2-134849f72bdb35a6754bed838d5c0f0412c3ca2863338b599b4cd9b0af070e05"],"exe-depends":[],"component-name":"lib"},{"type":"configured","id":"shake-0.19.7-e-shake-74d898c5705f61c05a8a7aee14d32e6ef38e5584b58da7af7f06efe4c3c36716","pkg-name":"shake","pkg-version":"0.19.7","flags":{"cloud":false,"embed-files":false,"portable":false},"style":"global","pkg-src":{"type":"repo-tar","repo":{"type":"secure-repo","uri":"http://hackage.haskell.org/"}},"pkg-cabal-sha256":"3cb5814cce210b9756fa9246ff1b2a1e1b86be46fdc4c5e2baacdc5bf83ce5c3","pkg-src-sha256":"352a56af12f70b50d564dcb61131555577281957ee196f1702a3723c0a3699d1","depends":["base-4.18.2.0","binary-0.8.9.1","bytestring-0.11.5.3","deepseq-1.4.8.1","directory-1.3.8.1","extra-1.7.14-5b3875febb50e86e1fd0471cb61fc83c08afae84f74dd82e3fe23bdc226bd3c9","filepath-1.4.200.1","filepattern-0.1.3-e0b05225cb586afea88cbd5fba3b81dbc7d8925b44e8dd467cfd9ed208da351b","hashable-1.4.3.0-cf03199beb9180bbbb9b383e3088c03deb3be32037dd08933c3d3ba08171d03e","heaps-0.4-582bc0f356369f4ac6a9badb439391d1ff82a6d0d7a4a55fe3db91d6d1a32875","js-dgtable-0.5.2-40721bc9982faf5e0f71e3119e01102f429fefca9219230921535f5382e177f7","js-flot-0.8.3-fadd4ccb467ede662552cdc382e02fb02027d8181620f296bae75d1f76774b0b","js-jquery-3.3.1-6a8cc1e84fc203e099644c71b32217b6615b055459038eb73f1b008db4b2f236","primitive-0.9.0.0-b327a6c8ea4577ea7938607770d363048048a528efdff4bc67a582b5feac66fc","process-1.6.17.0","random-1.2.1.1-e2b8c23c50d3a2e2d7c30c46d2a3344a9c2a38bf319885311c62efb7342cb80b","time-1.12.2","transformers-0.6.1.0","unix-2.8.4.0","unordered-containers-0.2.19.1-0eb0d95c2f270578763e7cbc938fd7d57fa65a8f3c10aa64b616bc79bbf6b993","utf8-string-1.0.2-134849f72bdb35a6754bed838d5c0f0412c3ca2863338b599b4cd9b0af070e05"],"exe-depends":[],"component-name":"exe:shake","bin-file":"/store/ghc-9.6.4/shake-0.19.7-e-shake-74d898c5705f61c05a8a7aee14d32e6ef38e5584b58da7af7f06efe4c3c36716/bin/shake"},{"type":"configured","id":"splitmix-0.1.0.5-232d2b1a4ce5cacd620dd2472d411c8d63e777af17182b5d56b631942f729187","pkg-name":"splitmix","pkg-version":"0.1.0.5","flags":{"optimised-mixer":false},"style":"global","pkg-src":{"type":"repo-tar","repo":{"type":"secure-repo","uri":"http://hackage.haskell.org/"}},"pkg-cabal-sha256":"bac0ae8d46a04e410666b0c8081cff63f060f29157983b569ca86ddb6e6e0dc6","pkg-src-sha256":"9df07a9611ef45f1b1258a0b412f4d02c920248f69d2e2ce8ccda328f7e13002","depends":["base-4.18.2.0","deepseq-1.4.8.1"],"exe-depends":[],"component-name":"lib"},{"type":"pre-existing","id":"stm-2.5.1.0","pkg-name":"stm","pkg-version":"2.5.1.0","depends":["array-0.5.6.0","base-4.18.2.0"]},{"type":"pre-existing","id":"system-cxx-std-lib-1.0","pkg-name":"system-cxx-std-lib","pkg-version":"1.0","depends":[]},{"type":"pre-existing","id":"template-haskell-2.20.0.0","pkg-name":"template-haskell","pkg-version":"2.20.0.0","depends":["base-4.18.2.0","ghc-boot-th-9.6.4","ghc-prim-0.10.0","pretty-1.1.3.6"]},{"type":"pre-existing","id":"text-2.0.2","pkg-name":"text","pkg-version":"2.0.2","depends":["array-0.5.6.0","base-4.18.2.0","binary-0.8.9.1","bytestring-0.11.5.3","deepseq-1.4.8.1","ghc-prim-0.10.0","system-cxx-std-lib-1.0","template-haskell-2.20.0.0"]},{"type":"pre-existing","id":"time-1.12.2","pkg-name":"time","pkg-version":"1.12.2","depends":["base-4.18.2.0","deepseq-1.4.8.1"]},{"type":"pre-existing","id":"transformers-0.6.1.0","pkg-name":"transformers","pkg-version":"0.6.1.0","depends":["base-4.18.2.0","ghc-prim-0.10.0"]},{"type":"pre-existing","id":"unix-2.8.4.0","pkg-name":"unix","pkg-version":"2.8.4.0","depends":["base-4.18.2.0","bytestring-0.11.5.3","filepath-1.4.200.1","time-1.12.2"]},{"type":"configured","id":"unordered-containers-0.2.19.1-0eb0d95c2f270578763e7cbc938fd7d57fa65a8f3c10aa64b616bc79bbf6b993","pkg-name":"unordered-containers","pkg-version":"0.2.19.1","flags":{"debug":false},"style":"global","pkg-src":{"type":"repo-tar","repo":{"type":"secure-repo","uri":"http://hackage.haskell.org/"}},"pkg-cabal-sha256":"1c28ca429e3960de0330908579a427ccacddd700cb84ec1969e2bbe576152add","pkg-src-sha256":"1b27bec5e0d522b27a6029ebf4c4a6d40acbc083c787008e32fb55c4b1d128d2","depends":["base-4.18.2.0","deepseq-1.4.8.1","hashable-1.4.3.0-cf03199beb9180bbbb9b383e3088c03deb3be32037dd08933c3d3ba08171d03e","template-haskell-2.20.0.0"],"exe-depends":[],"component-name":"lib"},{"type":"configured","id":"utf8-string-1.0.2-134849f72bdb35a6754bed838d5c0f0412c3ca2863338b599b4cd9b0af070e05","pkg-name":"utf8-string","pkg-version":"1.0.2","flags":{},"style":"global","pkg-src":{"type":"repo-tar","repo":{"type":"secure-repo","uri":"http://hackage.haskell.org/"}},"pkg-cabal-sha256":"79416292186feeaf1f60e49ac5a1ffae9bf1b120e040a74bf0e81ca7f1d31d3f","pkg-src-sha256":"ee48deada7600370728c4156cb002441de770d0121ae33a68139a9ed9c19b09a","depends":["base-4.18.2.0","bytestring-0.11.5.3"],"exe-depends":[],"component-name":"lib"}],"targets":[{"pkg-name":"Cabal","pkg-version":"3.8.1.0","component-name":"lib","available":[{"id":"Cabal-3.8.1.0-c668f818769193b477ca1a8b87e802e56126adbc7bed962d76bde34a01e8c306","component-name":"lib","build-by-default":true}]},{"pkg-name":"Cabal-syntax","pkg-version":"3.8.1.0","component-name":"lib","available":[{"id":"Cabal-syntax-3.8.1.0-b99db30153f1d2c83dc6d34e637d577dc69cabe5825778a1e3462bcf8317b588","component-name":"lib","build-by-default":true}]},{"pkg-name":"QuickCheck","pkg-version":"2.14.3","component-name":"lib","available":[{"id":"QuickCheck-2.14.3-116702925e70e233df64507a5cae969ff9c69efe35b3cc35e56c87d47168ff11","component-name":"lib","build-by-default":true}]},{"pkg-name":"QuickCheck","pkg-version":"2.14.3","component-name":"test:test-quickcheck","available":["TargetNotLocal"]},{"pkg-name":"QuickCheck","pkg-version":"2.14.3","component-name":"test:test-quickcheck-gcoarbitrary","available":["TargetNotLocal"]},{"pkg-name":"QuickCheck","pkg-version":"2.14.3","component-name":"test:test-quickcheck-generators","available":["TargetNotLocal"]},{"pkg-name":"QuickCheck","pkg-version":"2.14.3","component-name":"test:test-quickcheck-gshrink","available":["TargetNotLocal"]},{"pkg-name":"QuickCheck","pkg-version":"2.14.3","component-name":"test:test-quickcheck-misc","available":["TargetNotLocal"]},{"pkg-name":"QuickCheck","pkg-version":"2.14.3","component-name":"test:test-quickcheck-monadfix","available":["TargetNotLocal"]},{"pkg-name":"QuickCheck","pkg-version":"2.14.3","component-name":"test:test-quickcheck-split","available":["TargetNotLocal"]},{"pkg-name":"QuickCheck","pkg-version":"2.14.3","component-name":"test:test-quickcheck-terminal","available":["TargetNotLocal"]},{"pkg-name":"array","pkg-version":"0.5.6.0","component-name":"lib","available":[{"id":"array-0.5.6.0","component-name":"lib","build-by-default":true}]},{"pkg-name":"base","pkg-version":"4.18.2.0","component-name":"lib","available":[{"id":"base-4.18.2.0","component-name":"lib","build-by-default":true}]},{"pkg-name":"base16-bytestring","pkg-version":"1.0.2.0","component-name":"lib","available":[{"id":"base16-bytestring-1.0.2.0-48e234cd9d2674d718111ce6f52d0142cc28a3c5a0493618f8fb6a8b7f7dd1f7","component-name":"lib","build-by-default":true}]},{"pkg-name":"base16-bytestring","pkg-version":"1.0.2.0","component-name":"test:test","available":["TargetNotLocal"]},{"pkg-name":"base16-bytestring","pkg-version":"1.0.2.0","component-name":"bench:bench","available":["TargetNotLocal"]},{"pkg-name":"binary","pkg-version":"0.8.9.1","component-name":"lib","available":[{"id":"binary-0.8.9.1","component-name":"lib","build-by-default":true}]},{"pkg-name":"bytestring","pkg-version":"0.11.5.3","component-name":"lib","available":[{"id":"bytestring-0.11.5.3","component-name":"lib","build-by-default":true}]},{"pkg-name":"clock","pkg-version":"0.8.4","component-name":"lib","available":[{"id":"clock-0.8.4-b6af39fafa1fb93e9520050c562fc2d9803a08bc83cda5d8b8d907beefe150aa","component-name":"lib","build-by-default":true}]},{"pkg-name":"clock","pkg-version":"0.8.4","component-name":"test:test","available":["TargetNotLocal"]},{"pkg-name":"clock","pkg-version":"0.8.4","component-name":"bench:benchmarks","available":["TargetNotLocal"]},{"pkg-name":"containers","pkg-version":"0.6.7","component-name":"lib","available":[{"id":"containers-0.6.7","component-name":"lib","build-by-default":true}]},{"pkg-name":"cryptohash-sha256","pkg-version":"0.11.102.1","component-name":"lib","available":[{"id":"cryptohash-sha256-0.11.102.1-898616048405d66a1ac2538c4878965bc94c2902780e27b3e48e171cdfe34cf8","component-name":"lib","build-by-default":true}]},{"pkg-name":"cryptohash-sha256","pkg-version":"0.11.102.1","component-name":"exe:sha256sum","available":["TargetNotBuildable"]},{"pkg-name":"cryptohash-sha256","pkg-version":"0.11.102.1","component-name":"test:test-sha256","available":["TargetNotLocal"]},{"pkg-name":"cryptohash-sha256","pkg-version":"0.11.102.1","component-name":"bench:bench-sha256","available":["TargetNotLocal"]},{"pkg-name":"deepseq","pkg-version":"1.4.8.1","component-name":"lib","available":[{"id":"deepseq-1.4.8.1","component-name":"lib","build-by-default":true}]},{"pkg-name":"directory","pkg-version":"1.3.8.1","component-name":"lib","available":[{"id":"directory-1.3.8.1","component-name":"lib","build-by-default":true}]},{"pkg-name":"exceptions","pkg-version":"0.10.7","component-name":"lib","available":[{"id":"exceptions-0.10.7","component-name":"lib","build-by-default":true}]},{"pkg-name":"extra","pkg-version":"1.7.14","component-name":"lib","available":[{"id":"extra-1.7.14-5b3875febb50e86e1fd0471cb61fc83c08afae84f74dd82e3fe23bdc226bd3c9","component-name":"lib","build-by-default":true}]},{"pkg-name":"extra","pkg-version":"1.7.14","component-name":"test:extra-test","available":["TargetNotLocal"]},{"pkg-name":"filepath","pkg-version":"1.4.200.1","component-name":"lib","available":[{"id":"filepath-1.4.200.1","component-name":"lib","build-by-default":true}]},{"pkg-name":"filepattern","pkg-version":"0.1.3","component-name":"lib","available":[{"id":"filepattern-0.1.3-e0b05225cb586afea88cbd5fba3b81dbc7d8925b44e8dd467cfd9ed208da351b","component-name":"lib","build-by-default":true}]},{"pkg-name":"filepattern","pkg-version":"0.1.3","component-name":"test:filepattern-test","available":["TargetNotLocal"]},{"pkg-name":"ghc-bignum","pkg-version":"1.3","component-name":"lib","available":[{"id":"ghc-bignum-1.3","component-name":"lib","build-by-default":true}]},{"pkg-name":"ghc-boot-th","pkg-version":"9.6.4","component-name":"lib","available":[{"id":"ghc-boot-th-9.6.4","component-name":"lib","build-by-default":true}]},{"pkg-name":"ghc-prim","pkg-version":"0.10.0","component-name":"lib","available":[{"id":"ghc-prim-0.10.0","component-name":"lib","build-by-default":true}]},{"pkg-name":"hadrian","pkg-version":"0.1.0.0","component-name":"exe:hadrian","available":[{"id":"hadrian-0.1.0.0-inplace-hadrian","component-name":"exe:hadrian","build-by-default":true}]},{"pkg-name":"hashable","pkg-version":"1.4.3.0","component-name":"lib","available":[{"id":"hashable-1.4.3.0-cf03199beb9180bbbb9b383e3088c03deb3be32037dd08933c3d3ba08171d03e","component-name":"lib","build-by-default":true}]},{"pkg-name":"hashable","pkg-version":"1.4.3.0","component-name":"test:hashable-examples","available":["TargetNotLocal"]},{"pkg-name":"hashable","pkg-version":"1.4.3.0","component-name":"test:hashable-tests","available":["TargetNotLocal"]},{"pkg-name":"heaps","pkg-version":"0.4","component-name":"lib","available":[{"id":"heaps-0.4-582bc0f356369f4ac6a9badb439391d1ff82a6d0d7a4a55fe3db91d6d1a32875","component-name":"lib","build-by-default":true}]},{"pkg-name":"js-dgtable","pkg-version":"0.5.2","component-name":"lib","available":[{"id":"js-dgtable-0.5.2-40721bc9982faf5e0f71e3119e01102f429fefca9219230921535f5382e177f7","component-name":"lib","build-by-default":true}]},{"pkg-name":"js-dgtable","pkg-version":"0.5.2","component-name":"test:js-dgtable-test","available":["TargetNotLocal"]},{"pkg-name":"js-flot","pkg-version":"0.8.3","component-name":"lib","available":[{"id":"js-flot-0.8.3-fadd4ccb467ede662552cdc382e02fb02027d8181620f296bae75d1f76774b0b","component-name":"lib","build-by-default":true}]},{"pkg-name":"js-flot","pkg-version":"0.8.3","component-name":"test:js-flot-test","available":["TargetNotLocal"]},{"pkg-name":"js-jquery","pkg-version":"3.3.1","component-name":"lib","available":[{"id":"js-jquery-3.3.1-6a8cc1e84fc203e099644c71b32217b6615b055459038eb73f1b008db4b2f236","component-name":"lib","build-by-default":true}]},{"pkg-name":"js-jquery","pkg-version":"3.3.1","component-name":"test:js-jquery-test","available":["TargetNotLocal"]},{"pkg-name":"mtl","pkg-version":"2.3.1","component-name":"lib","available":[{"id":"mtl-2.3.1","component-name":"lib","build-by-default":true}]},{"pkg-name":"parsec","pkg-version":"3.1.16.1","component-name":"lib","available":[{"id":"parsec-3.1.16.1","component-name":"lib","build-by-default":true}]},{"pkg-name":"pretty","pkg-version":"1.1.3.6","component-name":"lib","available":[{"id":"pretty-1.1.3.6","component-name":"lib","build-by-default":true}]},{"pkg-name":"primitive","pkg-version":"0.9.0.0","component-name":"lib","available":[{"id":"primitive-0.9.0.0-b327a6c8ea4577ea7938607770d363048048a528efdff4bc67a582b5feac66fc","component-name":"lib","build-by-default":true}]},{"pkg-name":"primitive","pkg-version":"0.9.0.0","component-name":"test:test-qc","available":["TargetNotLocal"]},{"pkg-name":"primitive","pkg-version":"0.9.0.0","component-name":"bench:bench","available":["TargetNotLocal"]},{"pkg-name":"process","pkg-version":"1.6.17.0","component-name":"lib","available":[{"id":"process-1.6.17.0","component-name":"lib","build-by-default":true}]},{"pkg-name":"random","pkg-version":"1.2.1.1","component-name":"lib","available":[{"id":"random-1.2.1.1-e2b8c23c50d3a2e2d7c30c46d2a3344a9c2a38bf319885311c62efb7342cb80b","component-name":"lib","build-by-default":true}]},{"pkg-name":"random","pkg-version":"1.2.1.1","component-name":"test:doctests","available":["TargetNotLocal"]},{"pkg-name":"random","pkg-version":"1.2.1.1","component-name":"test:legacy-test","available":["TargetNotLocal"]},{"pkg-name":"random","pkg-version":"1.2.1.1","component-name":"test:spec","available":["TargetNotLocal"]},{"pkg-name":"random","pkg-version":"1.2.1.1","component-name":"test:spec-inspection","available":["TargetNotLocal"]},{"pkg-name":"random","pkg-version":"1.2.1.1","component-name":"bench:bench","available":["TargetNotLocal"]},{"pkg-name":"random","pkg-version":"1.2.1.1","component-name":"bench:legacy-bench","available":["TargetNotLocal"]},{"pkg-name":"shake","pkg-version":"0.19.7","component-name":"lib","available":[{"id":"shake-0.19.7-9369313762a66f683383a6b11b819b9aafcd8f0d518c176b2cb1f5a198ccf8cd","component-name":"lib","build-by-default":true}]},{"pkg-name":"shake","pkg-version":"0.19.7","component-name":"exe:shake","available":[{"id":"shake-0.19.7-e-shake-74d898c5705f61c05a8a7aee14d32e6ef38e5584b58da7af7f06efe4c3c36716","component-name":"exe:shake","build-by-default":true}]},{"pkg-name":"shake","pkg-version":"0.19.7","component-name":"test:shake-test","available":["TargetNotLocal"]},{"pkg-name":"splitmix","pkg-version":"0.1.0.5","component-name":"lib","available":[{"id":"splitmix-0.1.0.5-232d2b1a4ce5cacd620dd2472d411c8d63e777af17182b5d56b631942f729187","component-name":"lib","build-by-default":true}]},{"pkg-name":"splitmix","pkg-version":"0.1.0.5","component-name":"test:examples","available":["TargetNotLocal"]},{"pkg-name":"splitmix","pkg-version":"0.1.0.5","component-name":"test:initialization","available":["TargetNotLocal"]},{"pkg-name":"splitmix","pkg-version":"0.1.0.5","component-name":"test:montecarlo-pi","available":["TargetNotLocal"]},{"pkg-name":"splitmix","pkg-version":"0.1.0.5","component-name":"test:montecarlo-pi-32","available":["TargetNotLocal"]},{"pkg-name":"splitmix","pkg-version":"0.1.0.5","component-name":"test:splitmix-dieharder","available":["TargetNotLocal"]},{"pkg-name":"splitmix","pkg-version":"0.1.0.5","component-name":"test:splitmix-tests","available":["TargetNotLocal"]},{"pkg-name":"splitmix","pkg-version":"0.1.0.5","component-name":"test:splitmix-testu01","available":["TargetNotLocal"]},{"pkg-name":"splitmix","pkg-version":"0.1.0.5","component-name":"bench:comparison","available":["TargetNotLocal"]},{"pkg-name":"splitmix","pkg-version":"0.1.0.5","component-name":"bench:range","available":["TargetNotLocal"]},{"pkg-name":"splitmix","pkg-version":"0.1.0.5","component-name":"bench:simple-sum","available":["TargetNotLocal"]},{"pkg-name":"stm","pkg-version":"2.5.1.0","component-name":"lib","available":[{"id":"stm-2.5.1.0","component-name":"lib","build-by-default":true}]},{"pkg-name":"system-cxx-std-lib","pkg-version":"1.0","component-name":"lib","available":[{"id":"system-cxx-std-lib-1.0","component-name":"lib","build-by-default":true}]},{"pkg-name":"template-haskell","pkg-version":"2.20.0.0","component-name":"lib","available":[{"id":"template-haskell-2.20.0.0","component-name":"lib","build-by-default":true}]},{"pkg-name":"text","pkg-version":"2.0.2","component-name":"lib","available":[{"id":"text-2.0.2","component-name":"lib","build-by-default":true}]},{"pkg-name":"time","pkg-version":"1.12.2","component-name":"lib","available":[{"id":"time-1.12.2","component-name":"lib","build-by-default":true}]},{"pkg-name":"transformers","pkg-version":"0.6.1.0","component-name":"lib","available":[{"id":"transformers-0.6.1.0","component-name":"lib","build-by-default":true}]},{"pkg-name":"unix","pkg-version":"2.8.4.0","component-name":"lib","available":[{"id":"unix-2.8.4.0","component-name":"lib","build-by-default":true}]},{"pkg-name":"unordered-containers","pkg-version":"0.2.19.1","component-name":"lib","available":[{"id":"unordered-containers-0.2.19.1-0eb0d95c2f270578763e7cbc938fd7d57fa65a8f3c10aa64b616bc79bbf6b993","component-name":"lib","build-by-default":true}]},{"pkg-name":"unordered-containers","pkg-version":"0.2.19.1","component-name":"test:unordered-containers-tests","available":["TargetNotLocal"]},{"pkg-name":"unordered-containers","pkg-version":"0.2.19.1","component-name":"bench:benchmarks","available":["TargetNotLocal"]},{"pkg-name":"utf8-string","pkg-version":"1.0.2","component-name":"lib","available":[{"id":"utf8-string-1.0.2-134849f72bdb35a6754bed838d5c0f0412c3ca2863338b599b4cd9b0af070e05","component-name":"lib","build-by-default":true}]},{"pkg-name":"utf8-string","pkg-version":"1.0.2","component-name":"test:unit-tests","available":["TargetNotLocal"]}]} \ No newline at end of file +{"cabal-version":"3.10.3.0","cabal-lib-version":"3.10.3.0","compiler-id":"ghc-9.6.4","os":"linux","arch":"x86_64","install-plan":[{"type":"pre-existing","id":"Cabal-3.10.1.0","pkg-name":"Cabal","pkg-version":"3.10.1.0","depends":["Cabal-syntax-3.10.1.0","array-0.5.6.0","base-4.18.2.0","bytestring-0.11.5.3","containers-0.6.7","deepseq-1.4.8.1","directory-1.3.8.1","filepath-1.4.200.1","mtl-2.3.1","parsec-3.1.16.1","pretty-1.1.3.6","process-1.6.17.0","text-2.0.2","time-1.12.2","transformers-0.6.1.0","unix-2.8.4.0"]},{"type":"pre-existing","id":"Cabal-syntax-3.10.1.0","pkg-name":"Cabal-syntax","pkg-version":"3.10.1.0","depends":["array-0.5.6.0","base-4.18.2.0","binary-0.8.9.1","bytestring-0.11.5.3","containers-0.6.7","deepseq-1.4.8.1","directory-1.3.8.1","filepath-1.4.200.1","mtl-2.3.1","parsec-3.1.16.1","pretty-1.1.3.6","text-2.0.2","time-1.12.2","transformers-0.6.1.0","unix-2.8.4.0"]},{"type":"configured","id":"QuickCheck-2.14.3-12660abe9f5c6a28f87584c784112e82267cee7f5b9b5a1823ce30f9270ebf1a","pkg-name":"QuickCheck","pkg-version":"2.14.3","flags":{"old-random":false,"templatehaskell":true},"style":"global","pkg-src":{"type":"repo-tar","repo":{"type":"secure-repo","uri":"http://hackage.haskell.org/"}},"pkg-cabal-sha256":"f03d2f404d5ba465453d0fbc1944832789a759fe7c4f9bf8616bc1378a02fde4","pkg-src-sha256":"5c0f22b36b28a1a8fa110b3819818d3f29494a3b0dedbae299f064123ca70501","depends":["base-4.18.2.0","containers-0.6.7","deepseq-1.4.8.1","random-1.2.1.2-ccb717c59af131f21dfc040f6185e9cbf4f0b5a3f6de1b3b376d50859a348586","splitmix-0.1.0.5-232d2b1a4ce5cacd620dd2472d411c8d63e777af17182b5d56b631942f729187","template-haskell-2.20.0.0","transformers-0.6.1.0"],"exe-depends":[],"component-name":"lib"},{"type":"pre-existing","id":"array-0.5.6.0","pkg-name":"array","pkg-version":"0.5.6.0","depends":["base-4.18.2.0"]},{"type":"pre-existing","id":"base-4.18.2.0","pkg-name":"base","pkg-version":"4.18.2.0","depends":["ghc-bignum-1.3","ghc-prim-0.10.0"]},{"type":"configured","id":"base16-bytestring-1.0.2.0-48e234cd9d2674d718111ce6f52d0142cc28a3c5a0493618f8fb6a8b7f7dd1f7","pkg-name":"base16-bytestring","pkg-version":"1.0.2.0","flags":{},"style":"global","pkg-src":{"type":"repo-tar","repo":{"type":"secure-repo","uri":"http://hackage.haskell.org/"}},"pkg-cabal-sha256":"a694e88f9ec9fc79f0b03f233d3fea592b68f70a34aac2ddb5bcaecb6562e2fd","pkg-src-sha256":"1d5a91143ef0e22157536093ec8e59d226a68220ec89378d5dcaeea86472c784","depends":["base-4.18.2.0","bytestring-0.11.5.3"],"exe-depends":[],"component-name":"lib"},{"type":"pre-existing","id":"binary-0.8.9.1","pkg-name":"binary","pkg-version":"0.8.9.1","depends":["array-0.5.6.0","base-4.18.2.0","bytestring-0.11.5.3","containers-0.6.7","ghc-prim-0.10.0"]},{"type":"pre-existing","id":"bytestring-0.11.5.3","pkg-name":"bytestring","pkg-version":"0.11.5.3","depends":["base-4.18.2.0","deepseq-1.4.8.1","ghc-prim-0.10.0","template-haskell-2.20.0.0"]},{"type":"configured","id":"clock-0.8.4-b6af39fafa1fb93e9520050c562fc2d9803a08bc83cda5d8b8d907beefe150aa","pkg-name":"clock","pkg-version":"0.8.4","flags":{"llvm":false},"style":"global","pkg-src":{"type":"repo-tar","repo":{"type":"secure-repo","uri":"http://hackage.haskell.org/"}},"pkg-cabal-sha256":"b938655b00cf204ce69abfff946021bed111d2609a9f7a9c22e28a1a202e9115","pkg-src-sha256":"6ae9898afe788a5e334cd5fad5d18a3c2e8e59fa09aaf7b957dbb38a4767df2e","depends":["base-4.18.2.0"],"exe-depends":[],"component-name":"lib"},{"type":"pre-existing","id":"containers-0.6.7","pkg-name":"containers","pkg-version":"0.6.7","depends":["array-0.5.6.0","base-4.18.2.0","deepseq-1.4.8.1","template-haskell-2.20.0.0"]},{"type":"configured","id":"cryptohash-sha256-0.11.102.1-898616048405d66a1ac2538c4878965bc94c2902780e27b3e48e171cdfe34cf8","pkg-name":"cryptohash-sha256","pkg-version":"0.11.102.1","flags":{"exe":false,"use-cbits":true},"style":"global","pkg-src":{"type":"repo-tar","repo":{"type":"secure-repo","uri":"http://hackage.haskell.org/"}},"pkg-cabal-sha256":"acb64f2af52d81b0bb92c266f11d43def726a7a7b74a2c23d219e160b54edec7","pkg-src-sha256":"73a7dc7163871a80837495039a099967b11f5c4fe70a118277842f7a713c6bf6","depends":["base-4.18.2.0","bytestring-0.11.5.3"],"exe-depends":[],"component-name":"lib"},{"type":"pre-existing","id":"deepseq-1.4.8.1","pkg-name":"deepseq","pkg-version":"1.4.8.1","depends":["array-0.5.6.0","base-4.18.2.0","ghc-prim-0.10.0"]},{"type":"pre-existing","id":"directory-1.3.8.1","pkg-name":"directory","pkg-version":"1.3.8.1","depends":["base-4.18.2.0","filepath-1.4.200.1","time-1.12.2","unix-2.8.4.0"]},{"type":"pre-existing","id":"exceptions-0.10.7","pkg-name":"exceptions","pkg-version":"0.10.7","depends":["base-4.18.2.0","mtl-2.3.1","stm-2.5.1.0","template-haskell-2.20.0.0","transformers-0.6.1.0"]},{"type":"configured","id":"extra-1.7.16-dc63228cbe6629bad55bc0268aff37cd1d9389acb03be20763ed611a10fe3efc","pkg-name":"extra","pkg-version":"1.7.16","flags":{},"style":"global","pkg-src":{"type":"repo-tar","repo":{"type":"secure-repo","uri":"http://hackage.haskell.org/"}},"pkg-cabal-sha256":"edd191f77adf31acb1b53960b4d1ca9fca925ac28345a396c614414cb7bfa7ec","pkg-src-sha256":"250c6d43c30b2c71f2cf498a10e69e43ac035974d3819529385d99e42ce77c70","depends":["base-4.18.2.0","clock-0.8.4-b6af39fafa1fb93e9520050c562fc2d9803a08bc83cda5d8b8d907beefe150aa","directory-1.3.8.1","filepath-1.4.200.1","process-1.6.17.0","time-1.12.2","unix-2.8.4.0"],"exe-depends":[],"component-name":"lib"},{"type":"pre-existing","id":"filepath-1.4.200.1","pkg-name":"filepath","pkg-version":"1.4.200.1","depends":["base-4.18.2.0","bytestring-0.11.5.3","deepseq-1.4.8.1","exceptions-0.10.7","template-haskell-2.20.0.0"]},{"type":"configured","id":"filepattern-0.1.3-c45690bc0b4b5c677f6943e7896ddd599d085687db6e459293ba6fa381af7c6e","pkg-name":"filepattern","pkg-version":"0.1.3","flags":{},"style":"global","pkg-src":{"type":"repo-tar","repo":{"type":"secure-repo","uri":"http://hackage.haskell.org/"}},"pkg-cabal-sha256":"372c1733d83b90045eb29da9f010fed79bfef8771ce65eb126a1d83ecc54a9a2","pkg-src-sha256":"cc445d439ea2f65cac7604d3578aa2c3a62e5a91dc989f4ce5b3390db9e59636","depends":["base-4.18.2.0","directory-1.3.8.1","extra-1.7.16-dc63228cbe6629bad55bc0268aff37cd1d9389acb03be20763ed611a10fe3efc","filepath-1.4.200.1"],"exe-depends":[],"component-name":"lib"},{"type":"pre-existing","id":"ghc-bignum-1.3","pkg-name":"ghc-bignum","pkg-version":"1.3","depends":["ghc-prim-0.10.0"]},{"type":"pre-existing","id":"ghc-boot-th-9.6.4","pkg-name":"ghc-boot-th","pkg-version":"9.6.4","depends":["base-4.18.2.0"]},{"type":"pre-existing","id":"ghc-prim-0.10.0","pkg-name":"ghc-prim","pkg-version":"0.10.0","depends":[]},{"type":"configured","id":"hadrian-0.1.0.0-inplace-hadrian","pkg-name":"hadrian","pkg-version":"0.1.0.0","flags":{"selftest":true,"threaded":true},"style":"local","pkg-src":{"type":"local","path":"./hadrian/."},"dist-dir":"./hadrian/dist-newstyle/build/x86_64-linux/ghc-9.6.4/hadrian-0.1.0.0/x/hadrian","build-info":"./hadrian/dist-newstyle/build/x86_64-linux/ghc-9.6.4/hadrian-0.1.0.0/x/hadrian/build-info.json","depends":["Cabal-3.10.1.0","QuickCheck-2.14.3-12660abe9f5c6a28f87584c784112e82267cee7f5b9b5a1823ce30f9270ebf1a","base-4.18.2.0","base16-bytestring-1.0.2.0-48e234cd9d2674d718111ce6f52d0142cc28a3c5a0493618f8fb6a8b7f7dd1f7","bytestring-0.11.5.3","containers-0.6.7","cryptohash-sha256-0.11.102.1-898616048405d66a1ac2538c4878965bc94c2902780e27b3e48e171cdfe34cf8","directory-1.3.8.1","extra-1.7.16-dc63228cbe6629bad55bc0268aff37cd1d9389acb03be20763ed611a10fe3efc","filepath-1.4.200.1","mtl-2.3.1","parsec-3.1.16.1","shake-0.19.8-0ddb83d9db09621c7b8f326abc494d14323dc5751be6943ac5b5e19c9347d5c3","text-2.0.2","time-1.12.2","transformers-0.6.1.0","unordered-containers-0.2.20-0a8211d6220ec0e6694f219bbea9da08528b897266f5898f98f4d6e1ab6fd737"],"exe-depends":[],"component-name":"exe:hadrian","bin-file":"./hadrian/dist-newstyle/build/x86_64-linux/ghc-9.6.4/hadrian-0.1.0.0/x/hadrian/build/hadrian/hadrian"},{"type":"configured","id":"hashable-1.5.0.0-0ac0785933877296ccb7501af740625424a60e762d9e13c3f7fb819fa7014b88","pkg-name":"hashable","pkg-version":"1.5.0.0","flags":{"arch-native":false,"random-initial-seed":false},"style":"global","pkg-src":{"type":"repo-tar","repo":{"type":"secure-repo","uri":"http://hackage.haskell.org/"}},"pkg-cabal-sha256":"fc68b07d957ade5a0a0beadd560a8d093ceac30b2f35c85eed3bcf7889a25975","pkg-src-sha256":"e58b3a8e18da5f6cd7e937e5fd683e500bb1f8276b3768269759119ca0cddb6a","depends":["base-4.18.2.0","bytestring-0.11.5.3","containers-0.6.7","deepseq-1.4.8.1","filepath-1.4.200.1","ghc-bignum-1.3","ghc-prim-0.10.0","os-string-2.0.6-01e3c1e4563fbed004a4ac273e2beea9dfd497789ab9039e09b96161f470a497","text-2.0.2"],"exe-depends":[],"component-name":"lib"},{"type":"configured","id":"heaps-0.4-582bc0f356369f4ac6a9badb439391d1ff82a6d0d7a4a55fe3db91d6d1a32875","pkg-name":"heaps","pkg-version":"0.4","flags":{},"style":"global","pkg-src":{"type":"repo-tar","repo":{"type":"secure-repo","uri":"http://hackage.haskell.org/"}},"pkg-cabal-sha256":"66b19fcd813b0e4db3e0bac541bd46606c3b13d3d081d9f9666f4be0f5ff14b8","pkg-src-sha256":"89329df8b95ae99ef272e41e7a2d0fe2f1bb7eacfcc34bc01664414b33067cfd","depends":["base-4.18.2.0"],"exe-depends":[],"component-name":"lib"},{"type":"configured","id":"js-dgtable-0.5.2-40721bc9982faf5e0f71e3119e01102f429fefca9219230921535f5382e177f7","pkg-name":"js-dgtable","pkg-version":"0.5.2","flags":{},"style":"global","pkg-src":{"type":"repo-tar","repo":{"type":"secure-repo","uri":"http://hackage.haskell.org/"}},"pkg-cabal-sha256":"f75cb4fa53c88c65794becdd48eb0d3b2b8abd89a3d5c19e87af91f5225c15e4","pkg-src-sha256":"e28dd65bee8083b17210134e22e01c6349dc33c3b7bd17705973cd014e9f20ac","depends":["base-4.18.2.0"],"exe-depends":[],"component-name":"lib"},{"type":"configured","id":"js-flot-0.8.3-fadd4ccb467ede662552cdc382e02fb02027d8181620f296bae75d1f76774b0b","pkg-name":"js-flot","pkg-version":"0.8.3","flags":{},"style":"global","pkg-src":{"type":"repo-tar","repo":{"type":"secure-repo","uri":"http://hackage.haskell.org/"}},"pkg-cabal-sha256":"4c1c447a9a2fba0adba6d30678302a30c32b9dfde9e7aa9e9156483e1545096d","pkg-src-sha256":"1ba2f2a6b8d85da76c41f526c98903cbb107f8642e506c072c1e7e3c20fe5e7a","depends":["base-4.18.2.0"],"exe-depends":[],"component-name":"lib"},{"type":"configured","id":"js-jquery-3.3.1-6a8cc1e84fc203e099644c71b32217b6615b055459038eb73f1b008db4b2f236","pkg-name":"js-jquery","pkg-version":"3.3.1","flags":{},"style":"global","pkg-src":{"type":"repo-tar","repo":{"type":"secure-repo","uri":"http://hackage.haskell.org/"}},"pkg-cabal-sha256":"59ab6c79159549ef94b584abce8e6d3b336014c2cce1337b59a8f637e2856df5","pkg-src-sha256":"e0e0681f0da1130ede4e03a051630ea439c458cb97216cdb01771ebdbe44069b","depends":["base-4.18.2.0"],"exe-depends":[],"component-name":"lib"},{"type":"pre-existing","id":"mtl-2.3.1","pkg-name":"mtl","pkg-version":"2.3.1","depends":["base-4.18.2.0","transformers-0.6.1.0"]},{"type":"configured","id":"os-string-2.0.6-01e3c1e4563fbed004a4ac273e2beea9dfd497789ab9039e09b96161f470a497","pkg-name":"os-string","pkg-version":"2.0.6","flags":{},"style":"global","pkg-src":{"type":"repo-tar","repo":{"type":"secure-repo","uri":"http://hackage.haskell.org/"}},"pkg-cabal-sha256":"7699e7ae9bf74d056a62f384ceef8dfb2aa660f3f7c8016e9703f3b995e5e030","pkg-src-sha256":"22fcc7d5fc66676b5dfc57b714d2caf93cce2d5a79d242168352f9eb0fe2f18a","depends":["base-4.18.2.0","bytestring-0.11.5.3","deepseq-1.4.8.1","exceptions-0.10.7","template-haskell-2.20.0.0"],"exe-depends":[],"component-name":"lib"},{"type":"pre-existing","id":"parsec-3.1.16.1","pkg-name":"parsec","pkg-version":"3.1.16.1","depends":["base-4.18.2.0","bytestring-0.11.5.3","mtl-2.3.1","text-2.0.2"]},{"type":"pre-existing","id":"pretty-1.1.3.6","pkg-name":"pretty","pkg-version":"1.1.3.6","depends":["base-4.18.2.0","deepseq-1.4.8.1","ghc-prim-0.10.0"]},{"type":"configured","id":"primitive-0.9.0.0-b327a6c8ea4577ea7938607770d363048048a528efdff4bc67a582b5feac66fc","pkg-name":"primitive","pkg-version":"0.9.0.0","flags":{},"style":"global","pkg-src":{"type":"repo-tar","repo":{"type":"secure-repo","uri":"http://hackage.haskell.org/"}},"pkg-cabal-sha256":"2e08c5409e3559c7f1669ef50e9a0d9a397e68ecf51110d5e2cedf05cdd7d93c","pkg-src-sha256":"696d4bd291c94d736142d6182117dca4258d3ef28bfefdb649ac8b5ecd0999c7","depends":["base-4.18.2.0","deepseq-1.4.8.1","template-haskell-2.20.0.0","transformers-0.6.1.0"],"exe-depends":[],"component-name":"lib"},{"type":"pre-existing","id":"process-1.6.17.0","pkg-name":"process","pkg-version":"1.6.17.0","depends":["base-4.18.2.0","deepseq-1.4.8.1","directory-1.3.8.1","filepath-1.4.200.1","unix-2.8.4.0"]},{"type":"configured","id":"random-1.2.1.2-ccb717c59af131f21dfc040f6185e9cbf4f0b5a3f6de1b3b376d50859a348586","pkg-name":"random","pkg-version":"1.2.1.2","flags":{},"style":"global","pkg-src":{"type":"repo-tar","repo":{"type":"secure-repo","uri":"http://hackage.haskell.org/"}},"pkg-cabal-sha256":"32397de181e20ccaacf806ec70de9308cf044f089a2be37c936f3f8967bde867","pkg-src-sha256":"790f4dc2d2327c453ff6aac7bf15399fd123d55e927935f68f84b5df42d9a4b4","depends":["base-4.18.2.0","bytestring-0.11.5.3","deepseq-1.4.8.1","mtl-2.3.1","splitmix-0.1.0.5-232d2b1a4ce5cacd620dd2472d411c8d63e777af17182b5d56b631942f729187"],"exe-depends":[],"component-name":"lib"},{"type":"configured","id":"shake-0.19.8-0ddb83d9db09621c7b8f326abc494d14323dc5751be6943ac5b5e19c9347d5c3","pkg-name":"shake","pkg-version":"0.19.8","flags":{"cloud":false,"embed-files":false,"portable":false,"threaded":true},"style":"global","pkg-src":{"type":"repo-tar","repo":{"type":"secure-repo","uri":"http://hackage.haskell.org/"}},"pkg-cabal-sha256":"03c8f06de478e07ad6fde95984c9206920106d0d8432ecb7ab825ef108d45382","pkg-src-sha256":"6384e33a26a2590bf33719e88881076b899ac4b5340c1c9271e4caa37e9d6535","depends":["base-4.18.2.0","binary-0.8.9.1","bytestring-0.11.5.3","deepseq-1.4.8.1","directory-1.3.8.1","extra-1.7.16-dc63228cbe6629bad55bc0268aff37cd1d9389acb03be20763ed611a10fe3efc","filepath-1.4.200.1","filepattern-0.1.3-c45690bc0b4b5c677f6943e7896ddd599d085687db6e459293ba6fa381af7c6e","hashable-1.5.0.0-0ac0785933877296ccb7501af740625424a60e762d9e13c3f7fb819fa7014b88","heaps-0.4-582bc0f356369f4ac6a9badb439391d1ff82a6d0d7a4a55fe3db91d6d1a32875","js-dgtable-0.5.2-40721bc9982faf5e0f71e3119e01102f429fefca9219230921535f5382e177f7","js-flot-0.8.3-fadd4ccb467ede662552cdc382e02fb02027d8181620f296bae75d1f76774b0b","js-jquery-3.3.1-6a8cc1e84fc203e099644c71b32217b6615b055459038eb73f1b008db4b2f236","primitive-0.9.0.0-b327a6c8ea4577ea7938607770d363048048a528efdff4bc67a582b5feac66fc","process-1.6.17.0","random-1.2.1.2-ccb717c59af131f21dfc040f6185e9cbf4f0b5a3f6de1b3b376d50859a348586","time-1.12.2","transformers-0.6.1.0","unix-2.8.4.0","unordered-containers-0.2.20-0a8211d6220ec0e6694f219bbea9da08528b897266f5898f98f4d6e1ab6fd737","utf8-string-1.0.2-134849f72bdb35a6754bed838d5c0f0412c3ca2863338b599b4cd9b0af070e05"],"exe-depends":[],"component-name":"lib"},{"type":"configured","id":"shake-0.19.8-e-shake-7559c7ff704c4f74648b4baa6b6f1b1db1f99fa251704d87397a432f656a4846","pkg-name":"shake","pkg-version":"0.19.8","flags":{"cloud":false,"embed-files":false,"portable":false,"threaded":true},"style":"global","pkg-src":{"type":"repo-tar","repo":{"type":"secure-repo","uri":"http://hackage.haskell.org/"}},"pkg-cabal-sha256":"03c8f06de478e07ad6fde95984c9206920106d0d8432ecb7ab825ef108d45382","pkg-src-sha256":"6384e33a26a2590bf33719e88881076b899ac4b5340c1c9271e4caa37e9d6535","depends":["base-4.18.2.0","binary-0.8.9.1","bytestring-0.11.5.3","deepseq-1.4.8.1","directory-1.3.8.1","extra-1.7.16-dc63228cbe6629bad55bc0268aff37cd1d9389acb03be20763ed611a10fe3efc","filepath-1.4.200.1","filepattern-0.1.3-c45690bc0b4b5c677f6943e7896ddd599d085687db6e459293ba6fa381af7c6e","hashable-1.5.0.0-0ac0785933877296ccb7501af740625424a60e762d9e13c3f7fb819fa7014b88","heaps-0.4-582bc0f356369f4ac6a9badb439391d1ff82a6d0d7a4a55fe3db91d6d1a32875","js-dgtable-0.5.2-40721bc9982faf5e0f71e3119e01102f429fefca9219230921535f5382e177f7","js-flot-0.8.3-fadd4ccb467ede662552cdc382e02fb02027d8181620f296bae75d1f76774b0b","js-jquery-3.3.1-6a8cc1e84fc203e099644c71b32217b6615b055459038eb73f1b008db4b2f236","primitive-0.9.0.0-b327a6c8ea4577ea7938607770d363048048a528efdff4bc67a582b5feac66fc","process-1.6.17.0","random-1.2.1.2-ccb717c59af131f21dfc040f6185e9cbf4f0b5a3f6de1b3b376d50859a348586","time-1.12.2","transformers-0.6.1.0","unix-2.8.4.0","unordered-containers-0.2.20-0a8211d6220ec0e6694f219bbea9da08528b897266f5898f98f4d6e1ab6fd737","utf8-string-1.0.2-134849f72bdb35a6754bed838d5c0f0412c3ca2863338b599b4cd9b0af070e05"],"exe-depends":[],"component-name":"exe:shake","bin-file":"/store/ghc-9.6.4/shake-0.19.8-e-shake-7559c7ff704c4f74648b4baa6b6f1b1db1f99fa251704d87397a432f656a4846/bin/shake"},{"type":"configured","id":"splitmix-0.1.0.5-232d2b1a4ce5cacd620dd2472d411c8d63e777af17182b5d56b631942f729187","pkg-name":"splitmix","pkg-version":"0.1.0.5","flags":{"optimised-mixer":false},"style":"global","pkg-src":{"type":"repo-tar","repo":{"type":"secure-repo","uri":"http://hackage.haskell.org/"}},"pkg-cabal-sha256":"caa9b4a92abf1496c7f6a3c0f4e357426a54880077cb9f04e260a8bfa034b77b","pkg-src-sha256":"9df07a9611ef45f1b1258a0b412f4d02c920248f69d2e2ce8ccda328f7e13002","depends":["base-4.18.2.0","deepseq-1.4.8.1"],"exe-depends":[],"component-name":"lib"},{"type":"pre-existing","id":"stm-2.5.1.0","pkg-name":"stm","pkg-version":"2.5.1.0","depends":["array-0.5.6.0","base-4.18.2.0"]},{"type":"pre-existing","id":"system-cxx-std-lib-1.0","pkg-name":"system-cxx-std-lib","pkg-version":"1.0","depends":[]},{"type":"pre-existing","id":"template-haskell-2.20.0.0","pkg-name":"template-haskell","pkg-version":"2.20.0.0","depends":["base-4.18.2.0","ghc-boot-th-9.6.4","ghc-prim-0.10.0","pretty-1.1.3.6"]},{"type":"pre-existing","id":"text-2.0.2","pkg-name":"text","pkg-version":"2.0.2","depends":["array-0.5.6.0","base-4.18.2.0","binary-0.8.9.1","bytestring-0.11.5.3","deepseq-1.4.8.1","ghc-prim-0.10.0","system-cxx-std-lib-1.0","template-haskell-2.20.0.0"]},{"type":"pre-existing","id":"time-1.12.2","pkg-name":"time","pkg-version":"1.12.2","depends":["base-4.18.2.0","deepseq-1.4.8.1"]},{"type":"pre-existing","id":"transformers-0.6.1.0","pkg-name":"transformers","pkg-version":"0.6.1.0","depends":["base-4.18.2.0","ghc-prim-0.10.0"]},{"type":"pre-existing","id":"unix-2.8.4.0","pkg-name":"unix","pkg-version":"2.8.4.0","depends":["base-4.18.2.0","bytestring-0.11.5.3","filepath-1.4.200.1","time-1.12.2"]},{"type":"configured","id":"unordered-containers-0.2.20-0a8211d6220ec0e6694f219bbea9da08528b897266f5898f98f4d6e1ab6fd737","pkg-name":"unordered-containers","pkg-version":"0.2.20","flags":{"debug":false},"style":"global","pkg-src":{"type":"repo-tar","repo":{"type":"secure-repo","uri":"http://hackage.haskell.org/"}},"pkg-cabal-sha256":"c7fe9cba405ed9905e12d89c7add3b3eb9868dfba7975e70ba0cdd64b7b11abc","pkg-src-sha256":"d9cfb287cf00592d39dc9c3cac8b99627ea08f2c01798e70130fc39f7c90f11d","depends":["base-4.18.2.0","deepseq-1.4.8.1","hashable-1.5.0.0-0ac0785933877296ccb7501af740625424a60e762d9e13c3f7fb819fa7014b88","template-haskell-2.20.0.0"],"exe-depends":[],"component-name":"lib"},{"type":"configured","id":"utf8-string-1.0.2-134849f72bdb35a6754bed838d5c0f0412c3ca2863338b599b4cd9b0af070e05","pkg-name":"utf8-string","pkg-version":"1.0.2","flags":{},"style":"global","pkg-src":{"type":"repo-tar","repo":{"type":"secure-repo","uri":"http://hackage.haskell.org/"}},"pkg-cabal-sha256":"79416292186feeaf1f60e49ac5a1ffae9bf1b120e040a74bf0e81ca7f1d31d3f","pkg-src-sha256":"ee48deada7600370728c4156cb002441de770d0121ae33a68139a9ed9c19b09a","depends":["base-4.18.2.0","bytestring-0.11.5.3"],"exe-depends":[],"component-name":"lib"}],"targets":[{"pkg-name":"Cabal","pkg-version":"3.10.1.0","component-name":"lib","available":[{"id":"Cabal-3.10.1.0","component-name":"lib","build-by-default":true}]},{"pkg-name":"Cabal-syntax","pkg-version":"3.10.1.0","component-name":"lib","available":[{"id":"Cabal-syntax-3.10.1.0","component-name":"lib","build-by-default":true}]},{"pkg-name":"QuickCheck","pkg-version":"2.14.3","component-name":"lib","available":[{"id":"QuickCheck-2.14.3-12660abe9f5c6a28f87584c784112e82267cee7f5b9b5a1823ce30f9270ebf1a","component-name":"lib","build-by-default":true}]},{"pkg-name":"QuickCheck","pkg-version":"2.14.3","component-name":"test:test-quickcheck","available":["TargetNotLocal"]},{"pkg-name":"QuickCheck","pkg-version":"2.14.3","component-name":"test:test-quickcheck-gcoarbitrary","available":["TargetNotLocal"]},{"pkg-name":"QuickCheck","pkg-version":"2.14.3","component-name":"test:test-quickcheck-generators","available":["TargetNotLocal"]},{"pkg-name":"QuickCheck","pkg-version":"2.14.3","component-name":"test:test-quickcheck-gshrink","available":["TargetNotLocal"]},{"pkg-name":"QuickCheck","pkg-version":"2.14.3","component-name":"test:test-quickcheck-misc","available":["TargetNotLocal"]},{"pkg-name":"QuickCheck","pkg-version":"2.14.3","component-name":"test:test-quickcheck-monadfix","available":["TargetNotLocal"]},{"pkg-name":"QuickCheck","pkg-version":"2.14.3","component-name":"test:test-quickcheck-split","available":["TargetNotLocal"]},{"pkg-name":"QuickCheck","pkg-version":"2.14.3","component-name":"test:test-quickcheck-terminal","available":["TargetNotLocal"]},{"pkg-name":"array","pkg-version":"0.5.6.0","component-name":"lib","available":[{"id":"array-0.5.6.0","component-name":"lib","build-by-default":true}]},{"pkg-name":"base","pkg-version":"4.18.2.0","component-name":"lib","available":[{"id":"base-4.18.2.0","component-name":"lib","build-by-default":true}]},{"pkg-name":"base16-bytestring","pkg-version":"1.0.2.0","component-name":"lib","available":[{"id":"base16-bytestring-1.0.2.0-48e234cd9d2674d718111ce6f52d0142cc28a3c5a0493618f8fb6a8b7f7dd1f7","component-name":"lib","build-by-default":true}]},{"pkg-name":"base16-bytestring","pkg-version":"1.0.2.0","component-name":"test:test","available":["TargetNotLocal"]},{"pkg-name":"base16-bytestring","pkg-version":"1.0.2.0","component-name":"bench:bench","available":["TargetNotLocal"]},{"pkg-name":"binary","pkg-version":"0.8.9.1","component-name":"lib","available":[{"id":"binary-0.8.9.1","component-name":"lib","build-by-default":true}]},{"pkg-name":"bytestring","pkg-version":"0.11.5.3","component-name":"lib","available":[{"id":"bytestring-0.11.5.3","component-name":"lib","build-by-default":true}]},{"pkg-name":"clock","pkg-version":"0.8.4","component-name":"lib","available":[{"id":"clock-0.8.4-b6af39fafa1fb93e9520050c562fc2d9803a08bc83cda5d8b8d907beefe150aa","component-name":"lib","build-by-default":true}]},{"pkg-name":"clock","pkg-version":"0.8.4","component-name":"test:test","available":["TargetNotLocal"]},{"pkg-name":"clock","pkg-version":"0.8.4","component-name":"bench:benchmarks","available":["TargetNotLocal"]},{"pkg-name":"containers","pkg-version":"0.6.7","component-name":"lib","available":[{"id":"containers-0.6.7","component-name":"lib","build-by-default":true}]},{"pkg-name":"cryptohash-sha256","pkg-version":"0.11.102.1","component-name":"lib","available":[{"id":"cryptohash-sha256-0.11.102.1-898616048405d66a1ac2538c4878965bc94c2902780e27b3e48e171cdfe34cf8","component-name":"lib","build-by-default":true}]},{"pkg-name":"cryptohash-sha256","pkg-version":"0.11.102.1","component-name":"exe:sha256sum","available":["TargetNotBuildable"]},{"pkg-name":"cryptohash-sha256","pkg-version":"0.11.102.1","component-name":"test:test-sha256","available":["TargetNotLocal"]},{"pkg-name":"cryptohash-sha256","pkg-version":"0.11.102.1","component-name":"bench:bench-sha256","available":["TargetNotLocal"]},{"pkg-name":"deepseq","pkg-version":"1.4.8.1","component-name":"lib","available":[{"id":"deepseq-1.4.8.1","component-name":"lib","build-by-default":true}]},{"pkg-name":"directory","pkg-version":"1.3.8.1","component-name":"lib","available":[{"id":"directory-1.3.8.1","component-name":"lib","build-by-default":true}]},{"pkg-name":"exceptions","pkg-version":"0.10.7","component-name":"lib","available":[{"id":"exceptions-0.10.7","component-name":"lib","build-by-default":true}]},{"pkg-name":"extra","pkg-version":"1.7.16","component-name":"lib","available":[{"id":"extra-1.7.16-dc63228cbe6629bad55bc0268aff37cd1d9389acb03be20763ed611a10fe3efc","component-name":"lib","build-by-default":true}]},{"pkg-name":"extra","pkg-version":"1.7.16","component-name":"test:extra-test","available":["TargetNotLocal"]},{"pkg-name":"filepath","pkg-version":"1.4.200.1","component-name":"lib","available":[{"id":"filepath-1.4.200.1","component-name":"lib","build-by-default":true}]},{"pkg-name":"filepattern","pkg-version":"0.1.3","component-name":"lib","available":[{"id":"filepattern-0.1.3-c45690bc0b4b5c677f6943e7896ddd599d085687db6e459293ba6fa381af7c6e","component-name":"lib","build-by-default":true}]},{"pkg-name":"filepattern","pkg-version":"0.1.3","component-name":"test:filepattern-test","available":["TargetNotLocal"]},{"pkg-name":"ghc-bignum","pkg-version":"1.3","component-name":"lib","available":[{"id":"ghc-bignum-1.3","component-name":"lib","build-by-default":true}]},{"pkg-name":"ghc-boot-th","pkg-version":"9.6.4","component-name":"lib","available":[{"id":"ghc-boot-th-9.6.4","component-name":"lib","build-by-default":true}]},{"pkg-name":"ghc-prim","pkg-version":"0.10.0","component-name":"lib","available":[{"id":"ghc-prim-0.10.0","component-name":"lib","build-by-default":true}]},{"pkg-name":"hadrian","pkg-version":"0.1.0.0","component-name":"exe:hadrian","available":[{"id":"hadrian-0.1.0.0-inplace-hadrian","component-name":"exe:hadrian","build-by-default":true}]},{"pkg-name":"hashable","pkg-version":"1.5.0.0","component-name":"lib","available":[{"id":"hashable-1.5.0.0-0ac0785933877296ccb7501af740625424a60e762d9e13c3f7fb819fa7014b88","component-name":"lib","build-by-default":true}]},{"pkg-name":"hashable","pkg-version":"1.5.0.0","component-name":"test:hashable-examples","available":["TargetNotLocal"]},{"pkg-name":"hashable","pkg-version":"1.5.0.0","component-name":"test:hashable-tests","available":["TargetNotLocal"]},{"pkg-name":"hashable","pkg-version":"1.5.0.0","component-name":"test:xxhash-tests","available":["TargetNotLocal"]},{"pkg-name":"heaps","pkg-version":"0.4","component-name":"lib","available":[{"id":"heaps-0.4-582bc0f356369f4ac6a9badb439391d1ff82a6d0d7a4a55fe3db91d6d1a32875","component-name":"lib","build-by-default":true}]},{"pkg-name":"js-dgtable","pkg-version":"0.5.2","component-name":"lib","available":[{"id":"js-dgtable-0.5.2-40721bc9982faf5e0f71e3119e01102f429fefca9219230921535f5382e177f7","component-name":"lib","build-by-default":true}]},{"pkg-name":"js-dgtable","pkg-version":"0.5.2","component-name":"test:js-dgtable-test","available":["TargetNotLocal"]},{"pkg-name":"js-flot","pkg-version":"0.8.3","component-name":"lib","available":[{"id":"js-flot-0.8.3-fadd4ccb467ede662552cdc382e02fb02027d8181620f296bae75d1f76774b0b","component-name":"lib","build-by-default":true}]},{"pkg-name":"js-flot","pkg-version":"0.8.3","component-name":"test:js-flot-test","available":["TargetNotLocal"]},{"pkg-name":"js-jquery","pkg-version":"3.3.1","component-name":"lib","available":[{"id":"js-jquery-3.3.1-6a8cc1e84fc203e099644c71b32217b6615b055459038eb73f1b008db4b2f236","component-name":"lib","build-by-default":true}]},{"pkg-name":"js-jquery","pkg-version":"3.3.1","component-name":"test:js-jquery-test","available":["TargetNotLocal"]},{"pkg-name":"mtl","pkg-version":"2.3.1","component-name":"lib","available":[{"id":"mtl-2.3.1","component-name":"lib","build-by-default":true}]},{"pkg-name":"os-string","pkg-version":"2.0.6","component-name":"lib","available":[{"id":"os-string-2.0.6-01e3c1e4563fbed004a4ac273e2beea9dfd497789ab9039e09b96161f470a497","component-name":"lib","build-by-default":true}]},{"pkg-name":"os-string","pkg-version":"2.0.6","component-name":"test:bytestring-tests","available":["TargetNotLocal"]},{"pkg-name":"os-string","pkg-version":"2.0.6","component-name":"test:encoding-tests","available":["TargetNotLocal"]},{"pkg-name":"os-string","pkg-version":"2.0.6","component-name":"bench:bench","available":["TargetNotLocal"]},{"pkg-name":"parsec","pkg-version":"3.1.16.1","component-name":"lib","available":[{"id":"parsec-3.1.16.1","component-name":"lib","build-by-default":true}]},{"pkg-name":"pretty","pkg-version":"1.1.3.6","component-name":"lib","available":[{"id":"pretty-1.1.3.6","component-name":"lib","build-by-default":true}]},{"pkg-name":"primitive","pkg-version":"0.9.0.0","component-name":"lib","available":[{"id":"primitive-0.9.0.0-b327a6c8ea4577ea7938607770d363048048a528efdff4bc67a582b5feac66fc","component-name":"lib","build-by-default":true}]},{"pkg-name":"primitive","pkg-version":"0.9.0.0","component-name":"test:test-qc","available":["TargetNotLocal"]},{"pkg-name":"primitive","pkg-version":"0.9.0.0","component-name":"bench:bench","available":["TargetNotLocal"]},{"pkg-name":"process","pkg-version":"1.6.17.0","component-name":"lib","available":[{"id":"process-1.6.17.0","component-name":"lib","build-by-default":true}]},{"pkg-name":"random","pkg-version":"1.2.1.2","component-name":"lib","available":[{"id":"random-1.2.1.2-ccb717c59af131f21dfc040f6185e9cbf4f0b5a3f6de1b3b376d50859a348586","component-name":"lib","build-by-default":true}]},{"pkg-name":"random","pkg-version":"1.2.1.2","component-name":"test:doctests","available":["TargetNotLocal"]},{"pkg-name":"random","pkg-version":"1.2.1.2","component-name":"test:legacy-test","available":["TargetNotLocal"]},{"pkg-name":"random","pkg-version":"1.2.1.2","component-name":"test:spec","available":["TargetNotLocal"]},{"pkg-name":"random","pkg-version":"1.2.1.2","component-name":"test:spec-inspection","available":["TargetNotLocal"]},{"pkg-name":"random","pkg-version":"1.2.1.2","component-name":"bench:bench","available":["TargetNotLocal"]},{"pkg-name":"random","pkg-version":"1.2.1.2","component-name":"bench:legacy-bench","available":["TargetNotLocal"]},{"pkg-name":"shake","pkg-version":"0.19.8","component-name":"lib","available":[{"id":"shake-0.19.8-0ddb83d9db09621c7b8f326abc494d14323dc5751be6943ac5b5e19c9347d5c3","component-name":"lib","build-by-default":true}]},{"pkg-name":"shake","pkg-version":"0.19.8","component-name":"exe:shake","available":[{"id":"shake-0.19.8-e-shake-7559c7ff704c4f74648b4baa6b6f1b1db1f99fa251704d87397a432f656a4846","component-name":"exe:shake","build-by-default":true}]},{"pkg-name":"shake","pkg-version":"0.19.8","component-name":"test:shake-test","available":["TargetNotLocal"]},{"pkg-name":"splitmix","pkg-version":"0.1.0.5","component-name":"lib","available":[{"id":"splitmix-0.1.0.5-232d2b1a4ce5cacd620dd2472d411c8d63e777af17182b5d56b631942f729187","component-name":"lib","build-by-default":true}]},{"pkg-name":"splitmix","pkg-version":"0.1.0.5","component-name":"test:examples","available":["TargetNotLocal"]},{"pkg-name":"splitmix","pkg-version":"0.1.0.5","component-name":"test:initialization","available":["TargetNotLocal"]},{"pkg-name":"splitmix","pkg-version":"0.1.0.5","component-name":"test:montecarlo-pi","available":["TargetNotLocal"]},{"pkg-name":"splitmix","pkg-version":"0.1.0.5","component-name":"test:montecarlo-pi-32","available":["TargetNotLocal"]},{"pkg-name":"splitmix","pkg-version":"0.1.0.5","component-name":"test:splitmix-dieharder","available":["TargetNotLocal"]},{"pkg-name":"splitmix","pkg-version":"0.1.0.5","component-name":"test:splitmix-tests","available":["TargetNotLocal"]},{"pkg-name":"splitmix","pkg-version":"0.1.0.5","component-name":"test:splitmix-testu01","available":["TargetNotLocal"]},{"pkg-name":"splitmix","pkg-version":"0.1.0.5","component-name":"bench:comparison","available":["TargetNotLocal"]},{"pkg-name":"splitmix","pkg-version":"0.1.0.5","component-name":"bench:range","available":["TargetNotLocal"]},{"pkg-name":"splitmix","pkg-version":"0.1.0.5","component-name":"bench:simple-sum","available":["TargetNotLocal"]},{"pkg-name":"stm","pkg-version":"2.5.1.0","component-name":"lib","available":[{"id":"stm-2.5.1.0","component-name":"lib","build-by-default":true}]},{"pkg-name":"system-cxx-std-lib","pkg-version":"1.0","component-name":"lib","available":[{"id":"system-cxx-std-lib-1.0","component-name":"lib","build-by-default":true}]},{"pkg-name":"template-haskell","pkg-version":"2.20.0.0","component-name":"lib","available":[{"id":"template-haskell-2.20.0.0","component-name":"lib","build-by-default":true}]},{"pkg-name":"text","pkg-version":"2.0.2","component-name":"lib","available":[{"id":"text-2.0.2","component-name":"lib","build-by-default":true}]},{"pkg-name":"time","pkg-version":"1.12.2","component-name":"lib","available":[{"id":"time-1.12.2","component-name":"lib","build-by-default":true}]},{"pkg-name":"transformers","pkg-version":"0.6.1.0","component-name":"lib","available":[{"id":"transformers-0.6.1.0","component-name":"lib","build-by-default":true}]},{"pkg-name":"unix","pkg-version":"2.8.4.0","component-name":"lib","available":[{"id":"unix-2.8.4.0","component-name":"lib","build-by-default":true}]},{"pkg-name":"unordered-containers","pkg-version":"0.2.20","component-name":"lib","available":[{"id":"unordered-containers-0.2.20-0a8211d6220ec0e6694f219bbea9da08528b897266f5898f98f4d6e1ab6fd737","component-name":"lib","build-by-default":true}]},{"pkg-name":"unordered-containers","pkg-version":"0.2.20","component-name":"test:unordered-containers-tests","available":["TargetNotLocal"]},{"pkg-name":"unordered-containers","pkg-version":"0.2.20","component-name":"bench:benchmarks","available":["TargetNotLocal"]},{"pkg-name":"utf8-string","pkg-version":"1.0.2","component-name":"lib","available":[{"id":"utf8-string-1.0.2-134849f72bdb35a6754bed838d5c0f0412c3ca2863338b599b4cd9b0af070e05","component-name":"lib","build-by-default":true}]},{"pkg-name":"utf8-string","pkg-version":"1.0.2","component-name":"test:unit-tests","available":["TargetNotLocal"]}]} \ No newline at end of file From 648d39c34b5b0c840baf3dee4656d40e85c5e480 Mon Sep 17 00:00:00 2001 From: Hamish Mackenzie Date: Thu, 24 Oct 2024 23:43:08 +1300 Subject: [PATCH 20/50] Update materialized files --- .../ghc983-aarch64/base.nix | 49 +++++++++++ .../ghc983-aarch64/deriveConstants.nix | 39 +++++++++ .../ghc983-aarch64/genprimopcode.nix | 40 +++++++++ .../ghc983-aarch64/ghc-bignum.nix | 37 +++++++++ .../ghc983-aarch64/ghc-boot.nix | 46 +++++++++++ .../ghc983-aarch64/ghc-heap.nix | 36 +++++++++ .../ghc983-aarch64/ghc-prim.nix | 47 +++++++++++ .../ghc983-aarch64/ghc.nix | 81 +++++++++++++++++++ .../ghc983-aarch64/ghci.nix | 45 +++++++++++ .../ghc983-aarch64/hpc.nix | 38 +++++++++ .../ghc983-aarch64/integer-gmp.nix | 35 ++++++++ .../ghc983-aarch64/iserv.nix | 41 ++++++++++ .../ghc983-aarch64/remote-iserv.nix | 36 +++++++++ .../ghc983-aarch64/template-haskell.nix | 36 +++++++++ .../ghc983llvm-aarch64/base.nix | 49 +++++++++++ .../ghc983llvm-aarch64/deriveConstants.nix | 39 +++++++++ .../ghc983llvm-aarch64/genprimopcode.nix | 40 +++++++++ .../ghc983llvm-aarch64/ghc-bignum.nix | 37 +++++++++ .../ghc983llvm-aarch64/ghc-boot.nix | 46 +++++++++++ .../ghc983llvm-aarch64/ghc-heap.nix | 36 +++++++++ .../ghc983llvm-aarch64/ghc-prim.nix | 47 +++++++++++ .../ghc983llvm-aarch64/ghc.nix | 81 +++++++++++++++++++ .../ghc983llvm-aarch64/ghci.nix | 45 +++++++++++ .../ghc983llvm-aarch64/hpc.nix | 38 +++++++++ .../ghc983llvm-aarch64/integer-gmp.nix | 35 ++++++++ .../ghc983llvm-aarch64/iserv.nix | 41 ++++++++++ .../ghc983llvm-aarch64/remote-iserv.nix | 36 +++++++++ .../ghc983llvm-aarch64/template-haskell.nix | 36 +++++++++ .../ghc-boot-packages-nix/ghc983llvm/base.nix | 49 +++++++++++ .../ghc983llvm/deriveConstants.nix | 39 +++++++++ .../ghc983llvm/genprimopcode.nix | 40 +++++++++ .../ghc983llvm/ghc-bignum.nix | 37 +++++++++ .../ghc983llvm/ghc-boot.nix | 46 +++++++++++ .../ghc983llvm/ghc-heap.nix | 36 +++++++++ .../ghc983llvm/ghc-prim.nix | 47 +++++++++++ .../ghc-boot-packages-nix/ghc983llvm/ghc.nix | 81 +++++++++++++++++++ .../ghc-boot-packages-nix/ghc983llvm/ghci.nix | 45 +++++++++++ .../ghc-boot-packages-nix/ghc983llvm/hpc.nix | 38 +++++++++ .../ghc983llvm/integer-gmp.nix | 35 ++++++++ .../ghc983llvm/iserv.nix | 41 ++++++++++ .../ghc983llvm/remote-iserv.nix | 36 +++++++++ .../ghc983llvm/template-haskell.nix | 36 +++++++++ 42 files changed, 1818 insertions(+) create mode 100644 materialized/ghc-boot-packages-nix/ghc983-aarch64/base.nix create mode 100644 materialized/ghc-boot-packages-nix/ghc983-aarch64/deriveConstants.nix create mode 100644 materialized/ghc-boot-packages-nix/ghc983-aarch64/genprimopcode.nix create mode 100644 materialized/ghc-boot-packages-nix/ghc983-aarch64/ghc-bignum.nix create mode 100644 materialized/ghc-boot-packages-nix/ghc983-aarch64/ghc-boot.nix create mode 100644 materialized/ghc-boot-packages-nix/ghc983-aarch64/ghc-heap.nix create mode 100644 materialized/ghc-boot-packages-nix/ghc983-aarch64/ghc-prim.nix create mode 100644 materialized/ghc-boot-packages-nix/ghc983-aarch64/ghc.nix create mode 100644 materialized/ghc-boot-packages-nix/ghc983-aarch64/ghci.nix create mode 100644 materialized/ghc-boot-packages-nix/ghc983-aarch64/hpc.nix create mode 100644 materialized/ghc-boot-packages-nix/ghc983-aarch64/integer-gmp.nix create mode 100644 materialized/ghc-boot-packages-nix/ghc983-aarch64/iserv.nix create mode 100644 materialized/ghc-boot-packages-nix/ghc983-aarch64/remote-iserv.nix create mode 100644 materialized/ghc-boot-packages-nix/ghc983-aarch64/template-haskell.nix create mode 100644 materialized/ghc-boot-packages-nix/ghc983llvm-aarch64/base.nix create mode 100644 materialized/ghc-boot-packages-nix/ghc983llvm-aarch64/deriveConstants.nix create mode 100644 materialized/ghc-boot-packages-nix/ghc983llvm-aarch64/genprimopcode.nix create mode 100644 materialized/ghc-boot-packages-nix/ghc983llvm-aarch64/ghc-bignum.nix create mode 100644 materialized/ghc-boot-packages-nix/ghc983llvm-aarch64/ghc-boot.nix create mode 100644 materialized/ghc-boot-packages-nix/ghc983llvm-aarch64/ghc-heap.nix create mode 100644 materialized/ghc-boot-packages-nix/ghc983llvm-aarch64/ghc-prim.nix create mode 100644 materialized/ghc-boot-packages-nix/ghc983llvm-aarch64/ghc.nix create mode 100644 materialized/ghc-boot-packages-nix/ghc983llvm-aarch64/ghci.nix create mode 100644 materialized/ghc-boot-packages-nix/ghc983llvm-aarch64/hpc.nix create mode 100644 materialized/ghc-boot-packages-nix/ghc983llvm-aarch64/integer-gmp.nix create mode 100644 materialized/ghc-boot-packages-nix/ghc983llvm-aarch64/iserv.nix create mode 100644 materialized/ghc-boot-packages-nix/ghc983llvm-aarch64/remote-iserv.nix create mode 100644 materialized/ghc-boot-packages-nix/ghc983llvm-aarch64/template-haskell.nix create mode 100644 materialized/ghc-boot-packages-nix/ghc983llvm/base.nix create mode 100644 materialized/ghc-boot-packages-nix/ghc983llvm/deriveConstants.nix create mode 100644 materialized/ghc-boot-packages-nix/ghc983llvm/genprimopcode.nix create mode 100644 materialized/ghc-boot-packages-nix/ghc983llvm/ghc-bignum.nix create mode 100644 materialized/ghc-boot-packages-nix/ghc983llvm/ghc-boot.nix create mode 100644 materialized/ghc-boot-packages-nix/ghc983llvm/ghc-heap.nix create mode 100644 materialized/ghc-boot-packages-nix/ghc983llvm/ghc-prim.nix create mode 100644 materialized/ghc-boot-packages-nix/ghc983llvm/ghc.nix create mode 100644 materialized/ghc-boot-packages-nix/ghc983llvm/ghci.nix create mode 100644 materialized/ghc-boot-packages-nix/ghc983llvm/hpc.nix create mode 100644 materialized/ghc-boot-packages-nix/ghc983llvm/integer-gmp.nix create mode 100644 materialized/ghc-boot-packages-nix/ghc983llvm/iserv.nix create mode 100644 materialized/ghc-boot-packages-nix/ghc983llvm/remote-iserv.nix create mode 100644 materialized/ghc-boot-packages-nix/ghc983llvm/template-haskell.nix diff --git a/materialized/ghc-boot-packages-nix/ghc983-aarch64/base.nix b/materialized/ghc-boot-packages-nix/ghc983-aarch64/base.nix new file mode 100644 index 0000000000..d918879f6f --- /dev/null +++ b/materialized/ghc-boot-packages-nix/ghc983-aarch64/base.nix @@ -0,0 +1,49 @@ +{ system + , compiler + , flags + , pkgs + , hsPkgs + , pkgconfPkgs + , errorHandler + , config + , ... }: + { + flags = {}; + package = { + specVersion = "3.0"; + identifier = { name = "base"; version = "4.19.2.0"; }; + license = "BSD-3-Clause"; + copyright = ""; + maintainer = "Core Libraries Committee "; + author = ""; + homepage = ""; + url = ""; + synopsis = "Core data structures and operations"; + description = "Haskell's base library provides, among other things, core types (e.g. [Bool](\"Data.Bool\") and [Int](\"Data.Int\")),\ndata structures (e.g. [List](\"Data.List\"), [Tuple](\"Data.Tuple\") and [Maybe](\"Data.Maybe\")),\nthe [Exception](\"Control.Exception\") mechanism, and the [IO](\"System.IO\") & [Concurrency](\"Control.Concurrent\") operations.\nThe \"Prelude\" module, which is imported by default, exposes a curated set of types and functions from other modules.\n\nOther data structures like [Map](https://hackage.haskell.org/package/containers/docs/Data-Map.html),\n[Set](https://hackage.haskell.org/package/containers/docs/Data-Set.html) are available in the [containers](https://hackage.haskell.org/package/containers) library.\nTo work with textual data, use the [text](https://hackage.haskell.org/package/text/docs/Data-Text.html) library."; + buildType = "Configure"; + }; + components = { + "library" = { + depends = [ + (hsPkgs."rts" or (errorHandler.buildDepError "rts")) + (hsPkgs."ghc-prim" or (errorHandler.buildDepError "ghc-prim")) + (hsPkgs."ghc-bignum" or (errorHandler.buildDepError "ghc-bignum")) + ]; + libs = pkgs.lib.optionals (system.isWindows) [ + (pkgs."wsock32" or (errorHandler.sysDepError "wsock32")) + (pkgs."user32" or (errorHandler.sysDepError "user32")) + (pkgs."shell32" or (errorHandler.sysDepError "shell32")) + (pkgs."mingw32" or (errorHandler.sysDepError "mingw32")) + (pkgs."kernel32" or (errorHandler.sysDepError "kernel32")) + (pkgs."advapi32" or (errorHandler.sysDepError "advapi32")) + (pkgs."mingwex" or (errorHandler.sysDepError "mingwex")) + (pkgs."ws2_32" or (errorHandler.sysDepError "ws2_32")) + (pkgs."shlwapi" or (errorHandler.sysDepError "shlwapi")) + (pkgs."ole32" or (errorHandler.sysDepError "ole32")) + (pkgs."rpcrt4" or (errorHandler.sysDepError "rpcrt4")) + (pkgs."ntdll" or (errorHandler.sysDepError "ntdll")) + ]; + buildable = true; + }; + }; + } // rec { src = pkgs.lib.mkDefault ./.; } diff --git a/materialized/ghc-boot-packages-nix/ghc983-aarch64/deriveConstants.nix b/materialized/ghc-boot-packages-nix/ghc983-aarch64/deriveConstants.nix new file mode 100644 index 0000000000..135cdd02f6 --- /dev/null +++ b/materialized/ghc-boot-packages-nix/ghc983-aarch64/deriveConstants.nix @@ -0,0 +1,39 @@ +{ system + , compiler + , flags + , pkgs + , hsPkgs + , pkgconfPkgs + , errorHandler + , config + , ... }: + { + flags = {}; + package = { + specVersion = "1.10"; + identifier = { name = "deriveConstants"; version = "0.1"; }; + license = "BSD-3-Clause"; + copyright = "XXX"; + maintainer = "XXX"; + author = "XXX"; + homepage = ""; + url = ""; + synopsis = "Derive header files containing various constants for the GHC build process"; + description = "This utility is responsible for generating a number of C header files\nneeded during the GHC build process. See @rts/include/ghc.mk@ in the GHC\nbuild system for details."; + buildType = "Simple"; + }; + components = { + exes = { + "deriveConstants" = { + depends = [ + (hsPkgs."base" or (errorHandler.buildDepError "base")) + (hsPkgs."containers" or (errorHandler.buildDepError "containers")) + (hsPkgs."process" or (errorHandler.buildDepError "process")) + (hsPkgs."filepath" or (errorHandler.buildDepError "filepath")) + (hsPkgs."directory" or (errorHandler.buildDepError "directory")) + ]; + buildable = true; + }; + }; + }; + } // rec { src = pkgs.lib.mkDefault ./.; } diff --git a/materialized/ghc-boot-packages-nix/ghc983-aarch64/genprimopcode.nix b/materialized/ghc-boot-packages-nix/ghc983-aarch64/genprimopcode.nix new file mode 100644 index 0000000000..49bbe516ba --- /dev/null +++ b/materialized/ghc-boot-packages-nix/ghc983-aarch64/genprimopcode.nix @@ -0,0 +1,40 @@ +{ system + , compiler + , flags + , pkgs + , hsPkgs + , pkgconfPkgs + , errorHandler + , config + , ... }: + { + flags = { build-tool-depends = true; }; + package = { + specVersion = "2.0"; + identifier = { name = "genprimopcode"; version = "0.1"; }; + license = "BSD-3-Clause"; + copyright = "XXX"; + maintainer = "XXX"; + author = "XXX"; + homepage = ""; + url = ""; + synopsis = "Generates various files implementing GHC's primitive operations."; + description = "This utility reads a textual description of GHC's primitive operations\n(@primops.txt.pp@) and produces a number of outputs. These include,\n\n* the @GHC.Prim@ module included in the @ghc-prim@ package.\n* the @GHC.PrimopWrappers@ module included in the @ghc-prim@ package.\n* an LaTeX document describing the primitive operations."; + buildType = "Simple"; + }; + components = { + exes = { + "genprimopcode" = { + depends = [ + (hsPkgs."base" or (errorHandler.buildDepError "base")) + (hsPkgs."array" or (errorHandler.buildDepError "array")) + ]; + build-tools = pkgs.lib.optionals (flags.build-tool-depends) [ + (hsPkgs.pkgsBuildBuild.alex.components.exes.alex or (pkgs.pkgsBuildBuild.alex or (errorHandler.buildToolDepError "alex:alex"))) + (hsPkgs.pkgsBuildBuild.happy.components.exes.happy or (pkgs.pkgsBuildBuild.happy or (errorHandler.buildToolDepError "happy:happy"))) + ]; + buildable = true; + }; + }; + }; + } // rec { src = pkgs.lib.mkDefault ./.; } diff --git a/materialized/ghc-boot-packages-nix/ghc983-aarch64/ghc-bignum.nix b/materialized/ghc-boot-packages-nix/ghc983-aarch64/ghc-bignum.nix new file mode 100644 index 0000000000..46af6e0e9f --- /dev/null +++ b/materialized/ghc-boot-packages-nix/ghc983-aarch64/ghc-bignum.nix @@ -0,0 +1,37 @@ +{ system + , compiler + , flags + , pkgs + , hsPkgs + , pkgconfPkgs + , errorHandler + , config + , ... }: + { + flags = { native = false; ffi = false; gmp = false; check = false; }; + package = { + specVersion = "2.0"; + identifier = { name = "ghc-bignum"; version = "1.3"; }; + license = "BSD-3-Clause"; + copyright = ""; + maintainer = "libraries@haskell.org"; + author = "Sylvain Henry"; + homepage = ""; + url = ""; + synopsis = "GHC BigNum library"; + description = "This package provides the low-level implementation of the standard\n'BigNat', 'Natural' and 'Integer' types."; + buildType = "Configure"; + }; + components = { + "library" = { + depends = [ + (hsPkgs."ghc-prim" or (errorHandler.buildDepError "ghc-prim")) + ]; + buildable = (if !flags.native && !flags.gmp && !flags.ffi + then false + else true) && (if flags.native && (flags.gmp || flags.ffi) + then false + else true) && (if flags.gmp && flags.ffi then false else true); + }; + }; + } // rec { src = pkgs.lib.mkDefault ./.; } diff --git a/materialized/ghc-boot-packages-nix/ghc983-aarch64/ghc-boot.nix b/materialized/ghc-boot-packages-nix/ghc983-aarch64/ghc-boot.nix new file mode 100644 index 0000000000..276da77ac7 --- /dev/null +++ b/materialized/ghc-boot-packages-nix/ghc983-aarch64/ghc-boot.nix @@ -0,0 +1,46 @@ +{ system + , compiler + , flags + , pkgs + , hsPkgs + , pkgconfPkgs + , errorHandler + , config + , ... }: + { + flags = {}; + package = { + specVersion = "3.0"; + identifier = { name = "ghc-boot"; version = "9.8.3"; }; + license = "BSD-3-Clause"; + copyright = ""; + maintainer = "ghc-devs@haskell.org"; + author = ""; + homepage = ""; + url = ""; + synopsis = "Shared functionality between GHC and its boot libraries"; + description = "This library is shared between GHC, ghc-pkg, and other boot\nlibraries.\n.\nA note about \"GHC.Unit.Database\": it only deals with the subset of\nthe package database that the compiler cares about: modules\npaths etc and not package metadata like description, authors\netc. It is thus not a library interface to ghc-pkg and is *not*\nsuitable for modifying GHC package databases.\n.\nThe package database format and this library are constructed in\nsuch a way that while ghc-pkg depends on Cabal, the GHC library\nand program do not have to depend on Cabal."; + buildType = "Custom"; + setup-depends = [ + (hsPkgs.pkgsBuildBuild.base or (pkgs.pkgsBuildBuild.base or (errorHandler.setupDepError "base"))) + (hsPkgs.pkgsBuildBuild.Cabal or (pkgs.pkgsBuildBuild.Cabal or (errorHandler.setupDepError "Cabal"))) + (hsPkgs.pkgsBuildBuild.directory or (pkgs.pkgsBuildBuild.directory or (errorHandler.setupDepError "directory"))) + (hsPkgs.pkgsBuildBuild.filepath or (pkgs.pkgsBuildBuild.filepath or (errorHandler.setupDepError "filepath"))) + ]; + }; + components = { + "library" = { + depends = [ + (hsPkgs."base" or (errorHandler.buildDepError "base")) + (hsPkgs."binary" or (errorHandler.buildDepError "binary")) + (hsPkgs."bytestring" or (errorHandler.buildDepError "bytestring")) + (hsPkgs."containers" or (errorHandler.buildDepError "containers")) + (hsPkgs."directory" or (errorHandler.buildDepError "directory")) + (hsPkgs."filepath" or (errorHandler.buildDepError "filepath")) + (hsPkgs."deepseq" or (errorHandler.buildDepError "deepseq")) + (hsPkgs."ghc-boot-th" or (errorHandler.buildDepError "ghc-boot-th")) + ] ++ pkgs.lib.optional (!system.isWindows) (hsPkgs."unix" or (errorHandler.buildDepError "unix")); + buildable = true; + }; + }; + } // rec { src = pkgs.lib.mkDefault ./.; } diff --git a/materialized/ghc-boot-packages-nix/ghc983-aarch64/ghc-heap.nix b/materialized/ghc-boot-packages-nix/ghc983-aarch64/ghc-heap.nix new file mode 100644 index 0000000000..d85b660a50 --- /dev/null +++ b/materialized/ghc-boot-packages-nix/ghc983-aarch64/ghc-heap.nix @@ -0,0 +1,36 @@ +{ system + , compiler + , flags + , pkgs + , hsPkgs + , pkgconfPkgs + , errorHandler + , config + , ... }: + { + flags = {}; + package = { + specVersion = "3.0"; + identifier = { name = "ghc-heap"; version = "9.8.3"; }; + license = "BSD-3-Clause"; + copyright = ""; + maintainer = "libraries@haskell.org"; + author = ""; + homepage = ""; + url = ""; + synopsis = "Functions for walking GHC's heap"; + description = "This package provides functions for walking the GHC heap data structures\nand retrieving information about those data structures."; + buildType = "Simple"; + }; + components = { + "library" = { + depends = [ + (hsPkgs."base" or (errorHandler.buildDepError "base")) + (hsPkgs."ghc-prim" or (errorHandler.buildDepError "ghc-prim")) + (hsPkgs."rts" or (errorHandler.buildDepError "rts")) + (hsPkgs."containers" or (errorHandler.buildDepError "containers")) + ]; + buildable = true; + }; + }; + } // rec { src = pkgs.lib.mkDefault ./.; } diff --git a/materialized/ghc-boot-packages-nix/ghc983-aarch64/ghc-prim.nix b/materialized/ghc-boot-packages-nix/ghc983-aarch64/ghc-prim.nix new file mode 100644 index 0000000000..546c5704d0 --- /dev/null +++ b/materialized/ghc-boot-packages-nix/ghc983-aarch64/ghc-prim.nix @@ -0,0 +1,47 @@ +{ system + , compiler + , flags + , pkgs + , hsPkgs + , pkgconfPkgs + , errorHandler + , config + , ... }: + { + flags = { need-atomic = false; }; + package = { + specVersion = "2.2"; + identifier = { name = "ghc-prim"; version = "0.11.0"; }; + license = "BSD-3-Clause"; + copyright = ""; + maintainer = "libraries@haskell.org"; + author = ""; + homepage = ""; + url = ""; + synopsis = "GHC primitives"; + description = "This package contains the primitive types and operations supplied by GHC.\nIt is an internal package, only for the use of GHC developers.\nGHC users should not use it! If you do use it then expect\nbreaking changes at any time without warning. You should prefer\nto import @GHC.Exts@ from the @base@ package instead."; + buildType = "Custom"; + setup-depends = [ + (hsPkgs.pkgsBuildBuild.base or (pkgs.pkgsBuildBuild.base or (errorHandler.setupDepError "base"))) + (hsPkgs.pkgsBuildBuild.process or (pkgs.pkgsBuildBuild.process or (errorHandler.setupDepError "process"))) + (hsPkgs.pkgsBuildBuild.filepath or (pkgs.pkgsBuildBuild.filepath or (errorHandler.setupDepError "filepath"))) + (hsPkgs.pkgsBuildBuild.directory or (pkgs.pkgsBuildBuild.directory or (errorHandler.setupDepError "directory"))) + (hsPkgs.pkgsBuildBuild.Cabal or (pkgs.pkgsBuildBuild.Cabal or (errorHandler.setupDepError "Cabal"))) + ]; + }; + components = { + "library" = { + depends = [ (hsPkgs."rts" or (errorHandler.buildDepError "rts")) ]; + libs = (pkgs.lib.optionals (system.isWindows) [ + (pkgs."user32" or (errorHandler.sysDepError "user32")) + (pkgs."mingw32" or (errorHandler.sysDepError "mingw32")) + (pkgs."mingwex" or (errorHandler.sysDepError "mingwex")) + (pkgs."ucrt" or (errorHandler.sysDepError "ucrt")) + ] ++ pkgs.lib.optionals (system.isLinux) [ + (pkgs."c" or (errorHandler.sysDepError "c")) + (pkgs."m" or (errorHandler.sysDepError "m")) + ]) ++ pkgs.lib.optional (flags.need-atomic) (pkgs."atomic" or (errorHandler.sysDepError "atomic")); + buildable = true; + }; + }; + } // rec { src = pkgs.lib.mkDefault ./.; } diff --git a/materialized/ghc-boot-packages-nix/ghc983-aarch64/ghc.nix b/materialized/ghc-boot-packages-nix/ghc983-aarch64/ghc.nix new file mode 100644 index 0000000000..a4a239d30c --- /dev/null +++ b/materialized/ghc-boot-packages-nix/ghc983-aarch64/ghc.nix @@ -0,0 +1,81 @@ +{ system + , compiler + , flags + , pkgs + , hsPkgs + , pkgconfPkgs + , errorHandler + , config + , ... }: + { + flags = { + internal-interpreter = false; + dynamic-system-linker = true; + build-tool-depends = true; + with-libzstd = false; + static-libzstd = false; + hadrian-stage0 = false; + }; + package = { + specVersion = "2.2"; + identifier = { name = "ghc"; version = "9.8.3"; }; + license = "BSD-3-Clause"; + copyright = ""; + maintainer = "glasgow-haskell-users@haskell.org"; + author = "The GHC Team"; + homepage = "http://www.haskell.org/ghc/"; + url = ""; + synopsis = "The GHC API"; + description = "GHC's functionality can be useful for more things than just\ncompiling Haskell programs. Important use cases are programs\nthat analyse (and perhaps transform) Haskell code. Others\ninclude loading Haskell code dynamically in a GHCi-like manner.\nFor this reason, a lot of GHC's functionality is made available\nthrough this package.\n\nSee \nfor more information."; + buildType = "Custom"; + setup-depends = [ + (hsPkgs.pkgsBuildBuild.base or (pkgs.pkgsBuildBuild.base or (errorHandler.setupDepError "base"))) + (hsPkgs.pkgsBuildBuild.Cabal or (pkgs.pkgsBuildBuild.Cabal or (errorHandler.setupDepError "Cabal"))) + (hsPkgs.pkgsBuildBuild.directory or (pkgs.pkgsBuildBuild.directory or (errorHandler.setupDepError "directory"))) + (hsPkgs.pkgsBuildBuild.process or (pkgs.pkgsBuildBuild.process or (errorHandler.setupDepError "process"))) + (hsPkgs.pkgsBuildBuild.filepath or (pkgs.pkgsBuildBuild.filepath or (errorHandler.setupDepError "filepath"))) + (hsPkgs.pkgsBuildBuild.containers or (pkgs.pkgsBuildBuild.containers or (errorHandler.setupDepError "containers"))) + ]; + }; + components = { + "library" = { + depends = [ + (hsPkgs."base" or (errorHandler.buildDepError "base")) + (hsPkgs."deepseq" or (errorHandler.buildDepError "deepseq")) + (hsPkgs."directory" or (errorHandler.buildDepError "directory")) + (hsPkgs."process" or (errorHandler.buildDepError "process")) + (hsPkgs."bytestring" or (errorHandler.buildDepError "bytestring")) + (hsPkgs."binary" or (errorHandler.buildDepError "binary")) + (hsPkgs."time" or (errorHandler.buildDepError "time")) + (hsPkgs."containers" or (errorHandler.buildDepError "containers")) + (hsPkgs."array" or (errorHandler.buildDepError "array")) + (hsPkgs."filepath" or (errorHandler.buildDepError "filepath")) + (hsPkgs."template-haskell" or (errorHandler.buildDepError "template-haskell")) + (hsPkgs."hpc" or (errorHandler.buildDepError "hpc")) + (hsPkgs."transformers" or (errorHandler.buildDepError "transformers")) + (hsPkgs."exceptions" or (errorHandler.buildDepError "exceptions")) + (hsPkgs."semaphore-compat" or (errorHandler.buildDepError "semaphore-compat")) + (hsPkgs."stm" or (errorHandler.buildDepError "stm")) + (hsPkgs."ghc-boot" or (errorHandler.buildDepError "ghc-boot")) + (hsPkgs."ghc-heap" or (errorHandler.buildDepError "ghc-heap")) + (hsPkgs."ghci" or (errorHandler.buildDepError "ghci")) + ] ++ (if system.isWindows + then [ (hsPkgs."Win32" or (errorHandler.buildDepError "Win32")) ] + else [ (hsPkgs."unix" or (errorHandler.buildDepError "unix")) ]); + libs = pkgs.lib.optionals (flags.with-libzstd) (if flags.static-libzstd + then pkgs.lib.optional (!system.isOsx) (pkgs.":libzstd.a" or (errorHandler.sysDepError ":libzstd.a")) + else [ (pkgs."zstd" or (errorHandler.sysDepError "zstd")) ]); + build-tools = pkgs.lib.optionals (flags.build-tool-depends) [ + (hsPkgs.pkgsBuildBuild.alex.components.exes.alex or (pkgs.pkgsBuildBuild.alex or (errorHandler.buildToolDepError "alex:alex"))) + (hsPkgs.pkgsBuildBuild.happy.components.exes.happy or (pkgs.pkgsBuildBuild.happy or (errorHandler.buildToolDepError "happy:happy"))) + (hsPkgs.pkgsBuildBuild.genprimopcode.components.exes.genprimopcode or (pkgs.pkgsBuildBuild.genprimopcode or (errorHandler.buildToolDepError "genprimopcode:genprimopcode"))) + (hsPkgs.pkgsBuildBuild.deriveConstants.components.exes.deriveConstants or (pkgs.pkgsBuildBuild.deriveConstants or (errorHandler.buildToolDepError "deriveConstants:deriveConstants"))) + ]; + buildable = if flags.with-libzstd + then if flags.static-libzstd + then if system.isOsx then false else true + else true + else true; + }; + }; + } // rec { src = pkgs.lib.mkDefault ./.; } diff --git a/materialized/ghc-boot-packages-nix/ghc983-aarch64/ghci.nix b/materialized/ghc-boot-packages-nix/ghc983-aarch64/ghci.nix new file mode 100644 index 0000000000..a7a99f7cb6 --- /dev/null +++ b/materialized/ghc-boot-packages-nix/ghc983-aarch64/ghci.nix @@ -0,0 +1,45 @@ +{ system + , compiler + , flags + , pkgs + , hsPkgs + , pkgconfPkgs + , errorHandler + , config + , ... }: + { + flags = { internal-interpreter = false; }; + package = { + specVersion = "1.10"; + identifier = { name = "ghci"; version = "9.8.3"; }; + license = "BSD-3-Clause"; + copyright = ""; + maintainer = "ghc-devs@haskell.org"; + author = ""; + homepage = ""; + url = ""; + synopsis = "The library supporting GHC's interactive interpreter"; + description = "This library offers interfaces which mediate interactions between the\n@ghci@ interactive shell and @iserv@, GHC's out-of-process interpreter\nbackend."; + buildType = "Simple"; + }; + components = { + "library" = { + depends = [ + (hsPkgs."rts" or (errorHandler.buildDepError "rts")) + (hsPkgs."array" or (errorHandler.buildDepError "array")) + (hsPkgs."base" or (errorHandler.buildDepError "base")) + (hsPkgs."ghc-prim" or (errorHandler.buildDepError "ghc-prim")) + (hsPkgs."binary" or (errorHandler.buildDepError "binary")) + (hsPkgs."bytestring" or (errorHandler.buildDepError "bytestring")) + (hsPkgs."containers" or (errorHandler.buildDepError "containers")) + (hsPkgs."deepseq" or (errorHandler.buildDepError "deepseq")) + (hsPkgs."filepath" or (errorHandler.buildDepError "filepath")) + (hsPkgs."ghc-boot" or (errorHandler.buildDepError "ghc-boot")) + (hsPkgs."ghc-heap" or (errorHandler.buildDepError "ghc-heap")) + (hsPkgs."template-haskell" or (errorHandler.buildDepError "template-haskell")) + (hsPkgs."transformers" or (errorHandler.buildDepError "transformers")) + ] ++ pkgs.lib.optional (!system.isWindows) (hsPkgs."unix" or (errorHandler.buildDepError "unix")); + buildable = true; + }; + }; + } // rec { src = pkgs.lib.mkDefault ./.; } diff --git a/materialized/ghc-boot-packages-nix/ghc983-aarch64/hpc.nix b/materialized/ghc-boot-packages-nix/ghc983-aarch64/hpc.nix new file mode 100644 index 0000000000..f6b275cfd1 --- /dev/null +++ b/materialized/ghc-boot-packages-nix/ghc983-aarch64/hpc.nix @@ -0,0 +1,38 @@ +{ system + , compiler + , flags + , pkgs + , hsPkgs + , pkgconfPkgs + , errorHandler + , config + , ... }: + { + flags = {}; + package = { + specVersion = "2.2"; + identifier = { name = "hpc"; version = "0.7.0.0"; }; + license = "BSD-3-Clause"; + copyright = ""; + maintainer = "ghc-devs@haskell.org"; + author = "Andy Gill"; + homepage = ""; + url = ""; + synopsis = "Code Coverage Library for Haskell"; + description = "This package provides the code coverage library for Haskell.\n\nSee for more\ninformation."; + buildType = "Simple"; + }; + components = { + "library" = { + depends = [ + (hsPkgs."base" or (errorHandler.buildDepError "base")) + (hsPkgs."containers" or (errorHandler.buildDepError "containers")) + (hsPkgs."deepseq" or (errorHandler.buildDepError "deepseq")) + (hsPkgs."directory" or (errorHandler.buildDepError "directory")) + (hsPkgs."filepath" or (errorHandler.buildDepError "filepath")) + (hsPkgs."time" or (errorHandler.buildDepError "time")) + ]; + buildable = true; + }; + }; + } // rec { src = pkgs.lib.mkDefault ./.; } diff --git a/materialized/ghc-boot-packages-nix/ghc983-aarch64/integer-gmp.nix b/materialized/ghc-boot-packages-nix/ghc983-aarch64/integer-gmp.nix new file mode 100644 index 0000000000..94f930e70e --- /dev/null +++ b/materialized/ghc-boot-packages-nix/ghc983-aarch64/integer-gmp.nix @@ -0,0 +1,35 @@ +{ system + , compiler + , flags + , pkgs + , hsPkgs + , pkgconfPkgs + , errorHandler + , config + , ... }: + { + flags = {}; + package = { + specVersion = "2.0"; + identifier = { name = "integer-gmp"; version = "1.1"; }; + license = "BSD-3-Clause"; + copyright = ""; + maintainer = "hvr@gnu.org"; + author = "Herbert Valerio Riedel"; + homepage = "https://www.haskell.org/ghc/"; + url = ""; + synopsis = "Integer library based on GMP"; + description = "This package used to provide an implementation of the standard 'Integer'\ntype based on the\n.\n\nIt is now deprecated in favor of the 'ghc-bignum' package.\n\nIts purpose is to provide backward compatibility for codes directly\ndepending on the `integer-gmp` package."; + buildType = "Simple"; + }; + components = { + "library" = { + depends = [ + (hsPkgs."base" or (errorHandler.buildDepError "base")) + (hsPkgs."ghc-prim" or (errorHandler.buildDepError "ghc-prim")) + (hsPkgs."ghc-bignum" or (errorHandler.buildDepError "ghc-bignum")) + ]; + buildable = true; + }; + }; + } // rec { src = pkgs.lib.mkDefault ./.; } diff --git a/materialized/ghc-boot-packages-nix/ghc983-aarch64/iserv.nix b/materialized/ghc-boot-packages-nix/ghc983-aarch64/iserv.nix new file mode 100644 index 0000000000..297f43290c --- /dev/null +++ b/materialized/ghc-boot-packages-nix/ghc983-aarch64/iserv.nix @@ -0,0 +1,41 @@ +{ system + , compiler + , flags + , pkgs + , hsPkgs + , pkgconfPkgs + , errorHandler + , config + , ... }: + { + flags = {}; + package = { + specVersion = "1.10"; + identifier = { name = "iserv"; version = "9.8.3"; }; + license = "BSD-3-Clause"; + copyright = "XXX"; + maintainer = "XXX"; + author = "XXX"; + homepage = ""; + url = ""; + synopsis = "iserv allows GHC to delegate Template Haskell computations"; + description = "GHC can be provided with a path to the iserv binary with\n@-pgmi=/path/to/iserv-bin@, and will in combination with\n@-fexternal-interpreter@, compile Template Haskell though the\n@iserv-bin@ delegate. This is very similar to how ghcjs has been\ncompiling Template Haskell, by spawning a separate delegate (so\ncalled runner on the javascript vm) and evaluating the splices\nthere."; + buildType = "Simple"; + }; + components = { + exes = { + "iserv" = { + depends = [ + (hsPkgs."array" or (errorHandler.buildDepError "array")) + (hsPkgs."base" or (errorHandler.buildDepError "base")) + (hsPkgs."binary" or (errorHandler.buildDepError "binary")) + (hsPkgs."bytestring" or (errorHandler.buildDepError "bytestring")) + (hsPkgs."containers" or (errorHandler.buildDepError "containers")) + (hsPkgs."deepseq" or (errorHandler.buildDepError "deepseq")) + (hsPkgs."ghci" or (errorHandler.buildDepError "ghci")) + ] ++ pkgs.lib.optional (!system.isWindows) (hsPkgs."unix" or (errorHandler.buildDepError "unix")); + buildable = true; + }; + }; + }; + } // rec { src = pkgs.lib.mkDefault ./.; } diff --git a/materialized/ghc-boot-packages-nix/ghc983-aarch64/remote-iserv.nix b/materialized/ghc-boot-packages-nix/ghc983-aarch64/remote-iserv.nix new file mode 100644 index 0000000000..bfce58fa33 --- /dev/null +++ b/materialized/ghc-boot-packages-nix/ghc983-aarch64/remote-iserv.nix @@ -0,0 +1,36 @@ +{ system + , compiler + , flags + , pkgs + , hsPkgs + , pkgconfPkgs + , errorHandler + , config + , ... }: + { + flags = {}; + package = { + specVersion = "1.10"; + identifier = { name = "remote-iserv"; version = "9.8.3"; }; + license = "BSD-3-Clause"; + copyright = "XXX"; + maintainer = "Moritz Angermann "; + author = "Moritz Angermann "; + homepage = ""; + url = ""; + synopsis = "iserv allows GHC to delegate Template Haskell computations"; + description = "This is a very simple remote runner for iserv, to be used together\nwith iserv-proxy. The foundamental idea is that this this wrapper\nstarts running the GHCi server on a given port to which iserv-proxy will\nthen connect."; + buildType = "Simple"; + }; + components = { + exes = { + "remote-iserv" = { + depends = [ + (hsPkgs."base" or (errorHandler.buildDepError "base")) + (hsPkgs."ghci" or (errorHandler.buildDepError "ghci")) + ]; + buildable = true; + }; + }; + }; + } // rec { src = pkgs.lib.mkDefault ./.; } diff --git a/materialized/ghc-boot-packages-nix/ghc983-aarch64/template-haskell.nix b/materialized/ghc-boot-packages-nix/ghc983-aarch64/template-haskell.nix new file mode 100644 index 0000000000..3e26556434 --- /dev/null +++ b/materialized/ghc-boot-packages-nix/ghc983-aarch64/template-haskell.nix @@ -0,0 +1,36 @@ +{ system + , compiler + , flags + , pkgs + , hsPkgs + , pkgconfPkgs + , errorHandler + , config + , ... }: + { + flags = {}; + package = { + specVersion = "1.10"; + identifier = { name = "template-haskell"; version = "2.21.0.0"; }; + license = "BSD-3-Clause"; + copyright = ""; + maintainer = "libraries@haskell.org"; + author = ""; + homepage = ""; + url = ""; + synopsis = "Support library for Template Haskell"; + description = "This package provides modules containing facilities for manipulating\nHaskell source code using Template Haskell.\n\nSee for more\ninformation."; + buildType = "Simple"; + }; + components = { + "library" = { + depends = [ + (hsPkgs."base" or (errorHandler.buildDepError "base")) + (hsPkgs."ghc-boot-th" or (errorHandler.buildDepError "ghc-boot-th")) + (hsPkgs."ghc-prim" or (errorHandler.buildDepError "ghc-prim")) + (hsPkgs."pretty" or (errorHandler.buildDepError "pretty")) + ]; + buildable = true; + }; + }; + } // rec { src = pkgs.lib.mkDefault ./.; } diff --git a/materialized/ghc-boot-packages-nix/ghc983llvm-aarch64/base.nix b/materialized/ghc-boot-packages-nix/ghc983llvm-aarch64/base.nix new file mode 100644 index 0000000000..d918879f6f --- /dev/null +++ b/materialized/ghc-boot-packages-nix/ghc983llvm-aarch64/base.nix @@ -0,0 +1,49 @@ +{ system + , compiler + , flags + , pkgs + , hsPkgs + , pkgconfPkgs + , errorHandler + , config + , ... }: + { + flags = {}; + package = { + specVersion = "3.0"; + identifier = { name = "base"; version = "4.19.2.0"; }; + license = "BSD-3-Clause"; + copyright = ""; + maintainer = "Core Libraries Committee "; + author = ""; + homepage = ""; + url = ""; + synopsis = "Core data structures and operations"; + description = "Haskell's base library provides, among other things, core types (e.g. [Bool](\"Data.Bool\") and [Int](\"Data.Int\")),\ndata structures (e.g. [List](\"Data.List\"), [Tuple](\"Data.Tuple\") and [Maybe](\"Data.Maybe\")),\nthe [Exception](\"Control.Exception\") mechanism, and the [IO](\"System.IO\") & [Concurrency](\"Control.Concurrent\") operations.\nThe \"Prelude\" module, which is imported by default, exposes a curated set of types and functions from other modules.\n\nOther data structures like [Map](https://hackage.haskell.org/package/containers/docs/Data-Map.html),\n[Set](https://hackage.haskell.org/package/containers/docs/Data-Set.html) are available in the [containers](https://hackage.haskell.org/package/containers) library.\nTo work with textual data, use the [text](https://hackage.haskell.org/package/text/docs/Data-Text.html) library."; + buildType = "Configure"; + }; + components = { + "library" = { + depends = [ + (hsPkgs."rts" or (errorHandler.buildDepError "rts")) + (hsPkgs."ghc-prim" or (errorHandler.buildDepError "ghc-prim")) + (hsPkgs."ghc-bignum" or (errorHandler.buildDepError "ghc-bignum")) + ]; + libs = pkgs.lib.optionals (system.isWindows) [ + (pkgs."wsock32" or (errorHandler.sysDepError "wsock32")) + (pkgs."user32" or (errorHandler.sysDepError "user32")) + (pkgs."shell32" or (errorHandler.sysDepError "shell32")) + (pkgs."mingw32" or (errorHandler.sysDepError "mingw32")) + (pkgs."kernel32" or (errorHandler.sysDepError "kernel32")) + (pkgs."advapi32" or (errorHandler.sysDepError "advapi32")) + (pkgs."mingwex" or (errorHandler.sysDepError "mingwex")) + (pkgs."ws2_32" or (errorHandler.sysDepError "ws2_32")) + (pkgs."shlwapi" or (errorHandler.sysDepError "shlwapi")) + (pkgs."ole32" or (errorHandler.sysDepError "ole32")) + (pkgs."rpcrt4" or (errorHandler.sysDepError "rpcrt4")) + (pkgs."ntdll" or (errorHandler.sysDepError "ntdll")) + ]; + buildable = true; + }; + }; + } // rec { src = pkgs.lib.mkDefault ./.; } diff --git a/materialized/ghc-boot-packages-nix/ghc983llvm-aarch64/deriveConstants.nix b/materialized/ghc-boot-packages-nix/ghc983llvm-aarch64/deriveConstants.nix new file mode 100644 index 0000000000..135cdd02f6 --- /dev/null +++ b/materialized/ghc-boot-packages-nix/ghc983llvm-aarch64/deriveConstants.nix @@ -0,0 +1,39 @@ +{ system + , compiler + , flags + , pkgs + , hsPkgs + , pkgconfPkgs + , errorHandler + , config + , ... }: + { + flags = {}; + package = { + specVersion = "1.10"; + identifier = { name = "deriveConstants"; version = "0.1"; }; + license = "BSD-3-Clause"; + copyright = "XXX"; + maintainer = "XXX"; + author = "XXX"; + homepage = ""; + url = ""; + synopsis = "Derive header files containing various constants for the GHC build process"; + description = "This utility is responsible for generating a number of C header files\nneeded during the GHC build process. See @rts/include/ghc.mk@ in the GHC\nbuild system for details."; + buildType = "Simple"; + }; + components = { + exes = { + "deriveConstants" = { + depends = [ + (hsPkgs."base" or (errorHandler.buildDepError "base")) + (hsPkgs."containers" or (errorHandler.buildDepError "containers")) + (hsPkgs."process" or (errorHandler.buildDepError "process")) + (hsPkgs."filepath" or (errorHandler.buildDepError "filepath")) + (hsPkgs."directory" or (errorHandler.buildDepError "directory")) + ]; + buildable = true; + }; + }; + }; + } // rec { src = pkgs.lib.mkDefault ./.; } diff --git a/materialized/ghc-boot-packages-nix/ghc983llvm-aarch64/genprimopcode.nix b/materialized/ghc-boot-packages-nix/ghc983llvm-aarch64/genprimopcode.nix new file mode 100644 index 0000000000..49bbe516ba --- /dev/null +++ b/materialized/ghc-boot-packages-nix/ghc983llvm-aarch64/genprimopcode.nix @@ -0,0 +1,40 @@ +{ system + , compiler + , flags + , pkgs + , hsPkgs + , pkgconfPkgs + , errorHandler + , config + , ... }: + { + flags = { build-tool-depends = true; }; + package = { + specVersion = "2.0"; + identifier = { name = "genprimopcode"; version = "0.1"; }; + license = "BSD-3-Clause"; + copyright = "XXX"; + maintainer = "XXX"; + author = "XXX"; + homepage = ""; + url = ""; + synopsis = "Generates various files implementing GHC's primitive operations."; + description = "This utility reads a textual description of GHC's primitive operations\n(@primops.txt.pp@) and produces a number of outputs. These include,\n\n* the @GHC.Prim@ module included in the @ghc-prim@ package.\n* the @GHC.PrimopWrappers@ module included in the @ghc-prim@ package.\n* an LaTeX document describing the primitive operations."; + buildType = "Simple"; + }; + components = { + exes = { + "genprimopcode" = { + depends = [ + (hsPkgs."base" or (errorHandler.buildDepError "base")) + (hsPkgs."array" or (errorHandler.buildDepError "array")) + ]; + build-tools = pkgs.lib.optionals (flags.build-tool-depends) [ + (hsPkgs.pkgsBuildBuild.alex.components.exes.alex or (pkgs.pkgsBuildBuild.alex or (errorHandler.buildToolDepError "alex:alex"))) + (hsPkgs.pkgsBuildBuild.happy.components.exes.happy or (pkgs.pkgsBuildBuild.happy or (errorHandler.buildToolDepError "happy:happy"))) + ]; + buildable = true; + }; + }; + }; + } // rec { src = pkgs.lib.mkDefault ./.; } diff --git a/materialized/ghc-boot-packages-nix/ghc983llvm-aarch64/ghc-bignum.nix b/materialized/ghc-boot-packages-nix/ghc983llvm-aarch64/ghc-bignum.nix new file mode 100644 index 0000000000..46af6e0e9f --- /dev/null +++ b/materialized/ghc-boot-packages-nix/ghc983llvm-aarch64/ghc-bignum.nix @@ -0,0 +1,37 @@ +{ system + , compiler + , flags + , pkgs + , hsPkgs + , pkgconfPkgs + , errorHandler + , config + , ... }: + { + flags = { native = false; ffi = false; gmp = false; check = false; }; + package = { + specVersion = "2.0"; + identifier = { name = "ghc-bignum"; version = "1.3"; }; + license = "BSD-3-Clause"; + copyright = ""; + maintainer = "libraries@haskell.org"; + author = "Sylvain Henry"; + homepage = ""; + url = ""; + synopsis = "GHC BigNum library"; + description = "This package provides the low-level implementation of the standard\n'BigNat', 'Natural' and 'Integer' types."; + buildType = "Configure"; + }; + components = { + "library" = { + depends = [ + (hsPkgs."ghc-prim" or (errorHandler.buildDepError "ghc-prim")) + ]; + buildable = (if !flags.native && !flags.gmp && !flags.ffi + then false + else true) && (if flags.native && (flags.gmp || flags.ffi) + then false + else true) && (if flags.gmp && flags.ffi then false else true); + }; + }; + } // rec { src = pkgs.lib.mkDefault ./.; } diff --git a/materialized/ghc-boot-packages-nix/ghc983llvm-aarch64/ghc-boot.nix b/materialized/ghc-boot-packages-nix/ghc983llvm-aarch64/ghc-boot.nix new file mode 100644 index 0000000000..276da77ac7 --- /dev/null +++ b/materialized/ghc-boot-packages-nix/ghc983llvm-aarch64/ghc-boot.nix @@ -0,0 +1,46 @@ +{ system + , compiler + , flags + , pkgs + , hsPkgs + , pkgconfPkgs + , errorHandler + , config + , ... }: + { + flags = {}; + package = { + specVersion = "3.0"; + identifier = { name = "ghc-boot"; version = "9.8.3"; }; + license = "BSD-3-Clause"; + copyright = ""; + maintainer = "ghc-devs@haskell.org"; + author = ""; + homepage = ""; + url = ""; + synopsis = "Shared functionality between GHC and its boot libraries"; + description = "This library is shared between GHC, ghc-pkg, and other boot\nlibraries.\n.\nA note about \"GHC.Unit.Database\": it only deals with the subset of\nthe package database that the compiler cares about: modules\npaths etc and not package metadata like description, authors\netc. It is thus not a library interface to ghc-pkg and is *not*\nsuitable for modifying GHC package databases.\n.\nThe package database format and this library are constructed in\nsuch a way that while ghc-pkg depends on Cabal, the GHC library\nand program do not have to depend on Cabal."; + buildType = "Custom"; + setup-depends = [ + (hsPkgs.pkgsBuildBuild.base or (pkgs.pkgsBuildBuild.base or (errorHandler.setupDepError "base"))) + (hsPkgs.pkgsBuildBuild.Cabal or (pkgs.pkgsBuildBuild.Cabal or (errorHandler.setupDepError "Cabal"))) + (hsPkgs.pkgsBuildBuild.directory or (pkgs.pkgsBuildBuild.directory or (errorHandler.setupDepError "directory"))) + (hsPkgs.pkgsBuildBuild.filepath or (pkgs.pkgsBuildBuild.filepath or (errorHandler.setupDepError "filepath"))) + ]; + }; + components = { + "library" = { + depends = [ + (hsPkgs."base" or (errorHandler.buildDepError "base")) + (hsPkgs."binary" or (errorHandler.buildDepError "binary")) + (hsPkgs."bytestring" or (errorHandler.buildDepError "bytestring")) + (hsPkgs."containers" or (errorHandler.buildDepError "containers")) + (hsPkgs."directory" or (errorHandler.buildDepError "directory")) + (hsPkgs."filepath" or (errorHandler.buildDepError "filepath")) + (hsPkgs."deepseq" or (errorHandler.buildDepError "deepseq")) + (hsPkgs."ghc-boot-th" or (errorHandler.buildDepError "ghc-boot-th")) + ] ++ pkgs.lib.optional (!system.isWindows) (hsPkgs."unix" or (errorHandler.buildDepError "unix")); + buildable = true; + }; + }; + } // rec { src = pkgs.lib.mkDefault ./.; } diff --git a/materialized/ghc-boot-packages-nix/ghc983llvm-aarch64/ghc-heap.nix b/materialized/ghc-boot-packages-nix/ghc983llvm-aarch64/ghc-heap.nix new file mode 100644 index 0000000000..d85b660a50 --- /dev/null +++ b/materialized/ghc-boot-packages-nix/ghc983llvm-aarch64/ghc-heap.nix @@ -0,0 +1,36 @@ +{ system + , compiler + , flags + , pkgs + , hsPkgs + , pkgconfPkgs + , errorHandler + , config + , ... }: + { + flags = {}; + package = { + specVersion = "3.0"; + identifier = { name = "ghc-heap"; version = "9.8.3"; }; + license = "BSD-3-Clause"; + copyright = ""; + maintainer = "libraries@haskell.org"; + author = ""; + homepage = ""; + url = ""; + synopsis = "Functions for walking GHC's heap"; + description = "This package provides functions for walking the GHC heap data structures\nand retrieving information about those data structures."; + buildType = "Simple"; + }; + components = { + "library" = { + depends = [ + (hsPkgs."base" or (errorHandler.buildDepError "base")) + (hsPkgs."ghc-prim" or (errorHandler.buildDepError "ghc-prim")) + (hsPkgs."rts" or (errorHandler.buildDepError "rts")) + (hsPkgs."containers" or (errorHandler.buildDepError "containers")) + ]; + buildable = true; + }; + }; + } // rec { src = pkgs.lib.mkDefault ./.; } diff --git a/materialized/ghc-boot-packages-nix/ghc983llvm-aarch64/ghc-prim.nix b/materialized/ghc-boot-packages-nix/ghc983llvm-aarch64/ghc-prim.nix new file mode 100644 index 0000000000..546c5704d0 --- /dev/null +++ b/materialized/ghc-boot-packages-nix/ghc983llvm-aarch64/ghc-prim.nix @@ -0,0 +1,47 @@ +{ system + , compiler + , flags + , pkgs + , hsPkgs + , pkgconfPkgs + , errorHandler + , config + , ... }: + { + flags = { need-atomic = false; }; + package = { + specVersion = "2.2"; + identifier = { name = "ghc-prim"; version = "0.11.0"; }; + license = "BSD-3-Clause"; + copyright = ""; + maintainer = "libraries@haskell.org"; + author = ""; + homepage = ""; + url = ""; + synopsis = "GHC primitives"; + description = "This package contains the primitive types and operations supplied by GHC.\nIt is an internal package, only for the use of GHC developers.\nGHC users should not use it! If you do use it then expect\nbreaking changes at any time without warning. You should prefer\nto import @GHC.Exts@ from the @base@ package instead."; + buildType = "Custom"; + setup-depends = [ + (hsPkgs.pkgsBuildBuild.base or (pkgs.pkgsBuildBuild.base or (errorHandler.setupDepError "base"))) + (hsPkgs.pkgsBuildBuild.process or (pkgs.pkgsBuildBuild.process or (errorHandler.setupDepError "process"))) + (hsPkgs.pkgsBuildBuild.filepath or (pkgs.pkgsBuildBuild.filepath or (errorHandler.setupDepError "filepath"))) + (hsPkgs.pkgsBuildBuild.directory or (pkgs.pkgsBuildBuild.directory or (errorHandler.setupDepError "directory"))) + (hsPkgs.pkgsBuildBuild.Cabal or (pkgs.pkgsBuildBuild.Cabal or (errorHandler.setupDepError "Cabal"))) + ]; + }; + components = { + "library" = { + depends = [ (hsPkgs."rts" or (errorHandler.buildDepError "rts")) ]; + libs = (pkgs.lib.optionals (system.isWindows) [ + (pkgs."user32" or (errorHandler.sysDepError "user32")) + (pkgs."mingw32" or (errorHandler.sysDepError "mingw32")) + (pkgs."mingwex" or (errorHandler.sysDepError "mingwex")) + (pkgs."ucrt" or (errorHandler.sysDepError "ucrt")) + ] ++ pkgs.lib.optionals (system.isLinux) [ + (pkgs."c" or (errorHandler.sysDepError "c")) + (pkgs."m" or (errorHandler.sysDepError "m")) + ]) ++ pkgs.lib.optional (flags.need-atomic) (pkgs."atomic" or (errorHandler.sysDepError "atomic")); + buildable = true; + }; + }; + } // rec { src = pkgs.lib.mkDefault ./.; } diff --git a/materialized/ghc-boot-packages-nix/ghc983llvm-aarch64/ghc.nix b/materialized/ghc-boot-packages-nix/ghc983llvm-aarch64/ghc.nix new file mode 100644 index 0000000000..a4a239d30c --- /dev/null +++ b/materialized/ghc-boot-packages-nix/ghc983llvm-aarch64/ghc.nix @@ -0,0 +1,81 @@ +{ system + , compiler + , flags + , pkgs + , hsPkgs + , pkgconfPkgs + , errorHandler + , config + , ... }: + { + flags = { + internal-interpreter = false; + dynamic-system-linker = true; + build-tool-depends = true; + with-libzstd = false; + static-libzstd = false; + hadrian-stage0 = false; + }; + package = { + specVersion = "2.2"; + identifier = { name = "ghc"; version = "9.8.3"; }; + license = "BSD-3-Clause"; + copyright = ""; + maintainer = "glasgow-haskell-users@haskell.org"; + author = "The GHC Team"; + homepage = "http://www.haskell.org/ghc/"; + url = ""; + synopsis = "The GHC API"; + description = "GHC's functionality can be useful for more things than just\ncompiling Haskell programs. Important use cases are programs\nthat analyse (and perhaps transform) Haskell code. Others\ninclude loading Haskell code dynamically in a GHCi-like manner.\nFor this reason, a lot of GHC's functionality is made available\nthrough this package.\n\nSee \nfor more information."; + buildType = "Custom"; + setup-depends = [ + (hsPkgs.pkgsBuildBuild.base or (pkgs.pkgsBuildBuild.base or (errorHandler.setupDepError "base"))) + (hsPkgs.pkgsBuildBuild.Cabal or (pkgs.pkgsBuildBuild.Cabal or (errorHandler.setupDepError "Cabal"))) + (hsPkgs.pkgsBuildBuild.directory or (pkgs.pkgsBuildBuild.directory or (errorHandler.setupDepError "directory"))) + (hsPkgs.pkgsBuildBuild.process or (pkgs.pkgsBuildBuild.process or (errorHandler.setupDepError "process"))) + (hsPkgs.pkgsBuildBuild.filepath or (pkgs.pkgsBuildBuild.filepath or (errorHandler.setupDepError "filepath"))) + (hsPkgs.pkgsBuildBuild.containers or (pkgs.pkgsBuildBuild.containers or (errorHandler.setupDepError "containers"))) + ]; + }; + components = { + "library" = { + depends = [ + (hsPkgs."base" or (errorHandler.buildDepError "base")) + (hsPkgs."deepseq" or (errorHandler.buildDepError "deepseq")) + (hsPkgs."directory" or (errorHandler.buildDepError "directory")) + (hsPkgs."process" or (errorHandler.buildDepError "process")) + (hsPkgs."bytestring" or (errorHandler.buildDepError "bytestring")) + (hsPkgs."binary" or (errorHandler.buildDepError "binary")) + (hsPkgs."time" or (errorHandler.buildDepError "time")) + (hsPkgs."containers" or (errorHandler.buildDepError "containers")) + (hsPkgs."array" or (errorHandler.buildDepError "array")) + (hsPkgs."filepath" or (errorHandler.buildDepError "filepath")) + (hsPkgs."template-haskell" or (errorHandler.buildDepError "template-haskell")) + (hsPkgs."hpc" or (errorHandler.buildDepError "hpc")) + (hsPkgs."transformers" or (errorHandler.buildDepError "transformers")) + (hsPkgs."exceptions" or (errorHandler.buildDepError "exceptions")) + (hsPkgs."semaphore-compat" or (errorHandler.buildDepError "semaphore-compat")) + (hsPkgs."stm" or (errorHandler.buildDepError "stm")) + (hsPkgs."ghc-boot" or (errorHandler.buildDepError "ghc-boot")) + (hsPkgs."ghc-heap" or (errorHandler.buildDepError "ghc-heap")) + (hsPkgs."ghci" or (errorHandler.buildDepError "ghci")) + ] ++ (if system.isWindows + then [ (hsPkgs."Win32" or (errorHandler.buildDepError "Win32")) ] + else [ (hsPkgs."unix" or (errorHandler.buildDepError "unix")) ]); + libs = pkgs.lib.optionals (flags.with-libzstd) (if flags.static-libzstd + then pkgs.lib.optional (!system.isOsx) (pkgs.":libzstd.a" or (errorHandler.sysDepError ":libzstd.a")) + else [ (pkgs."zstd" or (errorHandler.sysDepError "zstd")) ]); + build-tools = pkgs.lib.optionals (flags.build-tool-depends) [ + (hsPkgs.pkgsBuildBuild.alex.components.exes.alex or (pkgs.pkgsBuildBuild.alex or (errorHandler.buildToolDepError "alex:alex"))) + (hsPkgs.pkgsBuildBuild.happy.components.exes.happy or (pkgs.pkgsBuildBuild.happy or (errorHandler.buildToolDepError "happy:happy"))) + (hsPkgs.pkgsBuildBuild.genprimopcode.components.exes.genprimopcode or (pkgs.pkgsBuildBuild.genprimopcode or (errorHandler.buildToolDepError "genprimopcode:genprimopcode"))) + (hsPkgs.pkgsBuildBuild.deriveConstants.components.exes.deriveConstants or (pkgs.pkgsBuildBuild.deriveConstants or (errorHandler.buildToolDepError "deriveConstants:deriveConstants"))) + ]; + buildable = if flags.with-libzstd + then if flags.static-libzstd + then if system.isOsx then false else true + else true + else true; + }; + }; + } // rec { src = pkgs.lib.mkDefault ./.; } diff --git a/materialized/ghc-boot-packages-nix/ghc983llvm-aarch64/ghci.nix b/materialized/ghc-boot-packages-nix/ghc983llvm-aarch64/ghci.nix new file mode 100644 index 0000000000..a7a99f7cb6 --- /dev/null +++ b/materialized/ghc-boot-packages-nix/ghc983llvm-aarch64/ghci.nix @@ -0,0 +1,45 @@ +{ system + , compiler + , flags + , pkgs + , hsPkgs + , pkgconfPkgs + , errorHandler + , config + , ... }: + { + flags = { internal-interpreter = false; }; + package = { + specVersion = "1.10"; + identifier = { name = "ghci"; version = "9.8.3"; }; + license = "BSD-3-Clause"; + copyright = ""; + maintainer = "ghc-devs@haskell.org"; + author = ""; + homepage = ""; + url = ""; + synopsis = "The library supporting GHC's interactive interpreter"; + description = "This library offers interfaces which mediate interactions between the\n@ghci@ interactive shell and @iserv@, GHC's out-of-process interpreter\nbackend."; + buildType = "Simple"; + }; + components = { + "library" = { + depends = [ + (hsPkgs."rts" or (errorHandler.buildDepError "rts")) + (hsPkgs."array" or (errorHandler.buildDepError "array")) + (hsPkgs."base" or (errorHandler.buildDepError "base")) + (hsPkgs."ghc-prim" or (errorHandler.buildDepError "ghc-prim")) + (hsPkgs."binary" or (errorHandler.buildDepError "binary")) + (hsPkgs."bytestring" or (errorHandler.buildDepError "bytestring")) + (hsPkgs."containers" or (errorHandler.buildDepError "containers")) + (hsPkgs."deepseq" or (errorHandler.buildDepError "deepseq")) + (hsPkgs."filepath" or (errorHandler.buildDepError "filepath")) + (hsPkgs."ghc-boot" or (errorHandler.buildDepError "ghc-boot")) + (hsPkgs."ghc-heap" or (errorHandler.buildDepError "ghc-heap")) + (hsPkgs."template-haskell" or (errorHandler.buildDepError "template-haskell")) + (hsPkgs."transformers" or (errorHandler.buildDepError "transformers")) + ] ++ pkgs.lib.optional (!system.isWindows) (hsPkgs."unix" or (errorHandler.buildDepError "unix")); + buildable = true; + }; + }; + } // rec { src = pkgs.lib.mkDefault ./.; } diff --git a/materialized/ghc-boot-packages-nix/ghc983llvm-aarch64/hpc.nix b/materialized/ghc-boot-packages-nix/ghc983llvm-aarch64/hpc.nix new file mode 100644 index 0000000000..f6b275cfd1 --- /dev/null +++ b/materialized/ghc-boot-packages-nix/ghc983llvm-aarch64/hpc.nix @@ -0,0 +1,38 @@ +{ system + , compiler + , flags + , pkgs + , hsPkgs + , pkgconfPkgs + , errorHandler + , config + , ... }: + { + flags = {}; + package = { + specVersion = "2.2"; + identifier = { name = "hpc"; version = "0.7.0.0"; }; + license = "BSD-3-Clause"; + copyright = ""; + maintainer = "ghc-devs@haskell.org"; + author = "Andy Gill"; + homepage = ""; + url = ""; + synopsis = "Code Coverage Library for Haskell"; + description = "This package provides the code coverage library for Haskell.\n\nSee for more\ninformation."; + buildType = "Simple"; + }; + components = { + "library" = { + depends = [ + (hsPkgs."base" or (errorHandler.buildDepError "base")) + (hsPkgs."containers" or (errorHandler.buildDepError "containers")) + (hsPkgs."deepseq" or (errorHandler.buildDepError "deepseq")) + (hsPkgs."directory" or (errorHandler.buildDepError "directory")) + (hsPkgs."filepath" or (errorHandler.buildDepError "filepath")) + (hsPkgs."time" or (errorHandler.buildDepError "time")) + ]; + buildable = true; + }; + }; + } // rec { src = pkgs.lib.mkDefault ./.; } diff --git a/materialized/ghc-boot-packages-nix/ghc983llvm-aarch64/integer-gmp.nix b/materialized/ghc-boot-packages-nix/ghc983llvm-aarch64/integer-gmp.nix new file mode 100644 index 0000000000..94f930e70e --- /dev/null +++ b/materialized/ghc-boot-packages-nix/ghc983llvm-aarch64/integer-gmp.nix @@ -0,0 +1,35 @@ +{ system + , compiler + , flags + , pkgs + , hsPkgs + , pkgconfPkgs + , errorHandler + , config + , ... }: + { + flags = {}; + package = { + specVersion = "2.0"; + identifier = { name = "integer-gmp"; version = "1.1"; }; + license = "BSD-3-Clause"; + copyright = ""; + maintainer = "hvr@gnu.org"; + author = "Herbert Valerio Riedel"; + homepage = "https://www.haskell.org/ghc/"; + url = ""; + synopsis = "Integer library based on GMP"; + description = "This package used to provide an implementation of the standard 'Integer'\ntype based on the\n.\n\nIt is now deprecated in favor of the 'ghc-bignum' package.\n\nIts purpose is to provide backward compatibility for codes directly\ndepending on the `integer-gmp` package."; + buildType = "Simple"; + }; + components = { + "library" = { + depends = [ + (hsPkgs."base" or (errorHandler.buildDepError "base")) + (hsPkgs."ghc-prim" or (errorHandler.buildDepError "ghc-prim")) + (hsPkgs."ghc-bignum" or (errorHandler.buildDepError "ghc-bignum")) + ]; + buildable = true; + }; + }; + } // rec { src = pkgs.lib.mkDefault ./.; } diff --git a/materialized/ghc-boot-packages-nix/ghc983llvm-aarch64/iserv.nix b/materialized/ghc-boot-packages-nix/ghc983llvm-aarch64/iserv.nix new file mode 100644 index 0000000000..297f43290c --- /dev/null +++ b/materialized/ghc-boot-packages-nix/ghc983llvm-aarch64/iserv.nix @@ -0,0 +1,41 @@ +{ system + , compiler + , flags + , pkgs + , hsPkgs + , pkgconfPkgs + , errorHandler + , config + , ... }: + { + flags = {}; + package = { + specVersion = "1.10"; + identifier = { name = "iserv"; version = "9.8.3"; }; + license = "BSD-3-Clause"; + copyright = "XXX"; + maintainer = "XXX"; + author = "XXX"; + homepage = ""; + url = ""; + synopsis = "iserv allows GHC to delegate Template Haskell computations"; + description = "GHC can be provided with a path to the iserv binary with\n@-pgmi=/path/to/iserv-bin@, and will in combination with\n@-fexternal-interpreter@, compile Template Haskell though the\n@iserv-bin@ delegate. This is very similar to how ghcjs has been\ncompiling Template Haskell, by spawning a separate delegate (so\ncalled runner on the javascript vm) and evaluating the splices\nthere."; + buildType = "Simple"; + }; + components = { + exes = { + "iserv" = { + depends = [ + (hsPkgs."array" or (errorHandler.buildDepError "array")) + (hsPkgs."base" or (errorHandler.buildDepError "base")) + (hsPkgs."binary" or (errorHandler.buildDepError "binary")) + (hsPkgs."bytestring" or (errorHandler.buildDepError "bytestring")) + (hsPkgs."containers" or (errorHandler.buildDepError "containers")) + (hsPkgs."deepseq" or (errorHandler.buildDepError "deepseq")) + (hsPkgs."ghci" or (errorHandler.buildDepError "ghci")) + ] ++ pkgs.lib.optional (!system.isWindows) (hsPkgs."unix" or (errorHandler.buildDepError "unix")); + buildable = true; + }; + }; + }; + } // rec { src = pkgs.lib.mkDefault ./.; } diff --git a/materialized/ghc-boot-packages-nix/ghc983llvm-aarch64/remote-iserv.nix b/materialized/ghc-boot-packages-nix/ghc983llvm-aarch64/remote-iserv.nix new file mode 100644 index 0000000000..bfce58fa33 --- /dev/null +++ b/materialized/ghc-boot-packages-nix/ghc983llvm-aarch64/remote-iserv.nix @@ -0,0 +1,36 @@ +{ system + , compiler + , flags + , pkgs + , hsPkgs + , pkgconfPkgs + , errorHandler + , config + , ... }: + { + flags = {}; + package = { + specVersion = "1.10"; + identifier = { name = "remote-iserv"; version = "9.8.3"; }; + license = "BSD-3-Clause"; + copyright = "XXX"; + maintainer = "Moritz Angermann "; + author = "Moritz Angermann "; + homepage = ""; + url = ""; + synopsis = "iserv allows GHC to delegate Template Haskell computations"; + description = "This is a very simple remote runner for iserv, to be used together\nwith iserv-proxy. The foundamental idea is that this this wrapper\nstarts running the GHCi server on a given port to which iserv-proxy will\nthen connect."; + buildType = "Simple"; + }; + components = { + exes = { + "remote-iserv" = { + depends = [ + (hsPkgs."base" or (errorHandler.buildDepError "base")) + (hsPkgs."ghci" or (errorHandler.buildDepError "ghci")) + ]; + buildable = true; + }; + }; + }; + } // rec { src = pkgs.lib.mkDefault ./.; } diff --git a/materialized/ghc-boot-packages-nix/ghc983llvm-aarch64/template-haskell.nix b/materialized/ghc-boot-packages-nix/ghc983llvm-aarch64/template-haskell.nix new file mode 100644 index 0000000000..3e26556434 --- /dev/null +++ b/materialized/ghc-boot-packages-nix/ghc983llvm-aarch64/template-haskell.nix @@ -0,0 +1,36 @@ +{ system + , compiler + , flags + , pkgs + , hsPkgs + , pkgconfPkgs + , errorHandler + , config + , ... }: + { + flags = {}; + package = { + specVersion = "1.10"; + identifier = { name = "template-haskell"; version = "2.21.0.0"; }; + license = "BSD-3-Clause"; + copyright = ""; + maintainer = "libraries@haskell.org"; + author = ""; + homepage = ""; + url = ""; + synopsis = "Support library for Template Haskell"; + description = "This package provides modules containing facilities for manipulating\nHaskell source code using Template Haskell.\n\nSee for more\ninformation."; + buildType = "Simple"; + }; + components = { + "library" = { + depends = [ + (hsPkgs."base" or (errorHandler.buildDepError "base")) + (hsPkgs."ghc-boot-th" or (errorHandler.buildDepError "ghc-boot-th")) + (hsPkgs."ghc-prim" or (errorHandler.buildDepError "ghc-prim")) + (hsPkgs."pretty" or (errorHandler.buildDepError "pretty")) + ]; + buildable = true; + }; + }; + } // rec { src = pkgs.lib.mkDefault ./.; } diff --git a/materialized/ghc-boot-packages-nix/ghc983llvm/base.nix b/materialized/ghc-boot-packages-nix/ghc983llvm/base.nix new file mode 100644 index 0000000000..d918879f6f --- /dev/null +++ b/materialized/ghc-boot-packages-nix/ghc983llvm/base.nix @@ -0,0 +1,49 @@ +{ system + , compiler + , flags + , pkgs + , hsPkgs + , pkgconfPkgs + , errorHandler + , config + , ... }: + { + flags = {}; + package = { + specVersion = "3.0"; + identifier = { name = "base"; version = "4.19.2.0"; }; + license = "BSD-3-Clause"; + copyright = ""; + maintainer = "Core Libraries Committee "; + author = ""; + homepage = ""; + url = ""; + synopsis = "Core data structures and operations"; + description = "Haskell's base library provides, among other things, core types (e.g. [Bool](\"Data.Bool\") and [Int](\"Data.Int\")),\ndata structures (e.g. [List](\"Data.List\"), [Tuple](\"Data.Tuple\") and [Maybe](\"Data.Maybe\")),\nthe [Exception](\"Control.Exception\") mechanism, and the [IO](\"System.IO\") & [Concurrency](\"Control.Concurrent\") operations.\nThe \"Prelude\" module, which is imported by default, exposes a curated set of types and functions from other modules.\n\nOther data structures like [Map](https://hackage.haskell.org/package/containers/docs/Data-Map.html),\n[Set](https://hackage.haskell.org/package/containers/docs/Data-Set.html) are available in the [containers](https://hackage.haskell.org/package/containers) library.\nTo work with textual data, use the [text](https://hackage.haskell.org/package/text/docs/Data-Text.html) library."; + buildType = "Configure"; + }; + components = { + "library" = { + depends = [ + (hsPkgs."rts" or (errorHandler.buildDepError "rts")) + (hsPkgs."ghc-prim" or (errorHandler.buildDepError "ghc-prim")) + (hsPkgs."ghc-bignum" or (errorHandler.buildDepError "ghc-bignum")) + ]; + libs = pkgs.lib.optionals (system.isWindows) [ + (pkgs."wsock32" or (errorHandler.sysDepError "wsock32")) + (pkgs."user32" or (errorHandler.sysDepError "user32")) + (pkgs."shell32" or (errorHandler.sysDepError "shell32")) + (pkgs."mingw32" or (errorHandler.sysDepError "mingw32")) + (pkgs."kernel32" or (errorHandler.sysDepError "kernel32")) + (pkgs."advapi32" or (errorHandler.sysDepError "advapi32")) + (pkgs."mingwex" or (errorHandler.sysDepError "mingwex")) + (pkgs."ws2_32" or (errorHandler.sysDepError "ws2_32")) + (pkgs."shlwapi" or (errorHandler.sysDepError "shlwapi")) + (pkgs."ole32" or (errorHandler.sysDepError "ole32")) + (pkgs."rpcrt4" or (errorHandler.sysDepError "rpcrt4")) + (pkgs."ntdll" or (errorHandler.sysDepError "ntdll")) + ]; + buildable = true; + }; + }; + } // rec { src = pkgs.lib.mkDefault ./.; } diff --git a/materialized/ghc-boot-packages-nix/ghc983llvm/deriveConstants.nix b/materialized/ghc-boot-packages-nix/ghc983llvm/deriveConstants.nix new file mode 100644 index 0000000000..135cdd02f6 --- /dev/null +++ b/materialized/ghc-boot-packages-nix/ghc983llvm/deriveConstants.nix @@ -0,0 +1,39 @@ +{ system + , compiler + , flags + , pkgs + , hsPkgs + , pkgconfPkgs + , errorHandler + , config + , ... }: + { + flags = {}; + package = { + specVersion = "1.10"; + identifier = { name = "deriveConstants"; version = "0.1"; }; + license = "BSD-3-Clause"; + copyright = "XXX"; + maintainer = "XXX"; + author = "XXX"; + homepage = ""; + url = ""; + synopsis = "Derive header files containing various constants for the GHC build process"; + description = "This utility is responsible for generating a number of C header files\nneeded during the GHC build process. See @rts/include/ghc.mk@ in the GHC\nbuild system for details."; + buildType = "Simple"; + }; + components = { + exes = { + "deriveConstants" = { + depends = [ + (hsPkgs."base" or (errorHandler.buildDepError "base")) + (hsPkgs."containers" or (errorHandler.buildDepError "containers")) + (hsPkgs."process" or (errorHandler.buildDepError "process")) + (hsPkgs."filepath" or (errorHandler.buildDepError "filepath")) + (hsPkgs."directory" or (errorHandler.buildDepError "directory")) + ]; + buildable = true; + }; + }; + }; + } // rec { src = pkgs.lib.mkDefault ./.; } diff --git a/materialized/ghc-boot-packages-nix/ghc983llvm/genprimopcode.nix b/materialized/ghc-boot-packages-nix/ghc983llvm/genprimopcode.nix new file mode 100644 index 0000000000..49bbe516ba --- /dev/null +++ b/materialized/ghc-boot-packages-nix/ghc983llvm/genprimopcode.nix @@ -0,0 +1,40 @@ +{ system + , compiler + , flags + , pkgs + , hsPkgs + , pkgconfPkgs + , errorHandler + , config + , ... }: + { + flags = { build-tool-depends = true; }; + package = { + specVersion = "2.0"; + identifier = { name = "genprimopcode"; version = "0.1"; }; + license = "BSD-3-Clause"; + copyright = "XXX"; + maintainer = "XXX"; + author = "XXX"; + homepage = ""; + url = ""; + synopsis = "Generates various files implementing GHC's primitive operations."; + description = "This utility reads a textual description of GHC's primitive operations\n(@primops.txt.pp@) and produces a number of outputs. These include,\n\n* the @GHC.Prim@ module included in the @ghc-prim@ package.\n* the @GHC.PrimopWrappers@ module included in the @ghc-prim@ package.\n* an LaTeX document describing the primitive operations."; + buildType = "Simple"; + }; + components = { + exes = { + "genprimopcode" = { + depends = [ + (hsPkgs."base" or (errorHandler.buildDepError "base")) + (hsPkgs."array" or (errorHandler.buildDepError "array")) + ]; + build-tools = pkgs.lib.optionals (flags.build-tool-depends) [ + (hsPkgs.pkgsBuildBuild.alex.components.exes.alex or (pkgs.pkgsBuildBuild.alex or (errorHandler.buildToolDepError "alex:alex"))) + (hsPkgs.pkgsBuildBuild.happy.components.exes.happy or (pkgs.pkgsBuildBuild.happy or (errorHandler.buildToolDepError "happy:happy"))) + ]; + buildable = true; + }; + }; + }; + } // rec { src = pkgs.lib.mkDefault ./.; } diff --git a/materialized/ghc-boot-packages-nix/ghc983llvm/ghc-bignum.nix b/materialized/ghc-boot-packages-nix/ghc983llvm/ghc-bignum.nix new file mode 100644 index 0000000000..46af6e0e9f --- /dev/null +++ b/materialized/ghc-boot-packages-nix/ghc983llvm/ghc-bignum.nix @@ -0,0 +1,37 @@ +{ system + , compiler + , flags + , pkgs + , hsPkgs + , pkgconfPkgs + , errorHandler + , config + , ... }: + { + flags = { native = false; ffi = false; gmp = false; check = false; }; + package = { + specVersion = "2.0"; + identifier = { name = "ghc-bignum"; version = "1.3"; }; + license = "BSD-3-Clause"; + copyright = ""; + maintainer = "libraries@haskell.org"; + author = "Sylvain Henry"; + homepage = ""; + url = ""; + synopsis = "GHC BigNum library"; + description = "This package provides the low-level implementation of the standard\n'BigNat', 'Natural' and 'Integer' types."; + buildType = "Configure"; + }; + components = { + "library" = { + depends = [ + (hsPkgs."ghc-prim" or (errorHandler.buildDepError "ghc-prim")) + ]; + buildable = (if !flags.native && !flags.gmp && !flags.ffi + then false + else true) && (if flags.native && (flags.gmp || flags.ffi) + then false + else true) && (if flags.gmp && flags.ffi then false else true); + }; + }; + } // rec { src = pkgs.lib.mkDefault ./.; } diff --git a/materialized/ghc-boot-packages-nix/ghc983llvm/ghc-boot.nix b/materialized/ghc-boot-packages-nix/ghc983llvm/ghc-boot.nix new file mode 100644 index 0000000000..276da77ac7 --- /dev/null +++ b/materialized/ghc-boot-packages-nix/ghc983llvm/ghc-boot.nix @@ -0,0 +1,46 @@ +{ system + , compiler + , flags + , pkgs + , hsPkgs + , pkgconfPkgs + , errorHandler + , config + , ... }: + { + flags = {}; + package = { + specVersion = "3.0"; + identifier = { name = "ghc-boot"; version = "9.8.3"; }; + license = "BSD-3-Clause"; + copyright = ""; + maintainer = "ghc-devs@haskell.org"; + author = ""; + homepage = ""; + url = ""; + synopsis = "Shared functionality between GHC and its boot libraries"; + description = "This library is shared between GHC, ghc-pkg, and other boot\nlibraries.\n.\nA note about \"GHC.Unit.Database\": it only deals with the subset of\nthe package database that the compiler cares about: modules\npaths etc and not package metadata like description, authors\netc. It is thus not a library interface to ghc-pkg and is *not*\nsuitable for modifying GHC package databases.\n.\nThe package database format and this library are constructed in\nsuch a way that while ghc-pkg depends on Cabal, the GHC library\nand program do not have to depend on Cabal."; + buildType = "Custom"; + setup-depends = [ + (hsPkgs.pkgsBuildBuild.base or (pkgs.pkgsBuildBuild.base or (errorHandler.setupDepError "base"))) + (hsPkgs.pkgsBuildBuild.Cabal or (pkgs.pkgsBuildBuild.Cabal or (errorHandler.setupDepError "Cabal"))) + (hsPkgs.pkgsBuildBuild.directory or (pkgs.pkgsBuildBuild.directory or (errorHandler.setupDepError "directory"))) + (hsPkgs.pkgsBuildBuild.filepath or (pkgs.pkgsBuildBuild.filepath or (errorHandler.setupDepError "filepath"))) + ]; + }; + components = { + "library" = { + depends = [ + (hsPkgs."base" or (errorHandler.buildDepError "base")) + (hsPkgs."binary" or (errorHandler.buildDepError "binary")) + (hsPkgs."bytestring" or (errorHandler.buildDepError "bytestring")) + (hsPkgs."containers" or (errorHandler.buildDepError "containers")) + (hsPkgs."directory" or (errorHandler.buildDepError "directory")) + (hsPkgs."filepath" or (errorHandler.buildDepError "filepath")) + (hsPkgs."deepseq" or (errorHandler.buildDepError "deepseq")) + (hsPkgs."ghc-boot-th" or (errorHandler.buildDepError "ghc-boot-th")) + ] ++ pkgs.lib.optional (!system.isWindows) (hsPkgs."unix" or (errorHandler.buildDepError "unix")); + buildable = true; + }; + }; + } // rec { src = pkgs.lib.mkDefault ./.; } diff --git a/materialized/ghc-boot-packages-nix/ghc983llvm/ghc-heap.nix b/materialized/ghc-boot-packages-nix/ghc983llvm/ghc-heap.nix new file mode 100644 index 0000000000..d85b660a50 --- /dev/null +++ b/materialized/ghc-boot-packages-nix/ghc983llvm/ghc-heap.nix @@ -0,0 +1,36 @@ +{ system + , compiler + , flags + , pkgs + , hsPkgs + , pkgconfPkgs + , errorHandler + , config + , ... }: + { + flags = {}; + package = { + specVersion = "3.0"; + identifier = { name = "ghc-heap"; version = "9.8.3"; }; + license = "BSD-3-Clause"; + copyright = ""; + maintainer = "libraries@haskell.org"; + author = ""; + homepage = ""; + url = ""; + synopsis = "Functions for walking GHC's heap"; + description = "This package provides functions for walking the GHC heap data structures\nand retrieving information about those data structures."; + buildType = "Simple"; + }; + components = { + "library" = { + depends = [ + (hsPkgs."base" or (errorHandler.buildDepError "base")) + (hsPkgs."ghc-prim" or (errorHandler.buildDepError "ghc-prim")) + (hsPkgs."rts" or (errorHandler.buildDepError "rts")) + (hsPkgs."containers" or (errorHandler.buildDepError "containers")) + ]; + buildable = true; + }; + }; + } // rec { src = pkgs.lib.mkDefault ./.; } diff --git a/materialized/ghc-boot-packages-nix/ghc983llvm/ghc-prim.nix b/materialized/ghc-boot-packages-nix/ghc983llvm/ghc-prim.nix new file mode 100644 index 0000000000..546c5704d0 --- /dev/null +++ b/materialized/ghc-boot-packages-nix/ghc983llvm/ghc-prim.nix @@ -0,0 +1,47 @@ +{ system + , compiler + , flags + , pkgs + , hsPkgs + , pkgconfPkgs + , errorHandler + , config + , ... }: + { + flags = { need-atomic = false; }; + package = { + specVersion = "2.2"; + identifier = { name = "ghc-prim"; version = "0.11.0"; }; + license = "BSD-3-Clause"; + copyright = ""; + maintainer = "libraries@haskell.org"; + author = ""; + homepage = ""; + url = ""; + synopsis = "GHC primitives"; + description = "This package contains the primitive types and operations supplied by GHC.\nIt is an internal package, only for the use of GHC developers.\nGHC users should not use it! If you do use it then expect\nbreaking changes at any time without warning. You should prefer\nto import @GHC.Exts@ from the @base@ package instead."; + buildType = "Custom"; + setup-depends = [ + (hsPkgs.pkgsBuildBuild.base or (pkgs.pkgsBuildBuild.base or (errorHandler.setupDepError "base"))) + (hsPkgs.pkgsBuildBuild.process or (pkgs.pkgsBuildBuild.process or (errorHandler.setupDepError "process"))) + (hsPkgs.pkgsBuildBuild.filepath or (pkgs.pkgsBuildBuild.filepath or (errorHandler.setupDepError "filepath"))) + (hsPkgs.pkgsBuildBuild.directory or (pkgs.pkgsBuildBuild.directory or (errorHandler.setupDepError "directory"))) + (hsPkgs.pkgsBuildBuild.Cabal or (pkgs.pkgsBuildBuild.Cabal or (errorHandler.setupDepError "Cabal"))) + ]; + }; + components = { + "library" = { + depends = [ (hsPkgs."rts" or (errorHandler.buildDepError "rts")) ]; + libs = (pkgs.lib.optionals (system.isWindows) [ + (pkgs."user32" or (errorHandler.sysDepError "user32")) + (pkgs."mingw32" or (errorHandler.sysDepError "mingw32")) + (pkgs."mingwex" or (errorHandler.sysDepError "mingwex")) + (pkgs."ucrt" or (errorHandler.sysDepError "ucrt")) + ] ++ pkgs.lib.optionals (system.isLinux) [ + (pkgs."c" or (errorHandler.sysDepError "c")) + (pkgs."m" or (errorHandler.sysDepError "m")) + ]) ++ pkgs.lib.optional (flags.need-atomic) (pkgs."atomic" or (errorHandler.sysDepError "atomic")); + buildable = true; + }; + }; + } // rec { src = pkgs.lib.mkDefault ./.; } diff --git a/materialized/ghc-boot-packages-nix/ghc983llvm/ghc.nix b/materialized/ghc-boot-packages-nix/ghc983llvm/ghc.nix new file mode 100644 index 0000000000..a4a239d30c --- /dev/null +++ b/materialized/ghc-boot-packages-nix/ghc983llvm/ghc.nix @@ -0,0 +1,81 @@ +{ system + , compiler + , flags + , pkgs + , hsPkgs + , pkgconfPkgs + , errorHandler + , config + , ... }: + { + flags = { + internal-interpreter = false; + dynamic-system-linker = true; + build-tool-depends = true; + with-libzstd = false; + static-libzstd = false; + hadrian-stage0 = false; + }; + package = { + specVersion = "2.2"; + identifier = { name = "ghc"; version = "9.8.3"; }; + license = "BSD-3-Clause"; + copyright = ""; + maintainer = "glasgow-haskell-users@haskell.org"; + author = "The GHC Team"; + homepage = "http://www.haskell.org/ghc/"; + url = ""; + synopsis = "The GHC API"; + description = "GHC's functionality can be useful for more things than just\ncompiling Haskell programs. Important use cases are programs\nthat analyse (and perhaps transform) Haskell code. Others\ninclude loading Haskell code dynamically in a GHCi-like manner.\nFor this reason, a lot of GHC's functionality is made available\nthrough this package.\n\nSee \nfor more information."; + buildType = "Custom"; + setup-depends = [ + (hsPkgs.pkgsBuildBuild.base or (pkgs.pkgsBuildBuild.base or (errorHandler.setupDepError "base"))) + (hsPkgs.pkgsBuildBuild.Cabal or (pkgs.pkgsBuildBuild.Cabal or (errorHandler.setupDepError "Cabal"))) + (hsPkgs.pkgsBuildBuild.directory or (pkgs.pkgsBuildBuild.directory or (errorHandler.setupDepError "directory"))) + (hsPkgs.pkgsBuildBuild.process or (pkgs.pkgsBuildBuild.process or (errorHandler.setupDepError "process"))) + (hsPkgs.pkgsBuildBuild.filepath or (pkgs.pkgsBuildBuild.filepath or (errorHandler.setupDepError "filepath"))) + (hsPkgs.pkgsBuildBuild.containers or (pkgs.pkgsBuildBuild.containers or (errorHandler.setupDepError "containers"))) + ]; + }; + components = { + "library" = { + depends = [ + (hsPkgs."base" or (errorHandler.buildDepError "base")) + (hsPkgs."deepseq" or (errorHandler.buildDepError "deepseq")) + (hsPkgs."directory" or (errorHandler.buildDepError "directory")) + (hsPkgs."process" or (errorHandler.buildDepError "process")) + (hsPkgs."bytestring" or (errorHandler.buildDepError "bytestring")) + (hsPkgs."binary" or (errorHandler.buildDepError "binary")) + (hsPkgs."time" or (errorHandler.buildDepError "time")) + (hsPkgs."containers" or (errorHandler.buildDepError "containers")) + (hsPkgs."array" or (errorHandler.buildDepError "array")) + (hsPkgs."filepath" or (errorHandler.buildDepError "filepath")) + (hsPkgs."template-haskell" or (errorHandler.buildDepError "template-haskell")) + (hsPkgs."hpc" or (errorHandler.buildDepError "hpc")) + (hsPkgs."transformers" or (errorHandler.buildDepError "transformers")) + (hsPkgs."exceptions" or (errorHandler.buildDepError "exceptions")) + (hsPkgs."semaphore-compat" or (errorHandler.buildDepError "semaphore-compat")) + (hsPkgs."stm" or (errorHandler.buildDepError "stm")) + (hsPkgs."ghc-boot" or (errorHandler.buildDepError "ghc-boot")) + (hsPkgs."ghc-heap" or (errorHandler.buildDepError "ghc-heap")) + (hsPkgs."ghci" or (errorHandler.buildDepError "ghci")) + ] ++ (if system.isWindows + then [ (hsPkgs."Win32" or (errorHandler.buildDepError "Win32")) ] + else [ (hsPkgs."unix" or (errorHandler.buildDepError "unix")) ]); + libs = pkgs.lib.optionals (flags.with-libzstd) (if flags.static-libzstd + then pkgs.lib.optional (!system.isOsx) (pkgs.":libzstd.a" or (errorHandler.sysDepError ":libzstd.a")) + else [ (pkgs."zstd" or (errorHandler.sysDepError "zstd")) ]); + build-tools = pkgs.lib.optionals (flags.build-tool-depends) [ + (hsPkgs.pkgsBuildBuild.alex.components.exes.alex or (pkgs.pkgsBuildBuild.alex or (errorHandler.buildToolDepError "alex:alex"))) + (hsPkgs.pkgsBuildBuild.happy.components.exes.happy or (pkgs.pkgsBuildBuild.happy or (errorHandler.buildToolDepError "happy:happy"))) + (hsPkgs.pkgsBuildBuild.genprimopcode.components.exes.genprimopcode or (pkgs.pkgsBuildBuild.genprimopcode or (errorHandler.buildToolDepError "genprimopcode:genprimopcode"))) + (hsPkgs.pkgsBuildBuild.deriveConstants.components.exes.deriveConstants or (pkgs.pkgsBuildBuild.deriveConstants or (errorHandler.buildToolDepError "deriveConstants:deriveConstants"))) + ]; + buildable = if flags.with-libzstd + then if flags.static-libzstd + then if system.isOsx then false else true + else true + else true; + }; + }; + } // rec { src = pkgs.lib.mkDefault ./.; } diff --git a/materialized/ghc-boot-packages-nix/ghc983llvm/ghci.nix b/materialized/ghc-boot-packages-nix/ghc983llvm/ghci.nix new file mode 100644 index 0000000000..a7a99f7cb6 --- /dev/null +++ b/materialized/ghc-boot-packages-nix/ghc983llvm/ghci.nix @@ -0,0 +1,45 @@ +{ system + , compiler + , flags + , pkgs + , hsPkgs + , pkgconfPkgs + , errorHandler + , config + , ... }: + { + flags = { internal-interpreter = false; }; + package = { + specVersion = "1.10"; + identifier = { name = "ghci"; version = "9.8.3"; }; + license = "BSD-3-Clause"; + copyright = ""; + maintainer = "ghc-devs@haskell.org"; + author = ""; + homepage = ""; + url = ""; + synopsis = "The library supporting GHC's interactive interpreter"; + description = "This library offers interfaces which mediate interactions between the\n@ghci@ interactive shell and @iserv@, GHC's out-of-process interpreter\nbackend."; + buildType = "Simple"; + }; + components = { + "library" = { + depends = [ + (hsPkgs."rts" or (errorHandler.buildDepError "rts")) + (hsPkgs."array" or (errorHandler.buildDepError "array")) + (hsPkgs."base" or (errorHandler.buildDepError "base")) + (hsPkgs."ghc-prim" or (errorHandler.buildDepError "ghc-prim")) + (hsPkgs."binary" or (errorHandler.buildDepError "binary")) + (hsPkgs."bytestring" or (errorHandler.buildDepError "bytestring")) + (hsPkgs."containers" or (errorHandler.buildDepError "containers")) + (hsPkgs."deepseq" or (errorHandler.buildDepError "deepseq")) + (hsPkgs."filepath" or (errorHandler.buildDepError "filepath")) + (hsPkgs."ghc-boot" or (errorHandler.buildDepError "ghc-boot")) + (hsPkgs."ghc-heap" or (errorHandler.buildDepError "ghc-heap")) + (hsPkgs."template-haskell" or (errorHandler.buildDepError "template-haskell")) + (hsPkgs."transformers" or (errorHandler.buildDepError "transformers")) + ] ++ pkgs.lib.optional (!system.isWindows) (hsPkgs."unix" or (errorHandler.buildDepError "unix")); + buildable = true; + }; + }; + } // rec { src = pkgs.lib.mkDefault ./.; } diff --git a/materialized/ghc-boot-packages-nix/ghc983llvm/hpc.nix b/materialized/ghc-boot-packages-nix/ghc983llvm/hpc.nix new file mode 100644 index 0000000000..f6b275cfd1 --- /dev/null +++ b/materialized/ghc-boot-packages-nix/ghc983llvm/hpc.nix @@ -0,0 +1,38 @@ +{ system + , compiler + , flags + , pkgs + , hsPkgs + , pkgconfPkgs + , errorHandler + , config + , ... }: + { + flags = {}; + package = { + specVersion = "2.2"; + identifier = { name = "hpc"; version = "0.7.0.0"; }; + license = "BSD-3-Clause"; + copyright = ""; + maintainer = "ghc-devs@haskell.org"; + author = "Andy Gill"; + homepage = ""; + url = ""; + synopsis = "Code Coverage Library for Haskell"; + description = "This package provides the code coverage library for Haskell.\n\nSee for more\ninformation."; + buildType = "Simple"; + }; + components = { + "library" = { + depends = [ + (hsPkgs."base" or (errorHandler.buildDepError "base")) + (hsPkgs."containers" or (errorHandler.buildDepError "containers")) + (hsPkgs."deepseq" or (errorHandler.buildDepError "deepseq")) + (hsPkgs."directory" or (errorHandler.buildDepError "directory")) + (hsPkgs."filepath" or (errorHandler.buildDepError "filepath")) + (hsPkgs."time" or (errorHandler.buildDepError "time")) + ]; + buildable = true; + }; + }; + } // rec { src = pkgs.lib.mkDefault ./.; } diff --git a/materialized/ghc-boot-packages-nix/ghc983llvm/integer-gmp.nix b/materialized/ghc-boot-packages-nix/ghc983llvm/integer-gmp.nix new file mode 100644 index 0000000000..94f930e70e --- /dev/null +++ b/materialized/ghc-boot-packages-nix/ghc983llvm/integer-gmp.nix @@ -0,0 +1,35 @@ +{ system + , compiler + , flags + , pkgs + , hsPkgs + , pkgconfPkgs + , errorHandler + , config + , ... }: + { + flags = {}; + package = { + specVersion = "2.0"; + identifier = { name = "integer-gmp"; version = "1.1"; }; + license = "BSD-3-Clause"; + copyright = ""; + maintainer = "hvr@gnu.org"; + author = "Herbert Valerio Riedel"; + homepage = "https://www.haskell.org/ghc/"; + url = ""; + synopsis = "Integer library based on GMP"; + description = "This package used to provide an implementation of the standard 'Integer'\ntype based on the\n.\n\nIt is now deprecated in favor of the 'ghc-bignum' package.\n\nIts purpose is to provide backward compatibility for codes directly\ndepending on the `integer-gmp` package."; + buildType = "Simple"; + }; + components = { + "library" = { + depends = [ + (hsPkgs."base" or (errorHandler.buildDepError "base")) + (hsPkgs."ghc-prim" or (errorHandler.buildDepError "ghc-prim")) + (hsPkgs."ghc-bignum" or (errorHandler.buildDepError "ghc-bignum")) + ]; + buildable = true; + }; + }; + } // rec { src = pkgs.lib.mkDefault ./.; } diff --git a/materialized/ghc-boot-packages-nix/ghc983llvm/iserv.nix b/materialized/ghc-boot-packages-nix/ghc983llvm/iserv.nix new file mode 100644 index 0000000000..297f43290c --- /dev/null +++ b/materialized/ghc-boot-packages-nix/ghc983llvm/iserv.nix @@ -0,0 +1,41 @@ +{ system + , compiler + , flags + , pkgs + , hsPkgs + , pkgconfPkgs + , errorHandler + , config + , ... }: + { + flags = {}; + package = { + specVersion = "1.10"; + identifier = { name = "iserv"; version = "9.8.3"; }; + license = "BSD-3-Clause"; + copyright = "XXX"; + maintainer = "XXX"; + author = "XXX"; + homepage = ""; + url = ""; + synopsis = "iserv allows GHC to delegate Template Haskell computations"; + description = "GHC can be provided with a path to the iserv binary with\n@-pgmi=/path/to/iserv-bin@, and will in combination with\n@-fexternal-interpreter@, compile Template Haskell though the\n@iserv-bin@ delegate. This is very similar to how ghcjs has been\ncompiling Template Haskell, by spawning a separate delegate (so\ncalled runner on the javascript vm) and evaluating the splices\nthere."; + buildType = "Simple"; + }; + components = { + exes = { + "iserv" = { + depends = [ + (hsPkgs."array" or (errorHandler.buildDepError "array")) + (hsPkgs."base" or (errorHandler.buildDepError "base")) + (hsPkgs."binary" or (errorHandler.buildDepError "binary")) + (hsPkgs."bytestring" or (errorHandler.buildDepError "bytestring")) + (hsPkgs."containers" or (errorHandler.buildDepError "containers")) + (hsPkgs."deepseq" or (errorHandler.buildDepError "deepseq")) + (hsPkgs."ghci" or (errorHandler.buildDepError "ghci")) + ] ++ pkgs.lib.optional (!system.isWindows) (hsPkgs."unix" or (errorHandler.buildDepError "unix")); + buildable = true; + }; + }; + }; + } // rec { src = pkgs.lib.mkDefault ./.; } diff --git a/materialized/ghc-boot-packages-nix/ghc983llvm/remote-iserv.nix b/materialized/ghc-boot-packages-nix/ghc983llvm/remote-iserv.nix new file mode 100644 index 0000000000..bfce58fa33 --- /dev/null +++ b/materialized/ghc-boot-packages-nix/ghc983llvm/remote-iserv.nix @@ -0,0 +1,36 @@ +{ system + , compiler + , flags + , pkgs + , hsPkgs + , pkgconfPkgs + , errorHandler + , config + , ... }: + { + flags = {}; + package = { + specVersion = "1.10"; + identifier = { name = "remote-iserv"; version = "9.8.3"; }; + license = "BSD-3-Clause"; + copyright = "XXX"; + maintainer = "Moritz Angermann "; + author = "Moritz Angermann "; + homepage = ""; + url = ""; + synopsis = "iserv allows GHC to delegate Template Haskell computations"; + description = "This is a very simple remote runner for iserv, to be used together\nwith iserv-proxy. The foundamental idea is that this this wrapper\nstarts running the GHCi server on a given port to which iserv-proxy will\nthen connect."; + buildType = "Simple"; + }; + components = { + exes = { + "remote-iserv" = { + depends = [ + (hsPkgs."base" or (errorHandler.buildDepError "base")) + (hsPkgs."ghci" or (errorHandler.buildDepError "ghci")) + ]; + buildable = true; + }; + }; + }; + } // rec { src = pkgs.lib.mkDefault ./.; } diff --git a/materialized/ghc-boot-packages-nix/ghc983llvm/template-haskell.nix b/materialized/ghc-boot-packages-nix/ghc983llvm/template-haskell.nix new file mode 100644 index 0000000000..3e26556434 --- /dev/null +++ b/materialized/ghc-boot-packages-nix/ghc983llvm/template-haskell.nix @@ -0,0 +1,36 @@ +{ system + , compiler + , flags + , pkgs + , hsPkgs + , pkgconfPkgs + , errorHandler + , config + , ... }: + { + flags = {}; + package = { + specVersion = "1.10"; + identifier = { name = "template-haskell"; version = "2.21.0.0"; }; + license = "BSD-3-Clause"; + copyright = ""; + maintainer = "libraries@haskell.org"; + author = ""; + homepage = ""; + url = ""; + synopsis = "Support library for Template Haskell"; + description = "This package provides modules containing facilities for manipulating\nHaskell source code using Template Haskell.\n\nSee for more\ninformation."; + buildType = "Simple"; + }; + components = { + "library" = { + depends = [ + (hsPkgs."base" or (errorHandler.buildDepError "base")) + (hsPkgs."ghc-boot-th" or (errorHandler.buildDepError "ghc-boot-th")) + (hsPkgs."ghc-prim" or (errorHandler.buildDepError "ghc-prim")) + (hsPkgs."pretty" or (errorHandler.buildDepError "pretty")) + ]; + buildable = true; + }; + }; + } // rec { src = pkgs.lib.mkDefault ./.; } From 72a3838933578027947ea7f4b4d9a0f476be5920 Mon Sep 17 00:00:00 2001 From: Hamish Mackenzie Date: Fri, 25 Oct 2024 00:14:29 +1300 Subject: [PATCH 21/50] Build ghc983 cross compilers with ghc983 --- overlays/bootstrap.nix | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/overlays/bootstrap.nix b/overlays/bootstrap.nix index 30ab5138e3..38cb77431a 100644 --- a/overlays/bootstrap.nix +++ b/overlays/bootstrap.nix @@ -829,7 +829,7 @@ in { bootPkgs = bootPkgsGhc94 // { ghc = if final.stdenv.buildPlatform != final.stdenv.targetPlatform - then final.buildPackages.buildPackages.haskell-nix.compiler.ghc966 + then final.buildPackages.buildPackages.haskell-nix.compiler.ghc983 else final.buildPackages.buildPackages.haskell.compiler.ghc966 or final.buildPackages.buildPackages.haskell.compiler.ghc965 or final.buildPackages.buildPackages.haskell.compiler.ghc964 From ef2e2f87283d3c35122fb44497fc3b7e91e9ca6c Mon Sep 17 00:00:00 2001 From: Hamish Mackenzie Date: Fri, 25 Oct 2024 00:35:38 +1300 Subject: [PATCH 22/50] Patch upper bounds --- overlays/bootstrap.nix | 9 +++---- .../ghc/ghc-9.8.3-text-upper-bound.patch | 24 +++++++++++++++++++ 2 files changed, 29 insertions(+), 4 deletions(-) create mode 100644 overlays/patches/ghc/ghc-9.8.3-text-upper-bound.patch diff --git a/overlays/bootstrap.nix b/overlays/bootstrap.nix index 38cb77431a..6edb412886 100644 --- a/overlays/bootstrap.nix +++ b/overlays/bootstrap.nix @@ -255,10 +255,11 @@ in { ++ onWindowsOrMusl (fromUntil "9.8.2" "9.11" ./patches/ghc/ghc-9.6-0006-Adds-support-for-Hidden-symbols.patch) ++ onWindowsOrMusl (fromUntil "9.6" "9.7" ./patches/ghc/ghc-9.6-0006-Adds-support-for-Hidden-symbols-2.patch) ++ onWindowsOrMusl (fromUntil "9.8.2" "9.11" ./patches/ghc/ghc-9.6-0006-Adds-support-for-Hidden-symbols-2.patch) - ++ fromUntil "9.9" "9.11" ./patches/ghc/ghc-9.9-Cabal-3.11.patch - ++ fromUntil "9.8" "9.8.3" ./patches/ghc/ghc-9.8-text-upper-bound.patch - ++ fromUntil "9.10" "9.11" ./patches/ghc/ghc-9.10-containers-upper-bound.patch - ++ fromUntil "9.10" "9.14" ./patches/ghc/ghc-9.10-merge-objects.patch + ++ fromUntil "9.9" "9.11" ./patches/ghc/ghc-9.9-Cabal-3.11.patch + ++ fromUntil "9.8" "9.8.3" ./patches/ghc/ghc-9.8-text-upper-bound.patch + ++ fromUntil "9.8.3" "9.10" ./patches/ghc/ghc-9.8.3-text-upper-bound.patch + ++ fromUntil "9.10" "9.11" ./patches/ghc/ghc-9.10-containers-upper-bound.patch + ++ fromUntil "9.10" "9.14" ./patches/ghc/ghc-9.10-merge-objects.patch # This patch will make windows stop emitting absolute relocations. This is one way in which binutils 2.36+ (with ASLR enabled), will just choke on the # assembly we generate because it's always absolute (32bit) addressing modes. diff --git a/overlays/patches/ghc/ghc-9.8.3-text-upper-bound.patch b/overlays/patches/ghc/ghc-9.8.3-text-upper-bound.patch new file mode 100644 index 0000000000..9a78784dad --- /dev/null +++ b/overlays/patches/ghc/ghc-9.8.3-text-upper-bound.patch @@ -0,0 +1,24 @@ +diff --git a/linters/lint-commit-msg/lint-commit-msg.cabal b/linters/lint-commit-msg/lint-commit-msg.cabal +index 7d1dbd0fcb..861ad6f03d 100644 +--- a/linters/lint-commit-msg/lint-commit-msg.cabal ++++ b/linters/lint-commit-msg/lint-commit-msg.cabal +@@ -26,4 +26,4 @@ executable lint-commit-msg + base + >= 4.14 && < 5, + text +- >= 1.2 && < 2.1 ++ >= 1.2 && < 2.2 +diff --git a/linters/lint-submodule-refs/lint-submodule-refs.cabal b/linters/lint-submodule-refs/lint-submodule-refs.cabal +index ce4012adfc..9ff85d2731 100644 +--- a/linters/lint-submodule-refs/lint-submodule-refs.cabal ++++ b/linters/lint-submodule-refs/lint-submodule-refs.cabal +@@ -15,7 +15,7 @@ executable lint-submodule-refs + base + >= 4.14 && < 5, + text +- >= 1.2 && < 2.1, ++ >= 1.2 && < 2.2, + linters-common + + ghc-options: + From b9d654d6bf96985e98e060df1631d464020884cc Mon Sep 17 00:00:00 2001 From: Hamish Mackenzie Date: Fri, 25 Oct 2024 09:00:48 +1300 Subject: [PATCH 23/50] ifdLevel 2 --- flake.nix | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/flake.nix b/flake.nix index c9235935ae..eafbf034cb 100644 --- a/flake.nix +++ b/flake.nix @@ -83,7 +83,7 @@ let callFlake = import flake-compat; - ifdLevel = 1; + ifdLevel = 2; runningHydraEvalTest = false; defaultCompiler = "ghc928"; config = import ./config.nix; From c177a3146e7e7321ba09f88622d70d492ec82087 Mon Sep 17 00:00:00 2001 From: Hamish Mackenzie Date: Fri, 25 Oct 2024 13:43:35 +1300 Subject: [PATCH 24/50] Disable broken tests --- test/plugin/default.nix | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/test/plugin/default.nix b/test/plugin/default.nix index 893e85de42..a611aaa2d3 100644 --- a/test/plugin/default.nix +++ b/test/plugin/default.nix @@ -20,7 +20,7 @@ in recurseIntoAttrs { # Not sure why this breaks for ghc 8.10.7 meta.disabled = compiler-nix-name == "ghc8107" - || builtins.elem compiler-nix-name [ "ghc91120240918" ] + || builtins.elem compiler-nix-name [ "ghc91220241014" "ghc91320241022" ] || stdenv.hostPlatform.isMusl || stdenv.hostPlatform.isGhcjs || stdenv.hostPlatform.isWindows From 15ac87511a4c7d215039a981eef2c06a0f7ad83c Mon Sep 17 00:00:00 2001 From: Hamish Mackenzie Date: Fri, 25 Oct 2024 13:44:35 +1300 Subject: [PATCH 25/50] ifdLevel 3 --- flake.nix | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/flake.nix b/flake.nix index eafbf034cb..4d7a252e95 100644 --- a/flake.nix +++ b/flake.nix @@ -83,7 +83,7 @@ let callFlake = import flake-compat; - ifdLevel = 2; + ifdLevel = 3; runningHydraEvalTest = false; defaultCompiler = "ghc928"; config = import ./config.nix; From 0ec35932e4fdb866ebddb74bac4affa1d7cf4dcc Mon Sep 17 00:00:00 2001 From: Hamish Mackenzie Date: Fri, 25 Oct 2024 16:59:57 +1300 Subject: [PATCH 26/50] Fix cabal-latests --- build.nix | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/build.nix b/build.nix index 4ddf83746f..968c1399da 100644 --- a/build.nix +++ b/build.nix @@ -28,7 +28,7 @@ in rec { pkgs.recurseIntoAttrs ({ cabal-latest = tool compiler-nix-name "cabal" ({ inherit evalPackages; - } // pkgs.lib.optionalAttrs (ghcFromTo "9.10" "9.12") { + } // pkgs.lib.optionalAttrs (ghcFromTo "9.12" "9.13") { cabalProjectLocal = builtins.readFile ./test/cabal.project.local; }); } // pkgs.lib.optionalAttrs (__compareVersions haskell.compiler.${compiler-nix-name}.version "9.8" < 0) { From c193e8287c2fa34ce32ca4b8f4ab70e6194e61d2 Mon Sep 17 00:00:00 2001 From: Hamish Mackenzie Date: Fri, 25 Oct 2024 19:21:35 +1300 Subject: [PATCH 27/50] Update head.hackage --- test/cabal.project.local | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/test/cabal.project.local b/test/cabal.project.local index eeeccc821c..3375b585f4 100644 --- a/test/cabal.project.local +++ b/test/cabal.project.local @@ -24,7 +24,7 @@ repository head.hackage.ghc.haskell.org f76d08be13e9a61a377a85e2fb63f4c5435d40f8feb3e12eb05905edb8cdea89 26021a13b401500c8eb2761ca95c61f2d625bfef951b939a8124ed12ecf07329 7541f32a4ccca4f97aea3b22f5e593ba2c0267546016b992dfadcd2fe944e55d - --sha256: sha256-IAYzsKIkZOgcNFuRkmwziLdwgU8tEe6vnhx+bugTSTw= + --sha256: sha256-rWkiXr/kSXKAPhf5jnx/E87BbqyRM7SKhuMZxo0gL2U= repository ghcjs-overlay url: https://raw.githubusercontent.com/input-output-hk/hackage-overlay-ghcjs/56cd424e8529e7a1fc29c6126abdc66f09467306 From 45cf189eae441792dfbdeadda414ada59160f2d2 Mon Sep 17 00:00:00 2001 From: Hamish Mackenzie Date: Tue, 29 Oct 2024 23:49:32 +1300 Subject: [PATCH 28/50] Disable HLS for ghc 9.8.3 for now --- build.nix | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/build.nix b/build.nix index 968c1399da..686c77f276 100644 --- a/build.nix +++ b/build.nix @@ -62,7 +62,7 @@ in rec { inherit evalPackages; src = pkgs.haskell-nix.sources."hls-2.2"; }; - } // pkgs.lib.optionalAttrs (ghcFromTo "9.0" "9.11") { + } // pkgs.lib.optionalAttrs (ghcFromTo "9.0" "9.8.3" || ghcFromTo "9.10" "9.11") { "hls-29" = tool compiler-nix-name "haskell-language-server" { inherit evalPackages; src = pkgs.haskell-nix.sources."hls-2.9"; From 3236cda8d0e78eb86c4ec493854df548ca696f3b Mon Sep 17 00:00:00 2001 From: Hamish Mackenzie Date: Tue, 29 Oct 2024 23:50:50 +1300 Subject: [PATCH 29/50] Update nixpkgs-unstable and fix issue with no libcxxabi --- compiler/ghc/default.nix | 2 +- flake.lock | 6 +++--- 2 files changed, 4 insertions(+), 4 deletions(-) diff --git a/compiler/ghc/default.nix b/compiler/ghc/default.nix index ef2c6b34b5..420e802697 100644 --- a/compiler/ghc/default.nix +++ b/compiler/ghc/default.nix @@ -9,7 +9,7 @@ let self = # build-tools , bootPkgs , buildPackages -, autoconf, automake, coreutils, fetchurl, fetchpatch, perl, python3, m4, sphinx, numactl, elfutils, libcxx, libcxxabi +, autoconf, automake, coreutils, fetchurl, fetchpatch, perl, python3, m4, sphinx, numactl, elfutils, libcxx, libcxxabi ? throw "No libcxxabi" , autoreconfHook , bash diff --git a/flake.lock b/flake.lock index 08d22fef22..87b962898c 100644 --- a/flake.lock +++ b/flake.lock @@ -557,11 +557,11 @@ }, "nixpkgs-unstable": { "locked": { - "lastModified": 1729265718, - "narHash": "sha256-4HQI+6LsO3kpWTYuVGIzhJs1cetFcwT7quWCk/6rqeo=", + "lastModified": 1729980323, + "narHash": "sha256-eWPRZAlhf446bKSmzw6x7RWEE4IuZgAp8NW3eXZwRAY=", "owner": "NixOS", "repo": "nixpkgs", - "rev": "ccc0c2126893dd20963580b6478d1a10a4512185", + "rev": "86e78d3d2084ff87688da662cf78c2af085d8e73", "type": "github" }, "original": { From 329d7f00a6631616e1ecb97e02fe5ea6c3a28a58 Mon Sep 17 00:00:00 2001 From: Hamish Mackenzie Date: Tue, 29 Oct 2024 23:51:07 +1300 Subject: [PATCH 30/50] Bump ghcjs-overlay and head.hackage --- test/cabal.project.local | 6 +++--- 1 file changed, 3 insertions(+), 3 deletions(-) diff --git a/test/cabal.project.local b/test/cabal.project.local index 3375b585f4..74cec3ddc5 100644 --- a/test/cabal.project.local +++ b/test/cabal.project.local @@ -24,14 +24,14 @@ repository head.hackage.ghc.haskell.org f76d08be13e9a61a377a85e2fb63f4c5435d40f8feb3e12eb05905edb8cdea89 26021a13b401500c8eb2761ca95c61f2d625bfef951b939a8124ed12ecf07329 7541f32a4ccca4f97aea3b22f5e593ba2c0267546016b992dfadcd2fe944e55d - --sha256: sha256-rWkiXr/kSXKAPhf5jnx/E87BbqyRM7SKhuMZxo0gL2U= + --sha256: sha256-aAxiXXxG6iWgjrdFYbBkXruUtA7BUUc/JjpJsQZWUC8= repository ghcjs-overlay - url: https://raw.githubusercontent.com/input-output-hk/hackage-overlay-ghcjs/56cd424e8529e7a1fc29c6126abdc66f09467306 + url: https://raw.githubusercontent.com/input-output-hk/hackage-overlay-ghcjs/ffb32dce467b9a4d27be759fdd2740a6edd09d0b secure: True root-keys: key-threshold: 0 - --sha256: sha256-nU0/HKy4Om1GohCcU+gUWCDPgyclYdFzAgzfXe0tgf0= + --sha256: sha256-mHxgsrbjHdyE8yqOkhZsk4WGKGZDFqSn07ENMPy1rVA= if os(ghcjs) extra-packages: ghci From 38be99b74573e366aba823e94b622e5fbf3fc865 Mon Sep 17 00:00:00 2001 From: Hamish Mackenzie Date: Tue, 29 Oct 2024 23:56:20 +1300 Subject: [PATCH 31/50] Enable external-static-plugin test for GHC >=9.6 (Fixes #2265) --- test/external-static-plugin/default.nix | 8 ++++---- 1 file changed, 4 insertions(+), 4 deletions(-) diff --git a/test/external-static-plugin/default.nix b/test/external-static-plugin/default.nix index d5a4ac7384..d1ba999259 100644 --- a/test/external-static-plugin/default.nix +++ b/test/external-static-plugin/default.nix @@ -1,4 +1,4 @@ -{ cabalProject', testSrc, compiler-nix-name, evalPackages, recurseIntoAttrs, haskellLib }: let +{ cabalProject', testSrc, compiler-nix-name, buildPackages evalPackages, recurseIntoAttrs, haskellLib }: let project = cabalProject' { src = testSrc "external-static-plugin"; inherit compiler-nix-name evalPackages; @@ -19,9 +19,9 @@ in recurseIntoAttrs { inherit (project) plan-nix; }; - meta.disabled = !(builtins.elem compiler-nix-name [ - "ghc810420210212" - ]) || haskellLib.isCrossHost; + meta.disabled = + __compareVersions buildPackages.haskell-nix.compiler.${compiler-nix-name}.version "9.6" < 0 + || haskellLib.isCrossHost; build = project.hsPkgs.prog.components.exes.prog; } From 3209fe17a3c6cebccea77b84e62071377ad2918d Mon Sep 17 00:00:00 2001 From: Hamish Mackenzie Date: Wed, 30 Oct 2024 12:18:53 +1300 Subject: [PATCH 32/50] Bump head.hackage --- test/cabal.project.local | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/test/cabal.project.local b/test/cabal.project.local index 74cec3ddc5..11e3517564 100644 --- a/test/cabal.project.local +++ b/test/cabal.project.local @@ -24,7 +24,7 @@ repository head.hackage.ghc.haskell.org f76d08be13e9a61a377a85e2fb63f4c5435d40f8feb3e12eb05905edb8cdea89 26021a13b401500c8eb2761ca95c61f2d625bfef951b939a8124ed12ecf07329 7541f32a4ccca4f97aea3b22f5e593ba2c0267546016b992dfadcd2fe944e55d - --sha256: sha256-aAxiXXxG6iWgjrdFYbBkXruUtA7BUUc/JjpJsQZWUC8= + --sha256: sha256-sC9Zntqgw99e+9iRjesMcnSk4oxO7EpgDIlJmhqi29s= repository ghcjs-overlay url: https://raw.githubusercontent.com/input-output-hk/hackage-overlay-ghcjs/ffb32dce467b9a4d27be759fdd2740a6edd09d0b From 79330b4df6b6f83eb82ba21cc0b851d925a08e8c Mon Sep 17 00:00:00 2001 From: Hamish Mackenzie Date: Wed, 30 Oct 2024 17:19:52 +1300 Subject: [PATCH 33/50] Fix external-static-plugin test --- test/external-static-plugin/default.nix | 2 +- test/external-static-plugin/plugin/src/Plugin.hs | 3 +-- test/external-static-plugin/prog/prog.cabal | 3 ++- 3 files changed, 4 insertions(+), 4 deletions(-) diff --git a/test/external-static-plugin/default.nix b/test/external-static-plugin/default.nix index d1ba999259..6f0307a4c9 100644 --- a/test/external-static-plugin/default.nix +++ b/test/external-static-plugin/default.nix @@ -1,4 +1,4 @@ -{ cabalProject', testSrc, compiler-nix-name, buildPackages evalPackages, recurseIntoAttrs, haskellLib }: let +{ cabalProject', testSrc, compiler-nix-name, buildPackages, evalPackages, recurseIntoAttrs, haskellLib }: let project = cabalProject' { src = testSrc "external-static-plugin"; inherit compiler-nix-name evalPackages; diff --git a/test/external-static-plugin/plugin/src/Plugin.hs b/test/external-static-plugin/plugin/src/Plugin.hs index 391a653ec1..1041ed4263 100644 --- a/test/external-static-plugin/plugin/src/Plugin.hs +++ b/test/external-static-plugin/plugin/src/Plugin.hs @@ -1,7 +1,6 @@ module Plugin (plugin) where -import GhcPlugins -import MonadUtils +import GHC.Plugins import System.IO import Control.Monad diff --git a/test/external-static-plugin/prog/prog.cabal b/test/external-static-plugin/prog/prog.cabal index 147b7007eb..487f1ce0a1 100644 --- a/test/external-static-plugin/prog/prog.cabal +++ b/test/external-static-plugin/prog/prog.cabal @@ -7,6 +7,7 @@ extra-source-files: CHANGELOG.md executable prog main-is: Main.hs - build-depends: base + build-depends: base, plugin hs-source-dirs: app + ghc-options: -fplugin=Plugin -fplugin-opt=Plugin:f1 -fplugin-opt=Plugin:f2 default-language: Haskell2010 From 37e1d86771ecd3c73e83d9fa4f364603ddb1188f Mon Sep 17 00:00:00 2001 From: Hamish Mackenzie Date: Wed, 30 Oct 2024 17:34:30 +1300 Subject: [PATCH 34/50] Fix external-static-plugin test --- test/external-static-plugin/default.nix | 5 ----- 1 file changed, 5 deletions(-) diff --git a/test/external-static-plugin/default.nix b/test/external-static-plugin/default.nix index 6f0307a4c9..1eff8ab632 100644 --- a/test/external-static-plugin/default.nix +++ b/test/external-static-plugin/default.nix @@ -3,11 +3,6 @@ src = testSrc "external-static-plugin"; inherit compiler-nix-name evalPackages; modules = [ { - packages.prog.components.exes.prog.plugins = [ { - inherit (project.hsPkgs.plugin.components) library; - moduleName = "Plugin"; - args = [ "f1" "f2" ]; - } ]; packages.prog.postInstall = '' test -f f1 test -f f2 From 97439a466c94114782eb310f65cb64031c21acaa Mon Sep 17 00:00:00 2001 From: Hamish Mackenzie Date: Wed, 30 Oct 2024 17:46:26 +1300 Subject: [PATCH 35/50] Fix eval issue with latest nixpkgs --- builder/shell-for.nix | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/builder/shell-for.nix b/builder/shell-for.nix index 141186a0b1..40481233e8 100644 --- a/builder/shell-for.nix +++ b/builder/shell-for.nix @@ -1,4 +1,4 @@ -{ lib, stdenv, mkShell, glibcLocales, pkgconfig, ghcForComponent, makeConfigFiles, hsPkgs, hoogleLocal, haskellLib, pkgsBuildBuild, evalPackages, compiler }: +{ lib, stdenv, mkShell, glibcLocales, ghcForComponent, makeConfigFiles, hsPkgs, hoogleLocal, haskellLib, pkgsBuildBuild, evalPackages, compiler }: { # `packages` function selects packages that will be worked on in the shell itself. # These packages will not be built by `shellFor`, but their From 0f0a5fb6661615225c35e73164ea3430c7ab767a Mon Sep 17 00:00:00 2001 From: Hamish Mackenzie Date: Wed, 30 Oct 2024 23:06:29 +1300 Subject: [PATCH 36/50] Skip th-dlls test for ghc 9.12 and head brances --- test/th-dlls/default.nix | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/test/th-dlls/default.nix b/test/th-dlls/default.nix index 5d7cf300e8..88ec1adbd2 100644 --- a/test/th-dlls/default.nix +++ b/test/th-dlls/default.nix @@ -28,7 +28,7 @@ in recurseIntoAttrs { || (compiler-nix-name == "ghc8107" && stdenv.hostPlatform.isWindows) # We need to update GHC HEAD to get a version of ghc-internal compatible # with th-lift from head.hackage. - || compiler-nix-name == "ghc91120240918" + || builtins.elem compiler-nix-name [ "ghc91220241014" "ghc91320241022" ] ; ifdInputs = { From 9ea5cb684c734e7a58a21c97c93ae7570e9ed45a Mon Sep 17 00:00:00 2001 From: Hamish Mackenzie Date: Wed, 30 Oct 2024 23:19:16 +1300 Subject: [PATCH 37/50] Fix HLS test --- test/haskell-language-server/cabal.nix | 6 +++--- 1 file changed, 3 insertions(+), 3 deletions(-) diff --git a/test/haskell-language-server/cabal.nix b/test/haskell-language-server/cabal.nix index 815ffe55fc..2dc5edb9dd 100644 --- a/test/haskell-language-server/cabal.nix +++ b/test/haskell-language-server/cabal.nix @@ -3,8 +3,7 @@ let project = haskell-nix.cabalProject' { inherit compiler-nix-name evalPackages; name = "haskell-language-server"; - src = haskell-nix.sources."hls-2.8"; - configureArgs = "--disable-benchmarks --disable-tests"; + src = haskell-nix.sources."hls-2.9"; }; in recurseIntoAttrs { ifdInputs = { @@ -16,5 +15,6 @@ in recurseIntoAttrs { meta.disabled = stdenv.hostPlatform != stdenv.buildPlatform || __compareVersions buildPackages.haskell-nix.compiler.${compiler-nix-name}.version "9.0.1" < 0 - || __compareVersions buildPackages.haskell-nix.compiler.${compiler-nix-name}.version "9.9.0" >= 0; + || __compareVersions buildPackages.haskell-nix.compiler.${compiler-nix-name}.version "9.11.0" >= 0 + || compiler-nix-name == "ghc983"; } From 13cd1d6f57e2d2e53df5c9e0b93a08fcccf30215 Mon Sep 17 00:00:00 2001 From: Hamish Mackenzie Date: Wed, 30 Oct 2024 23:54:46 +1300 Subject: [PATCH 38/50] Fix hls test --- test/haskell-language-server/cabal.nix | 1 + 1 file changed, 1 insertion(+) diff --git a/test/haskell-language-server/cabal.nix b/test/haskell-language-server/cabal.nix index 2dc5edb9dd..da938755c6 100644 --- a/test/haskell-language-server/cabal.nix +++ b/test/haskell-language-server/cabal.nix @@ -4,6 +4,7 @@ let inherit compiler-nix-name evalPackages; name = "haskell-language-server"; src = haskell-nix.sources."hls-2.9"; + configureArgs = "--disable-benchmarks --disable-tests"; # This makes cabalProject' more like the `tool` function }; in recurseIntoAttrs { ifdInputs = { From d7649b78b3e14d04e021b2507f6326812818418b Mon Sep 17 00:00:00 2001 From: Hamish Mackenzie Date: Sat, 2 Nov 2024 00:12:59 +1300 Subject: [PATCH 39/50] Bump head.hackage --- test/cabal.project.local | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/test/cabal.project.local b/test/cabal.project.local index 11e3517564..3d00eb2790 100644 --- a/test/cabal.project.local +++ b/test/cabal.project.local @@ -24,7 +24,7 @@ repository head.hackage.ghc.haskell.org f76d08be13e9a61a377a85e2fb63f4c5435d40f8feb3e12eb05905edb8cdea89 26021a13b401500c8eb2761ca95c61f2d625bfef951b939a8124ed12ecf07329 7541f32a4ccca4f97aea3b22f5e593ba2c0267546016b992dfadcd2fe944e55d - --sha256: sha256-sC9Zntqgw99e+9iRjesMcnSk4oxO7EpgDIlJmhqi29s= + --sha256: sha256-Kd4h2DJXtxkeBzSxDe9LlT8XTh111RnNqRNoxtCB7NY= repository ghcjs-overlay url: https://raw.githubusercontent.com/input-output-hk/hackage-overlay-ghcjs/ffb32dce467b9a4d27be759fdd2740a6edd09d0b From 1566d494c563c99ec204aa31a26797e1932247e8 Mon Sep 17 00:00:00 2001 From: Hamish Mackenzie Date: Sat, 2 Nov 2024 13:15:31 +1300 Subject: [PATCH 40/50] Bump head.hackage --- test/cabal.project.local | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/test/cabal.project.local b/test/cabal.project.local index 3d00eb2790..d03ab6c2cb 100644 --- a/test/cabal.project.local +++ b/test/cabal.project.local @@ -24,7 +24,7 @@ repository head.hackage.ghc.haskell.org f76d08be13e9a61a377a85e2fb63f4c5435d40f8feb3e12eb05905edb8cdea89 26021a13b401500c8eb2761ca95c61f2d625bfef951b939a8124ed12ecf07329 7541f32a4ccca4f97aea3b22f5e593ba2c0267546016b992dfadcd2fe944e55d - --sha256: sha256-Kd4h2DJXtxkeBzSxDe9LlT8XTh111RnNqRNoxtCB7NY= + --sha256: sha256-3sLKfBBTFmzRWgGpPcNBaMZ9HXw6xTIzlKvopQxA2LM= repository ghcjs-overlay url: https://raw.githubusercontent.com/input-output-hk/hackage-overlay-ghcjs/ffb32dce467b9a4d27be759fdd2740a6edd09d0b From 8a7a7a525a5d2370b59a95251b2b0af14ac241ee Mon Sep 17 00:00:00 2001 From: Hamish Mackenzie Date: Sat, 2 Nov 2024 15:48:24 +1300 Subject: [PATCH 41/50] Bump GHC git pins --- flake.nix | 2 +- lazy-inputs/ghc913/flake.lock | 8 ++++---- 2 files changed, 5 insertions(+), 5 deletions(-) diff --git a/flake.nix b/flake.nix index 4d7a252e95..c9235935ae 100644 --- a/flake.nix +++ b/flake.nix @@ -83,7 +83,7 @@ let callFlake = import flake-compat; - ifdLevel = 3; + ifdLevel = 1; runningHydraEvalTest = false; defaultCompiler = "ghc928"; config = import ./config.nix; diff --git a/lazy-inputs/ghc913/flake.lock b/lazy-inputs/ghc913/flake.lock index 00625dbdea..e64ad1b7b0 100644 --- a/lazy-inputs/ghc913/flake.lock +++ b/lazy-inputs/ghc913/flake.lock @@ -3,11 +3,11 @@ "ghc913": { "flake": false, "locked": { - "lastModified": 1729558540, - "narHash": "sha256-AgGMQro2YyO2qR7YTd1JuF4X1V14AUYsnakb+1BOGB0=", + "lastModified": 1730499133, + "narHash": "sha256-vROyv1V9bxMblJukZmg79ArEcRSwAWk/4JXlMRgfCqg=", "ref": "refs/heads/master", - "rev": "148059fea534aced44649c739cd0fad4c25a99f0", - "revCount": 67457, + "rev": "778ac793289934eb89f904cee4b8d4162b0539fa", + "revCount": 67494, "submodules": true, "type": "git", "url": "https://gitlab.haskell.org/ghc/ghc" From c0ea40d07e36fbe7c14177e7ad3ec5d68057a439 Mon Sep 17 00:00:00 2001 From: Hamish Mackenzie Date: Sat, 2 Nov 2024 22:32:45 +1300 Subject: [PATCH 42/50] ifdLevel 2 --- ci.nix | 2 +- flake.nix | 2 +- 2 files changed, 2 insertions(+), 2 deletions(-) diff --git a/ci.nix b/ci.nix index 4cba2038ab..7526274df1 100644 --- a/ci.nix +++ b/ci.nix @@ -90,7 +90,7 @@ inherit (lib.systems.examples) ghcjs; } // lib.optionalAttrs ( (__match ".*llvm" compiler-nix-name == null) - && ((system == "x86_64-linux" && !builtins.elem compiler-nix-name ["ghc884" "ghc902" "ghc928" "ghc91220241014" "ghc91320241022"]) # Including GHC HEAD here because the patches for rts/RtsSymbols.c no longer apply and mingwW64 GHC build fails without them + && ((system == "x86_64-linux" && !builtins.elem compiler-nix-name ["ghc884" "ghc902" "ghc928" "ghc91220241014" "ghc91320241101"]) # Including GHC HEAD here because the patches for rts/RtsSymbols.c no longer apply and mingwW64 GHC build fails without them || (system == "x86_64-darwin" && builtins.elem compiler-nix-name []))) { # TODO add ghc versions when we have more darwin build capacity inherit (lib.systems.examples) mingwW64; } // lib.optionalAttrs (nixpkgsName == "unstable" diff --git a/flake.nix b/flake.nix index c9235935ae..eafbf034cb 100644 --- a/flake.nix +++ b/flake.nix @@ -83,7 +83,7 @@ let callFlake = import flake-compat; - ifdLevel = 1; + ifdLevel = 2; runningHydraEvalTest = false; defaultCompiler = "ghc928"; config = import ./config.nix; From 57f689e42ade575e12fc3355253d11008e122790 Mon Sep 17 00:00:00 2001 From: Hamish Mackenzie Date: Sun, 3 Nov 2024 13:47:31 +1300 Subject: [PATCH 43/50] ifdLevel 3 --- flake.nix | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/flake.nix b/flake.nix index eafbf034cb..4d7a252e95 100644 --- a/flake.nix +++ b/flake.nix @@ -83,7 +83,7 @@ let callFlake = import flake-compat; - ifdLevel = 2; + ifdLevel = 3; runningHydraEvalTest = false; defaultCompiler = "ghc928"; config = import ./config.nix; From 2a460e6d69760f35ecec060a7bff018b02a81f76 Mon Sep 17 00:00:00 2001 From: Hamish Mackenzie Date: Mon, 4 Nov 2024 10:21:50 +1300 Subject: [PATCH 44/50] Add hackage-quirk for #2277 --- modules/hackage-quirks.nix | 8 ++++++++ test/cabal-simple/default.nix | 2 +- test/cabal.project.local | 2 +- test/shell-for-setup-deps/default.nix | 2 +- test/shell-for/default.nix | 3 --- 5 files changed, 11 insertions(+), 6 deletions(-) diff --git a/modules/hackage-quirks.nix b/modules/hackage-quirks.nix index 2d7baf253f..109479d4d1 100644 --- a/modules/hackage-quirks.nix +++ b/modules/hackage-quirks.nix @@ -30,6 +30,14 @@ in [ { _file = "haskell.nix/overlays/hackage-quirks.nix#${n}"; } // lib.mkIf (n == config.name) v) { + # See https://github.com/input-output-hk/haskell.nix/issues/2277 + hoogle = { + cabalProject = '' + packages: . + constraints: data-default-class >=0.2.0.0 + ''; + }; + lsp-test = { cabalProject = '' packages: . diff --git a/test/cabal-simple/default.nix b/test/cabal-simple/default.nix index 8e1af7e40b..c98578cfe6 100644 --- a/test/cabal-simple/default.nix +++ b/test/cabal-simple/default.nix @@ -33,7 +33,7 @@ in recurseIntoAttrs { test-shell = (project.shellFor { tools = { cabal = { cabalProjectLocal = builtins.readFile ../cabal.project.local; }; - hoogle = { cabalProjectLocal = builtins.readFile ../cabal.project.local; index-state = "2024-10-26T00:00:00Z"; }; + hoogle = { cabalProjectLocal = builtins.readFile ../cabal.project.local; }; }; withHoogle = true; }).overrideAttrs (_: _: { diff --git a/test/cabal.project.local b/test/cabal.project.local index d03ab6c2cb..6f70e2c541 100644 --- a/test/cabal.project.local +++ b/test/cabal.project.local @@ -24,7 +24,7 @@ repository head.hackage.ghc.haskell.org f76d08be13e9a61a377a85e2fb63f4c5435d40f8feb3e12eb05905edb8cdea89 26021a13b401500c8eb2761ca95c61f2d625bfef951b939a8124ed12ecf07329 7541f32a4ccca4f97aea3b22f5e593ba2c0267546016b992dfadcd2fe944e55d - --sha256: sha256-3sLKfBBTFmzRWgGpPcNBaMZ9HXw6xTIzlKvopQxA2LM= + --sha256: sha256-kFayk9sOpeopLOXQG8yyTqRwEBLKsQOR+6efzbm6YxE= repository ghcjs-overlay url: https://raw.githubusercontent.com/input-output-hk/hackage-overlay-ghcjs/ffb32dce467b9a4d27be759fdd2740a6edd09d0b diff --git a/test/shell-for-setup-deps/default.nix b/test/shell-for-setup-deps/default.nix index 6ee5f6e72e..6bf7214373 100644 --- a/test/shell-for-setup-deps/default.nix +++ b/test/shell-for-setup-deps/default.nix @@ -10,7 +10,7 @@ let }; env = project.shellFor { - tools.hoogle = { cabalProjectLocal = builtins.readFile ../cabal.project.local; index-state = "2024-10-26T00:00:00Z"; }; + tools.hoogle = { cabalProjectLocal = builtins.readFile ../cabal.project.local; }; withHoogle = true; }; diff --git a/test/shell-for/default.nix b/test/shell-for/default.nix index 4c26839c8e..18f5310110 100644 --- a/test/shell-for/default.nix +++ b/test/shell-for/default.nix @@ -22,7 +22,6 @@ let # they use a nix-shell --pure. Normally you would BYO cabal-install. tools = { cabal.cabalProjectLocal = builtins.readFile ../cabal.project.local; - hoogle.index-state = "2024-10-26T00:00:00Z"; }; exactDeps = true; # Avoid duplicate package issues when runghc looks for packages @@ -36,7 +35,6 @@ let # they use a nix-shell --pure. Normally you would BYO cabal-install. tools = { cabal.cabalProjectLocal = builtins.readFile ../cabal.project.local; - hoogle.index-state = "2024-10-26T00:00:00Z"; }; exactDeps = true; # Avoid duplicate package issues when runghc looks for packages @@ -51,7 +49,6 @@ let # they use a nix-shell --pure. Normally you would BYO cabal-install. tools = { cabal.cabalProjectLocal = builtins.readFile ../cabal.project.local; - hoogle.index-state = "2024-10-26T00:00:00Z"; }; # Avoid duplicate package issues when runghc looks for packages packageSetupDeps = false; From d802430862fc3fb2a095ecfd542ebeaf8ba54a84 Mon Sep 17 00:00:00 2001 From: Hamish Mackenzie Date: Mon, 4 Nov 2024 14:20:46 +1300 Subject: [PATCH 45/50] Bump head.hackage --- test/cabal.project.local | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/test/cabal.project.local b/test/cabal.project.local index 6f70e2c541..78d760ff26 100644 --- a/test/cabal.project.local +++ b/test/cabal.project.local @@ -24,7 +24,7 @@ repository head.hackage.ghc.haskell.org f76d08be13e9a61a377a85e2fb63f4c5435d40f8feb3e12eb05905edb8cdea89 26021a13b401500c8eb2761ca95c61f2d625bfef951b939a8124ed12ecf07329 7541f32a4ccca4f97aea3b22f5e593ba2c0267546016b992dfadcd2fe944e55d - --sha256: sha256-kFayk9sOpeopLOXQG8yyTqRwEBLKsQOR+6efzbm6YxE= + --sha256: sha256-0eRaAKpZ7NzlneI7AnTOymTGrRectxnoaLosjY4aGC4= repository ghcjs-overlay url: https://raw.githubusercontent.com/input-output-hk/hackage-overlay-ghcjs/ffb32dce467b9a4d27be759fdd2740a6edd09d0b From 0e469281dc4824805fb109d10e7d1c560cc4cf4b Mon Sep 17 00:00:00 2001 From: Hamish Mackenzie Date: Mon, 4 Nov 2024 14:54:54 +1300 Subject: [PATCH 46/50] Add hackage-quirk for #2277 --- modules/hackage-quirks.nix | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/modules/hackage-quirks.nix b/modules/hackage-quirks.nix index 109479d4d1..ebd45eb4ac 100644 --- a/modules/hackage-quirks.nix +++ b/modules/hackage-quirks.nix @@ -34,7 +34,7 @@ in [ hoogle = { cabalProject = '' packages: . - constraints: data-default-class >=0.2.0.0 + allow-newer: hoogle:crypton-connection ''; }; From c8aad1058e73ccfa600cc6c7a6a31fa532a02923 Mon Sep 17 00:00:00 2001 From: Hamish Mackenzie Date: Thu, 7 Nov 2024 20:34:17 +1300 Subject: [PATCH 47/50] Fix for ghcjs on macOS --- builder/comp-builder.nix | 3 +++ 1 file changed, 3 insertions(+) diff --git a/builder/comp-builder.nix b/builder/comp-builder.nix index cb49f21790..5e6bd41a85 100644 --- a/builder/comp-builder.nix +++ b/builder/comp-builder.nix @@ -197,6 +197,9 @@ let "--with-gcc=${pkgsBuildBuild.emscripten}/bin/emcc" "--with-ld=${pkgsBuildBuild.emscripten}/bin/emcc" ] + ++ lib.optionals (stdenv.hostPlatform.isGhcjs && stdenv.buildPlatform.isDarwin) [ + "--ar-options=--format=gnu" # Avoid `--format=darwin` it can cause `section too large` errors + ] ++ [ # other flags (disableFeature dontStrip "executable-stripping") (disableFeature dontStrip "library-stripping") From e64964374b101d9c2cb530d54c74cc0b89489abb Mon Sep 17 00:00:00 2001 From: Hamish Mackenzie Date: Thu, 7 Nov 2024 20:54:03 +1300 Subject: [PATCH 48/50] Disable broken tests --- test/plugin/default.nix | 2 +- test/th-dlls/default.nix | 2 +- 2 files changed, 2 insertions(+), 2 deletions(-) diff --git a/test/plugin/default.nix b/test/plugin/default.nix index a611aaa2d3..1e1a1bc4b2 100644 --- a/test/plugin/default.nix +++ b/test/plugin/default.nix @@ -20,7 +20,7 @@ in recurseIntoAttrs { # Not sure why this breaks for ghc 8.10.7 meta.disabled = compiler-nix-name == "ghc8107" - || builtins.elem compiler-nix-name [ "ghc91220241014" "ghc91320241022" ] + || builtins.elem compiler-nix-name [ "ghc91220241014" "ghc91320241101" ] || stdenv.hostPlatform.isMusl || stdenv.hostPlatform.isGhcjs || stdenv.hostPlatform.isWindows diff --git a/test/th-dlls/default.nix b/test/th-dlls/default.nix index 88ec1adbd2..bff7ac2900 100644 --- a/test/th-dlls/default.nix +++ b/test/th-dlls/default.nix @@ -28,7 +28,7 @@ in recurseIntoAttrs { || (compiler-nix-name == "ghc8107" && stdenv.hostPlatform.isWindows) # We need to update GHC HEAD to get a version of ghc-internal compatible # with th-lift from head.hackage. - || builtins.elem compiler-nix-name [ "ghc91220241014" "ghc91320241022" ] + || builtins.elem compiler-nix-name [ "ghc91220241014" "ghc91320241101" ] ; ifdInputs = { From 0d8eadf9568eefcf0f15f0931e3e480f0f14aa87 Mon Sep 17 00:00:00 2001 From: Hamish Mackenzie Date: Fri, 8 Nov 2024 10:57:34 +1300 Subject: [PATCH 49/50] Disable broken test --- test/gi-gtk/default.nix | 4 +++- 1 file changed, 3 insertions(+), 1 deletion(-) diff --git a/test/gi-gtk/default.nix b/test/gi-gtk/default.nix index 665d3dfb86..d407c8c342 100644 --- a/test/gi-gtk/default.nix +++ b/test/gi-gtk/default.nix @@ -29,7 +29,9 @@ in recurseIntoAttrs rec { # error: incompatible pointer to integer conversion assigning to 'ffi_arg' (aka 'unsigned long') from 'HsPtr' (aka 'void *') [-Wint-conversion] || builtins.elem compiler-nix-name ["ghc8107" "ghc902" "ghc928" "ghc948"] && stdenv.hostPlatform.isAarch64 # Cross compilation to aarch64 is also broken - || stdenv.hostPlatform.isAarch64 && !stdenv.buildPlatform.isAarch64; + || stdenv.hostPlatform.isAarch64 && !stdenv.buildPlatform.isAarch64 + # Building profiled version of Cabal for haskell-gi is currently broken for GHC head + || compiler-nix-name == "ghc91320241101"; ifdInputs = { inherit (project) plan-nix; From 126ed1c810e95ccc5c10aff40efbe3062da6a8df Mon Sep 17 00:00:00 2001 From: Hamish Mackenzie Date: Fri, 8 Nov 2024 12:56:36 +1300 Subject: [PATCH 50/50] Fix update scripts to use nixVersions.stable --- build.nix | 4 ++-- scripts/update-external.nix | 4 ++-- scripts/update-hackage.nix | 2 +- scripts/update-stackage.nix | 2 +- 4 files changed, 6 insertions(+), 6 deletions(-) diff --git a/build.nix b/build.nix index 686c77f276..84644af1a4 100644 --- a/build.nix +++ b/build.nix @@ -77,14 +77,14 @@ in rec { maintainer-scripts = pkgs.dontRecurseIntoAttrs { update-hackage = import ./scripts/update-hackage.nix { inherit (pkgs) stdenv lib writeScript coreutils glibc git - openssh nixFlakes gawk bash curl findutils; + openssh nixVersions gawk bash curl findutils; # Update scripts use the internal nix-tools (compiled with a fixed GHC version) nix-tools = haskell.nix-tools-unchecked; inherit (haskell) update-index-state-hashes cabal-issue-8352-workaround; }; update-stackage = haskell.callPackage ./scripts/update-stackage.nix { inherit (pkgs) stdenv lib writeScript coreutils glibc git - openssh nixFlakes gawk bash curl findutils; + openssh nixVersions gawk bash curl findutils; # Update scripts use the internal nix-tools (compiled with a fixed GHC version) nix-tools = haskell.nix-tools-unchecked; inherit (haskell) cabal-issue-8352-workaround; diff --git a/scripts/update-external.nix b/scripts/update-external.nix index aba071d091..e5777dece2 100644 --- a/scripts/update-external.nix +++ b/scripts/update-external.nix @@ -1,5 +1,5 @@ { stdenv, lib, writeScript, glibc, coreutils, git, openssh -, nix-tools, nixFlakes +, nix-tools, nixVersions , bash, curl, findutils, gawk, cabal-issue-8352-workaround }: { name, script }: @@ -15,7 +15,7 @@ in set -euo pipefail - export PATH="${makeBinPath ([ coreutils curl findutils gawk bash git openssh nix-tools nixFlakes ] ++ cabal-issue-8352-workaround ++ optional stdenv.isLinux glibc)}" + export PATH="${makeBinPath ([ coreutils curl findutils gawk bash git openssh nix-tools nixVersions.stable ] ++ cabal-issue-8352-workaround ++ optional stdenv.isLinux glibc)}" ${script} diff --git a/scripts/update-hackage.nix b/scripts/update-hackage.nix index 2e02aa429c..00308a95cd 100644 --- a/scripts/update-hackage.nix +++ b/scripts/update-hackage.nix @@ -1,5 +1,5 @@ { stdenv, lib, writeScript, coreutils, glibc, git, openssh -, nix-tools, nixFlakes +, nix-tools, nixVersions , gawk, bash, curl, findutils , update-index-state-hashes, cabal-issue-8352-workaround }@args: diff --git a/scripts/update-stackage.nix b/scripts/update-stackage.nix index 19bbf00ffb..1af620ad4e 100644 --- a/scripts/update-stackage.nix +++ b/scripts/update-stackage.nix @@ -1,5 +1,5 @@ { stdenv, lib, writeScript, coreutils, glibc, git, openssh -, nix-tools, nixFlakes +, nix-tools, nixVersions , gawk, bash, curl, findutils, cabal-issue-8352-workaround }@args: import ./update-external.nix args {