|
| 1 | +{ |
| 2 | + inputs, |
| 3 | + cell, |
| 4 | +}: let |
| 5 | + inherit (inputs) nixpkgs std; |
| 6 | + l = nixpkgs.lib // builtins; |
| 7 | + inherit (l) throwIfNot; |
| 8 | +in ( |
| 9 | + if l ? lazyDerivation |
| 10 | + then l.lazyDerivation |
| 11 | + else |
| 12 | + { |
| 13 | + /* |
| 14 | + Restrict a derivation to a predictable set of attribute names, so |
| 15 | + that the returned attrset is not strict in the actual derivation, |
| 16 | + saving a lot of computation when the derivation is non-trivial. |
| 17 | +
|
| 18 | + This is useful in situations where a derivation might only be used for its |
| 19 | + passthru attributes, improving evaluation performance. |
| 20 | +
|
| 21 | + The returned attribute set is lazy in `derivation`. Specifically, this |
| 22 | + means that the derivation will not be evaluated in at least the |
| 23 | + situations below. |
| 24 | +
|
| 25 | + For illustration and/or testing, we define derivation such that its |
| 26 | + evaluation is very noticeable. |
| 27 | +
|
| 28 | + let derivation = throw "This won't be evaluated."; |
| 29 | +
|
| 30 | + In the following expressions, `derivation` will _not_ be evaluated: |
| 31 | +
|
| 32 | + (lazyDerivation { inherit derivation; }).type |
| 33 | +
|
| 34 | + attrNames (lazyDerivation { inherit derivation; }) |
| 35 | +
|
| 36 | + (lazyDerivation { inherit derivation; } // { foo = true; }).foo |
| 37 | +
|
| 38 | + (lazyDerivation { inherit derivation; meta.foo = true; }).meta |
| 39 | +
|
| 40 | + In these expressions, it `derivation` _will_ be evaluated: |
| 41 | +
|
| 42 | + "${lazyDerivation { inherit derivation }}" |
| 43 | +
|
| 44 | + (lazyDerivation { inherit derivation }).outPath |
| 45 | +
|
| 46 | + (lazyDerivation { inherit derivation }).meta |
| 47 | +
|
| 48 | + And the following expressions are not valid, because the refer to |
| 49 | + implementation details and/or attributes that may not be present on |
| 50 | + some derivations: |
| 51 | +
|
| 52 | + (lazyDerivation { inherit derivation }).buildInputs |
| 53 | +
|
| 54 | + (lazyDerivation { inherit derivation }).passthru |
| 55 | +
|
| 56 | + (lazyDerivation { inherit derivation }).pythonPath |
| 57 | +
|
| 58 | + */ |
| 59 | + lazyDerivation = args @ { |
| 60 | + # The derivation to be wrapped. |
| 61 | + derivation, |
| 62 | + # Optional meta attribute. |
| 63 | + # |
| 64 | + # While this function is primarily about derivations, it can improve |
| 65 | + # the `meta` package attribute, which is usually specified through |
| 66 | + # `mkDerivation`. |
| 67 | + meta ? null, |
| 68 | + # Optional extra values to add to the returned attrset. |
| 69 | + # |
| 70 | + # This can be used for adding package attributes, such as `tests`. |
| 71 | + passthru ? {}, |
| 72 | + }: let |
| 73 | + # These checks are strict in `drv` and some `drv` attributes, but the |
| 74 | + # attrset spine returned by lazyDerivation does not depend on it. |
| 75 | + # Instead, the individual derivation attributes do depend on it. |
| 76 | + checked = |
| 77 | + throwIfNot (derivation.type or null == "derivation") |
| 78 | + "lazySimpleDerivation: input must be a derivation." |
| 79 | + throwIfNot |
| 80 | + (derivation.outputs == ["out"]) |
| 81 | + # Supporting multiple outputs should be a matter of inheriting more attrs. |
| 82 | + "The derivation ${derivation.name or "<unknown>"} has multiple outputs. This is not supported by lazySimpleDerivation yet. Support could be added, and be useful as long as the set of outputs is known in advance, without evaluating the actual derivation." |
| 83 | + derivation; |
| 84 | + in |
| 85 | + { |
| 86 | + # Hardcoded `type` |
| 87 | + # |
| 88 | + # `lazyDerivation` requires its `derivation` argument to be a derivation, |
| 89 | + # so if it is not, that is a programming error by the caller and not |
| 90 | + # something that `lazyDerivation` consumers should be able to correct |
| 91 | + # for after the fact. |
| 92 | + # So, to improve laziness, we assume correctness here and check it only |
| 93 | + # when actual derivation values are accessed later. |
| 94 | + type = "derivation"; |
| 95 | + |
| 96 | + # A fixed set of derivation values, so that `lazyDerivation` can return |
| 97 | + # its attrset before evaluating `derivation`. |
| 98 | + # This must only list attributes that are available on _all_ derivations. |
| 99 | + inherit (checked) outputs out outPath outputName drvPath name system; |
| 100 | + |
| 101 | + # The meta attribute can either be taken from the derivation, or if the |
| 102 | + # `lazyDerivation` caller knew a shortcut, be taken from there. |
| 103 | + meta = args.meta or checked.meta; |
| 104 | + } |
| 105 | + // passthru; |
| 106 | + } |
| 107 | + .lazyDerivation |
| 108 | +) |
0 commit comments