# 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`)`
  ``string` `^(`string` `arg1`, `string` `arg2`)`
  ``array` `^(`array` `arg1`, `array` `arg2`)`
  ``mapping` `^(`mapping` `arg1`, `mapping` `arg2`)`
  ``multiset` `^(`multiset` `arg1`, `multiset` `arg2`)`
  ``type` `^(`program`|`type` `arg1`, `program`|`type` `arg2`)`

Description

  Exclusive or.

  Every expression with the `^` operator becomes a call to this function, i.e. `a^b` is the same as `predef::`^(a,b)`.

Returns

  If there's a single argument, that argument 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`` | Bitwise exclusive or of `arg1` and `arg2`.
  ``string`` | The result is a string where each character is the bitwise exclusive or of the characters in the same position in `arg1` and `arg2`. The arguments must be strings of the same length.

  ``array``

  The result is an array with the elements in `arg1` that doesn't occur in `arg2` concatenated with those in `arg2` that doesn't occur in `arg1` (according to `==). The order between the elements that come from the same argument is kept.

  Every element is only matched once against an element in the other array, so if one contains several elements that are equal to each other and are more than their counterparts in the other array, the rightmost remaining elements are kept.

  ``mapping`` | The result is like `arg1` but with the entries from `arg1` and `arg2` whose indices are different between them (according to hash_value and `==).
  ``multiset`` | The result is like `arg1` but with the entries from `arg1` and `arg2` that are different between them (according to hash_value and `==). Subsequences with orderwise equal entries (i.e. where `< returns false) are handled just like the array case above.
  ``type`|`program`` | The result is a type computed like this: `(<code class='reference paramref'>arg1`&~<code class='reference paramref'>arg2)|(~<code class='reference paramref'>arg1&<code class='reference paramref'>arg2).

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

See also

  `&(), `|(), lfun::`^(), lfun::``^()