Um Set é uma estrutura de dados linear que possui uma coleção de valores que não se repetem. Um Set pode
armazenar valores únicos sem qualquer ordem particular.

No mundo real, os Sets podem ser usados para coletar todas as tags para postagens de blog ou participantes em uma conversa de chat.

Não tem muito segredo, como queremos uma estrutura que não permita dados duplicados vamos basear a estrutura do set em uma outra estrutura do golang chamada map que é baseada em hash, um conjunto de chave valor.

Então definimos o segundo tipo de dados como boleano, assim sendo possível fazer comparações de true e false entre os valores.

type Set struct {
    estrutura map[int]bool
}

func (set *Set) Criar() {
    set.estrutura = make(map[int]bool)
}

The insert method

O método AddValor adiciona o valor a um Set.

Aproveitados a o método PossuiValor para verificar se existe o valor dentro do set.
Se o resultado do método não for verdadeiro então set.estrutura recebe valor e definimos o segundo parâmetro do map como true.

func (set *Set) AddValor(valor int) {

    if !set.PossuiValor(valor) {
        set.estrutura[valor] = true
    }
}

The delete method

Aqui é reaproveitado o delete do próprio map da sdtlib do Golang então a implementação é mínima.

func (set *Set) DeletaValor(valor int) {

    delete(set.estrutura, valor)
}

The lookup method

O método PossuiValor do Set verifica se o valor existe ou não em set.estrutura e retorna um boolean com a resposta.

Definimos localizado como um boolean, o zaro value dele é false

Esse underline cheguei a comentar antes, mas ele anula o valor de uma variável, no caso aqui ele é anula o valor inteiro de set.estrutura para que a comparação possa ser feita apenas com o os boleanos.

func (set *Set) PossuiValor(valor int) bool {

    var localizado bool

    _, localizado = set.estrutura[valor]

    return localizado
}

The InterSect method

No código a seguir, o método CruzarCom retorna um setCruzado que consiste na interseção de set e setDiferente.

Instanciamos um set que será o retorno da interseção, em seguida fazemos um loop ao longo da estrutura já existente verificando apenas os valores, e anulando o segundo parâmetro do map que seria o boleano.

Reaproveitamos o método PossuiValor no parâmetro para fazer a comparação e com o valor da condição reutilizamos AddValor para inserir o valor no set que instanciamos.

func (set *Set) CruzarCom(setDiferente *Set) *Set {

    var setCruzado = &Set{}
    setCruzado.Criar()
    var valor int

    for valor, _ = range set.estrutura {

        if setDiferente.PossuiValor(valor) {

            setCruzado.AddValor(valor)
        }
    }

    return setCruzado
}

The Union method

O método UnirCom retorna um setReunido que consiste em uma união de set e setDiferente.

Instanciamos setReunido que será o retorno. E reutilizamos AddValor percorrendo o set original e o set no parâmetro inserindo os valores no set instanciado.

func (set *Set) UnirCom(setDiferente *Set) *Set {

    var setReunido = &Set{}
    setReunido.Criar()
    var valor int

    for valor, _ = range set.estrutura {
        setReunido.AddValor(valor)
    }

    for valor, _ = range setDiferente.estrutura {
        setReunido.AddValor(valor)
    }

    return setReunido
}

The main method

Utilizando a estrutura set na main func.

func main() {

    var set *Set
    set = &Set{}

    set.Criar()

    set.AddValor(1)
    set.AddValor(2)

    fmt.Println("set inicial", set)
    fmt.Println(set.PossuiValor(1))

    var setDiferente *Set
    setDiferente = &Set{}

    setDiferente.Criar()
    setDiferente.AddValor(2)
    setDiferente.AddValor(4)
    setDiferente.AddValor(5)

    fmt.Println("outro set", set)

    fmt.Println("cruzamento de sets", set.CruzarCom(setDiferente))

    fmt.Println("união de sets", set.UnirCom(setDiferente))

}

Output:

set inicial &{map[1:true 2:true]}
true
outro set &{map[1:true 2:true]}
cruzamento de sets &{map[2:true]}
união de sets &{map[1:true 2:true 4:true 5:true]}