# 2h: Set Logic

### `++in`

Set operations

Core whose arms contain a variety of functions that operate on `set`s. Its sample accepts the input `set` to be manipulated.

A `set`.

#### Source

```    ++  in
~/  %in
|_  a=(set)
```

#### Examples

```    > ~(. in (sy "asd"))
<13.evb [nlr(^\$1{@tD \$1}) <414.fvk 101.jzo 1.ypj %164>]>
```

### `+-all:in`

Logical AND

Computes the logical AND on every element in `a` slammed with `b`, producing a flag.

#### Accepts

`a` is a `set`.

`b` is a wet gate that accepts a noun and produces a flag.

A flag.

#### Source

```      +-  all
~/  %all
|*  b=\$-(* ?)
|-  ^-  ?
?~  a
&
?&((b n.a) \$(a l.a) \$(a r.a))
```

#### Examples

```    > =b (sy `(list [@t *])`[['a' 1] ['b' [2 3]] ~])
> (~(all in b) |=(a=* ?@(+.a & |)))
%.n

> =b (sy `(list @t)`['john' 'bonita' 'daniel' 'madeleine' ~])
> (~(all in b) |=(a=@t (gte a 100)))
%.y
```

### `+-any:in`

Logical OR

Computes the logical OR on every element of `a` slammed with `b`, producing a flag.

#### Accepts

`a` is a `set`.

`b` is a gate that accepts a noun and produces a flag.

A flag.

#### Source

```      +-  any
~/  %any
|*  b=\$-(* ?)
|-  ^-  ?
?~  a
|
?|((b n.a) \$(a l.a) \$(a r.a))
```

#### Examples

```    > =b (sy `(list [@t *])`[['a' 1] ['b' [2 3]] ~])
> (~(any in b) |=(a/* ?@(+.a & |)))
%.y

> =b (sy `(list @t)`['john' 'bonita' 'daniel' 'madeleine' ~])
> (~(any in b) |=(a=@t (lte a 100)))
%.n
```

### `+-apt:in`

Check correctness

Computes whether `a` has a correct horizontal order and a correct vertical order, producing a flag.

#### Accepts

`a` is a set.

A flag.

#### Source

```      +-  apt
=|  [l=(unit) r=(unit)]
|-  ^-  ?
?~  a   &
?&  ?~(l & (hor n.a u.l))
?~(r & (hor u.r n.a))
?~(l.a & ?&((vor n.a n.l.a) \$(a l.a, l `n.a)))
?~(r.a & ?&((vor n.a n.r.a) \$(a r.a, r `n.a)))
==
```

#### Examples

```    > ~(apt in ~)
%.y

> =a (sy [1 2 3 4 5 6 ~])
> a
[n=6 l={5 4} r={1 3 2}]
> ~(apt in a)
%.y

> =z ?~  a  ~  a(n 7)
> z
[n=7 l={5 4} r={1 3 2}]
> ~(apt in z)
%.n
```

#### Discussion

See section `2f` for more information on noun ordering.

### `+-bif:in`

Bifurcate

Splits set `a` into two sets `l` and `r`, with any noun `b` removed.

#### Accepts

`a` is a set.

`b` is a noun.

#### Produces

A cell of two sets.

#### Source

```      +-  bif
~/  %bif
|*  b=*
^+  [l=a r=a]
=<  [+< +>]
|-  ^+  a
?~  a
[b ~ ~]
?:  =(b n.a)
a
?:  (hor b n.a)
=+  c=\$(a l.a)
?>  ?=(^ c)
[n.c l.c [n.a r.c r.a]]
=+  c=\$(a r.a)
?>  ?=(^ c)
[n.c [n.a l.a l.c] r.c]
```

#### Examples

```    > =a (sy `(list @)`[1 2 3 4 5 6 ~])
> a
[n=6 l={5 4} r={1 3 2}]

> (~(bif in a) 6)
[l=[n=4 l=[n=5 l={} r={}] r=~] r=[n=2 l=[n=1 l={} r={3}] r=~]]

> (~(bif in a) 100)
[l=[n=6 l=[n=4 l={5} r={}] r=[n=2 l={1 3} r={}]] r=~]
```

### `+-del:in`

Remove noun

Removes `b` from the `set` `a`.

#### Accepts

`a` is a set.

`b` is a noun.

A set.

#### Source

```      +-  del
~/  %del
|*  b=*
|-  ^+  a
?~  a
~
?.  =(b n.a)
?:  (hor b n.a)
[n.a \$(a l.a) r.a]
[n.a l.a \$(a r.a)]
|-  ^-  {\$?(\$~ _a)}
?~  l.a  r.a
?~  r.a  l.a
?:  (vor n.l.a n.r.a)
[n.l.a l.l.a \$(l.a r.l.a)]
[n.r.a \$(r.a l.r.a) r.r.a]
```

#### Examples

```    > =b (sy `(list @t)`['a' 'b' 'c' ~])
> (~(del in b) 'a')
[n='b' l=[n='c' l={} r={}] r=~]

> =b (sy `(list @t)`['john' 'bonita' 'daniel' 'madeleine' ~])
> (~(del in b) 'john')

> (~(del in b) 'susan')
[n='madeleine' l=[n='daniel' l={} r={'bonita'}] r=[n='john' l={} r={}]]
```

### `+-dif:in`

Difference

Computes the difference between `a` and `b`, producing the set of items in `a` that are not in `b`.

#### Accepts

`a` is a set.

`b` is a set.

A set.

#### Source

```      +-  dif
~/  %dif
|*  b=_a
|-  ^+  a
?~  b
a
=+  c=(bif n.b)
?>  ?=(^ c)
=+  d=\$(a l.c, b l.b)
=+  e=\$(a r.c, b r.b)
|-  ^-  {\$?(\$~ _a)}
?~  e  d
?:  (vor n.d n.e)
[n.d l.d \$(d r.d)]
[n.e \$(e l.e) r.e]
```

#### Examples

```    > =c (sy 1 2 3 ~)
> =d (sy 2 3 4 ~)
> (~(dif in c) d)
[n=1 l=~ r=~]

> (~(dif in d) c)
[n=4 l=~ r=~]

> `(set @ud)`(~(dif in c) d)
{1}

> `(set @ud)`(~(dif in d) c)
{4}
```

### `+-dig:in`

Produce the tree address of `b` within `a`.

#### Accepts

`a` is a set.

`b` is a noun.

#### Produces

The `unit` of an atom.

#### Source

```      +-  dig
|=  b=*
=+  c=1
|-  ^-  (unit @)
?~  a  ~
?:  =(b n.a)  [~ u=(peg c 2)]
?:  (hor b n.a)
\$(a l.a, c (peg c 6))
\$(a r.a, c (peg c 7))
```

#### Examples

```    >  =a (sy `(list @)`[1 2 3 4 5 6 7 ~])
> `(set @)`a
{5 4 7 6 1 3 2}

> -.a
n=6

> (~(dig in a) 7)
[~ u=12]

> (~(dig in a) 2)
[~ u=14]

> (~(dig in a) 6)
[~ u=2]
```

#### Discussion

For more on the tree addressing system, see section 1b.

### `+-gas:in`

Concatenate

Insert the elements of a `list` `b` into a `set` `a`.

#### Accepts

`a` is a set.

`b` is a list.

A `set`.

#### Source

```      +-  gas
~/  %gas
|=  b=(list _?>(?=(^ a) n.a))
|-  ^+  a
?~  b
a
\$(b t.b, a (put i.b))
```

#### Examples

```    > =b `(set @t)`(sy `(list @t)`['bonita' 'madeleine' 'rudolf' 'john' ~])
> b

> (~(gas in b) `(list @t)`['14' 'things' 'number' '1.337' ~])
[n='number' l={'1.337' '14'} r={'things' 'bonita' 'madeleine' 'rudolf' 'john'}]

> =s (sy `(list @t)`['a' 'b' 'c' 'd' 'e' ~])
> (~(gas in s) `(list @t)`['1' '2' '3' ~])
[n='e' l=[n='1' l={} r={'3' '2'}] r=[n='b' l={'d' 'a' 'c'} r={}]]
```

### `+-has:in`

b in a?

Checks if `b` is an element of `a`, producing a flag.

#### Accepts

`a` is a set.

`b` is a noun.

A flag.

#### Source

```      +-  has
~/  %has
|*  b=*
|-  ^-  ?
?~  a
|
?:  =(b n.a)
&
?:  (hor b n.a)
\$(a l.a)
\$(a r.a)
```

#### Examples

```    > =a (~(gas in `(set @t)`~) `(list @t)`['a' 'b' 'c' ~])
> (~(has in a) 'a')
%.y

> (~(has in a) 'z')
%.n
```

### `+-int:in`

Intersection

Produces a set of the intersection between two sets of the same type, `a` and `b`.

#### Accepts

`a` is a set.

`b` is a set.

A `set`.

#### Source

```      +-  int
~/  %int
|*  b=_a
|-  ^+  a
?~  b
~
?~  a
~
?.  (vor n.a n.b)
\$(a b, b a)
?:  =(n.b n.a)
[n.a \$(a l.a, b l.b) \$(a r.a, b r.b)]
?:  (hor n.b n.a)
%-  uni(a \$(a l.a, b [n.b l.b ~]))  \$(b r.b)
%-  uni(a \$(a r.a, b [n.b ~ r.b]))  \$(b l.b)
```

#### Examples

```    > (~(int in `(set @t)`(sy "acmo")) `(set @t)`(sy "ham"))
[n='m' l={'a'} r={}]

> (~(int in (sy "acmo")) ~)
~

> (~(int in `(set @t)`(sy "ac")) `(set @t)`(sy "ha"))
[n='a' l={} r={}]
```

### `+-put:in`

Put b in a

Add an element `b` to the set `a`, producing a set.

#### Accepts

`a` is a set.

`b` is a noun.

A `set`.

#### Source

```      +-  put
~/  %put
|*  b=*
|-  ^+  a
?~  a
[b ~ ~]
?:  =(b n.a)
a
?:  (hor b n.a)
=+  c=\$(a l.a)
?>  ?=(^ c)
?:  (vor n.a n.c)
[n.a c r.a]
[n.c l.c [n.a r.c r.a]]
=+  c=\$(a r.a)
?>  ?=(^ c)
?:  (vor n.a n.c)
[n.a l.a c]
[n.c [n.a l.a l.c] r.c]
```

#### Examples

```    > =a (~(gas in `(set @t)`~) `(list @t)`['a' 'b' 'c' ~])
> =b (~(put in a) 'd')
> `(set @t)`b
{'d' 'a' 'c' 'b'}

> -.l.+.b
n='d'
```

### `+-rep:in`

Accumulate

Accumulate the elements of `a` using a gate `b`.

#### Accepts

`a` is a `set`.

`b` is a gate.

A noun.

#### Source

```    +-  rep                                               ::  replace by product
|*  b=_|=([* *] +<+)
|-
?~  a  +<+.b
\$(a r.a, +<+.b \$(a l.a, +<+.b (b n.a +<+.b)))
```

#### Examples

```    > =a (~(gas in *(set @)) [1 2 3 ~])
> `(set @)`a
{1 3 2}

> (~(rep in a) |=([a=@ b=@] (add a b)))
b=6
```

### `+-run:in`

Apply gate to set

Produce a `set` containing the products of gate `b` applied to each element in `a`.

#### Accepts

`a` is a `set`.

`b` is a gate.

A set.

#### Source

```      +-  run
~/  %run
|*  b=gate
=|  c=(set _?>(?=(^ a) (b n.a)))
|-  ?~  a  c
=.  c  (~(put in c) (b n.a))
=.  c  \$(a l.a, c c)
\$(a r.a, c c)
```

#### Examples

```    > =s (sy ~["a" "A" "b" "c"])
> `(set tape)`s
{"A" "a" "c" "b"}

> (~(run in s) cuss)
{"A" "C" "B"}
```

### `+-tap:in`

Set to list

Flattens the `set` `a` into a `list`.

#### Accepts

`a` is an set.

A list.

#### Source

```      +-  tap
~/  %tap
|=  b=(list _?>(?=(^ a) n.a))
^+  b
?~  a
b
\$(a r.a b [n.a \$(a l.a)])
```

#### Examples

```    > =s (sy `(list @t)`['a' 'b' 'c' 'd' 'e' ~])
> s
[n='e' l={} r={'d' 'a' 'c' 'b'}]

> ~(tap in s)
~['b' 'c' 'a' 'd' 'e']
```

### `+-uni:in`

Union

Produces a set of the union between two sets of the same type, `a` and `b`.

#### Accepts

`a` is a set.

`b` is a set.

A set.

#### Source

```      +-  uni
~/  %uni
|*  b=_a
?:  =(a b)  a
|-  ^+  a
?~  b
a
?~  a
b
?:  (vor n.a n.b)
?:  =(n.b n.a)
[n.b \$(a l.a, b l.b) \$(a r.a, b r.b)]
?:  (hor n.b n.a)
\$(a [n.a \$(a l.a, b [n.b l.b ~]) r.a], b r.b)
\$(a [n.a l.a \$(a r.a, b [n.b ~ r.b])], b l.b)
?:  =(n.a n.b)
[n.b \$(b l.b, a l.a) \$(b r.b, a r.a)]
?:  (hor n.a n.b)
\$(b [n.b \$(b l.b, a [n.a l.a ~]) r.b], a r.a)
\$(b [n.b l.b \$(b r.b, a [n.a ~ r.a])], a l.a)
::
```

#### Examples

```    > (~(uni in `(set @t)`(sy "ac")) `(set @)`(sy "ha"))
[n='c' l={'a'} r={'h'}]

> (~(uni in `(set @t)`(sy "acmo")) ~)
[n='c' l={'a'} r={'m' 'o'}]

> (~(uni in `(set @t)`(sy "acmo")) `(set @t)`(sy "ham"))
[n='c' l={'a'} r={'m' 'o' 'h'}]

> (~(uni in `(set @t)`(sy "acmo")) `(set @t)`(sy "lep"))
[n='e' l={} r={'a' 'c' 'm' 'l' 'o' 'p'}]
```

### `+-wyt:in`

Set size

Produces the number of elements in set `a` as an atom.

#### Accepts

`a` is an set.

An atom.

#### Source

```      +-  wyt                                               ::  size of set
|-  ^-  @
?~(a 0 +((add \$(a l.a) \$(a r.a))))
--
```

#### Examples

```    > =a (~(put in (~(put in (sy)) 'a')) 'b')
> ~(wyt in a)
2

> =b (sy `(list @t)`['john' 'bonita' 'daniel' 'madeleine' ~])
> ~(wyt in b)
4
```