The builtin `map()`, but with superpowers.
425984
def map_plus(target: Callable, mi, ma, a, mk, k):
    """"""
    if a is None:
        a = []
    if k is None:
        k = {}

    if mi is None and ma is None and mk is None:
        return []
    elif mi is None and ma is None:
        return [target(*a, **mki, **k) for mki in mk]
    elif ma is None and mk is None:
        return [target(mii, *a, **k) for mii in mi]
    elif mk is None and mi is None:
        return [target(*mai, *a, **k) for mai in ma]
    elif mi is None:
        return [target(*mai, *a, **mki, **k) for mai, mki in zip(ma, mk)]
    elif ma is None:
        return [target(mii, *a, **mki, **k) for mii, mki in zip(mi, mk)]
    elif mk is None:
        return [target(mii, *mai, *a, **k) for mii, mai in zip(mi, ma)]
    else:
        return [target(mii, *mai, *a, **mki, **k) for mii, mai, mki in zip(mi, ma, mk)]
995953
public static <K, V, V2> MutableMap<K, V2> collectValues(
            Map<K, V> map,
            Function2<? super K, ? super V, ? extends V2> function)
    {
        return MapIterate.collectValues(map, function, UnifiedMap.<K, V2>newMap(map.size()));
    }
62017
private MultiValueMap<String, String> union(MultiValueMap<String, String> map1, MultiValueMap<String, String> map2) {
		MultiValueMap<String, String> union = new LinkedMultiValueMap<String, String>(map1);
		Set<Entry<String, List<String>>> map2Entries = map2.entrySet();
		for (Iterator<Entry<String, List<String>>> entryIt = map2Entries.iterator(); entryIt.hasNext();) {
			Entry<String, List<String>> entry = entryIt.next();
			String key = entry.getKey();
			List<String> values = entry.getValue();
			for (String value : values) {
				union.add(key, value);
			}
		}
		return union;
	}
765132
public static <K, V> Dictionary<K, V> wrap(Map<K, V> map) {
        if (map instanceof DictionaryAsMap) {
            return ((DictionaryAsMap<K, V>) map).getDictionary();
        }
        return new MapAsDictionary<K, V>(map);
    }
501019
private Map<String, Scope> getSubMap(Map<String, Map<String, Scope>> parent, String key) {

	Map<String, Scope> context = parent.get(key);
	if (context != null) return context;

	context = MapFactory.<String, Scope>getConcurrentMap();
	parent.put(key, context);
	return context;

    }
907185
function(map) {

  var Fuzzymap = {};
  var Map = map;
  var PureMap = map;
  var LastValue = null;

  if(!_.isArray(map))
    Map = [Map]

  Fuzzymap.Map = function() { return PureMap; };
  Fuzzymap.last = function() { return LastValue; };
  Fuzzymap.keys = function() {
    return _.chain(Map)
      .compact()
      .map(function(mapDefinition) {
        return _.keys(mapDefinition);
      })
      .flatten()
      .uniq()
      .value();
  }

  Fuzzymap.map = function(item) {
    LastValue = item;
    
    if(_.isObject(item))
      testObject(item);
    else
      testItem(item);

    return Fuzzymap.last();
  };

  Fuzzymap.extract = function(item) {
    LastValue = item;

    if(!_.isObject)
      return item;

    return extractObject(item);
  };

  var extractObject = function(param) {
    var result = {};
    var defaults = {};
    _.each(Map, function(MapGroup) {
      _.each(_.keys(MapGroup), function(key) {
        if(!defaults.hasOwnProperty(key))
          defaults[key] = null;
      });
    });

    _.each(_.keys(param), function(key) {
      var mappedKey = testItem(key);
      if(defaults.hasOwnProperty(mappedKey))
        defaults[mappedKey] = param[key];
    });

    return defaults;
  };

  var testObject = function(param) {
    var result = {};
    _.each(_.keys(param), function(key) {
      var mappedKey = testItem(key);
      result[mappedKey] = param[key];
    });
    LastValue = result;
    
    return result;
  };

  var testItem = function(item) {
    LastValue = item;
    _.find(Map, function(MapGroup) {
      return testGroup(item, MapGroup) !== false;
    });

    return Fuzzymap.last();
  };
    
  var testGroup = function(item, MapGroup) {
    if(nil(MapGroup))
      MapGroup = {};

    var mapped = _.find(_.keys(MapGroup), function(mapString) {
      var regexes = MapGroup[mapString];

      if(!_.isArray(regexes))
        regexes = [regexes];

      var regex = _.find(regexes, function(regex) {
        return nil(item.match(regex)) === false;
      });
      
      return nil(regex) === false;
    });

    if(!nil(mapped))
      LastValue = mapped;
    
    return nil(mapped) === false;

  };

  return Fuzzymap;
}
198450
function Map(editable, edit, config, root, size) {
    this._editable = editable;
    this._edit = edit;
    this._config = config;
    this._root = root;
    this._size = size;
}
1151959
def _compute_product(map1, map2):
        
        data = map1.data * map2.data
        return HpxMap(data, map1.hpx)
913622
def _buildElementNsmap(using_elements):
    '''
    
    '''
    thisMap = {}
    for e in using_elements:
        thisMap[e.attrib['prefix']] = e.attrib['namespace']
    return thisMap
1065404
private static int mergeMaps(Map<String, Integer> map, Map<String, Integer> other)
    {
        int deltaSize = 0;
        for (Map.Entry<String, Integer> entry : other.entrySet()) {
            if (!map.containsKey(entry.getKey())) {
                deltaSize += entry.getKey().getBytes().length + SIZE_OF_INT;
            }
            map.put(entry.getKey(), map.getOrDefault(entry.getKey(), 0) + other.getOrDefault(entry.getKey(), 0));
        }
        return deltaSize;
    }
89967
function(width, height){
            this.map.setSize(width, height);
            var map = this.map;
            this.map.each(function(val, x, y){
                if(val === void 0){
                    map.set(x, y, []);
                }
            });
        }
260239
public final <R> R map(BiFunction<? super T1, ? super T2, ? extends R> function) {
        return function.apply(v1, v2);
    }
336019
public static final <K,V> MapList<K,V> unmodifiableMapList(MapList<K,V> map)
    {
        return new UnmodifiableMapList(Collections.unmodifiableMap(map), map.getComparator());
    }
1107358
public static <K, V> Map<V, K> inverse(Map<K, V> map) {
        return inverse(map, false);
    }
138897
function map(f, a)
{
	var newA = {
		ctor: '_Array',
		height: a.height,
		table: new Array(a.table.length)
	};
	if (a.height > 0)
	{
		newA.lengths = a.lengths;
	}
	for (var i = 0; i < a.table.length; i++)
	{
		newA.table[i] =
			a.height === 0
				? f(a.table[i])
				: map(f, a.table[i]);
	}
	return newA;
}
287084
def merge_map(a, b):
    
    if isinstance(a, list) and isinstance(b, list):
        return a + b

    if not isinstance(a, dict) or not isinstance(b, dict):
        return b

    for key in b:
        a[key] = merge_map(a[key], b[key]) if key in a else b[key]
    return a
84532
def lazy_binmap(f, xs):
    
    return (f(x, y) for x, y in zip(xs, xs[1:]))