nixfiles/std.nix

{ inputs, ... }: let
  std = let
    baseStd = inputs.std.lib;
    inherit (baseStd) set function list bool types optional;
    mergeWith = let
      append = {
        path
      , values
      , canMerge
      , mapToSet
      }: let
        mergeWith' = values: mergeWith {
          inherit canMerge mapToSet path;
          sets = list.map (v: (mapToSet path v).value) values;
        };
        mergeUntil = list.findIndex (function.not (canMerge path)) values;
        len = list.length values;
      in if len == 0 then { }
      else if len == 1 then list.unsafeHead values
      else if list.all (canMerge path) values then mergeWith' values
      else optional.match mergeUntil {
        just = i: let
          split = list.splitAt i values;
        in if i > 0
          then mergeWith' split._0
          else list.unsafeHead values;
        nothing = list.unsafeHead values;
      };
    in {
      canMerge ? path: v: optional.isJust (mapToSet path v),
      mapToSet ? path: v: bool.toOptional (types.attrs.check v) v,
      path ? [ ],
      sets
    }: set.mapZip (name: values: append {
      path = path ++ list.One name;
      inherit canMerge mapToSet values;
    }) sets;
    merge = sets: mergeWith {
      inherit sets;
    };
  in merge [
    baseStd
    {
      function = {
        pipe = list.foldl' (function.flip function.compose) function.id;
      };
      set = {
        inherit merge mergeWith;
        remap = f: s: set.fromList (list.map f (set.toList s));
        recursiveMap = f: s: let
          recurse = str: s: let
            g = str1: str2:
              if types.attrs.check str2
              then f (str ++ [str1]) (recurse (str ++ [str1]) str2)
              else f (str ++ [str1]) str2;
          in
            set.map g s;
        in
          f [] (recurse [] s);
      };
    }
  ];
in std