In order to implement a collection, we must provide a way to access each element in the collection, which can be accomplished using the int index value shown in the following code. We will implement a first in, first out (FIFO) order queue. We will provide a way to store the elements using a slice data structure. Lastly, we will implement a Next() method to provide a way to traverse the elements in the collection.

In the following code, we define an interface for the Iterator object. It has one method, Next(), which will return the next element in the collection and a Boolean flag to indicate whether it's OK to continue iterating:

type CarIterator interface {
     Next() (value string, ok bool)
}
const INVALID_INT_VAL = -1
const INVALID_STRING_VAL = ""

Next, we define a collection object that has two properties: an int index used to access the current element and a slice of strings, that is, the actual data in the collection:

type Collection struct {
       index...

Executing a composition or chain of functions is very much like executing a series of Bash commands, where the output from one command is piped into the next command. For example, we might cat an input a file that contains a list of timestamps and IP addresses in an awk command. The awk command removes all but the seventh column. Next, we sort the list in descending order, and finally, we group that data by unique IP addresses.

Consider the following Bash command:

$ cat ips.log | awk '{print $7}' | sort | uniq -c

Let's give this command the following input:

Sun Feb 12 20:27:32 EST 2017 74.125.196.101
Sun Feb 12 20:27:33 EST 2017 98.139.183.24
Sun Feb 12 20:27:34 EST 2017 151.101.0.73
Sun Feb 12 20:27:35 EST 2017 98.139.183.24
Sun Feb 12 20:27:36 EST 2017 151.101.0.73
>Sun Feb 12 20:27:37 EST 2017 74.125.196.101
Sun Feb 12 20:27:38 EST 2017 98.139.183.24
Sun Feb 12 20:27:39 EST 2017 151.101.0.73
Sun Feb 12 20:27:40 EST 2017 98.139.183.24
Sun Feb 12 20:27:41 EST 2017 151...

Go has three predeclared/raw data types: bool, string, numeric (float, int64, and so on). Other data types in Go require type declarations, that is, they require we use the type keyword. Functions fall in the later category of data types along with array, struct, pointer, interface, slice, map, and channel types. In Go, functions are first-class data types, which means that can be passed around as parameters and returned as values. Functions that can take functions as arguments and return functions are called high-order functions.

We can write function factories--functions that return functions--and even function factory factories. We can also write functions that modify functions or create functions for specific purposes.

We can use predicates to perform operations on input data. Predicates can be used to implement many of the functions that we apply to collections to transform input data into the result collection or value.

Let's create some predicate functions that we can use to manipulate a collection of cars.

The All() function returns true only if all the values in the collection satisfy the predicate condition:

package predicate

func All(vals []string, predicate func(string) bool) bool {
for _, val := range vals {
if !predicate(val) {
return false
              }
       }
return true
}

The Any() function returns true as long as any one of the values in the collection satisfies the predicate condition:

funcAny(vs []string, predicate func...

The next code example demonstrates the use of a few standard intermediate functions: map and filter.

Executable commands must always use package main. We can separate each import statement on a separate line for readability.

External packages can be referenced using their remote GitHub repository path. We can preface long package names with a shorter alias. The go_utils package can now be referenced with the u letter. Note that if we aliased a package name with _, its exported functions can be referenced directly in our Go code without indicating which package it came from:

package main
import (
   "fmt"
   "log"
   "strings"
   "errors"
   u "github.com/go-goodies/go_utils"
)

Let's consider another common collection operation: contains.

In Go, lists of things are often stored in a slice. Wouldn't it be nice if Go provided a contains method to tell us whether the item we are looking for is contained in the slice? Since there is no generic contains method for working with lists of items in Go, let's implement one to iterate over a collection of car objects.

package main
type Car struct {
     Make string
     Model string
}
type Cars []*Car

func (cars Cars) Contains(modelName string) bool {
     for _, a := range cars {
            if a.Model == modelName {
                   return...

If Go had generics, we could have written a function signature like the following to replace strings with runes, and we would not have to rewrite the inner logic:

func Map(f func(v <string>) <bool>, vs [] <string>) []<bool> 

However, Go does not have generics, so we can use empty interfaces and reflection to achieve the same result.

package main
import "fmt"
type Object interface{}
type Collection []Object
func NewCollection(size int) Collection {
     return make(Collection, size)
}

type Callback func(current, currentKey, src Object) Object

func Map(c Collection, cb Callback) Collection {
...