collections

Documentation

Overview

Package collections provides template functions for manipulating collections such as arrays, maps, and slices.

Index

• type Namespace
  • func New(deps *deps.Deps) *Namespace
  • func (ns *Namespace) After(index interface{}, seq interface{}) (interface{}, error)
  • func (ns *Namespace) Append(args ...interface{}) (interface{}, error)
  • func (ns *Namespace) Complement(seqs ...interface{}) (interface{}, error)
  • func (ns *Namespace) Dictionary(values ...interface{}) (map[string]interface{}, error)
  • func (ns *Namespace) EchoParam(a, key interface{}) interface{}
  • func (ns *Namespace) First(limit interface{}, seq interface{}) (interface{}, error)
  • func (ns *Namespace) In(l interface{}, v interface{}) (bool, error)
  • func (ns *Namespace) Intersect(l1, l2 interface{}) (interface{}, error)
  • func (ns *Namespace) IsSet(a interface{}, key interface{}) (bool, error)
  • func (ns *Namespace) Last(limit interface{}, seq interface{}) (interface{}, error)
  • func (ns *Namespace) Querify(params ...interface{}) (string, error)
  • func (ns *Namespace) Seq(args ...interface{}) ([]int, error)
  • func (ns *Namespace) Shuffle(seq interface{}) (interface{}, error)
  • func (ns *Namespace) SymDiff(s2, s1 interface{}) (interface{}, error)
  • func (ns *Namespace) Union(l1, l2 interface{}) (interface{}, error)
  • func (ns *Namespace) Uniq(seq interface{}) (interface{}, error)
  • func (ns *Namespace) Where(seq, key interface{}, args ...interface{}) (interface{}, error)

Types

type Namespace

type Namespace struct {
	// contains filtered or unexported fields
}

Namespace provides template functions for the "collections" namespace.

func New

func New(deps *deps.Deps) *Namespace

New returns a new instance of the collections-namespaced template functions.

func (*Namespace) After

func (ns *Namespace) After(index interface{}, seq interface{}) (interface{}, error)

After returns all the items after the first N in a rangeable list.

func (*Namespace) Append

func (ns *Namespace) Append(args ...interface{}) (interface{}, error)

Append appends the arguments up to the last one to the slice in the last argument. This construct allows template constructs like this:

{{ $pages = $pages | append $p2 $p1 }}

Note that with 2 arguments where both are slices of the same type, the first slice will be appended to the second:

{{ $pages = $pages | append .Site.RegularPages }}

func (*Namespace) Complement

func (ns *Namespace) Complement(seqs ...interface{}) (interface{}, error)

Complement gives the elements in the last element of seqs that are not in any of the others. All elements of seqs must be slices or arrays of comparable types.

The reasoning behind this rather clumsy API is so we can do this in the templates:

{{ $c := .Pages | complement $last4 }}

func (*Namespace) Dictionary

func (ns *Namespace) Dictionary(values ...interface{}) (map[string]interface{}, error)

Dictionary creates a map[string]interface{} from the given parameters by walking the parameters and treating them as key-value pairs. The number of parameters must be even.

func (*Namespace) EchoParam

func (ns *Namespace) EchoParam(a, key interface{}) interface{}

EchoParam returns a given value if it is set; otherwise, it returns an empty string.

func (*Namespace) First

func (ns *Namespace) First(limit interface{}, seq interface{}) (interface{}, error)

First returns the first N items in a rangeable list.

func (*Namespace) In

func (ns *Namespace) In(l interface{}, v interface{}) (bool, error)

In returns whether v is in the set l. l may be an array or slice.

func (*Namespace) Intersect

func (ns *Namespace) Intersect(l1, l2 interface{}) (interface{}, error)

Intersect returns the common elements in the given sets, l1 and l2. l1 and l2 must be of the same type and may be either arrays or slices.

func (*Namespace) IsSet

func (ns *Namespace) IsSet(a interface{}, key interface{}) (bool, error)

IsSet returns whether a given array, channel, slice, or map has a key defined.

func (*Namespace) Last

func (ns *Namespace) Last(limit interface{}, seq interface{}) (interface{}, error)

Last returns the last N items in a rangeable list.

func (*Namespace) Querify

func (ns *Namespace) Querify(params ...interface{}) (string, error)

Querify encodes the given parameters in URL-encoded form ("bar=baz&foo=quux") sorted by key.

func (*Namespace) Seq

func (ns *Namespace) Seq(args ...interface{}) ([]int, error)

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

Examples:

3 => 1, 2, 3
1 2 4 => 1, 3
-3 => -1, -2, -3
1 4 => 1, 2, 3, 4
1 -2 => 1, 0, -1, -2

func (*Namespace) Shuffle

func (ns *Namespace) Shuffle(seq interface{}) (interface{}, error)

Shuffle returns the given rangeable list in a randomised order.

func (*Namespace) SymDiff

func (ns *Namespace) SymDiff(s2, s1 interface{}) (interface{}, error)

SymDiff returns the symmetric difference of s1 and s2. Arguments must be either a slice or an array of comparable types.

func (*Namespace) Union

func (ns *Namespace) Union(l1, l2 interface{}) (interface{}, error)

Union returns the union of the given sets, l1 and l2. l1 and l2 must be of the same type and may be either arrays or slices. If l1 and l2 aren't of the same type then l1 will be returned. If either l1 or l2 is nil then the non-nil list will be returned.

func (*Namespace) Uniq

func (ns *Namespace) Uniq(seq interface{}) (interface{}, error)

Uniq takes in a slice or array and returns a slice with subsequent duplicate elements removed.

func (*Namespace) Where

func (ns *Namespace) Where(seq, key interface{}, args ...interface{}) (interface{}, error)

Where returns a filtered subset of a given data type.