| Extracted from Pike v7.8 release 866 at 2016-04-05.

[Top]

# 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(mixed) `|(program|type(mixed) arg1, program|type(mixed) arg2)`

Description

  Bitwise or/union.

  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: ``|(`|(<font face='courier'>arg1` , <font face='courier'>arg2 ), @<font face='courier'>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 or of arg1 and arg2 .
  `string` | The result is a string where each character is the bitwise 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 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 in arg1 is only matched once against an element in arg2 , so if arg2 contains several elements that are equal to each other and are more than their counterparts in arg1 , the rightmost remaining elements in arg2 are kept.

  `mapping` | The result is like arg1 but extended with the entries from arg2 . If the same index (according to hash_value and `== ) occur in both, the value from arg2 is used.
  `multiset` | The result is like arg1 but extended with the entries in arg2 that doesn't already occur in arg1 (according to `== ). Subsequences with orderwise equal entries (i.e. where `< returns false) are handled just like the array case above.
  `type(mixed)|program` | Type union of arg1 and arg2 .

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

See also

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