Merge branch 'master' into aarch64-native

Author: angerman

README.md

@@ -0,0 +1,115 @@
+# `haskell.nix` is infrastructure for building Haskell packages with Nix
+
+[![](https://badge.buildkite.com/d453edcd29bd2f8f3f3b32c9b7d6777a33773d9671c37a6ccc.svg?branch=master)](https://buildkite.com/input-output-hk/haskell-dot-nix)
+[![](https://img.shields.io/buildkite/c8d5a20d3ff0f440f82adb9190b43c16c91e5e47e8adfa867a/master.svg?label=nightly%20updates)](https://buildkite.com/input-output-hk/haskell-dot-nix-nightly-updates)
+
+`haskell.nix` can automatically translate your Cabal or Stack project and
+its dependencies into Nix code.  
+
+## [Documentation](https://input-output-hk.github.io/haskell.nix/)
+
+## Getting started
+
+### a) Using `cabal.project`
+
+Add a `default.nix`:
+
+```nix
+let 
+  # Fetch the latest haskell.nix and import its default.nix
+  haskellNix = import (builtins.fetchTarball https://github.com/input-output-hk/haskell.nix/archive/master.tar.gz) {};
+
+  # haskell.nix provides access to the nixpkgs pins which are used by our CI, hence
+  # you will be more likely to get cache hits when using these.
+  # But you can also just use your own, e.g. '<nixpkgs>'
+  nixpkgsSrc = haskellNix.sources.nixpkgs-2003;
+
+  # haskell.nix provides some arguments to be passed to nixpkgs, including some patches
+  # and also the haskell.nix functionality itself as an overlay.
+  nixpkgsArgs = haskellNix.nixpkgsArgs;
+in
+{ pkgs ? import nixpkgsSrc nixpkgsArgs
+, haskellCompiler ? "ghc865"
+}:
+
+# 'cabalProject' generates a package set based on a cabal.project (and the corresponding .cabal files)
+pkgs.haskell-nix.cabalProject {
+  # 'cleanGit' cleans a source directory based on the files known by git
+  src = pkgs.haskell-nix.haskellLib.cleanGit { name = "haskell-nix-project"; src = ./.; };
+  compiler-nix-name = haskellCompiler;
+}
+```
+
+Note that you'll need to add a comment specifying the expected sha256
+output for your `source-repository-packages` in your `cabal.project`
+file:
+
+```
+source-repository-package
+  type: git
+  location: https://github.com/input-output-hk/iohk-monitoring-framework
+  subdir:   plugins/backend-editor
+  tag: 4956b32f039579a0e7e4fd10793f65b4c77d9044
+  --sha256: 03lyb2m4i6p7rpjqarnhsx21nx48fwk6rzsrx15k6274a4bv0pix
+```
+
+### b) Using `stack.yaml`
+
+Add a `default.nix`:
+
+```nix
+let 
+  haskellNix = import (builtins.fetchTarball https://github.com/input-output-hk/haskell.nix/archive/master.tar.gz) {};
+  nixpkgsSrc = haskellNix.sources.nixpkgs-2003;
+  nixpkgsArgs = haskellNix.nixpkgsArgs;
+in
+{ pkgs ? import nixpkgsSrc nixpkgsArgs
+}:
+pkgs.haskell-nix.stackProject {
+  src = pkgs.haskell-nix.haskellLib.cleanGit { src = ./.; };
+}
+```
+
+To build the library component of a package in the project run:
+
+```shell
+nix build -f . your-package-name.components.library
+```
+
+To build an executable:
+
+```shell
+nix build -f . your-package-name.components.exes.your-exe-name
+```
+
+To open a shell for use with `cabal` run:
+
+```shell
+nix-shell -A shellFor
+cabal new-build your-package-name
+cabal new-repl your-package-name:library:your-package-name
+```
+
+## Using binary Cache to speed up compilation
+
+To use precompiled binaries you'll need:
+
+- to configure a binary cache by following instructions on [iohk.cachix.org](https://iohk.cachix.org).
+- to pin `nixpkgs` according to [nix/sources.json](nix/sources.json).
+
+
+## Related repos
+
+The `haskell.nix` repository contains the runtime system for building
+Haskell packages in Nix. It depends on other repos, which are:
+
+- [nix-tools](https://github.com/input-output-hk/nix-tools) — provides the programs for generating Nix expressions from  Haskell projects.
+
+- [hackage.nix](https://github.com/input-output-hk/hackage.nix) — the latest contents of the [Hackage](https://hackage.haskell.org/) databases, converted to Nix expressions.
+
+- [stackage.nix](https://github.com/input-output-hk/stackage.nix) — all of the [Stackage](https://www.stackage.org/) snapshots, converted to Nix expressions.
+
+## IRC Channel
+
+Join the [#haskell.nix](https://www.irccloud.com/invite?channel=%23haskell.nix&hostname=irc.freenode.net&port=6697&ssl=1) channel on [irc.freenode.net](https://freenode.net/) to get help or discuss
+the development of `haskell.nix` and `nix-tools`.

README.org

@@ -46,7 +46,12 @@ in rec {
     # use)
     check-hydra = pkgs.buildPackages.callPackage ./scripts/check-hydra.nix {};
     check-closure-size = pkgs.buildPackages.callPackage ./scripts/check-closure-size.nix {
-      inherit (haskell) nix-tools;
+      # Includes cabal-install and hpack since these are commonly used.
+      nix-tools = pkgs.linkFarm "common-tools" [
+        { name = "nix-tools";     path = haskell.nix-tools; }
+        { name = "cabal-install"; path = haskell.cabal-install; }
+        { name = "hpack";         path = haskell.haskellPackages.hpack.components.exes.hpack; }
+      ];
     };
   };
 

build.nix

@@ -3,14 +3,20 @@
 { supportedSystems ? [ "x86_64-linux" "x86_64-darwin" ]
 , ifdLevel ? 3
 # Whether or not we are evaluating in restricted mode. This is true in Hydra, but not in Hercules.
-, restrictEval ? false }:
-let
+, restrictEval ? false
+, checkMaterialization ? false }:
+ let
   inherit (import ./ci-lib.nix) dimension platformFilterGeneric filterAttrsOnlyRecursive;
-  inherit (import ./default.nix { checkMaterialization = false; }) sources nixpkgsArgs;
+  sources = import ./nix/sources.nix {};
   nixpkgsVersions = {
     "R1909" = "nixpkgs-1909";
     "R2003" = "nixpkgs-2003";
   };
+  compilerNixNames = builtins.mapAttrs (defaultCompilerNixName: _:
+    (import ./default.nix { inherit checkMaterialization defaultCompilerNixName; }).nixpkgsArgs) {
+    ghc865 = {};
+    ghc883 = {};
+  };
   systems = nixpkgs: nixpkgs.lib.filterAttrs (_: v: builtins.elem v supportedSystems) {
     # I wanted to take these from 'lib.systems.examples', but apparently there isn't one for linux!
     linux = "x86_64-linux";
@@ -33,54 +39,45 @@ dimension "Nixpkgs version" nixpkgsVersions (nixpkgsName: nixpkgs-pin:
   let pinnedNixpkgsSrc = sources.${nixpkgs-pin};
       # We need this for generic nixpkgs stuff at the right version
       genericPkgs = import pinnedNixpkgsSrc {};
-  in dimension "System" (systems genericPkgs) (systemName: system:
-    let pkgs = import pinnedNixpkgsSrc (nixpkgsArgs // { inherit system; });
-        build = import ./build.nix { inherit pkgs ifdLevel; };
-        platformFilter = platformFilterGeneric pkgs system;
-        compilers = {
-          inherit (pkgs.haskell-nix.compiler) ghc865 ghc883;
-        };
-    in filterAttrsOnlyRecursive (_: v: platformFilter v) {
-      # Native builds
-      # TODO: can we merge this into the general case by picking an appropriate "cross system" to mean native?
-      native = pkgs.recurseIntoAttrs ({
-        inherit (build) tests tools maintainer-scripts maintainer-script-cache;
-        ghc = pkgs.recurseIntoAttrs compilers;
-      } // pkgs.lib.optionalAttrs (ifdLevel >= 1) {
-        iserv-proxy = pkgs.recurseIntoAttrs (
-          pkgs.lib.mapAttrs (ghcName: _:
-            pkgs.ghc-extra-packages."${ghcName}".iserv-proxy.components.exes.iserv-proxy
-          ) compilers);
-      } // pkgs.lib.optionalAttrs (ifdLevel >= 2) {
-        hello = (pkgs.haskell-nix.hackage-package { name = "hello"; version = "1.0.0.2"; }).components.exes.hello;
-      });
-    }
-    //
-    dimension "Cross system" (crossSystems nixpkgsName genericPkgs system) (crossSystemName: crossSystem:
-      # Cross builds
-      let pkgs = import pinnedNixpkgsSrc (nixpkgsArgs // { inherit system crossSystem; });
+  in dimension "GHC version" compilerNixNames (compilerNixName: nixpkgsArgs:
+    dimension "System" (systems genericPkgs) (systemName: system:
+      let pkgs = import pinnedNixpkgsSrc (nixpkgsArgs // { inherit system; });
           build = import ./build.nix { inherit pkgs ifdLevel; };
-      in pkgs.recurseIntoAttrs (pkgs.lib.optionalAttrs (ifdLevel >= 1) {
-        ghc = pkgs.recurseIntoAttrs compilers;
-        # TODO: look into making tools work when cross compiling
-        # inherit (build) tools;
-      } // pkgs.lib.optionalAttrs (ifdLevel >= 2) {
-        remote-iserv = pkgs.recurseIntoAttrs (
-          pkgs.lib.mapAttrs (ghcName: _:
-            pkgs.ghc-extra-packages."${ghcName}".remote-iserv.components.exes.remote-iserv
-          ) compilers);
-        iserv-proxy = pkgs.recurseIntoAttrs (
-          pkgs.lib.mapAttrs (ghcName: _:
-            pkgs.ghc-extra-packages."${ghcName}".iserv-proxy.components.exes.iserv-proxy
-          ) compilers);
-      } // pkgs.lib.optionalAttrs (ifdLevel >= 3) {
-        hello = (pkgs.haskell-nix.hackage-package { name = "hello"; version = "1.0.0.2"; }).components.exes.hello;
+          platformFilter = platformFilterGeneric pkgs system;
+      in filterAttrsOnlyRecursive (_: v: platformFilter v) {
+        # Native builds
+        # TODO: can we merge this into the general case by picking an appropriate "cross system" to mean native?
+        native = pkgs.recurseIntoAttrs ({
+          inherit (build) tests tools maintainer-scripts maintainer-script-cache;
+          ghc = pkgs.haskell-nix.compiler."${compilerNixName}";
+        } // pkgs.lib.optionalAttrs (ifdLevel >= 1) {
+          iserv-proxy = pkgs.ghc-extra-packages."${compilerNixName}".iserv-proxy.components.exes.iserv-proxy;
+        } // pkgs.lib.optionalAttrs (ifdLevel >= 2) {
+          hello = (pkgs.haskell-nix.hackage-package { name = "hello"; version = "1.0.0.2"; }).components.exes.hello;
+        });
       }
       //
-      # Tests are broken on aarch64 cross https://github.com/input-output-hk/haskell.nix/issues/513
-      pkgs.lib.optionalAttrs (crossSystemName != "aarch64-multiplatform") {
-        inherit (build) tests;
-      })
+      dimension "Cross system" (crossSystems nixpkgsName genericPkgs system) (crossSystemName: crossSystem:
+        # Cross builds
+        let pkgs = import pinnedNixpkgsSrc (nixpkgsArgs // { inherit system crossSystem; });
+            build = import ./build.nix { inherit pkgs ifdLevel; };
+        in pkgs.recurseIntoAttrs (pkgs.lib.optionalAttrs (ifdLevel >= 1) {
+          # TODO: look into cross compiling ghc itself
+          # ghc = pkgs.haskell-nix.compiler."${compilerNixName}";
+          # TODO: look into making tools work when cross compiling
+          # inherit (build) tools;
+        } // pkgs.lib.optionalAttrs (ifdLevel >= 2) {
+          remote-iserv = pkgs.ghc-extra-packages."${compilerNixName}".remote-iserv.components.exes.remote-iserv;
+          iserv-proxy = pkgs.ghc-extra-packages."${compilerNixName}".iserv-proxy.components.exes.iserv-proxy;
+        } // pkgs.lib.optionalAttrs (ifdLevel >= 3) {
+          hello = (pkgs.haskell-nix.hackage-package { name = "hello"; version = "1.0.0.2"; }).components.exes.hello;
+        }
+        //
+        # Tests are broken on aarch64 cross https://github.com/input-output-hk/haskell.nix/issues/513
+        pkgs.lib.optionalAttrs (crossSystemName != "aarch64-multiplatform") {
+          inherit (build) tests;
+        })
+      )
     )
   )
 )