remove only cares about an item's id, but for consistency takes an object
330316
def remove(item)
      prev_item = Soulmate.redis.hget(database, item["id"])
      if prev_item
        prev_item = MultiJson.decode(prev_item)
        # undo the operations done in add
        Soulmate.redis.pipelined do
          Soulmate.redis.hdel(database, prev_item["id"])
          phrase = ([prev_item["term"]] + (prev_item["aliases"] || [])).join(' ')
          prefixes_for_phrase(phrase).each do |p|
            Soulmate.redis.srem(base, p)
            Soulmate.redis.zrem("#{base}:#{p}", prev_item["id"])
          end
        end
      end
    end
960658
def delete(self, item):
        """"""
        uri = "/%s/%s" % (self.uri_base, utils.get_id(item))
        return self._delete(uri)
195631
def remove(self, item, count=0):
        
        self._client.lrem(self.key_prefix, count, self._dumps(item))
1026944
def remove(self, item):
        
        index = self.index(item)
        self.real_list.remove(item)
        self.observer(UpdateType.DELETED, item, index)
446305
function sync(collection, newCollection, index) {
        if (index === void 0) { index = 'id'; }
        var answer = removeElements(collection, newCollection, index);
        if (newCollection) {
            newCollection.forEach(function (item) {
                var oldItem = _.find(collection, function (c) { return c[index] === item[index]; });
                if (!oldItem) {
                    answer = true;
                    collection.push(item);
                }
                else {
                    if (item !== oldItem) {
                        angular.copy(item, oldItem);
                        answer = true;
                    }
                }
            });
        }
        return answer;
    }
1176965
def remove_item(self, item):
        
        for idx, _item in enumerate(self.items):
            if item == _item:
                del self.items[idx]
                return True
        return False
1295148
def delete(self, item_id):
        
        try:
            response = self._request("tasks/delete/{id}".format(id=item_id))

            if response.status_code == 200:
                return True

        except sandboxapi.SandboxError:
            pass

        return False
949135
function removeDuplicates(items) {
    var temp = {}, result = [], x, i = items.length;
    while (i--) {
      x = getData(items[i], 'id', true);
      if (!temp.hasOwnProperty(x)) {
        temp[x] = 1;
        result.push(items[i]);
      }
    }
    return result;
  }
693307
function(id) {
    // get embed keys as a separate array to enable deleting keys in map
    var ids = Object.keys(embeds);
    for(var i = 0; i < ids.length; ++i) {
      var next = ids[i];
      if(next in embeds && _isObject(embeds[next].parent) &&
        embeds[next].parent['@id'] === id) {
        delete embeds[next];
        removeDependents(next);
      }
    }
  }
1248335
def _remove_from_index(index, obj):
    """"""
    try:
        index.value_map[indexed_value(index, obj)].remove(obj.id)
    except KeyError:
        pass
1344444
def remove_item(self, val):
        
        return cache.lrem(self.key, json.dumps(val))
338810
def remove(self, obj_id, obj_type=None):
        
        if not self.exists(obj_id, obj_type):
            raise KeyError('Object not found.')

        combined_id = self.object_key(obj_id, obj_type)
        title = self._title_data[combined_id]

        for word in self.tokenize_title(title):
            for substring in self.substrings(word):
                key = self.word_key(substring)
                if not self.database.zrange(key, 1, 2):
                    self.database.delete(key)
                else:
                    self.database.zrem(key, combined_id)

        del self._data[combined_id]
        del self._title_data[combined_id]
        del self._boosts[combined_id]
631917
def remove(id_):
    
    with LOCK:
        thread = REGISTRY.pop(id_, None)
        if thread is not None:
            thread.cancel()

    return thread
787335
def removeItem(self, item):
        """"""
        try:
            self.tree.removeItem(item)
        except AttributeError, e:
            raise VersionError('Saved versions are immutable')
1283833
@Override
    public void removeItem(int itemID) {
        super.removeItem(itemID);
        ratingsItem.remove(itemID);
        itemsStats.remove(itemID);
    }
1180991
protected void changeId(I item, String id) {

        if (m_items.remove(item.getId()) != null) {
            m_items.put(id, item);
        }
    }
371031
def delete_item(name)
      previous = items.size
      items.reject! { |item| item.name == name}
      previous != items.size
    end