anchor.diff:  
   
     /* Utility function that creates a {name, value} pair as expected by
  -     builtins.listToAttrs. */
  +     builtins.listToAttrs.
  +
  +     Example:
  +       nameValuePair "some" 6
  +       => { name = "some"; value = 6; }
  +  */
     nameValuePair = name: value: { inherit name value; };
   
   
  
positive.code:     };
  
  
    /* If the Boolean `cond' is true, return the attribute set `as',
       otherwise an empty attribute set. */
    optionalAttrs = cond: as: if cond then as else {};
  
  
    /* Merge sets of attributes and use the function f to merge attributes
       values. */
    zipAttrsWithNames = names: f: sets:
      listToAttrs (map (name: {
        inherit name;
        value = f name (catAttrs name sets);
      }) names);
  
    # implentation note: Common names  appear multiple times in the list of
    # names, hopefully this does not affect the system because the maximal
    # laziness avoid computing twice the same expression and listToAttrs does
    # not care about duplicated attribute names.
    zipAttrsWith = f: sets: zipAttrsWithNames (concatMap attrNames sets) f sets;
  
    zipAttrs = zipAttrsWith (name: values: values);
  
    /* backward compatibility */
    zipWithNames = zipAttrsWithNames;
    zip = builtins.trace "lib.zip is deprecated, use lib.zipAttrsWith instead" zipAttrsWith;
  
  
    /* Does the same as the update operator '//' except that attributes are
       merged until the given pedicate is verified.  The predicate should
  
negative.code:       !(isAttrs lhs && isAttrs rhs)
      ) lhs rhs;
  
    /* Returns true if the pattern is contained in the set. False otherwise.
  
       FIXME(zimbatm): this example doesn't work !!!
  
       Example:
         sys = mkSystem { }
         matchAttrs { cpu = { bits = 64; }; } sys
         => true
     */
    matchAttrs = pattern: attrs:
      fold or false (attrValues (zipAttrsWithNames (attrNames pattern) (n: values:
        let pat = head values; val = head (tail values); in
  