Merge branch 'spakin-master'

Author: deckarep

README.md

@@ -1,4 +1,5 @@
 [![Build Status](https://travis-ci.org/deckarep/golang-set.svg?branch=master)](https://travis-ci.org/deckarep/golang-set)
+[![Go Report Card](https://goreportcard.com/badge/github.com/deckarep/golang-set)](https://goreportcard.com/report/github.com/deckarep/golang-set)
 [![GoDoc](https://godoc.org/github.com/deckarep/golang-set?status.svg)](http://godoc.org/github.com/deckarep/golang-set)
 
 ## golang-set

bench_test.go

@@ -587,7 +587,7 @@ func benchString(b *testing.B, n int, s Set) {
 
 	b.ResetTimer()
 	for i := 0; i < b.N; i++ {
-		s.String()
+		_ = s.String()
 	}
 }
 

iterator_example_test.go

@@ -16,7 +16,7 @@ func ExampleIterator() {
 		&YourType{Name: "Nick"},
 	})
 
-	var found *YourType = nil
+	var found *YourType
 	it := set.Iterator()
 
 	for elem := range it.C {

set.go

@@ -28,11 +28,16 @@ SOFTWARE.
 // typical set operations: membership testing, intersection, union,
 // difference, symmetric difference and cloning.
 //
-// Package mapset provides two implementations. The default
-// implementation is safe for concurrent access. There is a non-threadsafe
-// implementation which is slightly more performant.
+// Package mapset provides two implementations of the Set
+// interface. The default implementation is safe for concurrent
+// access, but a non-thread-safe implementation is also provided for
+// programs that can benefit from the slight speed improvement and
+// that can enforce mutual exclusion through other means.
 package mapset
 
+// Set is the primary interface provided by the mapset package.  It
+// represents an unordered set of data and a large number of
+// operations that can be applied to that set.
 type Set interface {
 	// Adds an element to the set. Returns whether
 	// the item was added.
@@ -42,7 +47,7 @@ type Set interface {
 	Cardinality() int
 
 	// Removes all elements from the set, leaving
-	// the emtpy set.
+	// the empty set.
 	Clear()
 
 	// Returns a clone of the set using the same
@@ -163,7 +168,8 @@ type Set interface {
 	ToSlice() []interface{}
 }
 
-// Creates and returns a reference to an empty set.
+// NewSet creates and returns a reference to an empty set.  Operations
+// on the resulting set are thread-safe.
 func NewSet(s ...interface{}) Set {
 	set := newThreadSafeSet()
 	for _, item := range s {
@@ -172,22 +178,29 @@ func NewSet(s ...interface{}) Set {
 	return &set
 }
 
-// Creates and returns a new set with the given elements
+// NewSetWith creates and returns a new set with the given elements.
+// Operations on the resulting set are thread-safe.
 func NewSetWith(elts ...interface{}) Set {
 	return NewSetFromSlice(elts)
 }
 
-// Creates and returns a reference to a set from an existing slice
+// NewSetFromSlice creates and returns a reference to a set from an
+// existing slice.  Operations on the resulting set are thread-safe.
 func NewSetFromSlice(s []interface{}) Set {
 	a := NewSet(s...)
 	return a
 }
 
+// NewThreadUnsafeSet creates and returns a reference to an empty set.
+// Operations on the resulting set are not thread-safe.
 func NewThreadUnsafeSet() Set {
 	set := newThreadUnsafeSet()
 	return &set
 }
 
+// NewThreadUnsafeSetFromSlice creates and returns a reference to a
+// set from an existing slice.  Operations on the resulting set are
+// not thread-safe.
 func NewThreadUnsafeSetFromSlice(s []interface{}) Set {
 	a := NewThreadUnsafeSet()
 	for _, item := range s {

set_test.go

@@ -1031,7 +1031,7 @@ func Test_CartesianProduct(t *testing.T) {
 	d = empty.CartesianProduct(b)
 
 	if c.Cardinality() != 0 || d.Cardinality() != 0 {
-		t.Error("Cartesian product of any set and the emtpy set Ax0 || 0xA must be the empty set")
+		t.Error("Cartesian product of any set and the empty set Ax0 || 0xA must be the empty set")
 	}
 }
 

threadsafe_test.go

@@ -364,7 +364,7 @@ func Test_StringConcurrent(t *testing.T) {
 	wg.Add(len(ints))
 	for range ints {
 		go func() {
-			s.String()
+			_ = s.String()
 			wg.Done()
 		}()
 	}

threadunsafe.go

@@ -35,6 +35,7 @@ import (
 
 type threadUnsafeSet map[interface{}]struct{}
 
+// An OrderedPair represents a 2-tuple of values.
 type OrderedPair struct {
 	First  interface{}
 	Second interface{}
@@ -44,6 +45,7 @@ func newThreadUnsafeSet() threadUnsafeSet {
 	return make(threadUnsafeSet)
 }
 
+// Equal says whether two 2-tuples contain the same values in the same order.
 func (pair *OrderedPair) Equal(other OrderedPair) bool {
 	if pair.First == other.First &&
 		pair.Second == other.Second {
@@ -218,6 +220,7 @@ func (set *threadUnsafeSet) String() string {
 	return fmt.Sprintf("Set{%s}", strings.Join(items, ", "))
 }
 
+// String outputs a 2-tuple in the form "(A, B)".
 func (pair OrderedPair) String() string {
 	return fmt.Sprintf("(%v, %v)", pair.First, pair.Second)
 }