2020-11-15 13:44:38 +00:00
|
|
|
{ lib, ... }:
|
2020-04-24 23:36:52 +00:00
|
|
|
rec {
|
2024-06-05 15:53:02 +00:00
|
|
|
/**
|
2023-10-19 13:55:26 +00:00
|
|
|
`fix f` computes the fixed point of the given function `f`. In other words, the return value is `x` in `x = f x`.
|
2023-07-15 17:15:38 +00:00
|
|
|
|
2023-10-19 13:55:26 +00:00
|
|
|
`f` must be a lazy function.
|
|
|
|
This means that `x` must be a value that can be partially evaluated,
|
|
|
|
such as an attribute set, a list, or a function.
|
|
|
|
This way, `f` can use one part of `x` to compute another part.
|
|
|
|
|
|
|
|
**Relation to syntactic recursion**
|
|
|
|
|
|
|
|
This section explains `fix` by refactoring from syntactic recursion to a call of `fix` instead.
|
|
|
|
|
|
|
|
For context, Nix lets you define attributes in terms of other attributes syntactically using the [`rec { }` syntax](https://nixos.org/manual/nix/stable/language/constructs.html#recursive-sets).
|
|
|
|
|
|
|
|
```nix
|
|
|
|
nix-repl> rec {
|
|
|
|
foo = "foo";
|
|
|
|
bar = "bar";
|
|
|
|
foobar = foo + bar;
|
|
|
|
}
|
|
|
|
{ bar = "bar"; foo = "foo"; foobar = "foobar"; }
|
2023-07-15 17:15:38 +00:00
|
|
|
```
|
2023-10-19 13:55:26 +00:00
|
|
|
|
|
|
|
This is convenient when constructing a value to pass to a function for example,
|
|
|
|
but an equivalent effect can be achieved with the `let` binding syntax:
|
|
|
|
|
|
|
|
```nix
|
|
|
|
nix-repl> let self = {
|
|
|
|
foo = "foo";
|
|
|
|
bar = "bar";
|
|
|
|
foobar = self.foo + self.bar;
|
|
|
|
}; in self
|
|
|
|
{ bar = "bar"; foo = "foo"; foobar = "foobar"; }
|
2023-07-15 17:15:38 +00:00
|
|
|
```
|
|
|
|
|
2023-10-19 13:55:26 +00:00
|
|
|
But in general you can get more reuse out of `let` bindings by refactoring them to a function.
|
2023-07-15 17:15:38 +00:00
|
|
|
|
2023-10-19 13:55:26 +00:00
|
|
|
```nix
|
|
|
|
nix-repl> f = self: {
|
|
|
|
foo = "foo";
|
|
|
|
bar = "bar";
|
|
|
|
foobar = self.foo + self.bar;
|
|
|
|
}
|
2023-07-15 17:15:38 +00:00
|
|
|
```
|
2023-10-19 13:55:26 +00:00
|
|
|
|
2023-11-16 04:20:00 +00:00
|
|
|
This is where `fix` comes in, it contains the syntactic recursion that's not in `f` anymore.
|
2023-10-19 13:55:26 +00:00
|
|
|
|
|
|
|
```nix
|
|
|
|
nix-repl> fix = f:
|
|
|
|
let self = f self; in self;
|
|
|
|
```
|
|
|
|
|
|
|
|
By applying `fix` we get the final result.
|
|
|
|
|
|
|
|
```nix
|
2023-07-15 17:15:38 +00:00
|
|
|
nix-repl> fix f
|
|
|
|
{ bar = "bar"; foo = "foo"; foobar = "foobar"; }
|
|
|
|
```
|
|
|
|
|
2023-10-19 13:55:26 +00:00
|
|
|
Such a refactored `f` using `fix` is not useful by itself.
|
|
|
|
See [`extends`](#function-library-lib.fixedPoints.extends) for an example use case.
|
|
|
|
There `self` is also often called `final`.
|
|
|
|
|
2024-06-05 15:53:02 +00:00
|
|
|
# Inputs
|
2023-10-19 13:55:26 +00:00
|
|
|
|
2024-06-05 15:53:02 +00:00
|
|
|
`f`
|
|
|
|
|
|
|
|
: 1\. Function argument
|
|
|
|
|
|
|
|
# Type
|
|
|
|
|
|
|
|
```
|
|
|
|
fix :: (a -> a) -> a
|
|
|
|
```
|
|
|
|
|
|
|
|
# Examples
|
|
|
|
:::{.example}
|
|
|
|
## `lib.fixedPoints.fix` usage example
|
|
|
|
|
|
|
|
```nix
|
|
|
|
fix (self: { foo = "foo"; bar = "bar"; foobar = self.foo + self.bar; })
|
|
|
|
=> { bar = "bar"; foo = "foo"; foobar = "foobar"; }
|
|
|
|
|
|
|
|
fix (self: [ 1 2 (elemAt self 0 + elemAt self 1) ])
|
|
|
|
=> [ 1 2 3 ]
|
|
|
|
```
|
|
|
|
|
|
|
|
:::
|
2023-07-15 17:15:38 +00:00
|
|
|
*/
|
2024-09-19 14:19:46 +00:00
|
|
|
fix =
|
|
|
|
f:
|
|
|
|
let
|
|
|
|
x = f x;
|
|
|
|
in
|
|
|
|
x;
|
2020-04-24 23:36:52 +00:00
|
|
|
|
2024-06-05 15:53:02 +00:00
|
|
|
/**
|
2023-07-15 17:15:38 +00:00
|
|
|
A variant of `fix` that records the original recursive attribute set in the
|
|
|
|
result, in an attribute named `__unfix__`.
|
|
|
|
|
|
|
|
This is useful in combination with the `extends` function to
|
|
|
|
implement deep overriding.
|
2024-06-05 15:53:02 +00:00
|
|
|
|
|
|
|
# Inputs
|
|
|
|
|
|
|
|
`f`
|
|
|
|
|
|
|
|
: 1\. Function argument
|
2023-07-15 17:15:38 +00:00
|
|
|
*/
|
2024-09-19 14:19:46 +00:00
|
|
|
fix' =
|
|
|
|
f:
|
|
|
|
let
|
|
|
|
x = f x // {
|
|
|
|
__unfix__ = f;
|
|
|
|
};
|
|
|
|
in
|
|
|
|
x;
|
2020-04-24 23:36:52 +00:00
|
|
|
|
2024-06-05 15:53:02 +00:00
|
|
|
/**
|
2023-07-15 17:15:38 +00:00
|
|
|
Return the fixpoint that `f` converges to when called iteratively, starting
|
|
|
|
with the input `x`.
|
|
|
|
|
|
|
|
```
|
|
|
|
nix-repl> converge (x: x / 2) 16
|
|
|
|
0
|
|
|
|
```
|
|
|
|
|
2024-06-05 15:53:02 +00:00
|
|
|
# Inputs
|
|
|
|
|
|
|
|
`f`
|
|
|
|
|
|
|
|
: 1\. Function argument
|
|
|
|
|
|
|
|
`x`
|
|
|
|
|
|
|
|
: 2\. Function argument
|
|
|
|
|
|
|
|
# Type
|
|
|
|
|
|
|
|
```
|
|
|
|
(a -> a) -> a -> a
|
|
|
|
```
|
2023-07-15 17:15:38 +00:00
|
|
|
*/
|
2024-09-19 14:19:46 +00:00
|
|
|
converge =
|
|
|
|
f: x:
|
2020-04-24 23:36:52 +00:00
|
|
|
let
|
|
|
|
x' = f x;
|
|
|
|
in
|
2024-09-19 14:19:46 +00:00
|
|
|
if x' == x then x else converge f x';
|
2020-04-24 23:36:52 +00:00
|
|
|
|
2024-06-05 15:53:02 +00:00
|
|
|
/**
|
2024-01-13 08:15:51 +00:00
|
|
|
Extend a function using an overlay.
|
|
|
|
|
|
|
|
Overlays allow modifying and extending fixed-point functions, specifically ones returning attribute sets.
|
|
|
|
A fixed-point function is a function which is intended to be evaluated by passing the result of itself as the argument.
|
|
|
|
This is possible due to Nix's lazy evaluation.
|
|
|
|
|
|
|
|
A fixed-point function returning an attribute set has the form
|
|
|
|
|
|
|
|
```nix
|
|
|
|
final: { # attributes }
|
|
|
|
```
|
|
|
|
|
|
|
|
where `final` refers to the lazily evaluated attribute set returned by the fixed-point function.
|
|
|
|
|
|
|
|
An overlay to such a fixed-point function has the form
|
2023-07-15 17:15:38 +00:00
|
|
|
|
|
|
|
```nix
|
2024-01-13 08:15:51 +00:00
|
|
|
final: prev: { # attributes }
|
|
|
|
```
|
|
|
|
|
|
|
|
where `prev` refers to the result of the original function to `final`, and `final` is the result of the composition of the overlay and the original function.
|
|
|
|
|
|
|
|
Applying an overlay is done with `extends`:
|
|
|
|
|
|
|
|
```nix
|
|
|
|
let
|
|
|
|
f = final: { # attributes };
|
|
|
|
overlay = final: prev: { # attributes };
|
|
|
|
in extends overlay f;
|
|
|
|
```
|
|
|
|
|
|
|
|
To get the value of `final`, use `lib.fix`:
|
|
|
|
|
|
|
|
```nix
|
|
|
|
let
|
|
|
|
f = final: { # attributes };
|
|
|
|
overlay = final: prev: { # attributes };
|
|
|
|
g = extends overlay f;
|
|
|
|
in fix g
|
|
|
|
```
|
|
|
|
|
2024-02-29 20:09:43 +00:00
|
|
|
:::{.note}
|
|
|
|
The argument to the given fixed-point function after applying an overlay will *not* refer to its own return value, but rather to the value after evaluating the overlay function.
|
|
|
|
|
|
|
|
The given fixed-point function is called with a separate argument than if it was evaluated with `lib.fix`.
|
|
|
|
:::
|
|
|
|
|
2024-01-13 08:15:51 +00:00
|
|
|
:::{.example}
|
|
|
|
|
|
|
|
# Extend a fixed-point function with an overlay
|
|
|
|
|
|
|
|
Define a fixed-point function `f` that expects its own output as the argument `final`:
|
|
|
|
|
|
|
|
```nix-repl
|
|
|
|
f = final: {
|
|
|
|
# Constant value a
|
|
|
|
a = 1;
|
|
|
|
|
|
|
|
# b depends on the final value of a, available as final.a
|
|
|
|
b = final.a + 2;
|
|
|
|
}
|
|
|
|
```
|
|
|
|
|
|
|
|
Evaluate this using [`lib.fix`](#function-library-lib.fixedPoints.fix) to get the final result:
|
|
|
|
|
|
|
|
```nix-repl
|
|
|
|
fix f
|
|
|
|
=> { a = 1; b = 3; }
|
2023-07-15 17:15:38 +00:00
|
|
|
```
|
|
|
|
|
2024-01-13 08:15:51 +00:00
|
|
|
An overlay represents a modification or extension of such a fixed-point function.
|
|
|
|
Here's an example of an overlay:
|
2023-07-15 17:15:38 +00:00
|
|
|
|
2024-01-13 08:15:51 +00:00
|
|
|
```nix-repl
|
|
|
|
overlay = final: prev: {
|
|
|
|
# Modify the previous value of a, available as prev.a
|
|
|
|
a = prev.a + 10;
|
|
|
|
|
|
|
|
# Extend the attribute set with c, letting it depend on the final values of a and b
|
|
|
|
c = final.a + final.b;
|
|
|
|
}
|
2023-07-15 17:15:38 +00:00
|
|
|
```
|
2024-01-13 08:15:51 +00:00
|
|
|
|
|
|
|
Use `extends overlay f` to apply the overlay to the fixed-point function `f`.
|
|
|
|
This produces a new fixed-point function `g` with the combined behavior of `f` and `overlay`:
|
|
|
|
|
|
|
|
```nix-repl
|
|
|
|
g = extends overlay f
|
2023-07-15 17:15:38 +00:00
|
|
|
```
|
|
|
|
|
2024-01-13 08:15:51 +00:00
|
|
|
The result is a function, so we can't print it directly, but it's the same as:
|
|
|
|
|
|
|
|
```nix-repl
|
|
|
|
g' = final: {
|
|
|
|
# The constant from f, but changed with the overlay
|
|
|
|
a = 1 + 10;
|
2023-07-15 17:15:38 +00:00
|
|
|
|
2024-01-13 08:15:51 +00:00
|
|
|
# Unchanged from f
|
|
|
|
b = final.a + 2;
|
2023-07-15 17:15:38 +00:00
|
|
|
|
2024-01-13 08:15:51 +00:00
|
|
|
# Extended in the overlay
|
|
|
|
c = final.a + final.b;
|
|
|
|
}
|
2023-07-15 17:15:38 +00:00
|
|
|
```
|
2024-01-13 08:15:51 +00:00
|
|
|
|
|
|
|
Evaluate this using [`lib.fix`](#function-library-lib.fixedPoints.fix) again to get the final result:
|
|
|
|
|
|
|
|
```nix-repl
|
|
|
|
fix g
|
|
|
|
=> { a = 11; b = 13; c = 24; }
|
2023-07-15 17:15:38 +00:00
|
|
|
```
|
2024-01-13 08:15:51 +00:00
|
|
|
:::
|
|
|
|
|
2024-06-05 15:53:02 +00:00
|
|
|
# Inputs
|
|
|
|
|
|
|
|
`overlay`
|
2024-01-13 08:15:51 +00:00
|
|
|
|
2024-06-05 15:53:02 +00:00
|
|
|
: The overlay to apply to the fixed-point function
|
2024-01-13 08:15:51 +00:00
|
|
|
|
2024-06-05 15:53:02 +00:00
|
|
|
`f`
|
2024-01-13 08:15:51 +00:00
|
|
|
|
2024-06-05 15:53:02 +00:00
|
|
|
: The fixed-point function
|
2024-01-13 08:15:51 +00:00
|
|
|
|
2024-06-05 15:53:02 +00:00
|
|
|
# Type
|
|
|
|
|
|
|
|
```
|
|
|
|
extends :: (Attrs -> Attrs -> Attrs) # The overlay to apply to the fixed-point function
|
|
|
|
-> (Attrs -> Attrs) # A fixed-point function
|
|
|
|
-> (Attrs -> Attrs) # The resulting fixed-point function
|
|
|
|
```
|
|
|
|
|
|
|
|
# Examples
|
|
|
|
:::{.example}
|
|
|
|
## `lib.fixedPoints.extends` usage example
|
|
|
|
|
|
|
|
```nix
|
|
|
|
f = final: { a = 1; b = final.a + 2; }
|
|
|
|
|
|
|
|
fix f
|
|
|
|
=> { a = 1; b = 3; }
|
|
|
|
|
|
|
|
fix (extends (final: prev: { a = prev.a + 10; }) f)
|
|
|
|
=> { a = 11; b = 13; }
|
|
|
|
|
|
|
|
fix (extends (final: prev: { b = final.a + 5; }) f)
|
|
|
|
=> { a = 1; b = 6; }
|
|
|
|
|
|
|
|
fix (extends (final: prev: { c = final.a + final.b; }) f)
|
|
|
|
=> { a = 1; b = 3; c = 4; }
|
|
|
|
```
|
|
|
|
|
|
|
|
:::
|
2023-07-15 17:15:38 +00:00
|
|
|
*/
|
2024-01-13 08:15:51 +00:00
|
|
|
extends =
|
2024-09-19 14:19:46 +00:00
|
|
|
overlay: f:
|
2024-01-13 08:15:51 +00:00
|
|
|
# The result should be thought of as a function, the argument of that function is not an argument to `extends` itself
|
|
|
|
(
|
|
|
|
final:
|
|
|
|
let
|
|
|
|
prev = f final;
|
|
|
|
in
|
|
|
|
prev // overlay final prev
|
|
|
|
);
|
2020-04-24 23:36:52 +00:00
|
|
|
|
2024-06-05 15:53:02 +00:00
|
|
|
/**
|
2024-09-19 14:19:46 +00:00
|
|
|
Compose two overlay functions and return a single overlay function that combines them.
|
|
|
|
For more details see: [composeManyExtensions](#function-library-lib.fixedPoints.composeManyExtensions).
|
|
|
|
*/
|
|
|
|
composeExtensions =
|
|
|
|
f: g: final: prev:
|
|
|
|
let
|
|
|
|
fApplied = f final prev;
|
|
|
|
prev' = prev // fApplied;
|
|
|
|
in
|
|
|
|
fApplied // g final prev';
|
|
|
|
|
|
|
|
/**
|
|
|
|
Composes a list of [`overlays`](#chap-overlays) and returns a single overlay function that combines them.
|
2024-06-05 15:53:02 +00:00
|
|
|
|
2024-09-19 14:19:46 +00:00
|
|
|
:::{.note}
|
|
|
|
The result is produced by using the update operator `//`.
|
|
|
|
This means nested values of previous overlays are not merged recursively.
|
|
|
|
In other words, previously defined attributes are replaced, ignoring the previous value, unless referenced by the overlay; for example `final: prev: { foo = final.foo + 1; }`.
|
|
|
|
:::
|
2024-06-05 15:53:02 +00:00
|
|
|
|
|
|
|
# Inputs
|
|
|
|
|
2024-09-19 14:19:46 +00:00
|
|
|
`extensions`
|
2024-06-05 15:53:02 +00:00
|
|
|
|
2024-09-19 14:19:46 +00:00
|
|
|
: A list of overlay functions
|
|
|
|
:::{.note}
|
|
|
|
The order of the overlays in the list is important.
|
|
|
|
:::
|
2024-06-05 15:53:02 +00:00
|
|
|
|
2024-09-19 14:19:46 +00:00
|
|
|
: Each overlay function takes two arguments, by convention `final` and `prev`, and returns an attribute set.
|
|
|
|
- `final` is the result of the fixed-point function, with all overlays applied.
|
|
|
|
- `prev` is the result of the previous overlay function(s).
|
2024-06-05 15:53:02 +00:00
|
|
|
|
2024-09-19 14:19:46 +00:00
|
|
|
# Type
|
2024-06-05 15:53:02 +00:00
|
|
|
|
2024-09-19 14:19:46 +00:00
|
|
|
```
|
|
|
|
# Pseudo code
|
|
|
|
let
|
|
|
|
# final prev
|
|
|
|
# ↓ ↓
|
|
|
|
OverlayFn = { ... } -> { ... } -> { ... };
|
|
|
|
in
|
|
|
|
composeManyExtensions :: ListOf OverlayFn -> OverlayFn
|
|
|
|
```
|
2024-06-05 15:53:02 +00:00
|
|
|
|
2024-09-19 14:19:46 +00:00
|
|
|
# Examples
|
|
|
|
:::{.example}
|
|
|
|
## `lib.fixedPoints.composeManyExtensions` usage example
|
2024-06-05 15:53:02 +00:00
|
|
|
|
2024-09-19 14:19:46 +00:00
|
|
|
```nix
|
|
|
|
let
|
|
|
|
# The "original function" that is extended by the overlays.
|
|
|
|
# Note that it doesn't have prev: as argument since no overlay function precedes it.
|
|
|
|
original = final: { a = 1; };
|
2024-06-05 15:53:02 +00:00
|
|
|
|
2024-09-19 14:19:46 +00:00
|
|
|
# Each overlay function has 'final' and 'prev' as arguments.
|
|
|
|
overlayA = final: prev: { b = final.c; c = 3; };
|
|
|
|
overlayB = final: prev: { c = 10; x = prev.c or 5; };
|
2020-04-24 23:36:52 +00:00
|
|
|
|
2024-09-19 14:19:46 +00:00
|
|
|
extensions = composeManyExtensions [ overlayA overlayB ];
|
2023-07-15 17:15:38 +00:00
|
|
|
|
2024-09-19 14:19:46 +00:00
|
|
|
# Caluculate the fixed point of all composed overlays.
|
|
|
|
fixedpoint = lib.fix (lib.extends extensions original );
|
|
|
|
|
|
|
|
in fixedpoint
|
|
|
|
=>
|
|
|
|
{
|
|
|
|
a = 1;
|
|
|
|
b = 10;
|
|
|
|
c = 10;
|
|
|
|
x = 3;
|
|
|
|
}
|
2023-07-15 17:15:38 +00:00
|
|
|
```
|
2024-09-19 14:19:46 +00:00
|
|
|
:::
|
2023-07-15 17:15:38 +00:00
|
|
|
*/
|
2024-09-19 14:19:46 +00:00
|
|
|
composeManyExtensions = lib.foldr (x: y: composeExtensions x y) (final: prev: { });
|
2020-11-15 13:44:38 +00:00
|
|
|
|
2024-06-05 15:53:02 +00:00
|
|
|
/**
|
2023-07-15 17:15:38 +00:00
|
|
|
Create an overridable, recursive attribute set. For example:
|
|
|
|
|
|
|
|
```
|
2024-09-19 14:19:46 +00:00
|
|
|
nix-repl> obj = makeExtensible (final: { })
|
2023-07-15 17:15:38 +00:00
|
|
|
|
|
|
|
nix-repl> obj
|
|
|
|
{ __unfix__ = «lambda»; extend = «lambda»; }
|
|
|
|
|
2024-09-19 14:19:46 +00:00
|
|
|
nix-repl> obj = obj.extend (final: prev: { foo = "foo"; })
|
2023-07-15 17:15:38 +00:00
|
|
|
|
|
|
|
nix-repl> obj
|
|
|
|
{ __unfix__ = «lambda»; extend = «lambda»; foo = "foo"; }
|
|
|
|
|
2024-09-19 14:19:46 +00:00
|
|
|
nix-repl> obj = obj.extend (final: prev: { foo = prev.foo + " + "; bar = "bar"; foobar = final.foo + final.bar; })
|
2023-07-15 17:15:38 +00:00
|
|
|
|
|
|
|
nix-repl> obj
|
|
|
|
{ __unfix__ = «lambda»; bar = "bar"; extend = «lambda»; foo = "foo + "; foobar = "foo + bar"; }
|
|
|
|
```
|
|
|
|
*/
|
2020-04-24 23:36:52 +00:00
|
|
|
makeExtensible = makeExtensibleWithCustomName "extend";
|
|
|
|
|
2024-06-05 15:53:02 +00:00
|
|
|
/**
|
2023-07-15 17:15:38 +00:00
|
|
|
Same as `makeExtensible` but the name of the extending attribute is
|
|
|
|
customized.
|
2024-06-05 15:53:02 +00:00
|
|
|
|
|
|
|
# Inputs
|
|
|
|
|
|
|
|
`extenderName`
|
|
|
|
|
|
|
|
: 1\. Function argument
|
|
|
|
|
|
|
|
`rattrs`
|
|
|
|
|
|
|
|
: 2\. Function argument
|
2023-07-15 17:15:38 +00:00
|
|
|
*/
|
2024-09-19 14:19:46 +00:00
|
|
|
makeExtensibleWithCustomName =
|
|
|
|
extenderName: rattrs:
|
|
|
|
fix' (
|
|
|
|
self:
|
|
|
|
(rattrs self)
|
|
|
|
// {
|
|
|
|
${extenderName} = f: makeExtensibleWithCustomName extenderName (extends f rattrs);
|
|
|
|
}
|
|
|
|
);
|
|
|
|
|
|
|
|
/**
|
|
|
|
Convert to an extending function (overlay).
|
|
|
|
|
|
|
|
`toExtension` is the `toFunction` for extending functions (a.k.a. extensions or overlays).
|
|
|
|
It converts a non-function or a single-argument function to an extending function,
|
|
|
|
while returning a two-argument function as-is.
|
|
|
|
|
|
|
|
That is, it takes a value of the shape `x`, `prev: x`, or `final: prev: x`,
|
|
|
|
and returns `final: prev: x`, assuming `x` is not a function.
|
|
|
|
|
|
|
|
This function takes care of the input to `stdenv.mkDerivation`'s
|
|
|
|
`overrideAttrs` function.
|
|
|
|
It bridges the gap between `<pkg>.overrideAttrs`
|
|
|
|
before and after the overlay-style support.
|
|
|
|
|
|
|
|
# Inputs
|
|
|
|
|
|
|
|
`f`
|
|
|
|
: The function or value to convert to an extending function.
|
|
|
|
|
|
|
|
# Type
|
|
|
|
|
|
|
|
```
|
|
|
|
toExtension ::
|
|
|
|
b' -> Any -> Any -> b'
|
|
|
|
or
|
|
|
|
toExtension ::
|
|
|
|
(a -> b') -> Any -> a -> b'
|
|
|
|
or
|
|
|
|
toExtension ::
|
|
|
|
(a -> a -> b) -> a -> a -> b
|
|
|
|
where b' = ! Callable
|
|
|
|
|
|
|
|
Set a = b = b' = AttrSet & ! Callable to make toExtension return an extending function.
|
|
|
|
```
|
|
|
|
|
|
|
|
# Examples
|
|
|
|
:::{.example}
|
|
|
|
## `lib.fixedPoints.toExtension` usage example
|
|
|
|
|
|
|
|
```nix
|
|
|
|
fix (final: { a = 0; c = final.a; })
|
|
|
|
=> { a = 0; c = 0; };
|
|
|
|
|
|
|
|
fix (extends (toExtension { a = 1; b = 2; }) (final: { a = 0; c = final.a; }))
|
|
|
|
=> { a = 1; b = 2; c = 1; };
|
|
|
|
|
|
|
|
fix (extends (toExtension (prev: { a = 1; b = prev.a; })) (final: { a = 0; c = final.a; }))
|
|
|
|
=> { a = 1; b = 0; c = 1; };
|
|
|
|
|
|
|
|
fix (extends (toExtension (final: prev: { a = 1; b = prev.a; c = final.a + 1 })) (final: { a = 0; c = final.a; }))
|
|
|
|
=> { a = 1; b = 0; c = 2; };
|
|
|
|
```
|
|
|
|
:::
|
|
|
|
*/
|
|
|
|
toExtension =
|
|
|
|
f:
|
|
|
|
if lib.isFunction f then
|
|
|
|
final: prev:
|
|
|
|
let
|
|
|
|
fPrev = f prev;
|
|
|
|
in
|
|
|
|
if lib.isFunction fPrev then
|
|
|
|
# f is (final: prev: { ... })
|
|
|
|
f final prev
|
|
|
|
else
|
|
|
|
# f is (prev: { ... })
|
|
|
|
fPrev
|
|
|
|
else
|
|
|
|
# f is not a function; probably { ... }
|
|
|
|
final: prev: f;
|
2020-04-24 23:36:52 +00:00
|
|
|
}
|