anchor.diff:  
   
     # Return a list of integers from `first' up to and including `last'.
  -  range = first: last:
  -    if last < first
  -    then []
  -    else [first] ++ range (first + 1) last;
  +  range =
  +    if builtins ? genList then
  +      first: last:
  +        if first > last
  +        then []
  +        else genList (n: first + n) (last - first + 1)
  +    else
  +      first: last:
  +        if last < first
  +        then []
  +        else [first] ++ range (first + 1) last;
   
   
     # Partition the elements of a list in two lists, `right' and
  
positive.code:     ) { right = []; wrong = []; };
  
  
    zipListsWith = f: fst: snd:
      let
        len1 = length fst;
        len2 = length snd;
        len = if len1 < len2 then len1 else len2;
        zipListsWith' = n:
          if n != len then
            [ (f (elemAt fst n) (elemAt snd n)) ]
            ++ zipListsWith' (n + 1)
          else [];
      in zipListsWith' 0;
  
    zipLists = zipListsWith (fst: snd: { inherit fst snd; });
  
  
    # Reverse the order of the elements of a list.  FIXME: O(n^2)!
    reverseList = fold (e: acc: acc ++ [ e ]) [];
  
  
    # Sort a list based on a comparator function which compares two
  
negative.code:         xs = unique (drop 1 list);
        in [x] ++ remove x xs;
  
  
    # Intersects list 'e' and another list. O(nm) complexity.
    intersectLists = e: filter (x: elem x e);
  
  
    # Subtracts list 'e' from another list. O(nm) complexity.
    subtractLists = e: filter (x: !(elem x e));
  
  }
  