+++
title = "2h: Set Logic"
weight = 11
template = "doc.html"
+++

### `++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.

#### Accepts

A `set`.

#### Source

```hoon
    ++  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.

#### Produces

A flag.

#### Source

```hoon
  ++  all                                               ::  logical AND
    ~/  %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.

#### Produces

A flag.

#### Source

```hoon
  ++  any                                               ::  logical OR
    ~/  %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.

#### Produces

A flag.

#### Source

```hoon
  ++  apt                                               ::  check correctness
    =<  $
    ~/  %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 (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`](/docs/hoon/reference/stdlib/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

```hoon
  ++  bif                                               ::  splits a by b
    ~/  %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 (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.

#### Produces

A set.

#### Source

```hoon
  ++  del                                               ::  b without any a
    ~/  %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

```
    > =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')
    [n='madeleine' l=[n='daniel' l={} r={'bonita'}] r=~]

    > (~(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.

#### Produces

A set.

#### Source

```hoon
  ++  dif                                               ::  difference
    ~/  %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

```
    > =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`

Address b in a

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

#### Accepts

`a` is a set.

`b` is a noun.

#### Produces

The `unit` of an atom.

#### Source

```hoon
  ++  dig                                               ::  axis of a in b
    |=  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 (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](/docs/hoon/reference/stdlib/1b).

---
### `++gas:in`

Concatenate

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

#### Accepts

`a` is a set.

`b` is a list.

#### Produces

A `set`.

#### Source

```hoon
  ++  gas                                               ::  concatenate
    ~/  %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
    {'bonita' 'madeleine' 'rudolf' 'john'}

    > (~(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.

#### Produces

A flag.

#### Source

```hoon
  ++  has
    ~/  %has
    |*  b=*
    ^-  ?
    ::  wrap extracted item type in a unit because bunting fails
    ::
    ::    If we used the real item type of _?^(a n.a !!) as the sample type,
    ::    then hoon would bunt it to create the default sample for the gate.
    ::
    ::    However, bunting that expression fails if :a is ~. If we wrap it
    ::    in a unit, the bunted unit doesn't include the bunted item type.
    ::
    ::    This way we can ensure type safety of :b without needing to perform
    ::    this failing bunt. It's a hack.
    ::
    %.  [~ 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 (~(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.

#### Produces

A `set`.

#### Source

```hoon
  ++  int                                               ::  intersection
    ~/  %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

```
    > (~(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.

#### Produces

A `set`.

#### Source

```hoon
  ++  put                                               ::  puts b in a, sorted
    ~/  %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

```
    > =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.

#### Produces

A noun.

#### Source

```hoon
  ++  rep                                               ::  reduce to product
    ~/  %rep
    |*  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.

#### Produces

A set.

#### Source

```hoon
  ++  run                                               ::  apply gate to values
    ~/  %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.

#### Produces

A list.

#### Source

```hoon
  ++  tap                                               ::  convert to list
    =<  $
    ~/  %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.

#### Produces

A set.

#### Source

```hoon
  ++  uni                                               ::  union
    ~/  %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

```
    > (~(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.

#### Produces

An atom.

#### Source

```hoon
  ++  wyt                                               ::  size of set
    =<  $
    ~%  %wyt  +  ~
    |.  ^-  @
    ?~(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
```

---