makeOverridable

lib.makeOverridable

Docs pulled from | This Revision | about 1 hour ago

makeOverridable takes a function from attribute set to attribute set and injects override attribute which can be used to override arguments of the function.

Please refer to documentation on <pkg>.overrideDerivation to learn about overrideDerivation and caveats related to its use.

Inputs

f: 1. Function argument

Type

makeOverridable :: (AttrSet -> a) -> AttrSet -> a

Examples

`lib.customisation.makeOverridable` usage example

nix-repl> x = {a, b}: { result = a + b; }

nix-repl> y = lib.makeOverridable x { a = 1; b = 2; }

nix-repl> y
{ override = «lambda»; overrideDerivation = «lambda»; result = 3; }

nix-repl> y.override { a = 10; }
{ override = «lambda»; overrideDerivation = «lambda»; result = 12; }

(lib.customisation.makeOverridable)

Noogle detected

Aliases

Implementation

The following is the current implementation of this function.

makeOverridable =
    f:
    let
      # Creates a functor with the same arguments as f
      mirrorArgs = mirrorFunctionArgs f;
    in
    mirrorArgs (
      origArgs:
      let
        result = f origArgs;

        # Changes the original arguments with (potentially a function that returns) a set of new attributes
        overrideWith = newArgs: origArgs // (if isFunction newArgs then newArgs origArgs else newArgs);

        # Re-call the function but with different arguments
        overrideArgs = mirrorArgs (
          /**
            Change the arguments with which a certain function is called.

            In some cases, you may find a list of possible attributes to pass in this function's `__functionArgs` attribute, but it will not be complete for an original function like `args@{foo, ...}: ...`, which accepts arbitrary attributes.

            This function was provided by `lib.makeOverridable`.
          */
          newArgs: makeOverridable f (overrideWith newArgs)
        );
        # Change the result of the function call by applying g to it
        overrideResult = g: makeOverridable (mirrorArgs (args: g (f args))) origArgs;
      in
      if isAttrs result then
        result
        // {
          override = overrideArgs;
          overrideDerivation = fdrv: overrideResult (x: overrideDerivation x fdrv);
          ${if result ? overrideAttrs then "overrideAttrs" else null} =
            /**
              Override the attributes that were passed to `mkDerivation` in order to generate this derivation.

              This function is provided by `lib.makeOverridable`, and indirectly by `callPackage` among others, in order to make the combination of `override` and `overrideAttrs` work.
              Specifically, it re-adds the `override` attribute to the result of `overrideAttrs`.

              The real implementation of `overrideAttrs` is provided by `stdenv.mkDerivation`.
            */
            # NOTE: part of the above documentation had to be duplicated in `mkDerivation`'s `overrideAttrs`.
            #       design/tech debt issue: https://github.com/NixOS/nixpkgs/issues/273815
            fdrv: overrideResult (x: x.overrideAttrs fdrv);
        }
      else if isFunction result then
        # Transform the result into a functor while propagating its arguments
        setFunctionArgs result (functionArgs result)
        // {
          override = overrideArgs;
        }
      else
        result
    );