unsubscribe to the parameter key.
 this method is not described in the wiki.
 @param [String] key name of parameter key
 @return [Boolean] true
 @raise [RuntimeError] if failt
505158
def unsubscribe_param(key)
      code, message, uri = @proxy.unsubscribeParam(@caller_id, @slave_uri, key)
      if code == 1
        return true
      else
        raise message
      end
    end
667851
def unsubscribe(self, topic):
        

        del self.queues[topic]

        try:
            self.client.unsubscribe(topic)
        except operationError as exc:
            raise InternalError("Could not unsubscribe from topic", topic=topic, message=exc.message)
131324
@Override
    public V remove(@NonNull K key) {
        V removed = super.remove(key);
        mHashMap.remove(key);
        return removed;
    }
1268455
def delete(self, key):
        
        if key in self.cache:
            self.cache.pop(key, None)
930113
def delete(key, service=None, profile=None):  # pylint: disable=W0613
    '''
    
    '''
    client = _get_conn(profile)
    try:
        client.delete(key)
        return True
    except Exception:
        return False
1254978
def delete_param(key)
      code, message, value = @server.call("deleteParam", @caller_id, key)
      case code
      when 1
        return true
      else
        return false
      end
    end
520274
def unsubscribe_clients(channel, _json_data)
      log_debug "#{self.class} runs 'unsubscribe_clients' method with  #{channel}"
      return if channel.blank?
      unsubscribe_from_channel(channel)
      @server.subscribers[channel] = []
    end
175869
def delete_key(key, allow_secret = false)
      err = GPGME::gpgme_op_delete(self, key, allow_secret ? 1 : 0)
      exc = GPGME::error_to_exception(err)
      raise exc if exc
    end
247518
public Result<T> remove(ServiceInfo.Key key)
    {
        T previous = null;

        lock();
        try
        {
            ServiceType serviceType = keysToServiceTypes.remove(key);
            if (serviceType == null) return new Result<T>(null, null);
            previous = keysToServiceInfos.remove(key);
            previous.setRegistered(false);
        }
        finally
        {
            unlock();
        }

        notifyServiceRemoved(previous, null);
        return new Result<T>(previous, null);
    }
1168774
def remove(key)
      node = self

      while node do
        # Find index of the entry that best fits the key.
        i = node.search_key_index(key)
        if node.is_leaf?
          # This is a leaf node. Check if there is an exact match for the
          # given key and return the corresponding value or nil.
          if node.keys[i] == key
            @tree.entry_counter -= 1
            return node.remove_element(i)
          else
            return nil
          end
        end

        # Descend into the right child node to continue the search.
        node = node.children[i]
      end

      PEROBS.log.fatal 'Could not find proper node to remove from'
    end
1083083
def delete(key, options = {})
      custom_params = options[:dc] ? use_named_parameter('dc', options[:dc]) : nil
      ret = send_delete_request(@conn, ["/v1/query/#{key}"], options, custom_params)
      ret.status == 200
    end
1219280
def unsubscribe
      response = Rdkafka::Bindings.rd_kafka_unsubscribe(@native_kafka)
      if response != 0
        raise Rdkafka::RdkafkaError.new(response)
      end
    end
360386
def unsubscribe(self, request, *args, **kwargs):
        
        self.object = self.get_object()
        self.object.subscribers.remove(request.user)
        messages.success(self.request, self.success_message)
        return HttpResponseRedirect(self.get_success_url())
204707
public boolean delete(String key) {
        Jedis jedis = null;
        try {
            jedis = this.jedisPool.getResource();
            jedis.del(SafeEncoder.encode(key));
            logger.info("delete key:" + key);

            return true;
        } catch (Exception e) {
            logger.error(e.getMessage(), e);
            this.jedisPool.returnBrokenResource(jedis);
        } finally {
            if (jedis != null) {
                this.jedisPool.returnResource(jedis);
            }
        }
        return false;
    }
493402
def _pop(self, key, default=None):
        
        value = default
        if key in self:
            value = self[key]
            del self[key]
        return value
1232394
def delete_key(self, key_id):
        
        key = self.key(key_id)
        if key:
            return key.delete()
        return False
768903
def discard(key, matcher)
      @items.reject! {|i| (i[key] =~ matcher) ? true : false }
    end