/
set.d.ts
177 lines (167 loc) · 3.4 KB
/
set.d.ts
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
166
167
168
169
170
171
172
173
174
175
176
177
/**
* The `iiris/set` module includes functions for working with Sets. It is
* designed to be imported with a wildcard, e.g.
*
* ```typescript
* import * as S from 'iiris/array'
* ```
*
* @module
*/
/**
* Return a copy of `set` with `value`.
*
* - If `set` already contains `value`, it is returned unchanged.
*
* @category Basic set operations
* @example
*
* ```typescript
* S.add(4, S.from([1, 2, 3]))
* // => Set(4) { 1, 2, 3, 4 }
* ```
*
* @see add
* @see has
*/
export function add<T>(value: T): (set: Set<T>) => Set<T>
export function add<T>(value: T, set: Set<T>): Set<T>
/**
* Calculate the
* {@link https://en.wikipedia.org/wiki/Complement_(set_theory)#Relative_complement difference}
* between two sets.
*
* @category Set operations
* @example
*
* ```typescript
* S.difference(S.from([1, 2, 3]), S.from([2, 3, 4]))
* // => Set(4) { 1 }
* ```
*
* @see intersection
* @see union
*/
export function difference<T>(first: Set<T>): (second: Set<T>) => Set<T>
export function difference<T>(first: Set<T>, second: Set<T>): Set<T>
/**
* Create an empty set.
*
* @category Creating sets
* @example
*
* ```typescript
* S.empty()
* // => Set(0) {}
* ```
*
* @see from
* @see singleton
*/
export function empty<T>(): Set<T>
/**
* Convert an `iterable` into a set.
*
* @category Creating sets
* @example
*
* ```typescript
* S.from([1, 2, 3])
* // => Set(3) { 1, 2, 3 }
* ```
*
* @see empty
* @see singleton
*/
export function from<T>(iterable: Iterable<T>): Set<T>
/**
* Check if `set` contains `value`.
*
* @example
*
* ```typescript
* S.has(1, S.from([1, 2, 3]))
* // => true
* ```
*/
export function has<T>(value: T): (set: Set<T>) => boolean
export function has<T>(value: T, set: Set<T>): boolean
/**
* Calculate the
* {@link https://en.wikipedia.org/wiki/Intersection_(set_theory) intersection}
* between two sets.
*
* @category Set operations
* @example
*
* ```typescript
* S.intersection(S.from([1, 2, 3]), S.from([2, 3, 4]))
* // => Set(4) { 2, 3 }
* ```
*
* @see intersection
* @see union
*/
export function intersection<T>(first: Set<T>): (second: Set<T>) => Set<T>
export function intersection<T>(first: Set<T>, second: Set<T>): Set<T>
/**
* Check if the `set` is empty.
*
* @example
*
* ```typescript
* S.isEmpty(S.empty())
* // => true
* ```
*/
export function isEmpty<T>(set: Set<T>): boolean
/**
* Return a copy of `set` without `value`.
*
* - If `set` doesn't contain `value`, it is returned unchanged.
*
* @category Basic set operations
* @example
*
* ```typescript
* S.remove(1, S.from([1, 2, 3]))
* // => Set(2) { 2, 3 }
* ```
*
* @see add
* @see has
*/
export function remove<T>(value: T): (set: Set<T>) => Set<T>
export function remove<T>(value: T, set: Set<T>): Set<T>
/**
* Create a singleton set containing `value`.
*
* @category Creating sets
* @example
*
* ```typescript
* S.singleton(1)
* // => Set(1) { 1 }
* ```
*
* @see empty
* @see from
*/
export function singleton<T>(value: T): Set<T>
/**
* Calculate the {@link https://en.wikipedia.org/wiki/Union_(set_theory) union}
* between two sets.
*
* @category Set operations
* @example
*
* ```typescript
* S.union(S.from([1, 2, 3]), S.from([2, 3, 4]))
* // => Set(4) { 1, 2, 3, 4 }
* ```
*
* @see difference
* @see intersection
*/
export function union<T>(first: Set<T>): (second: Set<T>) => Set<T>
export function union<T>(first: Set<T>, second: Set<T>): Set<T>