anchor.diff:    #     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`). This function
  +  # 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:
     #
  
positive.code:   #     { 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
    # 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;
  
negative.code:   mergeAttrs = x: y: x // y;
  
    # 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; }
  