1
2
3 package list
4
5 import (
6 "cuelang.org/go/internal/core/adt"
7 "cuelang.org/go/internal/pkg"
8 )
9
10 func init() {
11 pkg.Register("list", p)
12 }
13
14 var _ = adt.TopKind
15
16 var p = &pkg.Package{
17 Native: []*pkg.Builtin{{
18 Name: "Drop",
19 Params: []pkg.Param{
20 {Kind: adt.ListKind},
21 {Kind: adt.IntKind},
22 },
23 Result: adt.ListKind,
24 Func: func(c *pkg.CallCtxt) {
25 x, n := c.List(0), c.Int(1)
26 if c.Do() {
27 c.Ret, c.Err = Drop(x, n)
28 }
29 },
30 }, {
31 Name: "FlattenN",
32 Params: []pkg.Param{
33 {Kind: adt.TopKind},
34 {Kind: adt.IntKind},
35 },
36 Result: adt.ListKind,
37 Func: func(c *pkg.CallCtxt) {
38 xs, depth := c.Value(0), c.Int(1)
39 if c.Do() {
40 c.Ret, c.Err = FlattenN(xs, depth)
41 }
42 },
43 }, {
44 Name: "Repeat",
45 Params: []pkg.Param{
46 {Kind: adt.ListKind},
47 {Kind: adt.IntKind},
48 },
49 Result: adt.ListKind,
50 Func: func(c *pkg.CallCtxt) {
51 x, count := c.List(0), c.Int(1)
52 if c.Do() {
53 c.Ret, c.Err = Repeat(x, count)
54 }
55 },
56 }, {
57 Name: "Concat",
58 Params: []pkg.Param{
59 {Kind: adt.ListKind},
60 },
61 Result: adt.ListKind,
62 Func: func(c *pkg.CallCtxt) {
63 a := c.List(0)
64 if c.Do() {
65 c.Ret, c.Err = Concat(a)
66 }
67 },
68 }, {
69 Name: "Take",
70 Params: []pkg.Param{
71 {Kind: adt.ListKind},
72 {Kind: adt.IntKind},
73 },
74 Result: adt.ListKind,
75 Func: func(c *pkg.CallCtxt) {
76 x, n := c.List(0), c.Int(1)
77 if c.Do() {
78 c.Ret, c.Err = Take(x, n)
79 }
80 },
81 }, {
82 Name: "Slice",
83 Params: []pkg.Param{
84 {Kind: adt.ListKind},
85 {Kind: adt.IntKind},
86 {Kind: adt.IntKind},
87 },
88 Result: adt.ListKind,
89 Func: func(c *pkg.CallCtxt) {
90 x, i, j := c.List(0), c.Int(1), c.Int(2)
91 if c.Do() {
92 c.Ret, c.Err = Slice(x, i, j)
93 }
94 },
95 }, {
96 Name: "MinItems",
97 Params: []pkg.Param{
98 {Kind: adt.ListKind},
99 {Kind: adt.IntKind},
100 },
101 Result: adt.BoolKind,
102 Func: func(c *pkg.CallCtxt) {
103 list, n := c.CueList(0), c.Int(1)
104 if c.Do() {
105 c.Ret, c.Err = MinItems(list, n)
106 }
107 },
108 }, {
109 Name: "MaxItems",
110 Params: []pkg.Param{
111 {Kind: adt.ListKind},
112 {Kind: adt.IntKind},
113 },
114 Result: adt.BoolKind,
115 Func: func(c *pkg.CallCtxt) {
116 list, n := c.CueList(0), c.Int(1)
117 if c.Do() {
118 c.Ret, c.Err = MaxItems(list, n)
119 }
120 },
121 }, {
122 Name: "UniqueItems",
123 Params: []pkg.Param{
124 {Kind: adt.ListKind},
125 },
126 Result: adt.BoolKind,
127 Func: func(c *pkg.CallCtxt) {
128 a := c.List(0)
129 if c.Do() {
130 c.Ret = UniqueItems(a)
131 }
132 },
133 }, {
134 Name: "Contains",
135 Params: []pkg.Param{
136 {Kind: adt.ListKind},
137 {Kind: adt.TopKind},
138 },
139 Result: adt.BoolKind,
140 Func: func(c *pkg.CallCtxt) {
141 a, v := c.List(0), c.Value(1)
142 if c.Do() {
143 c.Ret = Contains(a, v)
144 }
145 },
146 }, {
147 Name: "Avg",
148 Params: []pkg.Param{
149 {Kind: adt.ListKind},
150 },
151 Result: adt.NumKind,
152 Func: func(c *pkg.CallCtxt) {
153 xs := c.DecimalList(0)
154 if c.Do() {
155 c.Ret, c.Err = Avg(xs)
156 }
157 },
158 }, {
159 Name: "Max",
160 Params: []pkg.Param{
161 {Kind: adt.ListKind},
162 },
163 Result: adt.NumKind,
164 Func: func(c *pkg.CallCtxt) {
165 xs := c.DecimalList(0)
166 if c.Do() {
167 c.Ret, c.Err = Max(xs)
168 }
169 },
170 }, {
171 Name: "Min",
172 Params: []pkg.Param{
173 {Kind: adt.ListKind},
174 },
175 Result: adt.NumKind,
176 Func: func(c *pkg.CallCtxt) {
177 xs := c.DecimalList(0)
178 if c.Do() {
179 c.Ret, c.Err = Min(xs)
180 }
181 },
182 }, {
183 Name: "Product",
184 Params: []pkg.Param{
185 {Kind: adt.ListKind},
186 },
187 Result: adt.NumKind,
188 Func: func(c *pkg.CallCtxt) {
189 xs := c.DecimalList(0)
190 if c.Do() {
191 c.Ret, c.Err = Product(xs)
192 }
193 },
194 }, {
195 Name: "Range",
196 Params: []pkg.Param{
197 {Kind: adt.NumKind},
198 {Kind: adt.NumKind},
199 {Kind: adt.NumKind},
200 },
201 Result: adt.ListKind,
202 Func: func(c *pkg.CallCtxt) {
203 start, limit, step := c.Decimal(0), c.Decimal(1), c.Decimal(2)
204 if c.Do() {
205 c.Ret, c.Err = Range(start, limit, step)
206 }
207 },
208 }, {
209 Name: "Sum",
210 Params: []pkg.Param{
211 {Kind: adt.ListKind},
212 },
213 Result: adt.NumKind,
214 Func: func(c *pkg.CallCtxt) {
215 xs := c.DecimalList(0)
216 if c.Do() {
217 c.Ret, c.Err = Sum(xs)
218 }
219 },
220 }, {
221 Name: "Sort",
222 Params: []pkg.Param{
223 {Kind: adt.ListKind},
224 {Kind: adt.TopKind},
225 },
226 Result: adt.ListKind,
227 Func: func(c *pkg.CallCtxt) {
228 list, cmp := c.List(0), c.Value(1)
229 if c.Do() {
230 c.Ret, c.Err = Sort(list, cmp)
231 }
232 },
233 }, {
234 Name: "SortStable",
235 Params: []pkg.Param{
236 {Kind: adt.ListKind},
237 {Kind: adt.TopKind},
238 },
239 Result: adt.ListKind,
240 Func: func(c *pkg.CallCtxt) {
241 list, cmp := c.List(0), c.Value(1)
242 if c.Do() {
243 c.Ret, c.Err = SortStable(list, cmp)
244 }
245 },
246 }, {
247 Name: "SortStrings",
248 Params: []pkg.Param{
249 {Kind: adt.ListKind},
250 },
251 Result: adt.ListKind,
252 Func: func(c *pkg.CallCtxt) {
253 a := c.StringList(0)
254 if c.Do() {
255 c.Ret = SortStrings(a)
256 }
257 },
258 }, {
259 Name: "IsSorted",
260 Params: []pkg.Param{
261 {Kind: adt.ListKind},
262 {Kind: adt.TopKind},
263 },
264 Result: adt.BoolKind,
265 Func: func(c *pkg.CallCtxt) {
266 list, cmp := c.List(0), c.Value(1)
267 if c.Do() {
268 c.Ret = IsSorted(list, cmp)
269 }
270 },
271 }, {
272 Name: "IsSortedStrings",
273 Params: []pkg.Param{
274 {Kind: adt.ListKind},
275 },
276 Result: adt.BoolKind,
277 Func: func(c *pkg.CallCtxt) {
278 a := c.StringList(0)
279 if c.Do() {
280 c.Ret = IsSortedStrings(a)
281 }
282 },
283 }},
284 CUE: `{
285 Comparer: {
286 T: _
287 x: T
288 y: T
289 less: bool
290 }
291 Ascending: {
292 Comparer
293 T: number | string
294 x: T
295 y: T
296 less: x < y
297 }
298 Descending: {
299 Comparer
300 T: number | string
301 x: T
302 y: T
303 less: x > y
304 }
305 }`,
306 }
307
View as plain text