mirror of
https://github.com/NixOS/nixpkgs.git
synced 2024-11-16 06:45:16 +01:00
152c63c9ff
This does break the API of being able to import any lib file and get its libs, however I'm not sure people did this. I made this while exploring being able to swap out docFn with a stub in #2305, to avoid functor performance problems. I don't know if that is going to move forward (or if it is a problem or not,) but after doing all this work figured I'd put it up anyway :) Two notable advantages to this approach: 1. when a lib inherits another lib's functions, it doesn't automatically get put in to the scope of lib 2. when a lib implements a new obscure functions, it doesn't automatically get put in to the scope of lib Using the test script (later in this commit) I got the following diff on the API: + diff master fixed-lib 11764a11765,11766 > .types.defaultFunctor > .types.defaultTypeMerge 11774a11777,11778 > .types.isOptionType > .types.isType 11781a11786 > .types.mkOptionType 11788a11794 > .types.setType 11795a11802 > .types.types This means that this commit _adds_ to the API, however I can't find a way to fix these last remaining discrepancies. At least none are _removed_. Test script (run with nix-repl in the PATH): #!/bin/sh set -eux repl() { suff=${1:-} echo "(import ./lib)$suff" \ | nix-repl 2>&1 } attrs_to_check() { repl "${1:-}" \ | tr ';' $'\n' \ | grep "\.\.\." \ | cut -d' ' -f2 \ | sed -e "s/^/${1:-}./" \ | sort } summ() { repl "${1:-}" \ | tr ' ' $'\n' \ | sort \ | uniq } deep_summ() { suff="${1:-}" depth="${2:-4}" depth=$((depth - 1)) summ "$suff" for attr in $(attrs_to_check "$suff" | grep -v "types.types"); do if [ $depth -eq 0 ]; then summ "$attr" | sed -e "s/^/$attr./" else deep_summ "$attr" "$depth" | sed -e "s/^/$attr./" fi done } ( cd nixpkgs #git add . #git commit -m "Auto-commit, sorry" || true git checkout fixed-lib deep_summ > ../fixed-lib git checkout master deep_summ > ../master ) if diff master fixed-lib; then echo "SHALLOW MATCH!" fi ( cd nixpkgs git checkout fixed-lib repl .types )
79 lines
3.1 KiB
Nix
79 lines
3.1 KiB
Nix
{ ... }:
|
|
rec {
|
|
# Compute the fixed point of the given function `f`, which is usually an
|
|
# attribute set that expects its final, non-recursive representation as an
|
|
# argument:
|
|
#
|
|
# f = self: { foo = "foo"; bar = "bar"; foobar = self.foo + self.bar; }
|
|
#
|
|
# Nix evaluates this recursion until all references to `self` have been
|
|
# resolved. At that point, the final result is returned and `f x = x` holds:
|
|
#
|
|
# nix-repl> fix f
|
|
# { bar = "bar"; foo = "foo"; foobar = "foobar"; }
|
|
#
|
|
# Type: fix :: (a -> a) -> a
|
|
#
|
|
# See https://en.wikipedia.org/wiki/Fixed-point_combinator for further
|
|
# details.
|
|
fix = f: let x = f x; in x;
|
|
|
|
# A variant of `fix` that records the original recursive attribute set in the
|
|
# result. This is useful in combination with the `extends` function to
|
|
# implement deep overriding. See pkgs/development/haskell-modules/default.nix
|
|
# for a concrete example.
|
|
fix' = f: let x = f x // { __unfix__ = f; }; in x;
|
|
|
|
# Modify the contents of an explicitly recursive attribute set in a way that
|
|
# honors `self`-references. This is accomplished with a function
|
|
#
|
|
# g = self: super: { foo = super.foo + " + "; }
|
|
#
|
|
# that has access to the unmodified input (`super`) as well as the final
|
|
# non-recursive representation of the attribute set (`self`). `extends`
|
|
# differs from the native `//` operator insofar as that it's applied *before*
|
|
# references to `self` are resolved:
|
|
#
|
|
# nix-repl> fix (extends g f)
|
|
# { bar = "bar"; foo = "foo + "; foobar = "foo + bar"; }
|
|
#
|
|
# The name of the function is inspired by object-oriented inheritance, i.e.
|
|
# think of it as an infix operator `g extends f` that mimics the syntax from
|
|
# Java. It may seem counter-intuitive to have the "base class" as the second
|
|
# argument, but it's nice this way if several uses of `extends` are cascaded.
|
|
extends = f: rattrs: self: let super = rattrs self; in super // f self super;
|
|
|
|
# Compose two extending functions of the type expected by 'extends'
|
|
# into one where changes made in the first are available in the
|
|
# 'super' of the second
|
|
composeExtensions =
|
|
f: g: self: super:
|
|
let fApplied = f self super;
|
|
super' = super // fApplied;
|
|
in fApplied // g self super';
|
|
|
|
# Create an overridable, recursive attribute set. For example:
|
|
#
|
|
# nix-repl> obj = makeExtensible (self: { })
|
|
#
|
|
# nix-repl> obj
|
|
# { __unfix__ = «lambda»; extend = «lambda»; }
|
|
#
|
|
# nix-repl> obj = obj.extend (self: super: { foo = "foo"; })
|
|
#
|
|
# nix-repl> obj
|
|
# { __unfix__ = «lambda»; extend = «lambda»; foo = "foo"; }
|
|
#
|
|
# nix-repl> obj = obj.extend (self: super: { foo = super.foo + " + "; bar = "bar"; foobar = self.foo + self.bar; })
|
|
#
|
|
# nix-repl> obj
|
|
# { __unfix__ = «lambda»; bar = "bar"; extend = «lambda»; foo = "foo + "; foobar = "foo + bar"; }
|
|
makeExtensible = makeExtensibleWithCustomName "extend";
|
|
|
|
# Same as `makeExtensible` but the name of the extending attribute is
|
|
# customized.
|
|
makeExtensibleWithCustomName = extenderName: rattrs:
|
|
fix' rattrs // {
|
|
${extenderName} = f: makeExtensibleWithCustomName extenderName (extends f rattrs);
|
|
};
|
|
}
|