.mergeState(path Array, value Object) :void
773054
function () {
      var path = Immutable.List();
      for (var i = 0; i < arguments.length - 1; i++) {
        path = path.concat(arguments[i]);
      }
      var value = arguments[arguments.length - 1];
      this.state = this.state.mergeIn(path, Immutable.fromJS(value));
      this.emitChange();
    }
604187
function mergeConfigRecursively(baseObject, data) {
        var i;
        for (i in data) {
            if (data[i] !== undefined) {

                // exception
                if (baseObject[i] !== undefined && typeof data[i] !== typeof baseObject[i]) {
                    grunt.log.error('Data types not mutch. Property: ' + i +
                        ' {' + typeof baseObject[i] + '} !== {' +  typeof data[i] + '}');
                }

                // simple file type
                if (
                    baseObject[i] === undefined ||
                        typeof data[i] !== 'object' ||
                        data[i] instanceof Array
                ) {
                    baseObject[i] = data[i];
                } else {
                    mergeConfigRecursively(baseObject[i], data[i]);
                }
            }
        }
    }
313486
function merge(var_args) {
              var args = [].slice.call(arguments),
                  newObj = Object.create(null),
                  id = 0, key;

              while (args[id]) {
                for (key in args[id]) {
                  newObj[key] = args[id][key];
                }

                id++;
              }

              return newObj;
            }
796958
public void mergeWith(Core o) {
    o.num = this.num = (num < o.num ? num : o.num);
  }
691379
static boolean mergeKeepUpdate(Session session, HashMappedList rowSet,
                                   int[] cols, Type[] colTypes, Row row,
                                   Object[] newData) {

        Object[] data = (Object[]) rowSet.get(row);

        if (data != null) {
            if (IndexAVL
                    .compareRows(row
                        .getData(), newData, cols, colTypes) != 0 && IndexAVL
                            .compareRows(newData, data, cols, colTypes) != 0) {
                return false;
            }

            for (int j = 0; j < cols.length; j++) {
                newData[cols[j]] = data[cols[j]];
            }

            rowSet.put(row, newData);
        } else {
            rowSet.add(row, newData);
        }

        return true;
    }
1029195
function(options)
{
    if ('undefined' === typeof options) {
        throw new Error('No options defined');
    }

    this.path    = options.path || null;
    this.default = options.default || {};
    this.values  = options.values || {};

    if (options.default && options.values) {
        this.merge(options.values);
    }

    if (this.path) {
        this.load();
    }
}
881620
function setValueForPath(object, path, value, index) {
		index = index || 0;

		if (path.length > index + 1) {
			var obj = object[path[index]];

			// we always want the last object in an array
			if (_.isArray(obj)) obj = _.last(obj);

			setValueForPath(obj, path, value, index + 1);
		} else {
			// found the object so set its value
			object[path[index]] = value;
		}
	}
1369423
function merge (target, source) {
  if (isMergeable(source)) {
    var keys = Object.keys(source);
    for (var i = 0; i < keys.length; i++) {
      var key = keys[i];
      var sourceSetting = source[key];
      var targetSetting = target[key];

      if (isMergeable(sourceSetting)) {
        // It's a nested object, so merge it recursively
        target[key] = merge(targetSetting || {}, sourceSetting);
      }
      else if (sourceSetting !== undefined) {
        // It's a scalar value, function, or array. No merging necessary. Just overwrite the target value.
        target[key] = sourceSetting;
      }
    }
  }
  return target;
}
181694
function mergeInto(one, two) {
  checkMergeObjectArg(one);
  if (two != null) {
    checkMergeObjectArg(two);
    for (var key in two) {
      if (!two.hasOwnProperty(key)) {
        continue;
      }
      one[key] = two[key];
    }
  }
}
1271769
function merge(destination, source, preserve) {
        preserve = preserve || [];

        for (var property in source) {
          if (preserve.indexOf(property) === -1) {
            destination[property] = source[property];
          }
        }

        return destination;
      }
222463
function merge(defaultObject, objectToMerge) {
		var key;
		if (!objectToMerge) {
			return defaultObject;
		}

		for (key in objectToMerge) {
			defaultObject[key] = objectToMerge[key];
		}

		return defaultObject;
	}
1081715
function update (key, value) {
  if (Array.isArray(key)) {
    return AsyncStorage.multiMerge(key.map(([key, val]) => [key, JSON.stringify(val)]))
  }

  return AsyncStorage.mergeItem(key, JSON.stringify(value))
}
725012
function mergeDeepObjects(object1, object2) {
  const keys1 = Object.keys(object1);
  const keys2 = Object.keys(object2);

  let index = -1,
      mergedObject = {},
      key,
      indexOfKey;

  while (++index < keys1.length) {
    key = keys1[index];
    indexOfKey = keys2.indexOf(key);

    if (~indexOfKey) {
      mergedObject[key] = getDeeplyMergedValues(object1[key], object2[key]);

      keys2.splice(indexOfKey, 1);

      continue;
    }

    mergedObject[key] = object1[key];
  }

  if (keys2.length) {
    index = -1;

    while (++index < keys2.length) {
      key = keys2[index];

      mergedObject[key] = object2[key];
    }
  }

  return mergedObject;
}
438968
private void mergeProperties(Map<ExecutionConfigSource, Map<ExecutionProperty, List<String>>> sourceToPropertiesMap) {
        for ( ExecutionConfigSource s : propertySources) {
            Map<ExecutionProperty, List<String>> properties = sourceToPropertiesMap.get(s);
            for ( ExecutionProperty p : properties.keySet()) {
                List<String> valuesFromSource = properties.get(p);
                if ( valuesFromSource != null && !valuesFromSource.isEmpty()) {
                    List<String> vals = getOrCreatePropertyValues(p);
                    mergeValues(valuesFromSource, p, vals);
                }
            }
        }
    }
740299
function merge() {
    assert.object(arguments[0]);
    var obj = {};
    for (var i = 0; i < arguments.length; ++i) {
        _merge(obj, arguments[i]);
    }
    return (obj);
}
983828
private <T> T mergeObjectEncodedAsGroup(T value, final Schema<T> schema) throws IOException
    {
        // if (recursionDepth >= recursionLimit) {
        // throw ProtobufException.recursionLimitExceeded();
        // }
        // ++recursionDepth;

        if (value == null)
        {
            value = schema.newMessage();
        }
        schema.mergeFrom(this, value);
        if (!schema.isInitialized(value))
        {
            throw new UninitializedMessageException(value, schema);
        }
        // handling is in #readFieldNumber
        checkLastTagWas(0);
        // --recursionDepth;
        return value;
    }
192367
function(k, v) {
            var type = objType(v),
                tarType = objType(target[k]);

            if (deep && (type == "array" || type == "object")) {
                target[k] = type == tarType && (tarType == "array" || tarType == "object") ? target[k] : type == "array" ? [] : {};

                //to merge recursively
                jsonQ.merge(deep, target[k], v);
            } else {
                target[k] = v;
            }
        }