mine merge strategy: mine params over their. If params is already defined it gets overriden.
555106
function (mine, their) {
        this._doMerge(mine, their, function(k){
            mine[k] = their[k];
        });

        return mine;
    }
997353
def merge(base, opts= {})
      logger.info { "Merging #{branches.current.name} with #{base}" }
      args = []
      args << '-s' << opts[:merge_strategy] if opts[:merge_strategy]
      args << base
      return command(:merge, args)
    end
874826
def process_request_params(
        self,
        params: Sequence[ExtensionParameter],
        accepted_extensions: Sequence["Extension"],
    ) -> Tuple[List[ExtensionParameter], PerMessageDeflate]:
        
        if any(other.name == self.name for other in accepted_extensions):
            raise NegotiationError(f"Skipped duplicate {self.name}")

        # Load request parameters in local variables.
        (
            server_no_context_takeover,
            client_no_context_takeover,
            server_max_window_bits,
            client_max_window_bits,
        ) = _extract_parameters(params, is_server=True)

        # Configuration parameters are available in instance variables.

        # After comparing the request and the configuration, the response must
        # be available in the local variables.

        # server_no_context_takeover
        #
        #   Config  Req.    Resp.
        #   ------  ------  --------------------------------------------------
        #   False   False   False
        #   False   True    True
        #   True    False   True - must change value to True
        #   True    True    True

        if self.server_no_context_takeover:
            if not server_no_context_takeover:
                server_no_context_takeover = True

        # client_no_context_takeover
        #
        #   Config  Req.    Resp.
        #   ------  ------  --------------------------------------------------
        #   False   False   False
        #   False   True    True (or False)
        #   True    False   True - must change value to True
        #   True    True    True (or False)

        if self.client_no_context_takeover:
            if not client_no_context_takeover:
                client_no_context_takeover = True

        # server_max_window_bits

        #   Config  Req.    Resp.
        #   ------  ------  --------------------------------------------------
        #   None    None    None
        #   None    8≤M≤15  M
        #   8≤N≤15  None    N - must change value
        #   8≤N≤15  8≤M≤N   M
        #   8≤N≤15  N<M≤15  N - must change value

        if self.server_max_window_bits is None:
            pass

        else:
            if server_max_window_bits is None:
                server_max_window_bits = self.server_max_window_bits
            elif server_max_window_bits > self.server_max_window_bits:
                server_max_window_bits = self.server_max_window_bits

        # client_max_window_bits

        #   Config  Req.    Resp.
        #   ------  ------  --------------------------------------------------
        #   None    None    None
        #   None    True    None - must change value
        #   None    8≤M≤15  M (or None)
        #   8≤N≤15  None    Error!
        #   8≤N≤15  True    N - must change value
        #   8≤N≤15  8≤M≤N   M (or None)
        #   8≤N≤15  N<M≤15  N

        if self.client_max_window_bits is None:
            if client_max_window_bits is True:
                client_max_window_bits = self.client_max_window_bits

        else:
            if client_max_window_bits is None:
                raise NegotiationError("Required client_max_window_bits")
            elif client_max_window_bits is True:
                client_max_window_bits = self.client_max_window_bits
            elif self.client_max_window_bits < client_max_window_bits:
                client_max_window_bits = self.client_max_window_bits

        return (
            _build_parameters(
                server_no_context_takeover,
                client_no_context_takeover,
                server_max_window_bits,
                client_max_window_bits,
            ),
            PerMessageDeflate(
                client_no_context_takeover,  # remote_no_context_takeover
                server_no_context_takeover,  # local_no_context_takeover
                client_max_window_bits or 15,  # remote_max_window_bits
                server_max_window_bits or 15,  # local_max_window_bits
                self.compress_settings,
            ),
        )
1169970
def where(self, params):
        
        self.params = dict(self.params, **params)   # params overrides self.params
        return self
127956
def do_fill(self, params):
        
        self._zk.set(params.path, decoded(params.val * params.repeat))
275198
def add_params(self, p):
        """"""
        new_params = p.copy()
        for key,val in new_params.items():
            if not isinstance(val, collections.Iterable):
                new_params[key] = [new_params[key]]
            #_check_comb_param(key, val)
        self.comb_params.update(new_params)
913983
def _check_params(self,params):
        
        overridden_object_params = list(self._overridden.param)
        for item in params:
            if item not in overridden_object_params:
                self.param.warning("'%s' will be ignored (not a Parameter).",item)
15366
public function mergeInto(Miner $Miner, $overrideLimit = true)
    {
        if ($this->isSelect()) {
            $this->mergeSelectInto($Miner);
            $this->mergeFromInto($Miner);
            $this->mergeJoinInto($Miner);
            $this->mergeWhereInto($Miner);
            $this->mergeGroupByInto($Miner);
            $this->mergeHavingInto($Miner);
            $this->mergeOrderByInto($Miner);
            
            if ($overrideLimit) {
                $this->mergeLimitInto($Miner);
            }
        } elseif ($this->isInsert()) {
            $this->mergeInsertInto($Miner);
            $this->mergeSetInto($Miner);
        } elseif ($this->isReplace()) {
            $this->mergeReplaceInto($Miner);
            $this->mergeSetInto($Miner);
        } elseif ($this->isUpdate()) {
            $this->mergeUpdateInto($Miner);
            $this->mergeJoinInto($Miner);
            $this->mergeSetInto($Miner);
            $this->mergeWhereInto($Miner);
            
            // ORDER BY and LIMIT are only applicable when updating a single table.
            if (! $this->join) {
                $this->mergeOrderByInto($Miner);
                
                if ($overrideLimit) {
                    $this->mergeLimitInto($Miner);
                }
            }
        } elseif ($this->isDelete()) {
            $this->mergeDeleteInto($Miner);
            $this->mergeFromInto($Miner);
            $this->mergeJoinInto($Miner);
            $this->mergeWhereInto($Miner);
            
            // ORDER BY and LIMIT are only applicable when deleting from a single
            // table.
            if ($this->isDeleteTableFrom()) {
                $this->mergeOrderByInto($Miner);
                
                if ($overrideLimit) {
                    $this->mergeLimitInto($Miner);
                }
            }
        }
        
        return $Miner;
    }
1159644
function setUrlHashParameters(params) {

  var keys = Object.keys(params);
  var values = Object.values(params);
  var pairs = [];
  keys.forEach(function(key, i) {
    if (key != '') pairs.push(keys[i] + '=' + values[i]);
  });
  var hash = pairs.join('&');
  window.location.hash = hash;

}
631616
def merge!(scope)
      @options.merge!(scope.options)

      @attributes += scope.attributes
      @associations.merge!(scope.associations)

      @attributes.uniq!

      self
    end
282905
function (mine, their, strategy) {
        this._doMerge(mine, their, function(key){
            if (typeof their[key] === 'object') {
                if (their[key] instanceof Array) {
                    mine[key] = [].concat(mine[key], their[key]);
                } else {
                    mine[key] = this[strategy](mine[key], their[key]);
                }
            } else if (mine[key] === undefined ) {
                mine[key] = their[key];
            }
        });

        return mine;
    }
429354
function() {
    var e = this.get('extra_params') || e;
    e.cache_buster = new Date().getTime();
    this.set('extra_params', e);
    this.trigger('change', this);
  }
528468
def merge!(hash1, hash2)
      hash2.each_pair do |name, m|
        if m[:hide]
          if hash1[name]
            hash1.delete(name)
          else
            msg = "@hide used but #{m[:tagname]} #{m[:name]} not found in parent class"
            Logger.warn(:hide, msg, m[:files][0])
          end
        else
          if hash1[name]
            store_overrides(hash1[name], m)
          end
          hash1[name] = m
        end
      end
    end
43696
public function merge()
	{
		if($this->saveBackupBeforeMerge)
		{
			$this->saveBackup();
		}
		
		// Since the param bag has the merge functionality already, why not use it?
		$this->master->params()->merge($this->slave->params()->all());
		
		if($this->autoSaveMaster)
		{
			$this->master->save();
		}

		if($this->deleteSlaveOnMerge)
		{
			$this->slave->delete();
		}
	}
1333840
def _merge_params(url, params):
    """"""
    if isinstance(params, dict):
        params = list(params.items())

    scheme, netloc, path, query, fragment = urllib.parse.urlsplit(url)
    url_params = urllib.parse.parse_qsl(query, keep_blank_values=True)
    url_params.extend(params)

    query = _encode_data(url_params)

    return urllib.parse.urlunsplit((scheme, netloc, path, query, fragment))
1304075
function mergeObjects(params, addition) {
        for (var i in addition)
            if (i && addition.hasOwnProperty(i))
                params[i] = mergeParams(params[i], addition[i]);

        return params;
    }
1277262
def _mine_delete(self, load):
        '''
        
        '''
        load = self.__verify_load(load, ('id', 'fun', 'tok'))
        if load is False:
            return {}
        else:
            return self.masterapi._mine_delete(load)