anchor.diff:      else
         head found;
   
  -
  -  # Return true iff function `pred' returns true for at least element
  -  # of `list'.
  +  /**
  +   * Return true only if function `pred' returns true for at least
  +   * element of `list'.
  +   */
     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'.
  +  /**
  +   * Return true only if function `pred' returns true for all elements
  +   * of `list'.
  +   */
     all = builtins.all or (pred: fold (x: y: if pred x then y else false) true);
   
  -
  -  # Count how many times function `pred' returns true for the elements
  -  # of `list'.
  +  /**
  +   * Count how many times function `pred' returns true for the elements
  +   * of `list'.
  +   */
     count = pred: foldl' (c: x: if pred x then c + 1 else c) 0;
   
  -
  -  # Return a singleton list or an empty list, depending on a boolean
  -  # value.  Useful when building lists with optional elements
  -  # (e.g. `++ optional (system == "i686-linux") flashplayer').
  +  /**
  +   * Return a singleton list if true or an empty list if not true.
  +   *
  +   * Example:
  +   *   [ ] ++ optional (boolean argument) element)
  +   */
     optional = cond: elem:
       if cond then
         [ elem ]
       else
         [ ];
   
  -
  -  # Return a list or an empty list, dependening on a boolean value.
  +  /**
  +   * Return a list if true or an empty list if not true.
  +   *
  +   * Example:
  +   *   [ ] ++ optionals (boolean argument) [ element1 element2 ]
  +   */
     optionals = cond: elems:
       if cond then
         elems
       else
         [ ];
   
  -
  -  # If argument is a list, return it; else, wrap it in a singleton
  -  # list.  If you're using this, you should almost certainly
  -  # reconsider if there isn't a more "well-typed" approach.
  +  /**
  +   * If argument is a list, return it; else, wrap it in a singleton
  +   * list.
  +   * 
  +   * WARNING:
  +   *   If you're using this, you should almost certainly reconsider
  +   *   a more "well-typed" approach.
  +   */
     toList = x:
       if isList x then
         x
       else
         [ x ];
   
  -
  -  # Return a list of integers from `first' up to and including `last'.
  +  /**
  +   * Return a list of integers from `first' up to and including `last'.
  +   */
     range =
       if builtins ? genList then
         first: last:
  
positive.code:       wrong = [ ];
      };
  
  
    zipListsWith =
      if builtins ? genList then
        f: fst: snd:
        genList (n: f (elemAt fst n) (elemAt snd n)) (min (length fst) (length snd))
      else
        f: fst: snd:
        let
  
negative.code:     else
        head found;
  
    /**
     * Find the first element in the list matching the specified
     * predicate or returns `default' if no such element exists.
     */
    findFirst = pred: default: list:
      let
        found = filter pred list;
  