# 2h: Set Logic

## `+in` <a href="#in" id="in"></a>

Set operations.

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

#### Accepts

A `+set`.

#### Source

```hoon
~/  %in
=|  a=(tree)
|@
```

#### Examples

```
> ~(. in (sy "asd"))
<16.ufw [a=?(%~ [?(n=@tD n=#1) l=nlr(?(@tD #1)) r=nlr(?(@tD ^#1.?(@tD #1)))]) <123.zao 46.hgz 1.pnw %140>]>
```

### `+all:in` <a href="#allin" id="allin"></a>

Logical AND.

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

#### Accepts

`.a` is a `+set`, and is the sample of `+in`.

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

#### Produces

A `$flag`.

#### Source

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

#### Examples

```
> (~(all in (silt ~[1 2 3 4])) |=(a=@ (lth a 5)))
%.y
```

```
> (~(all in (silt ~[1 2 3 4 5])) |=(a=@ (lth a 5)))
%.n
```

***

### `+any:in` <a href="#anyin" id="anyin"></a>

Logical OR.

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

#### Accepts

`.a` is a `+set`, and is the sample of `+in`.

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

#### Produces

A `$flag`.

#### Source

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

#### Examples

```
> (~(any in (silt ~[2 3 4 5])) |=(a=@ (lth a 3)))
%.y
```

```
> (~(any in (silt ~[3 4 5])) |=(a=@ (lth a 3)))
%.n
```

***

### `+apt:in` <a href="#aptin" id="aptin"></a>

Check correctness.

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

#### Accepts

`.a` is a `+set`.

#### Produces

A `$flag`.

#### Source

```hoon
++  apt
  =<  $
  ~/  %apt
  =|  [l=(unit) r=(unit)]
  |.  ^-  ?
  ?~  a   &
  ?&  ?~(l & (gor n.a u.l))
      ?~(r & (gor u.r n.a))
      ?~(l.a & ?&((mor n.a n.l.a) $(a l.a, l `n.a)))
      ?~(r.a & ?&((mor n.a n.r.a) $(a r.a, r `n.a)))
  ==
```

#### Examples

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

```
> =a (silt ~[1 2 3])

> a
[n=2 l={1} r={3}]

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

```
> =z ?~(a ~ a(n 10))

> z
[n=10 l={1} r={3}]

> ~(apt in z)
%.n
```

#### Discussion

See section [`2f`](/hoon/stdlib/2f.md) for more information on `$noun` ordering.

***

### `+bif:in` <a href="#bifin" id="bifin"></a>

Bifurcate.

Splits set `.a` into sets `.l` and `.r`, which contain the items either side of `.b` but not including `.b`.

#### Accepts

`.a` is a `+set`, and is the sample of `+in`.

`.b` is a `$noun`.

#### Produces

A cell of two `+set`s.

#### Source

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

#### Examples

```
> =a `(set @)`(silt (gulf 1 20))
> a
{17 8 20 13 11 5 19 7 15 10 18 14 6 12 9 1 2 3 16 4}

> (~(bif in a) 10)
[l=[n=11 l={17 8 20 13} r={5 19 7 15}] r=[n=12 l={18 14 6} r={9 1 2 3 16 4}]]

> `[(set @) (set @)]`(~(bif in a) 10)
[{17 8 20 13 11 5 19 7 15} {18 14 6 12 9 1 2 3 16 4}]
```

#### Discussion

Note that `+set`s are horizontally ordered by the [mug](/hoon/stdlib/2e.md#mug) hash of their items and vertically ordered by the double-`+mug` hash of their items. This means bifurcating the set of numbers `(silt ~[10 20 30 40 50])` at `30` will not produce `[{10 20} {40 50}]`, but rather `[{20} {10 40 50}]` due to the tree structure resulting from their `+mug` hashes.

***

### `+del:in` <a href="#delin" id="delin"></a>

Remove `$noun`.

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

#### Accepts

`.a` is a `+set`, and is the sample of `+in`.

`.b` is a `$noun`.

#### Produces

A `+set`.

#### Source

```hoon
++  del
  ~/  %del
  |*  b=*
  |-  ^+  a
  ?~  a
    ~
  ?.  =(b n.a)
    ?:  (gor b n.a)
      a(l $(a l.a))
    a(r $(a r.a))
  |-  ^-  [$?(~ _a)]
  ?~  l.a  r.a
  ?~  r.a  l.a
  ?:  (mor n.l.a n.r.a)
    l.a(r $(l.a r.l.a))
  r.a(l $(r.a l.r.a))
```

#### Examples

```
> `(set @)`(~(del in (silt ~[1 2 3 4 5])) 3)
{5 1 2 4}
```

```
> `(set @t)`(~(del in (silt ~['foo' 'bar' 'baz'])) 'bar')
{'baz' 'foo'}
```

```
> `(set @)`(~(del in (silt ~[1 2 3 4 5])) 10)
{5 1 2 3 4}
```

```
> `(set @)`(~(del in ~) 10)
{}
```

***

### `+dif:in` <a href="#difin" id="difin"></a>

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`, and is the sample of `+in`.

`.b` is a `+set`.

#### Produces

A `+set`.

#### Source

```hoon
++  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)]
    ?~  d  e
    ?~  e  d
    ?:  (mor n.d n.e)
      d(r $(d r.d))
    e(l $(e l.e))
  --
```

#### Examples

```
> =a (silt ~[1 2 3 4 5])
> =b (silt ~[3 4])

> `(set @)`(~(dif in a) b)
{5 1 2}
```

***

### `+dig:in` <a href="#digin" id="digin"></a>

Address `.b` in `.a`.

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

#### Accepts

`.a` is a `+set`, and is the sample of `+in`.

`.b` is a `$noun`.

#### Produces

The `+unit` of an `$atom`.

#### Source

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

#### Examples

```
> =a (silt ~[1 2 3 4 5 6 7])

> -.a
n=6

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

> (~(dig in a) 2)
[~ 60]

> (~(dig in a) 6)
[~ 2]

> (~(dig in a) 10)
~
```

#### Discussion

For more on the tree addressing system, see section [1b](/hoon/stdlib/1b.md).

***

### `+gas:in` <a href="#gasin" id="gasin"></a>

Concatenate.

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

#### Accepts

`.a` is a `+set`, and is the sample of `+in`.

`.b` is a list.

#### Produces

A `+set`.

#### Source

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

#### Examples

```
> =a (silt ~['foo' 'bar' 'baz'])
> `(set @t)`a
{'bar' 'baz' 'foo'}

> `(set @t)`(~(gas in a) ~['foo' 'foo' 'foo' 'foo'])
{'bar' 'baz' 'foo'}

> `(set @t)`(~(gas in a) ~['abc' 'xyz' '123'])
{'xyz' 'bar' 'baz' 'foo' 'abc' '123'}
```

***

### `+has:in` <a href="#hasin" id="hasin"></a>

Is `.b` in `.a`?

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

#### Accepts

`.a` is a `+set`, and is the sample of `+in`.

`.b` is a `$noun`.

#### Produces

A `$flag`.

#### Source

```hoon
++  has
  ~/  %has
  |*  b=*
  ^-  ?
  %.  [~ b]
  |=  b=(unit _?>(?=(^ a) n.a))
  =>  .(b ?>(?=(^ b) u.b))
  |-  ^-  ?
  ?~  a
    |
  ?:  =(b n.a)
    &
  ?:  (gor b n.a)
    $(a l.a)
  $(a r.a)
```

#### Examples

```
> =a (silt ~[1 2 3 4 5])

> (~(has in a) 2)
%.y

> (~(has in a) 6)
%.n
```

***

### `+int:in` <a href="#intin" id="intin"></a>

Intersection.

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

#### Accepts

`.a` is a `+set`, and is the sample of `+in`.

`.b` is a `+set`.

#### Produces

A `+set`.

#### Source

```hoon
++  int
  ~/  %int
  =+  b=a
  |@
  ++  $
    |-  ^+  a
    ?~  b
      ~
    ?~  a
      ~
    ?.  (mor n.a n.b)
      $(a b, b a)
    ?:  =(n.b n.a)
      a(l $(a l.a, b l.b), r $(a r.a, b r.b))
    ?:  (gor n.b n.a)
      %-  uni(a $(a l.a, r.b ~))  $(b r.b)
    %-  uni(a $(a r.a, l.b ~))  $(b l.b)
  --
```

#### Examples

```
> `(set @tD)`(~(int in (silt "foobar")) (silt "bar"))
{'r' 'b' 'a'}
```

```
> `(set @tD)`(~(int in (silt "foobar")) ~)
{}
```

```
> `(set @tD)`(~(int in (silt "foobar")) (silt "baz"))
{'b' 'a'}
```

***

### `+put:in` <a href="#putin" id="putin"></a>

Put `.b` in `.a`.

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

#### Accepts

`.a` is a `+set`, and is the sample of `+in`.

`.b` is a `$noun`.

#### Produces

A `+set`.

#### Source

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

#### Examples

```
> `(set @)`(~(put in (silt ~[1 2 3])) 4)
{1 2 3 4}
```

```
> `(set @)`(~(put in `(set @)`~) 42)
{42}
```

***

### `+rep:in` <a href="#repin" id="repin"></a>

Accumulate.

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

#### Accepts

`.a` is a `+set`, and is the sample of `+in`.

`.b` is a gate.

#### Produces

A `$noun`.

#### Source

```hoon
++  rep
  ~/  %rep
  |*  b=_=>(~ |=([* *] +<+))
  |-
  ?~  a  +<+.b
  $(a r.a, +<+.b $(a l.a, +<+.b (b n.a +<+.b)))
```

#### Examples

```
> (~(rep in (silt ~[1 2 3 4 5])) add)
b=15
```

```
> `@t`(~(rep in (silt ~['foo' 'bar' 'baz'])) |=(a=[@ @] (cat 3 a)))
'foobarbaz'
```

***

### `+run:in` <a href="#runin" id="runin"></a>

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.

#### Produces

A `+set`.

#### Source

```hoon
++  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 (silt ~["a" "A" "b" "c"])

> `(set tape)`s
{"A" "a" "c" "b"}

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

***

### `+tap:in` <a href="#tapin" id="tapin"></a>

Set to list.

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

#### Accepts

`.a` is an set.

#### Produces

A list.

#### Source

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

#### Examples

```
> ~(tap in (silt "foobar"))
"oafbr"
```

```
> ~(tap in (silt ~[1 2 3 4 5]))
~[4 3 2 1 5]
```

***

### `+uni:in` <a href="#uniin" id="uniin"></a>

Union.

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

#### Accepts

`.a` is a `+set`, and is the sample of `+in`.

`.b` is a `+set`.

#### Produces

A `+set`.

#### Source

```hoon
++  uni
  ~/  %uni
  =+  b=a
  |@
  ++  $
    ?:  =(a b)  a
    |-  ^+  a
    ?~  b
      a
    ?~  a
      b
    ?:  =(n.b n.a)
      b(l $(a l.a, b l.b), r $(a r.a, b r.b))
    ?:  (mor n.a n.b)
      ?:  (gor n.b n.a)
        $(l.a $(a l.a, r.b ~), b r.b)
      $(r.a $(a r.a, l.b ~), b l.b)
    ?:  (gor n.a n.b)
      $(l.b $(b l.b, r.a ~), a r.a)
    $(r.b $(b r.b, l.a ~), a l.a)
  --
```

#### Examples

```
> =a (silt ~[1 2 3 4 5])
> =b (silt ~[4 5 6 7 8])

> `(set @)`(~(uni in a) b)
{8 5 7 6 1 2 3 4}

> `(set @)`(~(uni in a) ~)
{5 1 2 3 4}

> `(set @)`(~(uni in `(set @)`~) b)
{8 5 7 6 4}
```

***

### `+wyt:in` <a href="#wytin" id="wytin"></a>

Set size.

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

#### Accepts

`.a` is a `+set`.

#### Produces

An `$atom`.

#### Source

```hoon
++  wyt
  =<  $
  ~%  %wyt  +  ~
  |.  ^-  @
  ?~(a 0 +((add $(a l.a) $(a r.a))))
--
```

#### Examples

```
> ~(wyt in (silt ~[1 2 3 4]))
4
```

```
> ~(wyt in `(set @)`~)
0
```

***


---

# Agent Instructions: Querying This Documentation

If you need additional information that is not directly available in this page, you can query the documentation dynamically by asking a question.

Perform an HTTP GET request on the current page URL with the `ask` query parameter:

```
GET https://docs.urbit.org/hoon/stdlib/2h.md?ask=<question>
```

The question should be specific, self-contained, and written in natural language.
The response will contain a direct answer to the question and relevant excerpts and sources from the documentation.

Use this mechanism when the answer is not explicitly present in the current page, you need clarification or additional context, or you want to retrieve related documentation sections.