anchor.diff:          else op (elemAt list n) (fold' (n + 1));
       in fold' 0;
   
  -  /* Left fold: `fold op nul [x_1 x_2 ... x_n] == op (... (op (op nul
  -     x_1) x_2) ... x_n)'.
  +  /* `fold' is an alias of `foldr' for historic reasons */
  +  # FIXME(Profpatsch): deprecate?
  +  fold = foldr;
  +
  +
  +  /* “left fold”, like `foldr', but from the left:
  +     `foldl op nul [x_1 x_2 ... x_n] == op (... (op (op nul x_1) x_2) ... x_n)`.
  +
  +     Type:
  +       foldl :: (b -> a -> b) -> b -> [a] -> b
   
        Example:
          lconcat = foldl (a: b: a + b) "z"
          lconcat [ "a" "b" "c" ]
          => "zabc"
  +       # different types
  +       lstrange = foldl (str: int: str + toString (int + 1)) ""
  +       strange [ 1 2 3 4 ]
  +       => "a2345"
     */
     foldl = op: nul: list:
       let
  
positive.code:        any isString [ 1 { } ]
         => false
    */
    any = builtins.any or (pred: fold (x: y: if pred x then true else y) false);
  
    /* Return true iff function `pred' returns true for all elements of
       `list'.
  
negative.code:   */
    singleton = x: [x];
  
    /* “right fold” a binary function `op' between successive elements of
       `list' with `nul' as the starting value, i.e.,
       `foldr op nul [x_1 x_2 ... x_n] == op x_1 (op x_2 ... (op x_n nul))'.
       Type:
         foldr :: (a -> b -> b) -> b -> [a] -> b
  
       Example:
         concat = foldr (a: b: a + b) "z"
         concat [ "a" "b" "c" ]
         => "abcz"
         # different types
         strange = foldr (int: str: toString (int + 1) + str) "a"
         strange [ 1 2 3 4 ]
         => "2345a"
    */
    foldr = op: nul: list:
      let
        len = length list;
        fold' = n:
  