# Method `-()

Method `-

  ``mixed` `-(`mixed` `arg1`)`
  ``mixed` `-(`mixed` `arg1`, `mixed` `arg2`, `mixed` ... `extras`)`
  ``mixed` `-(`object` `arg1`, `mixed` `arg2`)`
  ``mixed` `-(`mixed` `arg1`, `object` `arg2`)`
  ``int` `-(`int` `arg1`, `int` `arg2`)`
  ``float` `-(`float` `arg1`, `int`|`float` `arg2`)`
  ``float` `-(`int`|`float` `arg1`, `float` `arg2`)`
  ``string` `-(`string` `arg1`, `string` `arg2`)`
  ``array` `-(`array` `arg1`, `array` `arg2`)`
  ``mapping` `-(`mapping` `arg1`, `array` `arg2`)`
  ``mapping` `-(`mapping` `arg1`, `mapping` `arg2`)`
  ``mapping` `-(`mapping` `arg1`, `multiset` `arg2`)`
  ``multiset` `-(`multiset` `arg1`, `multiset` `arg2`)`

Description

  Negation/subtraction/set difference.

  Every expression with the `-` operator becomes a call to this function, i.e. `-a` is the same as `predef::`-(a)` and `a-b` is the same as `predef::`-(a,b)`. Longer `-` expressions are normally optimized to one call, so e.g. `a-b-c` becomes `predef::`-(a,b,c)`.

Returns

  If there's a single argument, that argument is returned negated. If `arg1` is an object with an lfun::`-(), that function is called without arguments, and its result is returned.

  If there are more than two arguments the result is: ``-(`-(<code class='reference paramref'>arg1`, <code class='reference paramref'>arg2), @<code class='reference paramref'>extras).

  Otherwise, if `arg1` is an object with an lfun::`-(), that function is called with `arg2` as argument, and its result is returned.

  Otherwise, if `arg2` is an object with an lfun::``-(), that function is called with `arg1` as argument, and its result is returned.

  Otherwise the result depends on the argument types:

  `arg1` can have any of the following types:

  ``int`|`float`` | The result is `<code class='reference paramref'>arg1` - <code class='reference paramref'>arg2, and is a float if either `arg1` or `arg2` is a float.
  ``string`` | The result is `arg1` with all nonoverlapping occurrences of the substring `arg2` removed. In cases with two overlapping occurrences, the leftmost is removed.
  ``array`|`mapping`|`multiset`` | The result is like `arg1` but without the elements/indices that match any in `arg2` (according to `== and, in the case of mappings, hash_value).

  The function is not destructive on the arguments - the result is always a new instance.

Note

  In Pike 7.0 and earlier the subtraction order was unspecified.

See also

  `+()