doc: manual fixup after migration

    :::

  */

  attrByPath =

    # A list of strings representing the attribute path to return from `set`

    attrPath:

    # Default value if `attrPath` does not resolve to an existing value

    default:

    # The nested attribute set to select values from

    set:

    let

      lenAttrPath = length attrPath;

    :::

  */

  hasAttrByPath =

    # A list of strings representing the attribute path to check from `set`

    attrPath:

    # The nested attribute set to check

    e:

    let

      lenAttrPath = length attrPath;

    :::

  */

  longestValidPathPrefix =

    # A list of strings representing the longest possible path that may be returned.

    attrPath:

    # The nested attribute set to check.

    v:

    let

      lenAttrPath = length attrPath;

    :::

  */

  setAttrByPath =

    # A list of strings representing the attribute path to set

    attrPath:

    # The value to set at the location described by `attrPath`

    value:

    let

      len = length attrPath;

    :::

  */

  getAttrFromPath =

    # A list of strings representing the attribute path to get from `set`

    attrPath:

    # The nested attribute set to find the value in.

    set:

    attrByPath attrPath (abort ("cannot find attribute `" + concatStringsSep "." attrPath + "'")) set;

    :::

  */

  attrVals =

    # The list of attributes to fetch from `set`. Each attribute name must exist on the attrbitue set

    nameList:

    # The set to get attribute values from

    set: map (x: set.${x}) nameList;

    :::

  */

  getAttrs =

    # A list of attribute names to get out of `set`

    names:

    # The set to get the named attributes from

    attrs: genAttrs names (name: attrs.${name});

  /**

    :::

  */

  filterAttrs =

    # Predicate taking an attribute name and an attribute value, which returns `true` to include the attribute, or `false` to exclude the attribute.

    pred:

    # The attribute set to filter

    set:

    listToAttrs (concatMap (name: let v = set.${name}; in if pred name v then [(nameValuePair name v)] else []) (attrNames set));

    :::

  */

  filterAttrsRecursive =

    # Predicate taking an attribute name and an attribute value, which returns `true` to include the attribute, or `false` to exclude the attribute.

    pred:

    # The attribute set to filter

    set:

    listToAttrs (

      concatMap (name:

    The result of the callback function is often called `acc` for accumulator. It is passed between callbacks from left to right and the final `acc` is the return value of `foldlAttrs`.

    Attention:

      There is a completely different function

      `lib.foldAttrs`

    There is a completely different function `lib.foldAttrs`

    which has nothing to do with this function, despite the similar name.

    :::

  */

  foldAttrs =

    # A function, given a value and a collector combines the two.

    op:

    # The starting value.

    nul:

    # A list of attribute sets to fold together by key.

    list_of_attrs:

    foldr (n: a:

        foldr (name: o:

    :::

  */

  collect =

  # Given an attribute's value, determine if recursion should stop.

    pred:

  # The attribute set to recursively collect.

    attrs:

    if pred attrs then

      [ attrs ]

    :::

  */

  cartesianProductOfSets =

    # Attribute set with attributes that are lists of values

    attrsOfLists:

    foldl' (listOfAttrs: attrName:

      concatMap (attrs:

    :::

  */

  nameValuePair =

    # Attribute name

    name:

    # Attribute value

    value:

    { inherit name value; };

    :::

  */

  mapAttrs' =

    # A function, given an attribute's name and value, returns a new `nameValuePair`.

    f:

    # Attribute set to map over.

    set:

    listToAttrs (map (attr: f attr set.${attr}) (attrNames set));

    Call a function for each attribute in the given set and return

    the result in a list.

    # Inputs

    `f`

    :::

  */

  mapAttrsToList =

    # A function, given an attribute's name and value, returns a new value.

    f:

    # Attribute set to map over.

    attrs:

    map (name: f name attrs.${name}) (attrNames attrs);

    ```

  */

  mapAttrsRecursive =

    # A function that, given an attribute path as a list of strings and the corresponding attribute value, returns a new value.

    f:

    # Attribute set to recursively map over.

    set:

    mapAttrsRecursiveCond (as: true) f set;

    ```

  */

  mapAttrsRecursiveCond =

    # A function that, given the attribute set the recursion is currently at, determines if to recurse deeper into that attribute set.

    cond:

    # A function that, given an attribute path as a list of strings and the corresponding attribute value, returns a new value.

    # The attribute value is either an attribute set for which `cond` returns false, or something other than an attribute set.

    f:

    # Attribute set to recursively map over.

    set:

    let

      recurse = path:

    :::

  */

  genAttrs =

    # Names of values in the resulting attribute set.

    names:

    # A function, given the name of the attribute, returns the attribute's value.

    f:

    listToAttrs (map (n: nameValuePair n (f n)) names);

    :::

  */

  isDerivation =

    # Value to check.

    value: value.type or null == "derivation";

   /**

    ```

  */

   toDerivation =

     # A store path to convert to a derivation.

     path:

     let

       path' = builtins.storePath path;

    :::

  */

  optionalAttrs =

    # Condition under which the `as` attribute set is returned.

    cond:

    # The attribute set to return if `cond` is `true`.

    as:

    if cond then as else {};

    :::

  */

  zipAttrsWithNames =

    # List of attribute names to zip.

    names:

    # A function, accepts an attribute name, all the values, and returns a combined value.

    f:

    # List of values from the list of attribute sets.

    sets:

    listToAttrs (map (name: {

      inherit name;

    :::

  */

  recursiveUpdateUntil =

    # Predicate, taking the path to the current attribute as a list of strings for attribute names, and the two values at that path from the original arguments.

    pred:

    # Left attribute set of the merge.

    lhs:

    # Right attribute set of the merge.

    rhs:

    let f = attrPath:

      zipAttrsWith (n: values:

    :::

  */

  recursiveUpdate =

    # Left attribute set of the merge.

    lhs:

    # Right attribute set of the merge.

    rhs:

    recursiveUpdateUntil (path: lhs: rhs: !(isAttrs lhs && isAttrs rhs)) lhs rhs;

    :::

  */

  matchAttrs =

    # Attribute set structure to match

    pattern:

    # Attribute set to check

    attrs:

    assert isAttrs pattern;

    all

    :::

  */

  overrideExisting =

    # Original attribute set

    old:

    # Attribute set with attributes to override in `old`.

    new:

    mapAttrs (name: value: new.${name} or value) old;

    :::

  */

  showAttrPath =

    # Attribute path to render to a string

    path:

    if path == [] then "<root attribute path>"

    else concatMapStringsSep "." escapeNixIdentifier path;

    :::

  */

  recurseIntoAttrs =

    # An attribute set to scan for derivations.

    attrs:

    attrs // { recurseForDerivations = true; };

    ```

  */

  dontRecurseIntoAttrs =

    # An attribute set to not scan for derivations.

    attrs:

    attrs // { recurseForDerivations = false; };