diff --git a/cue/builtin.go b/cue/builtin.go
index d6716eb..d7fea05 100644
--- a/cue/builtin.go
+++ b/cue/builtin.go
@@ -574,6 +574,26 @@
 	return v
 }
 
+func (c *callCtxt) decimalList(i int) (a []*apd.Decimal) {
+	arg := c.args[i]
+	x := newValueRoot(c.ctx, arg)
+	v, err := x.List()
+	if err != nil {
+		c.invalidArgType(c.args[i], i, "list", err)
+		return nil
+	}
+	for j := 0; v.Next(); j++ {
+		num, err := v.Value().getNum(numKind)
+		if err != nil {
+			c.errf(c.src, err, "invalid list element %d in argument %d to %s: %v",
+				j, i, c.name(), err)
+			break
+		}
+		a = append(a, &num.v)
+	}
+	return a
+}
+
 func (c *callCtxt) strList(i int) (a []string) {
 	arg := c.args[i]
 	x := newValueRoot(c.ctx, arg)
diff --git a/cue/builtin_test.go b/cue/builtin_test.go
index 73d3fd7..6e63183 100644
--- a/cue/builtin_test.go
+++ b/cue/builtin_test.go
@@ -135,6 +135,51 @@
 		test("strconv", `strconv.FormatFloat(3.02, 1.0, 4, 64)`),
 		`_|_(cannot use 1.0 (type float) as int in argument 2 to strconv.FormatFloat)`,
 	}, {
+		test("list", `list.Avg([1, 2, 3, 4])`),
+		`2.5`,
+	}, {
+		test("list", `list.Avg([])`),
+		`_|_(error in call to list.Avg: empty list)`,
+	}, {
+		test("list", `list.Avg("foo")`),
+		`_|_(cannot use "foo" (type string) as list in argument 1 to list.Avg)`,
+	}, {
+		test("list", `list.Max([1, 2, 3, 4])`),
+		`4`,
+	}, {
+		test("list", `list.Max([])`),
+		`_|_(error in call to list.Max: empty list)`,
+	}, {
+		test("list", `list.Max("foo")`),
+		`_|_(cannot use "foo" (type string) as list in argument 1 to list.Max)`,
+	}, {
+		test("list", `list.Min([1, 2, 3, 4])`),
+		`1`,
+	}, {
+		test("list", `list.Min([])`),
+		`_|_(error in call to list.Min: empty list)`,
+	}, {
+		test("list", `list.Min("foo")`),
+		`_|_(cannot use "foo" (type string) as list in argument 1 to list.Min)`,
+	}, {
+		test("list", `list.Product([1, 2, 3, 4])`),
+		`24`,
+	}, {
+		test("list", `list.Product([])`),
+		`1`,
+	}, {
+		test("list", `list.Product("foo")`),
+		`_|_(cannot use "foo" (type string) as list in argument 1 to list.Product)`,
+	}, {
+		test("list", `list.Sum([1, 2, 3, 4])`),
+		`10`,
+	}, {
+		test("list", `list.Sum([])`),
+		`0`,
+	}, {
+		test("list", `list.Sum("foo")`),
+		`_|_(cannot use "foo" (type string) as list in argument 1 to list.Sum)`,
+	}, {
 		// Panics
 		test("math", `math.Jacobi(1000, 2000)`),
 		`_|_(error in call to math.Jacobi: big: invalid 2nd argument to Int.Jacobi: need odd integer but got 2000)`,
diff --git a/cue/builtins.go b/cue/builtins.go
index 2e6ef2a..efc4ffd 100644
--- a/cue/builtins.go
+++ b/cue/builtins.go
@@ -717,6 +717,118 @@
 					return false
 				}()
 			},
+		}, {
+			Name:   "Avg",
+			Params: []kind{listKind},
+			Result: numKind,
+			Func: func(c *callCtxt) {
+				xs := c.decimalList(0)
+				if c.do() {
+					c.ret, c.err = func() (interface{}, error) {
+						if 0 == len(xs) {
+							return nil, fmt.Errorf("empty list")
+						}
+
+						s := apd.New(0, 0)
+						for _, x := range xs {
+							_, err := internal.BaseContext.Add(s, x, s)
+							if err != nil {
+								return nil, err
+							}
+						}
+
+						var d apd.Decimal
+						l := apd.New(int64(len(xs)), 0)
+						_, err := internal.BaseContext.Quo(&d, s, l)
+						if err != nil {
+							return nil, err
+						}
+						return &d, nil
+					}()
+				}
+			},
+		}, {
+			Name:   "Max",
+			Params: []kind{listKind},
+			Result: numKind,
+			Func: func(c *callCtxt) {
+				xs := c.decimalList(0)
+				if c.do() {
+					c.ret, c.err = func() (interface{}, error) {
+						if 0 == len(xs) {
+							return nil, fmt.Errorf("empty list")
+						}
+
+						max := xs[0]
+						for _, x := range xs[1:] {
+							if -1 == max.Cmp(x) {
+								max = x
+							}
+						}
+						return max, nil
+					}()
+				}
+			},
+		}, {
+			Name:   "Min",
+			Params: []kind{listKind},
+			Result: numKind,
+			Func: func(c *callCtxt) {
+				xs := c.decimalList(0)
+				if c.do() {
+					c.ret, c.err = func() (interface{}, error) {
+						if 0 == len(xs) {
+							return nil, fmt.Errorf("empty list")
+						}
+
+						min := xs[0]
+						for _, x := range xs[1:] {
+							if +1 == min.Cmp(x) {
+								min = x
+							}
+						}
+						return min, nil
+					}()
+				}
+			},
+		}, {
+			Name:   "Product",
+			Params: []kind{listKind},
+			Result: numKind,
+			Func: func(c *callCtxt) {
+				xs := c.decimalList(0)
+				if c.do() {
+					c.ret, c.err = func() (interface{}, error) {
+						d := apd.New(1, 0)
+						for _, x := range xs {
+							_, err := internal.BaseContext.Mul(d, x, d)
+							if err != nil {
+								return nil, err
+							}
+						}
+						return d, nil
+					}()
+				}
+			},
+		}, {
+			Name:   "Sum",
+			Params: []kind{listKind},
+			Result: numKind,
+			Func: func(c *callCtxt) {
+				xs := c.decimalList(0)
+				if c.do() {
+					c.ret, c.err = func() (interface{}, error) {
+						d := apd.New(0, 0)
+						for _, x := range xs {
+							_, err := internal.BaseContext.Add(d, x, d)
+							if err != nil {
+								return nil, err
+							}
+						}
+						return d, nil
+					}()
+				}
+			},
 		}},
 	},
 	"math": &builtinPkg{
@@ -2027,6 +2139,7 @@
 			Func: func(c *callCtxt) {
 				s, min := c.string(0), c.int(1)
 				c.ret = func() interface{} {
+
 					return len([]rune(s)) >= min
 				}()
 			},
diff --git a/cue/gen.go b/cue/gen.go
index cd30512..7f607eb 100644
--- a/cue/gen.go
+++ b/cue/gen.go
@@ -399,6 +399,8 @@
 		return "bigRat"
 	case "internal.Decimal":
 		return "decimal"
+	case "[]*internal.Decimal":
+		return "decimalList"
 	case "cue.Struct":
 		return "structVal"
 	case "cue.Value":
@@ -440,6 +442,9 @@
 		cueKind += "numKind"
 	case "list":
 		cueKind += "listKind"
+	case "decimalList":
+		omitCheck = false
+		cueKind += "listKind"
 	case "strList":
 		omitCheck = false
 		cueKind += "listKind"
diff --git a/internal/internal.go b/internal/internal.go
index a7cdc42..f4e0ab7 100644
--- a/internal/internal.go
+++ b/internal/internal.go
@@ -69,6 +69,9 @@
 // keys.
 var CheckAndForkRuntime func(runtime, value interface{}) interface{}
 
+// BaseContext is used as CUEs default context for arbitrary-precision decimals
+var BaseContext = apd.BaseContext.WithPrecision(24)
+
 // ListEllipsis reports the list type and remaining elements of a list. If we
 // ever relax the usage of ellipsis, this function will likely change. Using
 // this function will ensure keeping correct behavior or causing a compiler
diff --git a/pkg/list/math.go b/pkg/list/math.go
new file mode 100644
index 0000000..4ce4ba3
--- /dev/null
+++ b/pkg/list/math.go
@@ -0,0 +1,99 @@
+// Copyright 2018 The CUE Authors
+//
+// Licensed under the Apache License, Version 2.0 (the "License");
+// you may not use this file except in compliance with the License.
+// You may obtain a copy of the License at
+//
+//     http://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS IS" BASIS,
+// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+// See the License for the specific language governing permissions and
+// limitations under the License.
+
+package list
+
+import (
+	"fmt"
+
+	"cuelang.org/go/internal"
+	"github.com/cockroachdb/apd/v2"
+)
+
+// Avg returns the average value of a non empty list xs.
+func Avg(xs []*internal.Decimal) (*internal.Decimal, error) {
+	if 0 == len(xs) {
+		return nil, fmt.Errorf("empty list")
+	}
+
+	s := apd.New(0, 0)
+	for _, x := range xs {
+		_, err := internal.BaseContext.Add(s, x, s)
+		if err != nil {
+			return nil, err
+		}
+	}
+
+	var d apd.Decimal
+	l := apd.New(int64(len(xs)), 0)
+	_, err := internal.BaseContext.Quo(&d, s, l)
+	if err != nil {
+		return nil, err
+	}
+	return &d, nil
+}
+
+// Max returns the maximum value of a non empty list xs.
+func Max(xs []*internal.Decimal) (*internal.Decimal, error) {
+	if 0 == len(xs) {
+		return nil, fmt.Errorf("empty list")
+	}
+
+	max := xs[0]
+	for _, x := range xs[1:] {
+		if -1 == max.Cmp(x) {
+			max = x
+		}
+	}
+	return max, nil
+}
+
+// Min returns the minimum value of a non empty list xs.
+func Min(xs []*internal.Decimal) (*internal.Decimal, error) {
+	if 0 == len(xs) {
+		return nil, fmt.Errorf("empty list")
+	}
+
+	min := xs[0]
+	for _, x := range xs[1:] {
+		if +1 == min.Cmp(x) {
+			min = x
+		}
+	}
+	return min, nil
+}
+
+// Product returns the product of a non empty list xs.
+func Product(xs []*internal.Decimal) (*internal.Decimal, error) {
+	d := apd.New(1, 0)
+	for _, x := range xs {
+		_, err := internal.BaseContext.Mul(d, x, d)
+		if err != nil {
+			return nil, err
+		}
+	}
+	return d, nil
+}
+
+// Sum returns the sum of a list non empty xs.
+func Sum(xs []*internal.Decimal) (*internal.Decimal, error) {
+	d := apd.New(0, 0)
+	for _, x := range xs {
+		_, err := internal.BaseContext.Add(d, x, d)
+		if err != nil {
+			return nil, err
+		}
+	}
+	return d, nil
+}