or with(propName) map(isEmpty) equalTo(true)
489280
public static <F, T extends Iterable<S>, S> PropertyPattern<F, T> empty(Property<F, T> property)
    {
        return PropertyPattern.upcast(property.matching(Iterables::isEmpty));
    }
415527
function isEmpty(data) {
    if (Array.isArray(data)) {
        return data.length === 0;
    }
    return Object.keys(data).length === 0;
}
202377
function isEmpty(val) {
  return _.isNull(val) || _.isUndefined(val) || _.isNaN(val) || helper.isBlank(val);
}
344391
function has(o, property) {
    if (arguments.length !== 2) {
      throw new Error('Expected two arguments to check.has, got only ' + arguments.length);
    }
    return Boolean(o && property &&
      typeof property === 'string' &&
      typeof o[property] !== 'undefined');
  }
651030
function (key) {
            var self = this, _queryMap;
            parseQuery(self);
            _queryMap = self._queryMap;
            if (key) {
                return key in _queryMap;
            } else {
                return !S.isEmptyObject(_queryMap);
            }
        }
120379
function or() {
    var predicates = Array.prototype.slice.call(arguments, 0);
    if (!predicates.length) {
      throw new Error('empty list of arguments to or');
    }

    return function orCheck() {
      var values = Array.prototype.slice.call(arguments, 0);
      return predicates.some(function (predicate) {
        try {
          return check.fn(predicate) ?
            predicate.apply(null, values) : Boolean(predicate);
        } catch (err) {
          // treat exceptions as false
          return false;
        }
      });
    };
  }
575511
function isEmpty (val) {
  if (val === 0) return true;
  if (Number.isNaN(val)) return true;
  return !_.isNumber(val) && _.isEmpty(val);
}
769962
def map &block
      if empty? then
        None.new
      else
        Some.new(block.call(get))
      end
    end
1206370
function(prop, val) {
      return val === undefined ? (this.length ? this[0][prop] : null) : this.each(function(index, el) {
        el[prop] = val;
      });
    }
401483
function isObjectEmpty(obj) {
        if (!this.isObject(obj)) {
            return false;
        }

        for (var x in obj) {
            if ({}.hasOwnProperty.call(obj, x)) {
                return false;
            }
        }

        return true;
    }
959109
def check_property(prop, name, **kwargs):
    

    checkers = {
        'color': check_color,
        'alpha': check_alpha,
        'size': check_size,
        'thickness': check_thickness,
        'index': check_index,
        'coordinates': check_coordinates,
        'colormap': check_colormap,
        'bins': check_bins,
        'spec': check_spec
    }

    if name in checkers:
        return checkers[name](prop, **kwargs)
    elif isinstance(prop, list) or isinstance(prop, ndarray) or isscalar(prop):
        return check_1d(prop, name)
    else:
        return prop
1271914
function shallowEqualWithoutReactElements(thisProps, nextProps) {
    var equals = false;
    if (thisProps === nextProps) {
        equals = true;
    } else if ((typeof thisProps === 'undefined' ? 'undefined' : _typeof(thisProps)) === 'object' && (typeof nextProps === 'undefined' ? 'undefined' : _typeof(nextProps)) === 'object') {
        equals = true;
        var propNames = new Set(Object.keys(thisProps), Object.keys(nextProps));
        var _iteratorNormalCompletion = true;
        var _didIteratorError = false;
        var _iteratorError = undefined;

        try {
            for (var _iterator = propNames[Symbol.iterator](), _step; !(_iteratorNormalCompletion = (_step = _iterator.next()).done); _iteratorNormalCompletion = true) {
                var propName = _step.value;

                if (thisProps[propName] !== nextProps[propName] && !isReactElement(thisProps[propName])) {
                    // No need to check nextProps[propName] as well, as we know they are not equal
                    equals = false;
                    break;
                }
            }
        } catch (err) {
            _didIteratorError = true;
            _iteratorError = err;
        } finally {
            try {
                if (!_iteratorNormalCompletion && _iterator.return) {
                    _iterator.return();
                }
            } finally {
                if (_didIteratorError) {
                    throw _iteratorError;
                }
            }
        }
    }
    return equals;
}
1045696
function hasProperty(obj, propName) {
        return obj != null && (typeof obj === 'undefined' ? 'undefined' : _typeof(obj)) === 'object' && propName in obj;
    }
131099
function equalSimpleMaps(map1, map2) {

	const keys1 = (map1 && Object.keys(map1));
	if (map1 && (keys1.length > 0)) {
		const keys2 = (map2 && Object.keys(map2));
		return (
			keys2 &&
				(keys2.length === keys1.length) &&
				keys2.every(k => (map2[k] === map1[k]))
		);
	}

	return (!map2 || (Object.keys(map2).length === 0));
}
640040
function(a, b, aParent, bParent, prop, compares, options){
	var subsetCheck;
	if( !(prop in aParent)) {
		subsetCheck = "subsetB";
	} else if(prop in bParent){
		// property in a and b and not the same
		return false;
	}
	if( !(prop in bParent) ) {
		subsetCheck = "subsetA";
	}
	if(subsetCheck === "subsetB") {
		options.result[prop] = b;
	} else {
		options.result[prop] = a;
	}
	return undefined;
}
71488
function result(object, propName) {
        var value = object[propName];
        return isFunction(value) ? value() : value;
    }
581803
function objectIsEmpty(obj) {
	if (obj === null || obj === undefined) return true;
	if (obj.isEmpty) return obj.isEmpty();
	for (let k in obj) {
		if (hasOwnProperty(obj, k)) return false;
	}
	return true;
}