overlay -> extras

Author: angerman

default.nix

@@ -75,10 +75,10 @@ let
         # The Stackage release referenced in the stack config
         pkg-def = stackage.${stack-pkgs.resolver};
         # The compiler referenced in the stack config
-        compiler = (stack-pkgs.overlay hackage).compiler or (pkg-def hackage).compiler;
+        compiler = (stack-pkgs.extras hackage).compiler or (pkg-def hackage).compiler;
       in self.mkPkgSet {
         inherit pkg-def;
-        pkg-def-extras = [ stack-pkgs.overlay ] ++ pkg-def-extras;
+        pkg-def-extras = [ stack-pkgs.extras ] ++ pkg-def-extras;
         modules = [ ghcHackagePatches.${compiler.nix-name} ] ++ modules;
       };
 
@@ -92,10 +92,10 @@ let
       let
         pkg-def = plan-pkgs.pkgs;
         # The compiler referenced in the stack config
-        compiler = (plan-pkgs.overlay hackage).compiler or (pkg-def hackage).compiler;
+        compiler = (plan-pkgs.extras hackage).compiler or (pkg-def hackage).compiler;
       in self.mkPkgSet {
         inherit pkg-def;
-        pkg-def-extras = [ plan-pkgs.overlay ] ++ pkg-def-extras;
+        pkg-def-extras = [ plan-pkgs.extras ] ++ pkg-def-extras;
         modules = [ ghcHackagePatches.${compiler.nix-name} ] ++ modules;
       };
 

docs/iohk-nix.md

@@ -41,7 +41,7 @@ iohk-nix.json
 nix/pkgs.nix
 ```
 { pkgs ? import <nixpkgs> {}
-, iohk-overlay ? {}
+, iohk-extras ? {}
 , iohk-module ? {}
 , haskell
 , hackage
@@ -67,16 +67,16 @@ let
   #  packages.cbors.patches = [ ./one.patch ];
   #  packages.cbors.flags.optimize-gmp = false;
   #
-  compiler = (stack-pkgs.overlay hackage).compiler.nix-name;
+  compiler = (stack-pkgs.extras hackage).compiler.nix-name;
   pkgSet = haskell.mkNewPkgSet {
     inherit pkgs;
     pkg-def = stackage.${stack-pkgs.resolver};
-    # The extras allow extension or restriction of the set of
-    # packages we are interested in. By using the stack-pkgs.overlay
+    # These extras allow extension or restriction of the set of
+    # packages we are interested in. By using the stack-pkgs.extras
     # we restrict our package set to the ones provided in stack.yaml.
     pkg-def-extras = [
-      stack-pkgs.overlay
-      iohk-overlay.${compiler}
+      stack-pkgs.extras
+      iohk-extras.${compiler}
     ];
     # package customizations
     modules = [

docs/user-guide-cabal.md

@@ -50,7 +50,7 @@ file as follows:
 ```nix
 let plan = import ./plan.nix; in
 { pkg-def = plan;
-  overlay =
+  extras =
     { local-package-a = ./local-package-a.nix;
       local-package-b = ./local-package-b.nix;
       source-import-a = ./source-import-a.nix;

docs/user-guide-stack.md

@@ -17,7 +17,7 @@ This will produce a `nix/pkgs.nix` file that looks like the following:
 ```nix
 {
   resolver = "lts-12.17";
-  overlay = hackage:
+  extras = hackage:
     {
       packages = {
         "o-clock" = hackage.o-clock."0.1.1".revisions.default;
@@ -30,9 +30,9 @@ This will produce a `nix/pkgs.nix` file that looks like the following:
 }
 ```
 
-This file contains the stackage resolver, as well as an overlay of
-packages.  The overlay specifies which `extra-deps` (here: o-clock-0.1.1)
-we wanted to overlay over the stackage snapshot, and what local
+This file contains the stackage resolver, as well as set of extra
+packages.  The extras specifies which `extra-deps` (here: o-clock-0.1.1)
+we wanted to add over the stackage snapshot, and what local
 packages we want (here: my-package).
 
 *If you came here from the [User Guide](/user-guide), go back and

docs/user-guide.md

@@ -87,11 +87,11 @@ let
   pkgSet = haskell.mkPkgSet {
     pkg-def = my-pkgs.pkg-def;
     pkg-def-extras = [
-      # this overlay will provide additional packages
+      # these extras will provide additional packages
       # ontop of the package set.  E.g. extra-deps
       # for stack packages. or local packages for
       # cabal.projects
-      my-pkgs.overlay
+      my-pkgs.extras
     ];
     modules = [
       # specific package overrides would go here

package-set.nix

@@ -33,7 +33,7 @@ in pkgs.lib.evalModules {
         # or
         # { y = ./foo.nix; }
         # As such the desugarer desugars this short hand syntax.
-        let desugar = overlay:
+        let desugar = extras:
           let
             isPath  = x: builtins.typeOf x == "path";
             # rewrite
@@ -51,11 +51,11 @@ in pkgs.lib.evalModules {
             # into
             #   x.revision = import ./some/path;
             expand-paths = pkg: if !(isPath pkg.revision) then pkg else { revision = import pkg.revision; };
-          # apply injection and expansion to the "packages" in overlay.
+          # apply injection and expansion to the "packages" in extras.
           in lib.mapAttrs (k: v: if k != "packages"
                               then v
                               else lib.mapAttrs (_: pkg: (expand-paths (inject-revision pkg))) v)
-                                                (inject-packages overlay);
+                                                (inject-packages extras);
         # fold any potential `pkg-def-extras`
         # onto the `pkg-def`.
         #

test/cabal-sublib/default.nix

@@ -10,7 +10,7 @@ let
   # 3. plan-to-nix ./dist-newstyle/cache/plan.json > plan.nix
   pkgSet = mkPkgSet {
     pkg-def = import ./plan.nix;
-    pkg-def-overlays = [
+    pkg-def-extras = [
       { cabal-sublib = ./cabal-sublib.nix;
       }
     ];

test/stack-simple/stack-pkgs.nix

@@ -1,5 +1,5 @@
 {
-  overlay = hackage:
+  extras = hackage:
     { packages = {} // { stack-simple = ./.stack.nix/stack-simple.nix; }; };
   resolver = "lts-13.6";
-  }
+}