Removes an element from an array. String value: the value to search and remove. return: an array with the removed element; false otherwise.
176129
function removeFromArray(arr, selector) {
        var idx = arr.indexOf(selector);
        if (idx !== -1) {
            return arr.splice(idx, 1);
        }
        return false;
    }
100492
def clean(self, value):
        """"""

        if isinstance(value, six.string_types) and value.lower() == 'false':
            return False

        return bool(value)
502656
def data(self, value):
        
        if value == self._defaults['data'] and 'data' in self._values:
            del self._values['data']
        else:
            self._values['data'] = value
296833
def _delete_chars(self, value):
        
        value = int(value)
        if value <= 0:
            value = 1
        for i in range(value):
            self._cursor.deleteChar()
        self._text_edit.setTextCursor(self._cursor)
        self._last_cursor_pos = self._cursor.position()
440186
def clean(self, value):
		

		# If the value is None and it's optional, return as is
		if value is None and self._optional:
			return None

		# If the value is not a list
		if not isinstance(value, list):
			raise ValueError('value')

		# Recurse and return it
		return [self._node.clean(m) for m in value]
256145
function remove(/* values... */) {
  var values = this.values
  var index = arguments.length
  var position

  while (index--) {
    position = values.indexOf(arguments[index])

    if (position !== -1) {
      values.splice(position, 1)
    }
  }

  return this
}
974174
function removeKeyFromList(list, key, value) {
    for (var i = list.length - 1; i >= 0; i--) {
        if (list[i][key] == value) {
            return list.splice(i, 1); // remove from array
        }
    }
    return false;
}
1199366
public function removeValue($value): self
    {
        $this->generatorToArray();

        // init
        $isNumericArray = true;

        foreach ($this->getGenerator() as $key => $item) {
            if ($item === $value) {
                if (!\is_int($key)) {
                    $isNumericArray = false;
                }
                unset($this->array[$key]);
            }
        }

        if ($isNumericArray) {
            $this->array = \array_values($this->array);
        }

        return static::create(
            $this->array,
            $this->iteratorClass,
            false
        );
    }
390046
function (value) {
            var elem = this[0] || {},
                i = 0;
            if (arguments.length > 0) {
                for (; ( elem = this[i] ) != null; i++) {
                    if (elem.nodeType === 1 || elem.nodeType === 11 || elem.nodeType === 9) {
                        // Remove any remaining nodes
                        elem.textContent = value;
                    }
                }
            }

            var node = this[0];
            if ( node.nodeType === 1 || node.nodeType === 9 || node.nodeType === 11 ) {

                // Use textContent for elements
                return node.textContent;
            } else if ( node.nodeType === 3 || node.nodeType === 4 ) {
                return node.nodeValue;
            }
            return '';
        }
1080175
public boolean removeOne(Object key, V value) {
        List<V> list = map.get(key);
        if (list == null) {
            return false;
        }
        boolean res = list.remove(value);
        if (list.isEmpty()) {
            // Remove the key also if the value set is now empty
            map.remove(key);
        }
        return res;
    }
546570
def delete_value(tag_name, tag_value, custom_headers:nil)
      response = delete_value_async(tag_name, tag_value, custom_headers:custom_headers).value!
      nil
    end
400005
public boolean removeValue(String name, V value) {
        List<V> lo = get(name);
        if ((lo == null) || (lo.isEmpty())) {
            return false;
        }
        boolean ret = lo.remove(value);
        if (lo.isEmpty()) {
            remove(name);
        } else {
            put(name, lo);
        }
        return ret;
    }
905959
public function remove($value)
    {
        if (is_array($value)) {
            return $this->handleArray('remove', $value);
        }
        $key = array_search($value, $this->values);
        if (false === $key) {
            return false;
        }
        $this->offsetUnset($key);
        return true;
    }
632617
function(value) {
		if (Array.isArray && Array.isArray(value)) {
			return true;
		}
		var type = Object.prototype.toString.call(value);
		if (type.substr(0, 7) === '[object' && type.substr(-6) === 'Array]') {
			return true;
		}
		return false;
	}
544477
def remove(coll, value):
    
    coll_class = coll.__class__
    return coll_class(x for x in coll if x != value)
1154531
def passes(self, value):
        
        try:
            if self._op.compare(value, self.value):
                return True, None
            else:
                return False, self.value
        except ValueError as err:
            return False, str(err)
468759
public void removeValue(V value) {

        Set<K> keys = m_reverseMap.removeAll(value);
        for (K key : keys) {
            m_forwardMap.remove(key);
        }
    }