anchor.diff:    #     { 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 mimicks the syntax from
  +  # 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;
  
positive.code:   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 `extend` 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;
  
negative.code:   #     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:
    #
  