Update lib overlay

nixpkgs/overlays/lib/attrsets.nix

@@ -1,12 +1,49 @@
-self: super:
+final: prev:
 let
-  inherit (super.lib.attrsets) listToAttrs nameValuePair;
-  inherit (super.lib.lists) foldr;
-in super.lib.attrsets // {
+  inherit (prev.lib.attrsets) mapAttrs isAttrs filterAttrs listToAttrs nameValuePair attrNames mapAttrsToList;
+  inherit (prev.lib.lists) foldr imap0 imap1;
+in prev.lib.attrsets // rec {
   # a -> [String] -> AttrSet{a}
   mapToAttrsWithConst = constant: items:
     listToAttrs (map (name: nameValuePair name constant) items);
 
   # [AttrSet] -> AttrSet
   concatAttrs = foldr (a: b: a // b) {};
+
+  # (Int -> String -> a -> a) -> AttrSet -> AttrSet
+  imap0Attrs = f: set:
+    listToAttrs (imap0 (i: attr: nameValuePair attr (f i attr set.${attr})) (attrNames set));
+
+  # (Int -> String -> a -> a) -> AttrSet -> AttrSet
+  imap1Attrs = f: set:
+    listToAttrs (imap1 (i: attr: nameValuePair attr (f i attr set.${attr})) (attrNames set));
+
+  # (Int -> String -> a -> nameValuePair) -> AttrSet -> AttrSet
+  imap0Attrs' = f: set:
+    listToAttrs (imap0 (i: attr: f i attr set.${attr}) (attrNames set));
+
+  # (Int -> String -> a -> nameValuePair) -> AttrSet -> AttrSet
+  imap1Attrs' = f: set:
+    listToAttrs (imap1 (i: attr: f i attr set.${attr}) (attrNames set));
+
+  # AttrSet -> AttrSet
+  recursivelyFlatten = set: let
+    shouldRecurse = filterAttrs (n: v: isAttrs v) set;
+    shouldNotRecurse = filterAttrs (n: v: !(isAttrs v)) set;
+    recursedAttrs = mapAttrsToList (n: v: recursivelyFlatten v) shouldRecurse;
+  in
+    concatAttrs ([shouldNotRecurse] ++ recursedAttrs);
+
+  # Takes in a predicate which decides whether or not to recurse further. (true -> recurse)
+  # This will let you recurse until you recurse until you hit attrsets with a special meaning
+  # that you would like to handle after flattening.
+  # It will also stop at everything other than an attribute set.
+  #
+  # (a -> Bool) -> AttrSet -> AttrSet
+  recursivelyFlattenUntil = pred: set: let
+    shouldRecurse = filterAttrs (n: v: isAttrs v && !(pred v)) set;
+    shouldNotRecurse = filterAttrs (n: v: !(isAttrs v) || pred v) set;
+    recursedAttrs = mapAttrsToList (n: v: recursivelyFlattenUntil pred v) shouldRecurse;
+  in
+    concatAttrs ([shouldNotRecurse] ++ recursedAttrs);
 }

nixpkgs/overlays/lib/default.nix

@@ -1,9 +1,10 @@
-self: super: 
+final: prev: 
 {
-  lib = super.lib // {
-    attrsets = import ./attrsets.nix self super;
-    lists = import ./lists.nix self super;
-    strings = import ./strings.nix self super;
-    termColors = import ./termColors.nix self super;
+  lib = prev.lib // {
+    attrsets =   (import ./attrsets.nix) final prev;
+    lists =      (import ./lists.nix) final prev;
+    strings =    (import ./strings.nix) final prev;
+    termColors = (import ./termColors.nix) final prev;
+    trivial =    (import ./trivial.nix) final prev;
   };
 }

nixpkgs/overlays/lib/lists.nix

@@ -1,8 +1,8 @@
-self: super:
+final: prev:
 let 
-  inherit (super.lib.trivial) const;
-  inherit (super.lib.lists) range any all;
-in super.lib.lists // {
+  inherit (prev.lib.trivial) const;
+  inherit (prev.lib.lists) range any all;
+in prev.lib.lists // {
   # a -> Int -> [a]
   repeat = item: times: map (const item) (range 1 times);
 

nixpkgs/overlays/lib/strings.nix

@@ -1,8 +1,9 @@
-self: super:
+final: prev:
 let
-  inherit (self.lib.lists) repeat length;
-  inherit (super.lib.strings) concatStringsSep replaceStrings splitString;
-in super.lib.strings // rec {
+  inherit (final.lib.lists) repeat length;
+  inherit (prev.lib.strings) concatStringsSep replaceStrings splitString;
+  # inherit (final.lib.strings) wrap;
+in prev.lib.strings // rec {
   # String -> [String]
   lines = splitString "\n";
 

nixpkgs/overlays/lib/termColors.nix

@@ -1,7 +1,8 @@
-self: super:
+final: prev:
 let
-  inherit (self.lib.strings) wrap;
-  inherit (super.lib.attrsets) mapAttrs' nameValuePair;
+  inherit (final.lib.strings) wrap;
+  inherit (prev.lib.attrsets) mapAttrs' nameValuePair;
+  # inherit (final.lib.myStuff.termColors) escapeCharacter escapeColor resetCharacter wrapWithColor' colorMappings;
 in rec {
   # String
   escapeCharacter = "";

nixpkgs/overlays/lib/trivial.nix

@@ -0,0 +1,7 @@
+final: prev:
+let
+in prev.lib.trivial // {
+  # a -> b -> Either (a b)
+  withDefault = default: value:
+    if (value == null) then default else value;
+}