Hashable can return an error.

README.md

@@ -19,11 +19,11 @@ sending data across the network, caching values locally (de-dup), and so on.
 
   * Optionally, specify a custom hash function to optimize for speed, collision
     avoidance for your data set, etc.
-  
+
   * Optionally, hash the output of `.String()` on structs that implement fmt.Stringer,
     allowing effective hashing of time.Time
 
-  * Optionally, override the hashing process with a `hash` field or by implementing `hashstructure.Hashable`.
+  * Optionally, override the hashing process by implementing `Hashable`.
 
 ## Installation
 

hashstructure.go

@@ -235,12 +235,8 @@ func (w *walker) visit(v reflect.Value, opts *visitOpts) (uint64, error) {
 			include = impl
 		}
 
-		if f := v.FieldByName("hash"); f.IsValid() {
-			return f.Uint(), nil
-		}
-
 		if impl, ok := parent.(Hashable); ok {
-			return impl.Hash(), nil
+			return impl.Hash()
 		}
 
 		t := v.Type()

hashstructure_test.go

@@ -125,46 +125,6 @@ func TestHash_equal(t *testing.T) {
 			true,
 		},
 
-		{
-			struct {
-				Foo        string
-				unexported string
-				hash       uint64
-			}{
-				Foo:        "bar",
-				unexported: "baz",
-				hash:       10,
-			},
-			struct {
-				Foo        string
-				unexported string
-				hash       uint64
-			}{
-				Foo:        "bar",
-				unexported: "bang",
-				hash:       20,
-			},
-			false,
-		},
-
-		{
-			struct {
-				Foo  string
-				hash uint64
-			}{
-				Foo:  "bar",
-				hash: 10,
-			},
-			struct {
-				Foo  string
-				hash uint64
-			}{
-				Foo:  "baz",
-				hash: 10,
-			},
-			true,
-		},
-
 		{
 			struct {
 				testFoo
@@ -584,35 +544,58 @@ func TestHash_hashable(t *testing.T) {
 	cases := []struct {
 		One, Two interface{}
 		Match    bool
+		Err      string
 	}{
 		{
 			testHashable{Value: "foo"},
 			testHashable{Value: "foo"},
 			true,
+			"",
 		},
 
 		{
 			testHashable{Value: "foo1"},
 			testHashable{Value: "foo2"},
 			true,
+			"",
 		},
 		{
 			testHashable{Value: "foo"},
 			testHashable{Value: "bar"},
 			false,
+			"",
 		},
 		{
 			testHashable{Value: "nofoo"},
 			testHashable{Value: "bar"},
 			true,
+			"",
+		},
+		{
+			testHashable{Value: "bar", Err: fmt.Errorf("oh no")},
+			testHashable{Value: "bar"},
+			true,
+			"oh no",
 		},
 	}
 
 	for _, tc := range cases {
 		one, err := Hash(tc.One, nil)
+		if tc.Err != "" {
+			if err == nil {
+				t.Fatal("expected error")
+			}
+
+			if !strings.Contains(err.Error(), tc.Err) {
+				t.Fatalf("expected error to contain %q, got: %s", tc.Err, err)
+			}
+
+			return
+		}
 		if err != nil {
 			t.Fatalf("Failed to hash %#v: %s", tc.One, err)
 		}
+
 		two, err := Hash(tc.Two, nil)
 		if err != nil {
 			t.Fatalf("Failed to hash %#v: %s", tc.Two, err)
@@ -657,11 +640,17 @@ func (t testIncludableMap) HashIncludeMap(field string, k, v interface{}) (bool,
 
 type testHashable struct {
 	Value string
+	Err   error
 }
 
-func (t testHashable) Hash() uint64 {
+func (t testHashable) Hash() (uint64, error) {
+	if t.Err != nil {
+		return 0, t.Err
+	}
+
 	if strings.HasPrefix(t.Value, "foo") {
-		return 500
+		return 500, nil
 	}
-	return 100
+
+	return 100, nil
 }

include.go

@@ -14,7 +14,9 @@ type IncludableMap interface {
 	HashIncludeMap(field string, k, v interface{}) (bool, error)
 }
 
-// Hashable is an interface that can optionally be implemented by a struct to override the hash generation.
+// Hashable is an interface that can optionally be implemented by a struct
+// to override the hash value. This value will override the hash value for
+// the entire struct. Entries in the struct will not be hashed.
 type Hashable interface {
-	Hash() uint64
+	Hash() (uint64, error)
 }