diff --git a/cabal.project b/cabal.project index 3e62cb0..69a81ad 100644 --- a/cabal.project +++ b/cabal.project @@ -1 +1 @@ -packages: . hackage-db +packages: . hackage-db \ No newline at end of file diff --git a/nix/cabal-licenses.nix b/nix/cabal-licenses.nix index 01ce63c..e89d27c 100644 --- a/nix/cabal-licenses.nix +++ b/nix/cabal-licenses.nix @@ -1,2 +1,8 @@ -stdenv: with stdenv.lib.licenses; -{ BSD-3-Clause = bsd3; } +lib: with lib.licenses; +{ + BSD-2-Clause = bsd2; + BSD-3-Clause = bsd3; + MIT = mit; + ISC = isc; + LicenseRef-LGPL = "LGPL"; +} diff --git a/nix/cabal-os-arch-comp.nix b/nix/cabal-os-arch-comp.nix index 047cbf0..cdcb45c 100644 --- a/nix/cabal-os-arch-comp.nix +++ b/nix/cabal-os-arch-comp.nix @@ -19,18 +19,18 @@ # OSs isLinux = false; isWindows = false; - isOSX = false; - isFreeBSD = false; + isOsx = false; + isFreebsd = false; isOpenBSD = false; isNetBSD = false; isDragonFly = false; isSolaris = false; - isAIX = false; + isAix = false; isHPUX = false; isIRIX = false; - isHaLVM = false; + isHalvm = false; isHurd = false; - isIOS = false; + isIos = false; isAndroid = false; isGhcjs = false; }; diff --git a/nix/comp-builder.nix b/nix/comp-builder.nix new file mode 100644 index 0000000..c417e0b --- /dev/null +++ b/nix/comp-builder.nix @@ -0,0 +1,108 @@ +{ stdenv, ghc, lib, pkgconfig, writeText, haskellLib }: + +{ componentId +, component +, package +, name +, setup +, src +, flags +, cabalFile +}: + +let + flagsAndConfig = field: xs: { + flags = map (x: "--${field}=${x}") xs; + config = lib.optional (xs != []) "${field}: ${lib.concatStringsSep " " xs}"; + }; + + allFlagsAndConfigs = { + packageDbs = + let + makePairs = map (p: rec { key="${val}"; val=p.components.${p.identifier.name}; }); + closure = builtins.genericClosure { + startSet = makePairs component.depends; + operator = {val,...}: makePairs val.config.depends; + }; + flatDepends = map ({val,...}: val) closure; + in flagsAndConfig "package-db" (map (p: "${p}/package.conf.d") flatDepends); + + extraLibDirs = flagsAndConfig "extra-lib-dirs" (map (p: "${p}/lib") component.libs); + extraIncludeDirs = flagsAndConfig "extra-include-dirs" (map (p: "${lib.getDev p}/include") component.libs); + extraFameworks = flagsAndConfig "extra-framework-dirs" (map (p: "${p}/Library/Frameworks") component.frameworks); + userFlags = { + flags = [("--flags=\"" + lib.concatStringsSep " " (lib.mapAttrsToList (fname: val: lib.optionalString (!val) "-" + fname) flags) + "\"")]; + config = []; + }; + }; + + finalConfigureFlags = lib.concatStringsSep " " ( + [ "--prefix=$out" "${componentId.ctype}:${componentId.cname}" ] + ++ builtins.concatLists (lib.mapAttrsToList (_: x: x.flags) allFlagsAndConfigs) + ++ component.configureFlags + ); +in stdenv.mkDerivation { + name = "${name}-${componentId.ctype}-${componentId.cname}"; + + inherit src; + + doCheck = componentId.ctype == "test"; + + passthru = { + inherit (package) identifier; + config = component; + }; + + meta = { + homepage = package.homepage; + description = package.synopsis; + license = (import ./cabal-licenses.nix lib).${package.license}; + }; + + CABAL_CONFIG = writeText + "package-db-cabal.config" + (lib.concatStringsSep "\n" (builtins.concatLists (lib.mapAttrsToList (_: x: x.config) allFlagsAndConfigs))); + + enableParallelBuilding = true; + + buildInputs = component.libs + ++ component.pkgconfig; + + nativeBuildInputs = + [ghc] + ++ lib.optional (component.pkgconfig != []) pkgconfig + ++ lib.concatMap (c: if c.isHaskell or false + then builtins.attrValues (c.components.exes or {}) + else [c]) component.build-tools; + + SETUP_HS = setup + /bin/Setup; + + # Phases + prePatch = lib.optionalString (cabalFile != null) '' + cat ${cabalFile} > ${package.identifier.name}.cabal + ''; + + configurePhase = '' + echo Configure flags: + printf "%q " ${finalConfigureFlags} + echo + $SETUP_HS configure ${finalConfigureFlags} + ''; + + buildPhase = '' + $SETUP_HS build -j$NIX_BUILD_CORES + ''; + + checkPhase = '' + $SETUP_HS test + ''; + + installPhase = '' + $SETUP_HS copy + ${lib.optionalString (haskellLib.isLibrary componentId) '' + $SETUP_HS register --gen-pkg-config=${name}.conf + ghc-pkg init $out/package.conf.d + ghc-pkg ${lib.concatStringsSep " " allFlagsAndConfigs.packageDbs.flags} -f $out/package.conf.d register ${name}.conf + ''} + ''; +} diff --git a/nix/compat-driver.nix b/nix/compat-driver.nix new file mode 100644 index 0000000..119e313 --- /dev/null +++ b/nix/compat-driver.nix @@ -0,0 +1,13 @@ +{ pkgs, lib, haskellLib, ghc, weakCallPackage, plan }: + +lib.fix (hsPkgs: pkgs.callPackage "${pkgs.path}/pkgs/development/haskell-modules" { + haskellLib = pkgs.haskell.lib; + inherit ghc; + buildHaskellPackages = hsPkgs; + compilerConfig = _: _: lib.mapAttrs (_: _: null) (builtins.removeAttrs plan.compiler.packages ["ghc"]); + initialPackages = args: self: + lib.mapAttrs + (_: pkg: self.callPackage ./driver.nix { expr = lib.fix pkg; inherit lib; }) + (plan.packages self); + packageSetConfig = plan.overlay pkgs; +}) diff --git a/nix/component-driver.nix b/nix/component-driver.nix new file mode 100644 index 0000000..b33cce4 --- /dev/null +++ b/nix/component-driver.nix @@ -0,0 +1,11 @@ +{ pkgs, lib, haskellLib, ghc, weakCallPackage, plan }: +let + new-builder = weakCallPackage pkgs ./new-builder.nix { + inherit haskellLib ghc weakCallPackage; + }; +in +lib.fix (self: + { buildPackages = self; } + // lib.mapAttrs (_: _: null) plan.compiler.packages + // lib.mapAttrs (_: pkg: new-builder (lib.fix pkg)) (plan.packages self) +) diff --git a/nix/default.nix b/nix/default.nix new file mode 100644 index 0000000..3205e70 --- /dev/null +++ b/nix/default.nix @@ -0,0 +1,121 @@ +{ pkgs ? import {} +, planFunc ? import ../stackage/lts-11.4.nix +, hackage ? import ../hackage +, driver ? ./component-driver.nix +}: + +(pkgs.lib.fix (self: with self; { + inherit (pkgs) lib stdenv; + ghc = pkgs.haskell.compiler.${plan.compiler.nix-name}; + + # Avoid pkgs.callPackage for now. It does a lot of nonsense with OOP + # style programming that we should avoid until we know we want it. + weakCallPackage = scope: f: args: + let f' = if lib.isFunction f then f else import f; + args' = scope // args; + in f' (builtins.intersectAttrs (builtins.functionArgs f') args'); + + haskellLib = import ./lib.nix { inherit lib haskellLib; }; + + hackageConfigs = + lib.flip lib.mapAttrs hackage + (pname: lib.mapAttrs + (vnum: version: version // { + revisions = + let + rev2Config = rev: { + inherit (version) sha256; + inherit (rev) outPath; + revision = rev.revNum; + revisionSha256 = rev.sha256; + }; + f = rev: acc: acc // { + # If there's a collision (e.g. a revision was + # reverted), pick the one with the smaller + # revNum. They're identical, but if the smaller one is + # r0 then we don't have to download a cabal file. + ${rev.sha256} = if lib.hasAttr rev.sha256 acc && acc.${rev.sha256}.revNum < rev.revNum + then acc.${rev.sha256} + else rev; + }; + contentAddressedRevs = lib.foldr f {} (builtins.attrValues version.revisions); + in lib.mapAttrs (_: rev2Config) (version.revisions // contentAddressedRevs); + })); + plan = + let p = planFunc hackageConfigs; + in p // { + packages = hsPkgs: + let + args = { + inherit hsPkgs compiler system pkgconfPkgs; + pkgs = adjustedPkgs; + }; + in lib.mapAttrs (pname: { revision, flags ? {} }: self: + # Set the flags with the rhs of the recursiveUpdate, but + # pass the final choice in flags using open recursion. + lib.recursiveUpdate (import revision (args // { inherit (self) flags; })) { + inherit flags; + inherit (revision) sha256 revision revisionSha256; + } + ) + p.packages; + }; + + cabal = import ./cabal-os-arch-comp.nix; + + compiler = cabal.compiler // { + isGhc = true; + version = lib.mapAttrs (_: f: v: f (builtins.compareVersions plan.compiler.version v)) { + eq = c: c == 0; + gt = c: c > 0; + ge = c: c >= 0; + lt = c: c < 0; + le = c: c <= 0; + }; + }; + system = let + hostMap = import ./host-map.nix pkgs.stdenv; + in cabal.os // { "is${hostMap.os}" = true; } + // cabal.arch // { "is${hostMap.arch}" = true; }; + + adjustedPkgs = pkgs // { + pthread = null; + "stdc++" = null; + ssl = pkgs.openssl.dev; + crypto = pkgs.openssl.dev; + z = pkgs.zlib; + GL = pkgs.libGL; + GLU = pkgs.libGLU; + alut = pkgs.freealut; + X11 = pkgs.xorg.libX11; + Xrandr = pkgs.xorg.libXrandr; + Xext = pkgs.xorg.libXext; + Xi = pkgs.xorg.libXi; + Xxf86vm = pkgs.xorg.libXxf86vm; + Xcursor = pkgs.xorg.libXcursor; + Xinerama = pkgs.xorg.libXinerama; + mysqlclient = pkgs.mysql; + Imlib2 = pkgs.imlib2; + asound = pkgs.alsaLib; + ffi = null; + }; + pkgconfPkgs = pkgs // { + cairo-pdf = pkgs.cairo; + cairo-ps = pkgs.cairo; + cairo-svg = pkgs.cairo; + xft = pkgs.xorg.libXft; + xau = pkgs.xorg.libXau; + libR = pkgs.R; + fftw3f = pkgs.fftwFloat; + fftw3 = pkgs.fftw; + }; + + # hsPkgs = adjustedPkgs + # // { buildPackages = hsPkgs; } + # // lib.mapAttrs (_: _: null) (plan.compiler.packages // { hsc2hs = "0.68.2"; }) + # // lib.mapAttrs (_: driver) configs; + + hsPkgs = weakCallPackage pkgs driver { + inherit haskellLib ghc weakCallPackage plan; + }; +})) diff --git a/nix/driver.nix b/nix/driver.nix index 4c373bf..37cddc7 100644 --- a/nix/driver.nix +++ b/nix/driver.nix @@ -1,50 +1,31 @@ -{ cabalexpr, pkgs, compiler ? "Ghc", os ? "OSX", arch ? "X86_64" }: -assert (builtins.elem compiler ["Ghc" "Ghcjs" "Nhc" "Yhc" "Hugs" "Hbc" "Helium" "Jhc" "Lhc" "Uhc" "Eta"]); -assert (builtins.elem os ["Linux" "Windows" "OSX" "FreeBSD" "OpenBSD" "NetBSD" "DragonFly" "Solaris" "AIX" "HPUX" "IRIX" "HaLVM" "Hurd" "IOS" "Android" "Ghcjs"]); -assert (builtins.elem arch ["I386" "X86_64" "PPC" "PPC64" "Sparc" "Arm" "Aarch64" "Mips" "SH" "IA64" "S390" "Alpha" "Hppa" "Rs6000" "M68k" "Vax" "JavaScript"]); +{ lib, expr, mkDerivation }: -with rec { +let # utilities - collectAttr = a: s: pkgs.lib.lists.fold (e: acc: (if e ? ${a} then e.${a} else []) ++ acc) [] (builtins.attrValues s); - - # resolver for cabal license to nix license - resolve = { license = stdenv: license: (import ./cabal-licenses.nix stdenv).${license}; }; - - # cabal os, arch and compilers. - cabal = import ./cabal-os-arch-comp.nix; - - expr = cabalexpr { - # null out self references. Tests, Benchmarks, ... - # naturally depend on the package (as a library), but - # we don't want those dependencies. - hsPkgs = pkgs.haskellPackages // { ${pname} = null; }; - pkgs = pkgs; - compiler = cabal.compiler // { "is${compiler}" = true; }; - system = cabal.os // { "is${os}" = true; } - // cabal.arch // { "is${arch}" = true; }; - }; - + collectAttr = a: s: lib.lists.fold (e: acc: (if e ? ${a} then e.${a} else []) ++ acc) [] (builtins.attrValues s); pname = expr.package.identifier.name; -}; -{ mkDerivation, stdenv }: -mkDerivation { - +in mkDerivation ({ inherit pname; version = expr.package.identifier.version; - sha256 = null; isLibrary = builtins.hasAttr pname expr.components; isExecutable = builtins.hasAttr "exes" expr.components; homepage = expr.package.homepage; description = expr.package.synopsis; - license = resolve.license stdenv expr.package.license; -} // pkgs.lib.optionalAttrs (builtins.hasAttr pname expr.components) { - libraryHaskeallDepends = expr.components.${pname}.depends; -} // pkgs.lib.optionalAttrs (builtins.hasAttr "exes" expr.components) { + license = (import ./cabal-licenses.nix lib).${expr.package.license}; + +} // lib.optionalAttrs (expr ? revision) { + revision = "${toString expr.revision}"; + editedCabalFile = expr.revisionSha256; +} // lib.optionalAttrs (expr ? sha256) { + inherit (expr) sha256; +} // lib.optionalAttrs (builtins.hasAttr pname expr.components) { + libraryHaskellDepends = expr.components.${pname}.depends; +} // lib.optionalAttrs (builtins.hasAttr "exes" expr.components) { executableHaskellDepends = collectAttr "depends" expr.components.exes; -} // pkgs.lib.optionalAttrs (builtins.hasAttr "tests" expr.components) { +} // lib.optionalAttrs (builtins.hasAttr "tests" expr.components) { testHaskellDepends = collectAttr "depends" expr.components.tests; -} // pkgs.lib.optionalAttrs (builtins.hasAttr "benchmarks" expr.components) { +} // lib.optionalAttrs (builtins.hasAttr "benchmarks" expr.components) { benchmarkHaskellDepends = collectAttr "depends" expr.components.benchmarks; -} +}) diff --git a/nix/lib.nix b/nix/lib.nix new file mode 100644 index 0000000..934f8fc --- /dev/null +++ b/nix/lib.nix @@ -0,0 +1,153 @@ +{ lib, haskellLib }: + +with haskellLib; + +{ + subComponentTypes = [ + "sublibs" + "foreignlibs" + "exes" + "tests" + "benchmarks" + ]; + + mergeComponents = lib.zipAttrsWith (_: comps: lib.genAttrs [ + "depends" + "libs" + "frameworks" + "pkgconfig" + "build-tools" + ] (n: { + ${n} = lib.concatMap (comp: comp.${n} or []) comps; + })); + + unionrAttrs = lib.foldr (a: b: a // b) {}; + + mergeConfigs = configs: + let + mergeComponentType = type: mergeComponents (map (conf: (conf.components or {}).${type} or {}) configs); + in unionrAttrs configs // { + flags = unionrAttrs (map (conf: conf.flags or {}) configs); + package = lib.foldr (conf: lib.recursiveUpdate (conf.package or {})) {} configs; + components = + mergeComponents (map (conf: removeAttrs (conf.components or {}) subComponentTypes) configs) + // lib.genAttrs subComponentTypes mergeComponentType; + configureFlags = concatMap (conf: conf.configureFlags or []) configs; + }; + + foldrAttrVals = f: z: attrs: + lib.foldr (g: acc: g acc) z (lib.mapAttrsToList f attrs); + + attrLength = attrs: builtins.length (builtins.attrValues attrs); + + foldComponents = tys: f: z: conf: + let + comps = conf.components or {}; + foldSection = foldrAttrVals f; + libComp = acc: + foldSection acc + (removeAttrs comps subComponentTypes); + subComps = acc: + lib.foldr + (ty: acc': foldSection acc' (comps.${ty} or {})) + acc + tys; + in libComp (subComps z); + + componentPrefix = { + # Are all of these right? + sublibs = "sublib"; + foreignlibs = "foreignlib"; + exes = "exe"; + tests = "test"; + benchmarks = "bench"; + }; + + applyComponents = f: comps: + let + libComp = lib.mapAttrs (cname: f {ctype="lib"; inherit cname;}) (removeAttrs comps subComponentTypes); + subComps = lib.mapAttrs + (ctype: lib.mapAttrs (cname: f {inherit cname; ctype=componentPrefix.${ctype};})) + (builtins.intersectAttrs (lib.genAttrs subComponentTypes (_: null)) comps); + in subComps // libComp; + + isLibrary = componentId: componentId.ctype == "lib"; + + adjustHackage = hackage: args: + let + handleVer = vdata: + let + revs = builtins.removeAttrs vdata ["sha256"]; + rev2HashedConfig = name: rev: { name = rev.cabalSha256; value = revConfigs.${name}; }; + revConfigs = lib.mapAttrs (_: rev2config vdata.sha256) revs; + in revConfigs // lib.mapAttrs' rev2HashedConfig revs; + rev2config = sha256: rev: self: import rev (args // { inherit (self) flags; }) // { + inherit sha256; + inherit (rev) cabalFile; + }; + in lib.mapAttrs (_: lib.mapAttrs (_: handleVer)) hackage; + + buildPlan = { pkgs, plan }: + let + ghc = pkgs.haskell.compiler.${plan.compiler.nix-name}; + weakCallPackage = scope: f: args: + let f' = if lib.isFunction f then f else import f; + args' = scope // args; + in f' (builtins.intersectAttrs (builtins.functionArgs f') args'); + + new-builder = weakCallPackage pkgs ./new-builder.nix { + inherit haskellLib ghc weakCallPackage; + }; + cabal = import ./cabal-os-arch-comp.nix; + configs = lib.mapAttrs (_: lib.fix) plan.packages; + in { + system = + let hostMap = import ./host-map.nix pkgs.stdenv; + in cabal.os // { "is${hostMap.os}" = true; } + // cabal.arch // { "is${hostMap.arch}" = true; }; + compiler = cabal.compiler // { + isGhc = true; + version = lib.mapAttrs (_: f: v: f (builtins.compareVersions plan.compiler.version v)) { + eq = c: c == 0; + gt = c: c > 0; + ge = c: c >= 0; + lt = c: c < 0; + le = c: c <= 0; + }; + }; + pkgconfPkgs = pkgs // { + cairo-pdf = pkgs.cairo; + cairo-ps = pkgs.cairo; + cairo-svg = pkgs.cairo; + xft = pkgs.xorg.libXft; + xau = pkgs.xorg.libXau; + libR = pkgs.R; + fftw3f = pkgs.fftwFloat; + fftw3 = pkgs.fftw; + }; + pkgs = pkgs // { + pthread = null; + "stdc++" = null; + ssl = pkgs.openssl.dev; + crypto = pkgs.openssl.dev; + z = pkgs.zlib; + GL = pkgs.libGL; + GLU = pkgs.libGLU; + alut = pkgs.freealut; + X11 = pkgs.xorg.libX11; + Xrandr = pkgs.xorg.libXrandr; + Xext = pkgs.xorg.libXext; + Xi = pkgs.xorg.libXi; + Xxf86vm = pkgs.xorg.libXxf86vm; + Xcursor = pkgs.xorg.libXcursor; + Xinerama = pkgs.xorg.libXinerama; + mysqlclient = pkgs.mysql; + Imlib2 = pkgs.imlib2; + asound = pkgs.alsaLib; + ffi = null; + }; + hsPkgs = lib.mapAttrs (_: _: null) (plan.compiler.packages // { hsc2hs = "0.68.2"; }) + // lib.mapAttrs (_: new-builder) configs; + }; + +} diff --git a/nix/new-builder.nix b/nix/new-builder.nix new file mode 100644 index 0000000..f84bf5f --- /dev/null +++ b/nix/new-builder.nix @@ -0,0 +1,81 @@ +{ pkgs, stdenv, lib, haskellLib, ghc, fetchurl, writeText, runCommand, pkgconfig, weakCallPackage }: + +{ flags ? {} +, package ? {} +, components ? {} + +, name ? "${package.identifier.name}-${package.identifier.version}" +, sha256 ? null +, src ? fetchurl { url = "mirror://hackage/${name}.tar.gz"; inherit sha256; } +, revision ? null +, revisionSha256 ? null +}@config: + +let + cabalFile = if revision == null || revision == 0 then null else + fetchurl { + url = "https://hackage.haskell.org/package/${name}/revision/${toString revision}.cabal"; + sha256 = revisionSha256; + }; + defaultSetupSrc = builtins.toFile "Setup.hs" '' + import Distribution.Simple + main = defaultMain + ''; + defaultSetup = runCommand "default-Setup" { nativeBuildInputs = [ghc]; } '' + cat ${defaultSetupSrc} > Setup.hs + ghc Setup.hs --make -o $out + ''; + + setup = stdenv.mkDerivation { + name = "${name}-setup"; + nativeBuildInputs = [ghc]; + inherit src; + phases = ["unpackPhase" "buildPhase" "installPhase"]; + buildPhase = '' + setup=${defaultSetup} + for f in Setup.hs Setup.lhs; do + if [ -f $f ]; then + if ! (diff $f ${defaultSetupSrc} > /dev/null); then + echo Compiling package $f + ghc $f --make -o ./Setup + setup=$(pwd)/Setup + else + echo Using default Setup + fi + break + fi + done + ''; + + installPhase = '' + mkdir -p $out/bin + install $setup $out/bin/Setup + ''; + }; + + comp-builder = weakCallPackage pkgs ./comp-builder.nix { inherit ghc haskellLib; }; + + buildComp = componentId: component: comp-builder { + inherit componentId package name src flags setup cabalFile; + component = + let + nonNullLists = fs: component // lib.genAttrs fs (field: + if component ? ${field} + then builtins.filter (x: x != null) component.${field} + else []); + in nonNullLists [ + "depends" + "libs" + "frameworks" + "pkgconfig" + "build-tools" + "configureFlags" + ]; + }; + +in { + components = haskellLib.applyComponents buildComp components; + inherit (package) identifier; + inherit setup cabalFile; + isHaskell = true; +} diff --git a/plan.nix b/plan.nix index 413cd7c..28cb160 100644 --- a/plan.nix +++ b/plan.nix @@ -1,139 +1,260 @@ hackage: { packages = { - "http-client" = hackage.http-client."0.5.13.1"; - "semigroupoids" = hackage.semigroupoids."5.3.1"; - "cookie" = hackage.cookie."0.4.4"; - "tf-random" = hackage.tf-random."0.5"; - "exceptions" = hackage.exceptions."0.10.0"; - "free" = hackage.free."5.1"; - "void" = hackage.void."0.7.2"; - "cereal" = hackage.cereal."0.5.7.0"; - "streaming-commons" = hackage.streaming-commons."0.2.1.0"; - "regex-tdfa-text" = hackage.regex-tdfa-text."1.0.0.3"; - "serialise" = hackage.serialise."0.2.0.0"; - "cryptohash-sha1" = hackage.cryptohash-sha1."0.11.100.1"; - "haskell-lexer" = hackage.haskell-lexer."1.0.1"; - "socks" = hackage.socks."0.5.6"; - "integer-logarithms" = hackage.integer-logarithms."1.0.2.2"; - "these" = hackage.these."0.7.5"; - "lens-family" = hackage.lens-family."1.2.2"; - "basement" = hackage.basement."0.0.8"; - "ansi-wl-pprint" = hackage.ansi-wl-pprint."0.6.8.2"; - "logict" = hackage.logict."0.6.0.2"; - "data-fix" = hackage.data-fix."0.2.0"; - "case-insensitive" = hackage.case-insensitive."1.2.0.11"; - "x509-validation" = hackage.x509-validation."1.6.10"; - "extra" = hackage.extra."1.6.11"; - "hourglass" = hackage.hourglass."0.2.12"; - "haskeline" = hackage.haskeline."0.7.4.3"; - "hashing" = hackage.hashing."0.1.0.1"; - "split" = hackage.split."0.2.3.3"; - "stm" = hackage.stm."2.4.5.1"; - "data-default-class" = hackage.data-default-class."0.1.2.0"; - "comonad" = hackage.comonad."5.0.4"; - "parser-combinators" = hackage.parser-combinators."1.0.0"; - "deriving-compat" = hackage.deriving-compat."0.5.2"; - "pointed" = hackage.pointed."5.0.1"; - "unordered-containers" = hackage.unordered-containers."0.2.9.0"; - "pem" = hackage.pem."0.2.4"; - "adjunctions" = hackage.adjunctions."4.4"; - "cryptohash-md5" = hackage.cryptohash-md5."0.11.100.1"; - "invariant" = hackage.invariant."0.5.1"; - "clock" = hackage.clock."0.7.2"; - "megaparsec" = hackage.megaparsec."6.5.0"; - "th-orphans" = hackage.th-orphans."0.13.6"; - "syb" = hackage.syb."0.7"; - "distributive" = hackage.distributive."0.6"; - "kan-extensions" = hackage.kan-extensions."5.2"; - "cborg" = hackage.cborg."0.2.0.0"; - "foundation" = hackage.foundation."0.0.21"; - "tls" = hackage.tls."1.4.1"; - "asn1-types" = hackage.asn1-types."0.3.2"; - "network" = hackage.network."2.8.0.0"; - "async" = hackage.async."2.2.1"; - "x509-store" = hackage.x509-store."1.6.6"; - "connection" = hackage.connection."0.2.8"; - "dlist" = hackage.dlist."0.8.0.5"; - "conduit" = hackage.conduit."1.3.0.3"; - "lens-family-th" = hackage.lens-family-th."0.5.0.2"; - "vector-instances" = hackage.vector-instances."3.4"; - "semigroups" = hackage.semigroups."0.18.5"; - "th-reify-many" = hackage.th-reify-many."0.1.8"; - "lens-family-core" = hackage.lens-family-core."1.2.2"; - "base-orphans" = hackage.base-orphans."0.8"; - "memory" = hackage.memory."0.14.16"; - "repline" = hackage.repline."0.1.7.0"; - "th-abstraction" = hackage.th-abstraction."0.2.8.0"; - "xml" = hackage.xml."1.3.14"; - "erf" = hackage.erf."2.0.0.0"; - "th-lift-instances" = hackage.th-lift-instances."0.1.11"; - "tagged" = hackage.tagged."0.8.6"; - "haskell-src-exts" = hackage.haskell-src-exts."1.20.2"; - "x509" = hackage.x509."1.7.4"; - "keys" = hackage.keys."3.12.1"; - "blaze-builder" = hackage.blaze-builder."0.4.1.0"; - "ansi-terminal" = hackage.ansi-terminal."0.8.1"; - "unliftio-core" = hackage.unliftio-core."0.1.2.0"; - "base-compat" = hackage.base-compat."0.10.4"; - "x509-system" = hackage.x509-system."1.6.6"; - "polyparse" = hackage.polyparse."1.12"; - "hnix" = hackage.hnix."0.5.2"; - "bifunctors" = hackage.bifunctors."5.5.3"; - "cryptohash-sha256" = hackage.cryptohash-sha256."0.11.101.0"; - "interpolate" = hackage.interpolate."0.2.0"; - "old-time" = hackage.old-time."1.1.0.3"; - "regex-tdfa" = hackage.regex-tdfa."1.2.3.1"; - "text-metrics" = hackage.text-metrics."0.3.0"; - "old-locale" = hackage.old-locale."1.0.0.7"; - "http-client-tls" = hackage.http-client-tls."0.3.5.3"; - "contravariant" = hackage.contravariant."1.5"; - "mime-types" = hackage.mime-types."0.1.0.8"; - "StateVar" = hackage.StateVar."1.1.1.1"; - "regex-base" = hackage.regex-base."0.93.2"; - "th-expand-syns" = hackage.th-expand-syns."0.4.4.0"; - "cryptonite" = hackage.cryptonite."0.25"; - "zlib" = hackage.zlib."0.6.2"; - "network-uri" = hackage.network-uri."2.6.1.0"; - "asn1-parse" = hackage.asn1-parse."0.9.4"; - "microlens-aeson" = hackage.microlens-aeson."2.3.0"; - "happy" = hackage.happy."1.19.9"; - "hashable" = hackage.hashable."1.2.7.0"; - "cpphs" = hackage.cpphs."1.20.8"; - "transformers-base" = hackage.transformers-base."0.4.5.2"; - "cryptohash-sha512" = hackage.cryptohash-sha512."0.11.100.1"; - "vector-algorithms" = hackage.vector-algorithms."0.8.0.0"; - "byteable" = hackage.byteable."0.1.1"; - "pretty-show" = hackage.pretty-show."1.8.2"; - "base16-bytestring" = hackage.base16-bytestring."0.1.1.6"; - "attoparsec" = hackage.attoparsec."0.13.2.2"; - "colour" = hackage.colour."2.3.4"; - "infer-license" = hackage.infer-license."0.2.0"; - "optparse-applicative" = hackage.optparse-applicative."0.14.2.0"; - "random" = hackage.random."1.1"; - "uuid-types" = hackage.uuid-types."1.0.3"; - "scientific" = hackage.scientific."0.3.6.2"; - "monadlist" = hackage.monadlist."0.0.2"; - "asn1-encoding" = hackage.asn1-encoding."0.9.5"; - "QuickCheck" = hackage.QuickCheck."2.12.4"; - "half" = hackage.half."0.3"; - "haskell-src-meta" = hackage.haskell-src-meta."0.8.0.3"; - "cabal-doctest" = hackage.cabal-doctest."1.0.6"; - "th-lift" = hackage.th-lift."0.7.11"; - "resourcet" = hackage.resourcet."1.2.1"; - "http-types" = hackage.http-types."0.12.1"; - "microlens" = hackage.microlens."0.4.9.1"; - "Glob" = hackage.Glob."0.9.2"; - "aeson" = hackage.aeson."1.4.0.0"; - "mono-traversable" = hackage.mono-traversable."1.0.9.0"; - "primitive" = hackage.primitive."0.6.4.0"; - "safe" = hackage.safe."0.3.17"; - "yaml" = hackage.yaml."0.10.2.0"; - "transformers-compat" = hackage.transformers-compat."0.6.2"; - "profunctors" = hackage.profunctors."5.3"; - "vector" = hackage.vector."0.12.0.1"; - "time-locale-compat" = hackage.time-locale-compat."0.1.1.5"; - "hpack" = hackage.hpack."0.31.0"; + http-client.revision = hackage.http-client."0.5.13.1".revisions.default; + http-client.flags.network-uri = true; + semigroupoids.revision = hackage.semigroupoids."5.3.1".revisions.default; + semigroupoids.flags.comonad = true; + semigroupoids.flags.doctests = true; + semigroupoids.flags.unordered-containers = true; + semigroupoids.flags.distributive = true; + semigroupoids.flags.tagged = true; + semigroupoids.flags.containers = true; + semigroupoids.flags.contravariant = true; + cookie.revision = hackage.cookie."0.4.4".revisions.default; + tf-random.revision = hackage.tf-random."0.5".revisions.default; + exceptions.revision = hackage.exceptions."0.10.0".revisions.default; + free.revision = hackage.free."5.1".revisions.default; + void.revision = hackage.void."0.7.2".revisions.default; + void.flags.safe = false; + cereal.revision = hackage.cereal."0.5.7.0".revisions.default; + cereal.flags.bytestring-builder = false; + streaming-commons.revision = hackage.streaming-commons."0.2.1.0".revisions.default; + streaming-commons.flags.use-bytestring-builder = false; + regex-tdfa-text.revision = hackage.regex-tdfa-text."1.0.0.3".revisions.default; + serialise.revision = hackage.serialise."0.2.1.0".revisions.default; + serialise.flags.newtime15 = true; + cryptohash-sha1.revision = hackage.cryptohash-sha1."0.11.100.1".revisions.default; + haskell-lexer.revision = hackage.haskell-lexer."1.0.2".revisions.default; + socks.revision = hackage.socks."0.5.6".revisions.default; + integer-logarithms.revision = hackage.integer-logarithms."1.0.2.2".revisions.default; + integer-logarithms.flags.check-bounds = false; + integer-logarithms.flags.integer-gmp = true; + these.revision = hackage.these."0.7.5".revisions.default; + lens-family.revision = hackage.lens-family."1.2.3".revisions.default; + basement.revision = hackage.basement."0.0.8".revisions.default; + ansi-wl-pprint.revision = hackage.ansi-wl-pprint."0.6.8.2".revisions.default; + ansi-wl-pprint.flags.example = false; + logict.revision = hackage.logict."0.6.0.2".revisions.default; + data-fix.revision = hackage.data-fix."0.2.0".revisions.default; + case-insensitive.revision = hackage.case-insensitive."1.2.0.11".revisions.default; + x509-validation.revision = hackage.x509-validation."1.6.10".revisions.default; + extra.revision = hackage.extra."1.6.13".revisions.default; + hourglass.revision = hackage.hourglass."0.2.12".revisions.default; + haskeline.revision = hackage.haskeline."0.7.4.3".revisions.default; + haskeline.flags.terminfo = true; + hashing.revision = hackage.hashing."0.1.0.1".revisions.default; + split.revision = hackage.split."0.2.3.3".revisions.default; + stm.revision = hackage.stm."2.5.0.0".revisions.default; + data-default-class.revision = hackage.data-default-class."0.1.2.0".revisions.default; + comonad.revision = hackage.comonad."5.0.4".revisions.default; + comonad.flags.distributive = true; + comonad.flags.test-doctests = true; + comonad.flags.containers = true; + comonad.flags.contravariant = true; + parser-combinators.revision = hackage.parser-combinators."1.0.0".revisions.default; + parser-combinators.flags.dev = false; + deriving-compat.revision = hackage.deriving-compat."0.5.2".revisions.default; + deriving-compat.flags.base-4-9 = true; + deriving-compat.flags.template-haskell-2-11 = true; + deriving-compat.flags.new-functor-classes = true; + pointed.revision = hackage.pointed."5.0.1".revisions.default; + pointed.flags.semigroupoids = true; + pointed.flags.stm = true; + pointed.flags.comonad = true; + pointed.flags.unordered-containers = true; + pointed.flags.kan-extensions = true; + pointed.flags.semigroups = true; + pointed.flags.tagged = true; + pointed.flags.containers = true; + pointed.flags.transformers = true; + unordered-containers.revision = hackage.unordered-containers."0.2.9.0".revisions.default; + unordered-containers.flags.debug = false; + pem.revision = hackage.pem."0.2.4".revisions.default; + adjunctions.revision = hackage.adjunctions."4.4".revisions.default; + cryptohash-md5.revision = hackage.cryptohash-md5."0.11.100.1".revisions.default; + invariant.revision = hackage.invariant."0.5.1".revisions.default; + clock.revision = hackage.clock."0.7.2".revisions.default; + clock.flags.llvm = false; + megaparsec.revision = hackage.megaparsec."6.5.0".revisions.default; + megaparsec.flags.dev = false; + th-orphans.revision = hackage.th-orphans."0.13.6".revisions.default; + syb.revision = hackage.syb."0.7".revisions.default; + distributive.revision = hackage.distributive."0.6".revisions.default; + distributive.flags.semigroups = true; + distributive.flags.tagged = true; + kan-extensions.revision = hackage.kan-extensions."5.2".revisions.default; + cborg.revision = hackage.cborg."0.2.1.0".revisions.default; + cborg.flags.optimize-gmp = true; + tls.revision = hackage.tls."1.4.1".revisions.default; + tls.flags.compat = true; + tls.flags.network = true; + tls.flags.hans = false; + asn1-types.revision = hackage.asn1-types."0.3.2".revisions.default; + network.revision = hackage.network."2.8.0.0".revisions.default; + async.revision = hackage.async."2.2.1".revisions.default; + async.flags.bench = false; + x509-store.revision = hackage.x509-store."1.6.6".revisions.default; + connection.revision = hackage.connection."0.2.8".revisions.default; + dlist.revision = hackage.dlist."0.8.0.5".revisions.default; + conduit.revision = hackage.conduit."1.3.1".revisions.default; + lens-family-th.revision = hackage.lens-family-th."0.5.0.2".revisions.default; + vector-instances.revision = hackage.vector-instances."3.4".revisions.default; + vector-instances.flags.hashable = true; + semigroups.revision = hackage.semigroups."0.18.5".revisions.default; + semigroups.flags.bytestring = true; + semigroups.flags.unordered-containers = true; + semigroups.flags.text = true; + semigroups.flags.tagged = true; + semigroups.flags.containers = true; + semigroups.flags.binary = true; + semigroups.flags.hashable = true; + semigroups.flags.transformers = true; + semigroups.flags.deepseq = true; + semigroups.flags.bytestring-builder = false; + th-reify-many.revision = hackage.th-reify-many."0.1.8".revisions.default; + lens-family-core.revision = hackage.lens-family-core."1.2.3".revisions.default; + base-orphans.revision = hackage.base-orphans."0.8".revisions.default; + memory.revision = hackage.memory."0.14.18".revisions.default; + memory.flags.support_bytestring = true; + memory.flags.support_basement = true; + memory.flags.support_foundation = true; + memory.flags.support_deepseq = true; + repline.revision = hackage.repline."0.2.0.0".revisions.default; + th-abstraction.revision = hackage.th-abstraction."0.2.8.0".revisions.default; + xml.revision = hackage.xml."1.3.14".revisions.default; + erf.revision = hackage.erf."2.0.0.0".revisions.default; + th-lift-instances.revision = hackage.th-lift-instances."0.1.11".revisions.default; + tagged.revision = hackage.tagged."0.8.6".revisions.default; + tagged.flags.transformers = true; + tagged.flags.deepseq = true; + haskell-src-exts.revision = hackage.haskell-src-exts."1.20.3".revisions.default; + x509.revision = hackage.x509."1.7.4".revisions.default; + keys.revision = hackage.keys."3.12.1".revisions.default; + blaze-builder.revision = hackage.blaze-builder."0.4.1.0".revisions.default; + ansi-terminal.revision = hackage.ansi-terminal."0.8.1".revisions.default; + ansi-terminal.flags.example = false; + unliftio-core.revision = hackage.unliftio-core."0.1.2.0".revisions.default; + base-compat.revision = hackage.base-compat."0.10.4".revisions.default; + x509-system.revision = hackage.x509-system."1.6.6".revisions.default; + hnix.revision = hackage.hnix."0.5.2".revisions.default; + hnix.flags.tracing = false; + hnix.flags.profiling = false; + hnix.flags.optimize = false; + tar.revision = hackage.tar."0.5.1.0".revisions.default; + tar.flags.old-time = false; + tar.flags.old-bytestring = false; + bifunctors.revision = hackage.bifunctors."5.5.3".revisions.default; + bifunctors.flags.semigroups = true; + bifunctors.flags.tagged = true; + utf8-string.revision = hackage.utf8-string."1.0.1.1".revisions.default; + cryptohash-sha256.revision = hackage.cryptohash-sha256."0.11.101.0".revisions.default; + cryptohash-sha256.flags.exe = false; + interpolate.revision = hackage.interpolate."0.2.0".revisions.default; + regex-tdfa.revision = hackage.regex-tdfa."1.2.3.1".revisions.default; + regex-tdfa.flags.devel = false; + text-metrics.revision = hackage.text-metrics."0.3.0".revisions.default; + text-metrics.flags.dev = false; + http-client-tls.revision = hackage.http-client-tls."0.3.5.3".revisions.default; + contravariant.revision = hackage.contravariant."1.5".revisions.default; + contravariant.flags.semigroups = true; + contravariant.flags.tagged = true; + contravariant.flags.statevar = true; + contravariant.flags.safe = false; + mime-types.revision = hackage.mime-types."0.1.0.8".revisions.default; + StateVar.revision = hackage.StateVar."1.1.1.1".revisions.default; + regex-base.revision = hackage.regex-base."0.93.2".revisions.default; + regex-base.flags.splitbase = true; + regex-base.flags.newbase = true; + th-expand-syns.revision = hackage.th-expand-syns."0.4.4.0".revisions.default; + cryptonite.revision = hackage.cryptonite."0.25".revisions.default; + cryptonite.flags.support_sse = false; + cryptonite.flags.integer-gmp = true; + cryptonite.flags.support_rdrand = true; + cryptonite.flags.support_aesni = true; + cryptonite.flags.support_deepseq = true; + cryptonite.flags.support_pclmuldq = false; + cryptonite.flags.check_alignment = false; + cryptonite.flags.old_toolchain_inliner = false; + zlib.revision = hackage.zlib."0.6.2".revisions.default; + zlib.flags.non-blocking-ffi = false; + zlib.flags.pkg-config = false; + network-uri.revision = hackage.network-uri."2.6.1.0".revisions.default; + asn1-parse.revision = hackage.asn1-parse."0.9.4".revisions.default; + microlens-aeson.revision = hackage.microlens-aeson."2.3.0".revisions.default; + happy.revision = hackage.happy."1.19.9".revisions.default; + happy.flags.small_base = true; + hashable.revision = hackage.hashable."1.2.7.0".revisions.default; + hashable.flags.sse2 = true; + hashable.flags.integer-gmp = true; + hashable.flags.sse41 = false; + hashable.flags.examples = false; + transformers-base.revision = hackage.transformers-base."0.4.5.2".revisions.default; + transformers-base.flags.orphaninstances = true; + cryptohash-sha512.revision = hackage.cryptohash-sha512."0.11.100.1".revisions.default; + vector-algorithms.revision = hackage.vector-algorithms."0.8.0.1".revisions.default; + vector-algorithms.flags.unsafechecks = false; + vector-algorithms.flags.internalchecks = false; + vector-algorithms.flags.llvm = false; + vector-algorithms.flags.boundschecks = true; + vector-algorithms.flags.bench = true; + vector-algorithms.flags.properties = true; + byteable.revision = hackage.byteable."0.1.1".revisions.default; + pretty-show.revision = hackage.pretty-show."1.8.2".revisions.default; + base16-bytestring.revision = hackage.base16-bytestring."0.1.1.6".revisions.default; + attoparsec.revision = hackage.attoparsec."0.13.2.2".revisions.default; + attoparsec.flags.developer = false; + colour.revision = hackage.colour."2.3.4".revisions.default; + infer-license.revision = hackage.infer-license."0.2.0".revisions.default; + optparse-applicative.revision = hackage.optparse-applicative."0.14.3.0".revisions.default; + random.revision = hackage.random."1.1".revisions.default; + uuid-types.revision = hackage.uuid-types."1.0.3".revisions.default; + scientific.revision = hackage.scientific."0.3.6.2".revisions.default; + scientific.flags.integer-simple = false; + scientific.flags.bytestring-builder = false; + monadlist.revision = hackage.monadlist."0.0.2".revisions.default; + asn1-encoding.revision = hackage.asn1-encoding."0.9.5".revisions.default; + QuickCheck.revision = hackage.QuickCheck."2.12.6.1".revisions.default; + QuickCheck.flags.templatehaskell = true; + half.revision = hackage.half."0.3".revisions.default; + haskell-src-meta.revision = hackage.haskell-src-meta."0.8.0.3".revisions.default; + cabal-doctest.revision = hackage.cabal-doctest."1.0.6".revisions.default; + libyaml.revision = hackage.libyaml."0.1.0.0".revisions.default; + libyaml.flags.system-libyaml = false; + libyaml.flags.no-unicode = false; + th-lift.revision = hackage.th-lift."0.7.11".revisions.default; + resourcet.revision = hackage.resourcet."1.2.2".revisions.default; + http-types.revision = hackage.http-types."0.12.2".revisions.default; + microlens.revision = hackage.microlens."0.4.9.1".revisions.default; + Glob.revision = hackage.Glob."0.9.3".revisions.default; + aeson.revision = hackage.aeson."1.4.1.0".revisions.default; + aeson.flags.cffi = false; + aeson.flags.fast = false; + aeson.flags.bytestring-builder = false; + aeson.flags.developer = false; + mono-traversable.revision = hackage.mono-traversable."1.0.9.0".revisions.default; + primitive.revision = hackage.primitive."0.6.4.0".revisions.default; + safe.revision = hackage.safe."0.3.17".revisions.default; + yaml.revision = hackage.yaml."0.11.0.0".revisions.default; + yaml.flags.no-exe = true; + yaml.flags.no-examples = true; + transformers-compat.revision = hackage.transformers-compat."0.6.2".revisions.default; + transformers-compat.flags.five = false; + transformers-compat.flags.generic-deriving = true; + transformers-compat.flags.two = false; + transformers-compat.flags.five-three = true; + transformers-compat.flags.mtl = true; + transformers-compat.flags.four = false; + transformers-compat.flags.three = false; + profunctors.revision = hackage.profunctors."5.3".revisions.default; + vector.revision = hackage.vector."0.12.0.1".revisions.default; + vector.flags.unsafechecks = false; + vector.flags.internalchecks = false; + vector.flags.wall = false; + vector.flags.boundschecks = true; + time-locale-compat.revision = hackage.time-locale-compat."0.1.1.5".revisions.default; + time-locale-compat.flags.old-locale = false; + hpack.revision = hackage.hpack."0.31.0".revisions.default; }; compiler = { version = "8.4.3"; @@ -220,7 +341,6 @@ hackage: distributive = dontCheck' (super.distributive); kan-extensions = dontCheck' (super.kan-extensions); cborg = dontCheck' (super.cborg); - foundation = dontCheck' (super.foundation); tls = dontCheck' (super.tls); asn1-types = dontCheck' (super.asn1-types); network = dontCheck' (super.network); @@ -250,15 +370,14 @@ hackage: unliftio-core = dontCheck' (super.unliftio-core); base-compat = dontCheck' (super.base-compat); x509-system = dontCheck' (super.x509-system); - polyparse = dontCheck' (super.polyparse); hnix = dontCheck' (super.hnix); + tar = dontCheck' (super.tar); bifunctors = dontCheck' (super.bifunctors); + utf8-string = dontCheck' (super.utf8-string); cryptohash-sha256 = dontCheck' (super.cryptohash-sha256); interpolate = dontCheck' (super.interpolate); - old-time = dontCheck' (super.old-time); regex-tdfa = dontCheck' (super.regex-tdfa); text-metrics = dontCheck' (super.text-metrics); - old-locale = dontCheck' (super.old-locale); http-client-tls = dontCheck' (super.http-client-tls); contravariant = dontCheck' (super.contravariant); mime-types = dontCheck' (super.mime-types); @@ -272,7 +391,6 @@ hackage: microlens-aeson = dontCheck' (super.microlens-aeson); happy = dontCheck' (super.happy); hashable = dontCheck' (super.hashable); - cpphs = dontCheck' (super.cpphs); transformers-base = dontCheck' (super.transformers-base); cryptohash-sha512 = dontCheck' (super.cryptohash-sha512); vector-algorithms = dontCheck' (super.vector-algorithms); @@ -292,6 +410,7 @@ hackage: half = dontCheck' (super.half); haskell-src-meta = dontCheck' (super.haskell-src-meta); cabal-doctest = dontCheck' (super.cabal-doctest); + libyaml = dontCheck' (super.libyaml); th-lift = dontCheck' (super.th-lift); resourcet = dontCheck' (super.resourcet); http-types = dontCheck' (super.http-types);