anchor.diff:  let
   
     inherit (builtins)
  -    head tail isList stringLength substring lessThan sub listToAttrs;
  +    head tail isList stringLength substring lessThan sub
  +    listToAttrs attrNames hasAttr;
   
   in
   
  
positive.code:           # compared to flags flagsSet does also contain the implied flags.. This makes it easy to write assertions. ( assert args.
            inherit options flatOptions collectAttrs optsConcatStrs;
  
            buildInputs = map ( attr: if (! __hasAttr attr args) then throw "argument ${attr} is missing!" else (__getAttr attr args) )
                          (flatten  (catAttrs "buildInputs" flatOptions));
  
            configureFlags = optsConcatStrs " " "cfgOption";
  
            #flags = listToAttrs (map ( flag: av flag (__hasAttr flag options) ) (__attrNames flagConfig) );
            flags_prefixed = listToAttrs (map ( flag: av ("flag_set_"+flag) (__hasAttr flag options) ) (__attrNames flagConfig) );
  
            pass = mergeAttrs (flatten (collectAttrs "pass") );
        } #  now add additional phase actions (see examples)
  
negative.code:   any = f : l : fold logicalOR false (map f l);
  
    # iterates over a list of attributes collecting the attribute attr if it exists
    catAttrs = attr : l : fold ( s : l : if (hasAttr attr s) then [(builtins.getAttr attr s)] ++ l else l) [] l;
  
    mergeAttrs = fold ( x : y : x // y) {};
  
    flattenAttrs = set : map ( attr : builtins.getAttr attr set) (attrNames set);
    mapIf = cond : f :  fold ( x : l : if (cond x) then [(f x)] ++ l else l) [];
  
  # Marc 2nd proposal: (not everything has been tested in detail yet..)
  