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:   # 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;
      in if found == [] then default
         else if tail found != [] then multiple
         else head found;
  
  
    # Find the first element in the list matching the specified
  
negative.code: # General list operations.
  let
    inherit (import ./trivial.nix) deepSeq;
  
    inc = builtins.add 1;
  
    dec = n: builtins.sub n 1;
  
    inherit (builtins) elemAt;
  in rec {
    inherit (builtins) head tail length isList add sub lessThan;
  
  
  