What causes "argument must be a slice" in gohugoio/hugo?

Ensure the argument is a slice: `{{ collections.Reverse (slice 1 2 3) }}` or a page collection like `.Pages`.

argument must be a slice

Error message

argument must be a slice

What it means

The `collections.Reverse` template function only accepts a slice; it reflects on the argument's kind and rejects anything that is not `reflect.Slice`. Arrays, maps, strings, and page collections that aren't slices trigger this error.

Source

Thrown at tpl/collections/collections.go:401

	if limitv > seqv.Len() {
		limitv = seqv.Len()
	}

	return seqv.Slice(seqv.Len()-limitv, seqv.Len()).Interface(), nil
}

// Reverse creates a copy of the list l and reverses it.
func (ns *Namespace) Reverse(l any) (any, error) {
	if l == nil {
		return nil, nil
	}
	v := reflect.ValueOf(l)

	switch v.Kind() {
	case reflect.Slice:
	default:
		return nil, errors.New("argument must be a slice")
	}

	sliceCopy := reflect.MakeSlice(v.Type(), v.Len(), v.Len())

	for i := v.Len() - 1; i >= 0; i-- {
		element := sliceCopy.Index(i)
		element.Set(v.Index(v.Len() - 1 - i))
	}

	return sliceCopy.Interface(), nil
}

// Sanity check for slices created by Seq and D.
const maxSeqSize = 1000000

var errSeqSizeExceedsLimit = errors.New("size of result exceeds limit")

// Seq creates a sequence of integers from args. It's named and used as GNU's seq.

View on GitHub ↗ (pinned to 8a468df065)

Solutions

Ensure the argument is a slice: `{{ collections.Reverse (slice 1 2 3) }}` or a page collection like `.Pages`.
To reverse sorted pages, prefer `.Pages.ByDate.Reverse` on page collections.
Convert other data to a slice first (e.g. via `slice` or `sort`) before reversing.

Example fix

<!-- before -->
{{ collections.Reverse .Params.settings }}  <!-- a map -->
<!-- after -->
{{ collections.Reverse .Params.items }}  <!-- a list in front matter -->

Defensive patterns

Strategy: type-guard

Validate before calling

{{ if reflect.IsSlice $v }}
  {{ $shuffled := shuffle $v }}
{{ else }}
  {{ warnf "expected slice, got %T" $v }}
{{ end }}

Type guard

{{ $isSlice := reflect.IsSlice $v }}

Prevention

Guard with `reflect.IsSlice` before calling shuffle/sort-like functions.
Remember `.Params.foo` from front matter may be a scalar or map even if you expect a list; normalize with `slice` when unsure.
Use `default (slice)` to fall back to an empty slice for missing params only when explicitly desired.

When it happens

Trigger: Calling `{{ collections.Reverse $x }}` where `$x` is a map, string, integer, or other non-slice value. A nil argument returns nil without error; only non-nil non-slices fail.

Common situations: Trying to reverse a string character-by-character; passing a dict/map from front matter; passing a single page instead of a page collection.

Related errors

AI-assisted analysis of gohugoio/hugo@8a468df065 (2026-07-31). Data as JSON: /data/errors/319fd02c7b0bf259.json. Report an issue: GitHub ↗.