anchor.diff:    # `list' with `nul' as the starting value, i.e., `fold op nul [x_1
     # x_2 ... x_n] == op x_1 (op x_2 ... (op x_n nul))'.  (This is
     # Haskell's foldr).
  -  fold =
  -    if builtins ? elemAt
  -    then op: nul: list:
  -      let
  -        len = length list;
  -        fold' = n:
  -          if n == len
  -          then nul
  -          else op (builtins.elemAt list n) (fold' (add n 1));
  -      in fold' 0
  -    else op: nul:
  -      let fold' = list:
  -        if list == []
  +  fold = op: nul: list:
  +    let
  +      len = length list;
  +      fold' = n:
  +        if n == len
           then nul
  -        else op (head list) (fold' (tail list));
  -      in fold';
  -
  -    
  +        else op (elemAt list n) (fold' (inc n));
  +    in fold' 0;
  +
     # Left fold: `fold op nul [x_1 x_2 ... x_n] == op (... (op (op nul
     # x_1) x_2) ... x_n)'.
  -  foldl =
  -    if builtins ? elemAt
  -    then op: nul: list:
  -      let
  -        len = length list;
  -        foldl' = n:
  -          if n == minus1
  -          then nul
  -          else op (foldl' (sub n 1)) (builtins.elemAt list n);
  -      in foldl' (sub (length list) 1)
  -    else op:
  -      let foldl' = nul: list:
  -        if list == []
  +  foldl = op: nul: list:
  +    let
  +      len = length list;
  +      foldl' = n:
  +        if n == minus1
           then nul
  -        else foldl' (op nul (head list)) (tail list);
  -      in foldl';
  -
  -  minus1 = sub 0 1;
  +        else op (foldl' (dec n)) (elemAt list n);
  +    in foldl' (dec (length list));
  +
  +  minus1 = dec 0;
   
   
     # map with index: `imap (i: v: "${v}-${toString i}") ["a" "b"] ==
     # ["a-1" "b-2"]'
     imap = f: list:
  -    zipListsWith f (range 1 (length list)) list;
  +    let
  +      len = length list;
  +      imap' = n:
  +        if n == len
  +          then []
  +          else [ (f n (elemAt list n)) ] ++ imap' (inc n);
  +    in imap' 0;
   
       
     # Concatenate a list of lists.
  
positive.code: 
  
    zipListsWith = f: fst: snd:
      if fst != [] && snd != [] then
        [ (f (head fst) (head snd)) ]
        ++ zipListsWith f (tail fst) (tail snd)
      else [];
  
    zipLists = zipListsWith (fst: snd: { inherit fst snd; });
  
    
    # Reverse the order of the elements of a list.
    reverseList = l:
      let reverse_ = accu: l:
        if l == [] then accu
        else reverse_ ([(head l)] ++ accu) (tail l);
      in reverse_ [] l;
  
      
    # Sort a list based on a comparator function which compares two
    # elements and returns true if the first argument is strictly below
    # the second argument.  The returned list is sorted in an increasing
    # order.  The implementation does a quick-sort.
    sort = strictLess: list:
      let
        # This implementation only has one element list on the left hand
        # side of the concatenation operator.
        qs = l: concat:
          if l == [] then concat
          else if length l == 1 then l ++ concat
          else let
            part = partition (strictLess (head l)) (tail l);
          in
            qs part.wrong ([(head l)] ++ qs part.right concat);
      in
        qs list [];
  
  
    # Return the first (at most) N elements of a list.
    take = count: list:
      if list == [] || count == 0 then []
      else [ (head list) ] ++ take (builtins.sub count 1) (tail list);
  
      
    # Remove the first (at most) N elements of a list.
    drop = count: list:
      if count == 0 then list
      else drop (builtins.sub count 1) (tail list);
  
      
    last = list:
      assert list != [];
      let loop = l: if tail l == [] then head l else loop (tail l); in
      loop list;
  
  
    # Zip two lists together.
    zipTwoLists = xs: ys:
      if xs != [] && ys != [] then
        [ {first = head xs; second = head ys;} ]
        ++ zipTwoLists (tail xs) (tail ys)
      else [];
  
    deepSeqList = xs: y: if any (x: deepSeq x false) xs then y else y;
  }
  
negative.code:   # predicate, returns `default' if no such element exists, or
    # `multiple' if there are multiple matching elements.
    findSingle = pred: default: multiple: list:
      let found = filter pred list; len = length found;
      in if len == 0 then default
        else if len != 1 then multiple
        else head found;
  
  
    # Find the first element in the list matching the specified
  