docs: def lazy_value_map(f, m, *args, **kwargs):
      '''
      lazy_value_map(f, mapping) yields a lazy map whose keys are the same as those of the given dict
        or mapping object and whose values, for each key k are f(mapping[k]).
      lazy_value_map(f, mapping, *args, **kw) additionally passes the given arguments to the function
        f, so in the resulting map, each key k is mapped to f(mapping[k], *args, **kw).
  
      If a dict object that is not persistent is passed to lazy_value_map, then a persistent copy of
      it is made for use with the lazy-map; accordingly, it's not necessary to worry about the 
      persistence of the map you pass to this function. It is, however, important to worry about the
      persistence of the values in the map you pass. If these values are mutated in-place, then the
      lazy map returned from this function could change as well.
  
      If the given mapping object is an ITable object, then an ITable object is returned.
      '''
      if not is_map(m): raise ValueError('Non-mapping object passed to lazy_value_map')
      if not is_lazy_map(m) and not is_pmap(m): m = ps.pmap(m)
      def curry_fn(k): return lambda:f(m[k], *args, **kwargs)
      m0 = {k:curry_fn(k) for k in six.iterkeys(m)}
      from .table import (is_itable, itable)
      return itable(m0) if is_itable(m) else lazy_map(m0)