fix/add expected time complexity comments

src/genAttrs.nix

@@ -1,6 +1,9 @@
 lib:
 let
+  # O(n * f)
   genAttrsOld = names: f: lib.listToAttrs (map (n: lib.nameValuePair n (f n)) names);
+
+  # O(n * f)
   genAttrsNew = names: f: lib.listToAttrs (map (n: { name = n; value = f n; }) names);
 
   bigdata = lib.imap0 (i: _: toString i) (lib.replicate 999999 null);

src/getAttrs.nix

@@ -1,7 +1,12 @@
 lib:
 let
+  # O(n)? (assuming `name: attrs.${name}` is O(1))
   getAttrsOld = names: attrs: lib.genAttrs names (name: attrs.${name});
+
+  # O(n^2)
   getAttrsNew1 = names: attrs: lib.filterAttrs (n: _: builtins.elem n names) attrs;
+
+  # O(n log m) (where m is the larger attrset, i.e. `attrs` in this case)
   getAttrsNew2 = names: attrs: builtins.intersectAttrs (lib.genAttrs names (_: null)) attrs;
 
   bigdata = lib.genAttrs (lib.imap0 (i: _: toString i) (lib.replicate 999999 null)) (_: null);

src/subtractLists.nix

@@ -1,13 +1,13 @@
 lib:
 let
-  # O(nm)
+  # O(n * m)
   subtractListsOld = e: builtins.filter (x: !(builtins.elem x e));
 
   # O(n + m) (hopefully)
   subtractListsNew = e: let
-    # Assuming genAttrs is O(n)
+    # Assuming genAttrs is O(n * f) and f = (_: null) is O(1), so O(n) in total
     e' = lib.genAttrs e (_: null);
-  # Assuming hasAttr is O(1)
+  # Assuming `filter` is O(n) and  `hasAttr` is O(1)
   in builtins.filter (x: !(builtins.hasAttr x e'));
 
   bigdata = lib.imap0 (i: _: toString i) (lib.replicate 999999 null);

src/unique.nix

@@ -1,5 +1,6 @@
 lib:
 let
+  # O(n^2), assuming foldl' is O(n) and ++ causes a reallocation every time
   uniqueOld = builtins.foldl' (acc: e: if builtins.elem e acc then acc else acc ++ [ e ]) [];
   # uniqueNew = xs: let
   #   entries = lib.genAttrs xs (_: null);