code: @Pure
  	public static <K, V> Map<K, V> operator_minus(Map<K, V> left, final Map<? extends K, ? extends V> right) {
  		return Maps.filterEntries(left, new Predicate<Entry<K, V>>() {
  			@Override
  			public boolean apply(Entry<K, V> input) {
  				final V value = right.get(input.getKey());
  				if (value == null) {
  					return input.getValue() == null && right.containsKey(input.getKey());
  				}
  				return !Objects.equal(input.getValue(), value);
  			}
  		});
  	}
docs: Replies the elements of the left map without the pairs in the right map.
  If the pair's values differ from
  the value within the map, the map entry is not removed.
  
  <p>
  The difference is an immutable
  snapshot of the state of the maps at the time this method is called. It
  will never change, even if the maps change at a later time.
  </p>
  
  <p>
  Since this method uses {@code HashMap} instances internally, the keys of
  the supplied maps must be well-behaved with respect to
  {@link Object#equals} and {@link Object#hashCode}.
  </p>
  
  @param <K> type of the map keys.
  @param <V> type of the map values.
  @param left the map to update.
  @param right the pairs to remove.
  @return the map with the content of the left map except the pairs of the right map.
  @since 2.15