cuelang.org/go@v0.13.0/pkg/list/pkg.go (about)

     1  // Code generated by cuelang.org/go/pkg/gen. DO NOT EDIT.
     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 // in case the adt package isn't used
    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: "Reverse",
    97  		Params: []pkg.Param{
    98  			{Kind: adt.ListKind},
    99  		},
   100  		Result: adt.ListKind,
   101  		Func: func(c *pkg.CallCtxt) {
   102  			x := c.List(0)
   103  			if c.Do() {
   104  				c.Ret = Reverse(x)
   105  			}
   106  		},
   107  	}, {
   108  		Name: "MinItems",
   109  		Params: []pkg.Param{
   110  			{Kind: adt.ListKind},
   111  			{Kind: adt.IntKind},
   112  		},
   113  		Result: adt.BoolKind,
   114  		Func: func(c *pkg.CallCtxt) {
   115  			list, n := c.CueList(0), c.Int(1)
   116  			if c.Do() {
   117  				c.Ret, c.Err = MinItems(list, n)
   118  			}
   119  		},
   120  	}, {
   121  		Name: "MaxItems",
   122  		Params: []pkg.Param{
   123  			{Kind: adt.ListKind},
   124  			{Kind: adt.IntKind},
   125  		},
   126  		Result: adt.BoolKind,
   127  		Func: func(c *pkg.CallCtxt) {
   128  			list, n := c.CueList(0), c.Int(1)
   129  			if c.Do() {
   130  				c.Ret, c.Err = MaxItems(list, n)
   131  			}
   132  		},
   133  	}, {
   134  		Name: "UniqueItems",
   135  		Params: []pkg.Param{
   136  			{Kind: adt.ListKind},
   137  		},
   138  		Result: adt.BoolKind,
   139  		Func: func(c *pkg.CallCtxt) {
   140  			a := c.List(0)
   141  			if c.Do() {
   142  				c.Ret, c.Err = UniqueItems(a)
   143  			}
   144  		},
   145  	}, {
   146  		Name: "Contains",
   147  		Params: []pkg.Param{
   148  			{Kind: adt.ListKind},
   149  			{Kind: adt.TopKind},
   150  		},
   151  		Result: adt.BoolKind,
   152  		Func: func(c *pkg.CallCtxt) {
   153  			a, v := c.List(0), c.Value(1)
   154  			if c.Do() {
   155  				c.Ret = Contains(a, v)
   156  			}
   157  		},
   158  	}, {
   159  		Name: "MatchN",
   160  		Params: []pkg.Param{
   161  			{Kind: adt.ListKind},
   162  			{Kind: adt.TopKind},
   163  			{Kind: adt.TopKind},
   164  		},
   165  		Result:      adt.BoolKind,
   166  		NonConcrete: true,
   167  		Func: func(c *pkg.CallCtxt) {
   168  			list, n, matchValue := c.List(0), c.Schema(1), c.Schema(2)
   169  			if c.Do() {
   170  				c.Ret, c.Err = matchN(c.OpContext(), list, n, matchValue)
   171  			}
   172  		},
   173  	}, {
   174  		Name: "Avg",
   175  		Params: []pkg.Param{
   176  			{Kind: adt.ListKind},
   177  		},
   178  		Result: adt.NumberKind,
   179  		Func: func(c *pkg.CallCtxt) {
   180  			xs := c.DecimalList(0)
   181  			if c.Do() {
   182  				c.Ret, c.Err = Avg(xs)
   183  			}
   184  		},
   185  	}, {
   186  		Name: "Max",
   187  		Params: []pkg.Param{
   188  			{Kind: adt.ListKind},
   189  		},
   190  		Result: adt.NumberKind,
   191  		Func: func(c *pkg.CallCtxt) {
   192  			xs := c.DecimalList(0)
   193  			if c.Do() {
   194  				c.Ret, c.Err = Max(xs)
   195  			}
   196  		},
   197  	}, {
   198  		Name: "Min",
   199  		Params: []pkg.Param{
   200  			{Kind: adt.ListKind},
   201  		},
   202  		Result: adt.NumberKind,
   203  		Func: func(c *pkg.CallCtxt) {
   204  			xs := c.DecimalList(0)
   205  			if c.Do() {
   206  				c.Ret, c.Err = Min(xs)
   207  			}
   208  		},
   209  	}, {
   210  		Name: "Product",
   211  		Params: []pkg.Param{
   212  			{Kind: adt.ListKind},
   213  		},
   214  		Result: adt.NumberKind,
   215  		Func: func(c *pkg.CallCtxt) {
   216  			xs := c.DecimalList(0)
   217  			if c.Do() {
   218  				c.Ret, c.Err = Product(xs)
   219  			}
   220  		},
   221  	}, {
   222  		Name: "Range",
   223  		Params: []pkg.Param{
   224  			{Kind: adt.NumberKind},
   225  			{Kind: adt.NumberKind},
   226  			{Kind: adt.NumberKind},
   227  		},
   228  		Result: adt.ListKind,
   229  		Func: func(c *pkg.CallCtxt) {
   230  			start, limit, step := c.Decimal(0), c.Decimal(1), c.Decimal(2)
   231  			if c.Do() {
   232  				c.Ret, c.Err = Range(start, limit, step)
   233  			}
   234  		},
   235  	}, {
   236  		Name: "Sum",
   237  		Params: []pkg.Param{
   238  			{Kind: adt.ListKind},
   239  		},
   240  		Result: adt.NumberKind,
   241  		Func: func(c *pkg.CallCtxt) {
   242  			xs := c.DecimalList(0)
   243  			if c.Do() {
   244  				c.Ret, c.Err = Sum(xs)
   245  			}
   246  		},
   247  	}, {
   248  		Name: "Sort",
   249  		Params: []pkg.Param{
   250  			{Kind: adt.ListKind},
   251  			{Kind: adt.TopKind},
   252  		},
   253  		Result: adt.ListKind,
   254  		Func: func(c *pkg.CallCtxt) {
   255  			list, cmp := c.List(0), c.Value(1)
   256  			if c.Do() {
   257  				c.Ret, c.Err = Sort(list, cmp)
   258  			}
   259  		},
   260  	}, {
   261  		Name: "SortStable",
   262  		Params: []pkg.Param{
   263  			{Kind: adt.ListKind},
   264  			{Kind: adt.TopKind},
   265  		},
   266  		Result: adt.ListKind,
   267  		Func: func(c *pkg.CallCtxt) {
   268  			list, cmp := c.List(0), c.Value(1)
   269  			if c.Do() {
   270  				c.Ret, c.Err = SortStable(list, cmp)
   271  			}
   272  		},
   273  	}, {
   274  		Name: "SortStrings",
   275  		Params: []pkg.Param{
   276  			{Kind: adt.ListKind},
   277  		},
   278  		Result: adt.ListKind,
   279  		Func: func(c *pkg.CallCtxt) {
   280  			a := c.StringList(0)
   281  			if c.Do() {
   282  				c.Ret = SortStrings(a)
   283  			}
   284  		},
   285  	}, {
   286  		Name: "IsSorted",
   287  		Params: []pkg.Param{
   288  			{Kind: adt.ListKind},
   289  			{Kind: adt.TopKind},
   290  		},
   291  		Result: adt.BoolKind,
   292  		Func: func(c *pkg.CallCtxt) {
   293  			list, cmp := c.List(0), c.Value(1)
   294  			if c.Do() {
   295  				c.Ret = IsSorted(list, cmp)
   296  			}
   297  		},
   298  	}, {
   299  		Name: "IsSortedStrings",
   300  		Params: []pkg.Param{
   301  			{Kind: adt.ListKind},
   302  		},
   303  		Result: adt.BoolKind,
   304  		Func: func(c *pkg.CallCtxt) {
   305  			a := c.StringList(0)
   306  			if c.Do() {
   307  				c.Ret = IsSortedStrings(a)
   308  			}
   309  		},
   310  	}},
   311  	CUE: `{
   312  	Comparer: {
   313  		T:    _
   314  		x:    T
   315  		y:    T
   316  		less: bool
   317  	}
   318  	Ascending: {
   319  		Comparer
   320  		T:    number | string
   321  		x:    T
   322  		y:    T
   323  		less: x < y
   324  	}
   325  	Descending: {
   326  		Comparer
   327  		T:    number | string
   328  		x:    T
   329  		y:    T
   330  		less: x > y
   331  	}
   332  }`,
   333  }