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

Accepts
-------

A `++set`.

Source
------

    ++  in                                                  ::  set engine
      ~/  %in
      |_  a/(set)

Examples
--------

    > ~(. in (sa "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 boolean.

Accepts
-------

`a` is a `++set`.

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

Produces
--------

A boolean.

Source
------

      +-  all                                               ::  logical AND
        ~/  %all
        |*  b/$-(* ?)
        |-  ^-  ?
        ?~  a
          &
        ?&((b n.a) $(a l.a) $(a r.a))


Examples
--------

    > =b (sa `(list [@t *])`[['a' 1] ['b' [2 3]] ~])
    > (~(all in b) |=(a/* ?@(+.a & |)))
        %.n
    > =b (sa `(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`.

Accepts
-------

`a` is a `++set`.

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

Produces
--------

A boolean.

Source
------

      +-  any                                               ::  logical OR
        ~/  %any
        |*  b/$-(* ?)
        |-  ^-  ?
        ?~  a
          |
        ?|((b n.a) $(a l.a) $(a r.a))
      ::


Examples
--------

    > =b (sa `(list [@t *])`[['a' 1] ['b' [2 3]] ~])
    > (~(any in b) |=(a/* ?@(+.a & |)))
        %.y
    > =b (sa `(list @t)`['john' 'bonita' 'daniel' 'madeleine' ~])
    > (~(any in b) |=(a/@t (lte a 100)))
        %.n

------------------------------------------------------------------------

### `+-del:in`

Remove noun

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

Accepts
-------

`a` is a set.

`b` is a noun.

Produces
--------

A set.

Source
------

      +-  del                                               ::  b without any a
        ~/  %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 (sa `(list @t)`['a' 'b' 'c' ~])
    > (~(del in b) 'a')
    {'c' 'b'}
    > =b (sa `(list @t)`['john' 'bonita' 'daniel' 'madeleine' ~])
    > (~(del in b) 'john')
    {'bonita' 'madeleine' 'daniel'}
    > (~(del in b) 'susan')
    {'bonita' 'madeleine' 'daniel' 'john'}

------------------------------------------------------------------------

### `+-dig:in`

Axis a in b

Produce the axis of `b` within `a`.

Accepts
-------

`a` is a `++set`.

`b` is a noun.

Produces
--------

The `++unit` of an atom.

Source
------

      +-  dig                                               ::  axis of a in b
        |=  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 (sa `(list @)`[1 2 3 4 5 6 7 ~])
    > a
    {5 4 7 6 1 3 2}
    > -.a
    n=6
    > (~(dig in a) 7)
    [~ 12]
    > (~(dig in a) 2)
    [~ 14]
    > (~(dig in a) 6)
    [~ 2]

------------------------------------------------------------------------

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

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


Examples
--------

    > b
    {'bonita' 'madeleine' 'rudolf' 'john'}
    > (~(gas in b) `(list @t)`['14' 'things' 'number' '1.337' ~])
    {'1.337' '14' 'number' 'things' 'bonita' 'madeleine' 'rudolf' 'john'}
    > (~(gas in s) `(list ,@t)`['1' '2' '3' ~])
    {'1' '3' '2' 'e' 'd' 'a' 'c' 'b'}

------------------------------------------------------------------------

### `+-has:in`

b in a?

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

Accepts
-------

`a` is a [`++set`]().

`b` is a [noun]().

Produces
--------

A boolean.

Source
------

      +-  has                                               ::  b exists in a check
        ~/  %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 `++set`s of the same type,
`a` and `b`.

Accepts
-------

`a` is a set.

`b` is a set.

Produces
--------

A `++set`.

Source
------

      +-  int                                               ::  intersection
        ~/  %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 (sa "ac")) (sa "ha"))
    {~~a}
    > (~(int in (sa "acmo")) ~)
    {}
    > (~(int in (sa "acmo")) (sa "ham"))
    {~~a ~~m}
    > (~(int in (sa "acmo")) (sa "lep"))
    {}

------------------------------------------------------------------------

### `+-put:in`

Put b in a

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

Accepts
-------

`a` is a set.

`b` is a noun.

Produces
--------

A `++set`.

Source
------

      +-  put                                               ::  puts b in a, sorted
        ~/  %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`)
    > b
    {`d` `a` `c` `b`}
    > -.l.+.b
    n=`d`

------------------------------------------------------------------------

### `+-rep:in`

Accumulate

Accumulate the elements of `a` using a gate `c` and an accumulator `b`.

Accepts
--------

`a` is a `++set`.

`b` is a noun.

`c` is a gate.

Produces
--------

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 ~])
    > a
    {1 3 2}
    > (~(rep in a) 0 |=([a/@ b/@] (add a b)))
    6

------------------------------------------------------------------------

### `+-tap:in`

Set to list

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

Accepts
-------

`a` is an set.

Produces
--------

A list.

Source
------

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



Examples
--------

    > =s (sa `(list @t)`['a' 'b' 'c' 'd' 'e' ~])
    > s
    {'e' 'd' 'a' 'c' 'b'}
    > (~(tap in s) `(list @t)`['1' '2' '3' ~])
    ~['b' 'c' 'a' 'd' 'e' '1' '2' '3']
    > b
    {'bonita' 'madeleine' 'daniel' 'john'}
    ~zod/try=> (~(tap in b) `(list ,@t)`['david' 'people' ~])
    ~['john' 'daniel' 'madeleine' 'bonita' 'david' 'people']

------------------------------------------------------------------------

### `+-uni:in`

Union

Produces a set of the union between two [`++set`]()s of the same type, `a` and
`b`.

Accepts
-------

`a` is a set.

`b` is a set.

Produces
--------

A set.

Source
------

      +-  uni                                               ::  union
        ~/  %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 (sa "ac")) (sa "ha"))
    {~~a ~~c ~~h}
     > (~(uni in (sa "acmo")) ~)
    {~~a ~~c ~~m ~~o}
    > (~(uni in (sa "acmo")) (sa "ham"))
    {~~a ~~c ~~m ~~o ~~h}
    > (~(uni in (sa "acmo")) (sa "lep"))
    {~~e ~~a ~~c ~~m ~~l ~~o ~~p}

------------------------------------------------------------------------

### `+-wyt:in`

Set size

Produce the number of elements in [`++set`]() `a` as an atom.

Accepts
-------

`a` is an set.

Produces
--------

An atom.

Source
------

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



Examples
--------

    > =a (~(put in (~(put in (sa)) 'a')) 'b')
    > ~(wyt in a)
    2
    > b
    {'bonita' 'madeleine' 'daniel' 'john'}
    > ~(wyt in b)
    4


***