# Slices Package: Contains, Delete, and Equal

- Published: September 8, 2023
- Author: William Kennedy
- URL: https://www.ardanlabs.com/blog/2023/09/golang-slices-contains-delete-equal.html

### Series

Here are all the posts in this series about the slices package.

- [Binary Search](https://www.ardanlabs.com/blog/2023/08/golang-slices-binary-search.html)
- [Clip, Clone, and Compact](https://www.ardanlabs.com/blog/2023/08/golang-slices-clip-clone-compact.html)
- [Compare](https://www.ardanlabs.com/blog/2023/08/golang-slices-compare.html)
- [Contains, Delete, and Equal](https://www.ardanlabs.com/blog/2023/09/golang-slices-contains-delete-equal.html)

### Introduction

In the last post of this series, I discussed the [Compare](https://www.ardanlabs.com/blog/2023/08/golang-slices-compare.html) API from the slices package. In this post, I will share how the `Contains`, `Delete`, and `Equal` APIs work.

### Contains

The `Contains` API reports whether a specified value exists in a specified collection.

**Listing 1**  
```
01 package main
02
03 import (
04     "fmt"
05     "slices"
06 )
07
08 func main() {
09     list := []int{1, 2, 3, 4, 5, 6}
10     fmt.Println("Slice", list)
```

Listing 1 starts with creating a collection of integers and then displaying those integers. It just so happens the list is sorted, but this is not a requirement.

**Listing 2**  
```
12     ​​hasZero := slices.Contains(list, 0)
13     fmt.Println("Does the list contain 0:", hasZero)
14
15     hasFour := slices.Contains(list, 4)
16     fmt.Println("Does the list contain 4:", hasFour)
17 }
```

Listing 2 performs two calls to the `Contains` API. The first call looks for a value that does not exist and the second call looks for a value that does exist.

**Listing 3**  
```
Slice [1 2 3 4 5 6]
Does the list contain 0: false
Does the list contain 4: true
```

Listing 3 shows the output of running this program. You can see `0` is not found, but the value of `4` is found.

There is a version of the `Contains` API that allows you to provide a custom compare function.

**Listing 4**  
```
25 func compare(a int) func(int) bool {
26     return func(b int) bool {
27         return a == b
28     }
29 }
```

Listing 4 shows a function named `compare` that returns a compare function that can be used with the `ContainsFunc` API. It uses closures to accept the value to compare with a value in the collection. The `ContainsFunc` API will call the returned function for every element in the collection until it is found.

**Listing 5**  
```
18     hasZero = slices.ContainsFunc(list, compare(0))
19     fmt.Println("Does the list contain 0:", hasZero)
20
21     hasFour = slices.ContainsFunc(list, compare(4))
22     fmt.Println("Does the list contain 4:", hasFour)
23 }
```

Listing 5 performs two calls to the `ContainsFunc` API. The two calls and the results are the same as in the example calling the `Contains` API.

### Delete

The `Delete` API removes a specified contiguous set of elements from a specified collection. The underlying array is modified eliminating the creation a new underlying array.

**Listing 6**  
```
01 package main
02
03 import (
04     "fmt"
05     "slices"
06 )
07
08 func main() {
09     list := []int{1, 2, 3, 4, 5, 6}
10     fmt.Printf("List: Addr(%x), %v\n", &list[0], list)
11 }
```

Listing 6 starts the program by constructing and printing a collection of integers.

**Listing 7**  
```
List: Addr(c00007a000), [1 2 3 4 5 6]
```

Listing 7 shows the output of the program. Notice the address of the first element since it’s important to see if that changes after a delete operation.

**Listing 8**  
```
12     list = slices.Delete(list, 1, 2)
13     fmt.Printf("List: Addr(%x), %v\n", &list[0], list)
14 }
```

Listing 8 calls the `Delete` API to remove the second element (the number 2) from the collection. The parameters are like a slice operation where [1, 2) or remove elements at index 1 through index 2 not including index 2.

**Listing 9**  
```
List: Addr(c00007a000), [1 3 4 5 6]
```

Listing 9 shows the output of the program. Notice the value of 2 has been removed and the address of the underlying array is the same.

**Listing 10**  
```
15     list = slices.Delete(list, 2, 4)
16     fmt.Printf("List: Addr(%x), %v\n", &list[0], list)
17 }
```

Listing 10 calls the `Delete` API to remove the third and fourth elements (the numbers 4 and 5 ) from the collection.

**Listing 11**  
```
List: Addr(c00007a000), [1 3 6]
```

Listing 11 shows the output of the program. Notice the values of 4 and 5 have been removed and the address of the underlying array is still the same.

### Equal

The `Equal` API reports whether two collections are equal by comparing the length of each collection and then testing that all the elements are equal.

**Listing 12**  
```
01 package main
02
03 import (
04     "fmt"
05     "slices"
06 )
07
08 func main() {
09     list1 := []int{1, 2, 3, 4, 5}
10     list2 := []int{1, 2, 6, 4, 5, 6}
11     list3 := []int{1, 2, 3, 4}
12     list4 := []int{1, 2, 3, 4}
13
14     fmt.Println("Slice1", list1)
15     fmt.Println("Slice2", list2)
16     fmt.Println("Slice3", list3)
17     fmt.Println("Slice4", list4)
18 }
```

Listing 12 starts the program with 4 different integer collections. The third and forth collections are identical.

**Listing 13**  
```
Slice1 [1 2 3 4 5]
Slice2 [1 2 6 4 5 6]
Slice3 [1 2 3 4]
Slice4 [1 2 3 4]
```

Listing 13 shows the output of the program. Notice slice 3 and 4 are the same.

**Listing 14**  
```
19     fmt.Println("list1 == list2", slices.Equal(list1, list2))
20     fmt.Println("list3 == list4", slices.Equal(list3, list4))
21 }
```

Listing 14 makes calls to the `Equal` API inside calls to `Println`. The result of the `Equal` API is either `true` or `false` and the result is passed as a parameter to the `Println` function. In the first call, the first and second collections are compared and in the second call, the third and fourth collections are compared.

**Listing 15**  
```
list1 == list2 false
list3 == list4 true
```

Listing 15 shows the output of the program. You can see the `Equal` API identifies the first and second collections are not equal, but the third and forth collections are equal.

There is a version of the `Equals` API that allows you to provide a custom compare function.

**Listing 16**  
```
26 func compare(a, b int) bool {
27     return a == b
28 }
```

Listing 16 shows a function named `compare` that returns a bool depending if the two specified values are equal. When it comes to integers, this check is obvious. When it comes to a more complex type, this function lets you define how the values can be considered equal.

**Listing 17**  
```
22    fmt.Println("list1 == list2", slices.EqualFunc(list1, list2, compare))
23    fmt.Println("list3 == list4", slices.EqualFunc(list3, list4, compare))
24 }
```

Listing 17 makes the same calls as in listing 14, but this time uses the `EqualFunc` API and the custom `compare` function. The output is identical.

**Listing 18**  
```
list1 == list2 false
list3 == list4 true
```

Listing 17 shows the output of the program.

### Conclusion

You can see how cool this new slices package is by providing the Contains, Delete, and Equal APIs. In the next post, we will explore the Index, Grow,, and Insert APIs.

If you want to cheat and see all the examples I have prepared for future posts, check out the Go training repo.
https://github.com/ardanlabs/gotraining/tree/master/topics/go/packages/slices