Add without and has functions.

README.md

@@ -215,6 +215,10 @@ These are used to manipulate lists: `{{ list 1 2 3 | reverse | first }}`
 - initial: Get all but the last item in a list: 'list 1 2 3 | initial' returns '[1 2]'
 - append: Add an item to the end of a list: 'append $list 4' adds '4' to the end of '$list'
 - prepend: Add an item to the beginning of a list: 'prepend $list 4' puts 4 at the beginning of the list.
+- reverse: Reverse the items in a list.
+- uniq: Remove duplicates from a list.
+- without: Return a list with the given values removed: 'without (list 1 2 3) 1' would return '[2 3]'
+- has: Return 'tru' if the item is found in the list: 'has "foo" $list' will return 'true' if the list contains "foo"
 
 ### Dict Functions:
 

doc.go

@@ -169,6 +169,8 @@ These are used to manipulate lists: '{{ list 1 2 3 | reverse | first }}'
 	- prepend: Add an item to the beginning of a list: 'prepend $list 4' puts 4 at the beginning of the list.
 	- reverse: Reverse the items in a list.
 	- uniq: Remove duplicates from a list.
+	- without: Return a list with the given values removed: 'without (list 1 2 3) 1' would return '[2 3]'
+	- has: Return 'true' if the item is found in the list: 'has "foo" $list' will return 'true' if the list contains "foo"
 
 Dict Functions:
 

functions.go

@@ -234,6 +234,8 @@ var genericMap = map[string]interface{}{
 	"initial": initial,
 	"reverse": reverse,
 	"uniq":    uniq,
+	"without": without,
+	"has":     func(needle interface{}, haystack []interface{}) bool { return inList(haystack, needle) },
 
 	// Crypto:
 	"genPrivateKey":  generatePrivateKey,

list.go

@@ -81,20 +81,29 @@ func compact(list []interface{}) []interface{} {
 
 func uniq(list []interface{}) []interface{} {
 	dest := []interface{}{}
+	for _, item := range list {
+		if !inList(dest, item) {
+			dest = append(dest, item)
+		}
+	}
+	return dest
+}
 
-	skip := func(haystack []interface{}, needle interface{}) bool {
-		for _, h := range haystack {
-			if reflect.DeepEqual(needle, h) {
-				return true
-			}
+func inList(haystack []interface{}, needle interface{}) bool {
+	for _, h := range haystack {
+		if reflect.DeepEqual(needle, h) {
+			return true
 		}
-		return false
 	}
+	return false
+}
 
-	for _, item := range list {
-		if !skip(dest, item) {
-			dest = append(dest, item)
+func without(list []interface{}, omit ...interface{}) []interface{} {
+	res := []interface{}{}
+	for _, i := range list {
+		if !inList(omit, i) {
+			res = append(res, i)
 		}
 	}
-	return dest
+	return res
 }

list_test.go

@@ -109,3 +109,27 @@ func TestUniq(t *testing.T) {
 		assert.NoError(t, runt(tpl, expect))
 	}
 }
+
+func TestWithout(t *testing.T) {
+	tests := map[string]string{
+		`{{ without (list 1 2 3 4) 1 }}`:           `[2 3 4]`,
+		`{{ without (list "a" "b" "c" "d") "a" }}`: `[b c d]`,
+		`{{ without (list 1 1 1 1 2) 1 }}`:         `[2]`,
+		`{{ without (list) 1 }}`:                   `[]`,
+		`{{ without (list 1 2 3) }}`:               `[1 2 3]`,
+		`{{ without list }}`:                       `[]`,
+	}
+	for tpl, expect := range tests {
+		assert.NoError(t, runt(tpl, expect))
+	}
+}
+
+func TestHas(t *testing.T) {
+	tests := map[string]string{
+		`{{ list 1 2 3 | has 1 }}`: `true`,
+		`{{ list 1 2 3 | has 4 }}`: `false`,
+	}
+	for tpl, expect := range tests {
+		assert.NoError(t, runt(tpl, expect))
+	}
+}