| description | Set data structure operations including union, intersection, difference, and membership testing. | |||||||||||||||||||
|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|
| layout |
|
Set operations.
Core whose arms contain a variety of functions that operate on +sets. Its sample accepts the input +set to be manipulated.
A +set.
~/ %in
=| a=(tree)
|@> ~(. 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>]>
Logical AND.
Computes the logical AND on every element in .a slammed with .b, producing a $flag.
.a is a +set, and is the sample of +in.
.b is a gate that accepts a $noun and produces a $flag.
A $flag.
++ all
~/ %all
|* b=$-(* ?)
|- ^- ?
?~ a
&
?&((b n.a) $(a l.a) $(a r.a))> (~(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
Logical OR.
Computes the logical OR on every element of .a slammed with .b, producing a $flag.
.a is a +set, and is the sample of +in.
.b is a gate that accepts a $noun and produces a $flag.
A $flag.
++ any
~/ %any
|* b=$-(* ?)
|- ^- ?
?~ a
|
?|((b n.a) $(a l.a) $(a r.a))> (~(any in (silt ~[2 3 4 5])) |=(a=@ (lth a 3)))
%.y
> (~(any in (silt ~[3 4 5])) |=(a=@ (lth a 3)))
%.n
Check correctness.
Computes whether .a has a correct horizontal order and a correct vertical order, producing a $flag.
.a is a +set.
A $flag.
++ apt
=< $
~/ %apt
=| [l=(unit) r=(unit)]
|. ^- ?
?~ a &
?& ?~(l & &((gor n.a u.l) !=(n.a u.l)))
?~(r & &((gor u.r n.a) !=(u.r n.a)))
?~(l.a & ?&((mor n.a n.l.a) !=(n.a n.l.a) $(a l.a, l `n.a)))
?~(r.a & ?&((mor n.a n.r.a) !=(n.a n.r.a) $(a r.a, r `n.a)))
==> ~(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
See section 2f for more information on $noun ordering.
Bifurcate.
Splits set .a into sets .l and .r, which contain the items either side of .b but not including .b.
.a is a +set, and is the sample of +in.
.b is a $noun.
A cell of two +sets.
++ 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))> =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}]
Note that +sets are horizontally ordered by the 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.
Remove $noun.
Removes .b from the +set .a.
.a is a +set, and is the sample of +in.
.b is a $noun.
A +set.
++ del
~/ %del
|* b=*
=> .(b `_?>(?=(^ a) n.a)`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))> `(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)
{}
Difference.
Computes the difference between .a and .b, producing the set of items in .a that are not in .b.
.a is a +set, and is the sample of +in.
.b is a +set.
A +set.
++ 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))
--> =a (silt ~[1 2 3 4 5])
> =b (silt ~[3 4])
> `(set @)`(~(dif in a) b)
{5 1 2}
Address .b in .a.
Produce the tree address of .b within .a.
.a is a +set, and is the sample of +in.
.b is a $noun.
The +unit of an $atom.
++ 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))> =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)
~
For more on the tree addressing system, see section 1b.
Concatenate.
Insert the elements of a +list .b into a +set .a.
.a is a +set, and is the sample of +in.
.b is a list.
A +set.
++ gas
~/ %gas
|= b=(list _?>(?=(^ a) n.a))
|- ^+ a
?~ b
a
$(b t.b, a (put i.b))> =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'}
Is .b in .a?
Checks if .b is an element of .a, producing a $flag.
.a is a +set, and is the sample of +in.
.b is a $noun.
A $flag.
++ 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)> =a (silt ~[1 2 3 4 5])
> (~(has in a) 2)
%.y
> (~(has in a) 6)
%.n
Intersection.
Produces a +set of the intersection between two sets of the same type, .a and .b.
.a is a +set, and is the sample of +in.
.b is a +set.
A +set.
++ 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)> `(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 .b in .a.
Add an element .b to the set .a, producing a +set.
.a is a +set, and is the sample of +in.
.b is a $noun.
A +set.
++ 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))> `(set @)`(~(put in (silt ~[1 2 3])) 4)
{1 2 3 4}
> `(set @)`(~(put in `(set @)`~) 42)
{42}
Accumulate.
Accumulate the elements of .a using binary gate .b.
.a is a +set, and is the sample of +in.
.b is a gate.
A $noun.
++ rep
~/ %rep
|* b=_=>(~ |=([* *] +<+))
|-
?~ a +<+.b
$(a r.a, +<+.b $(a l.a, +<+.b (b n.a +<+.b)))> (~(rep in (silt ~[1 2 3 4 5])) add)
b=15
> `@t`(~(rep in (silt ~['foo' 'bar' 'baz'])) |=(a=[@ @] (cat 3 a)))
'foobarbaz'
Apply gate to set.
Produce a +set containing the products of gate .b applied to each element in .a.
.a is a +set.
.b is a gate.
A +set.
++ 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)> =s (silt ~["a" "A" "b" "c"])
> `(set tape)`s
{"A" "a" "c" "b"}
> (~(run in s) cuss)
{"A" "C" "B"}
Set to list.
Flattens the +set .a into a +list.
.a is an set.
A list.
++ tap
=< $
~/ %tap
=+ b=`(list _?>(?=(^ a) n.a))`~
|. ^+ b
?~ a
b
$(a r.a, b [n.a $(a l.a)])> ~(tap in (silt "foobar"))
"oafbr"
> ~(tap in (silt ~[1 2 3 4 5]))
~[4 3 2 1 5]
Union.
Produces a +set of the union between two sets of the same type, .a and .b.
.a is a +set, and is the sample of +in.
.b is a +set.
A +set.
++ 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)> =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}
Set size.
Produces the number of elements in set .a as an $atom.
.a is a +set.
An $atom.
++ wyt
=< $
~% %wyt + ~
|. ^- @
?~(a 0 +((add $(a l.a) $(a r.a))))> ~(wyt in (silt ~[1 2 3 4]))
4
> ~(wyt in `(set @)`~)
0