*2.7, 2.15: adda/vertical bar operator uses:*

. the vertical bar operator has several uses

that are quite similar across most fields:

**number theory:**

. n|m is a truth function: does m divide n evenly?

because of that,

I wondered if it could double as the div operator;

ie, (int / int) -> Q (float or rational);

whereas (int | int) -> Z {truncate, floor, ceiling, ...}

. if you consider context, there is indeed

precidence for (n|m) as a div operator:

in number theory, (n|m) assumes

the result is being passed to a truth variable .

. this is also how (=) doubles as {equals, becomes}

in the basic.lang (eg, if a=b then a=c);

case depending on type:

# number? integer quotient;

# truth? mod = 0 .

. notice though, that the question of divisibility

is actually depending on the mod operation ...;

**set theory:**

{ f(x) | x`range } -- set generators

f(x) | (x in range) -- definite integrals .

-- like number theory, it concerns division:

the set is infinite until divided by

the finite range of its control variable .

**linguistics:**

. (a|b|c) means pick exactly one,

reminding me of unique existence;

however, in systems programming

there is often a need to apply both div's

and bit-wise xor's to the same ints;

eg, n xor (n div 31);

so, I'm wondering if I can find

something besides (|) for xor,

since it already fits nicely with div .

. math's existence operator(∃) adds a bang(!)

to express a unique existence:

eg, ( for some! x: p(x,y) )

would mean

( for exactly one x: p(x,y) );

[2.28:

. notice how math uses separate operators

whenever there is quantification

or control var's involved;

even though it could be more elegant

if it reused set generators:

eg, +(i.int|i = 1...n)

is a summation over 1..n;

math would prefer to present this as:

n

∑ (i)

i = 1 .

. likewise, math's ∃x(p(x)) can also be

expressed as

or( p(x)| x in universe );

\/ is math's operator for logical-or;

therefore,

in the pursuit of minimal language,]

a good symbol for unique existence

could be \! .

. xor is used often in computingand is like unique existence

but only for the special pair-wise case:

. the composition of xor's for reducing

a list larger than a pair

is not generally equivalent to an (\!);

because, recursively, an xor's return of false

may indicate either {many, none};

while a return of true indicates uniqueness;

so then here is a counter example

(existence but non-unique):

(true xor true) xor (true xor false)but true was supposed to mean unique;

(many) xor (unique) =

(false) xor (true) = true

whereas this was an example of many,

which should have registered as false

if testing for unique existence .

. math`s symbol for xor is a circled plus

reminding us it functions as

clock addition modulo 2 .

. if restricting the arg of (\!) to pairs

a computer's xor operation can implement

unique existence .