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:         else op (foldl' (n - 1)) (elemAt list n);
      in foldl' (length list - 1);
  
    /* Strict version of foldl.
  
       The difference is that evaluation is forced upon access. Usually used
       with small whole results (in contract with lazily-generated list or large
  
negative.code:        all (x: x < 3) [ 1 2 3 ]
         => false
    */
    all = builtins.all or (pred: foldr (x: y: if pred x then y else false) true);
  
    /* Count how many times function `pred' returns true for the elements
       of `list'.
  