func (matcher *MatchYAMLMatcher) equal(expected interface{}, actual interface{}) (bool, string, error) {
	actualString, err := matcher.prettyPrint(actual)
	if err != nil {
		return false, "", err
	}

	expectedString, err := matcher.prettyPrint(expected)
	if err != nil {
		return false, "", err
	}

	var actualValue interface{}
	var expectedValue interface{}

	// this is guarded by prettyPrint
	yaml.Unmarshal([]byte(actualString), &actualValue)
	yaml.Unmarshal([]byte(expectedString), &expectedValue)

	equal, difference := deepequal.Compare(expectedValue, actualValue)

	return equal, prettyprint.ExpectationFailure(difference), nil
}
		"uint64":     {uint64(1), uint64(2)},
		"uintptr":    {uintptr(1), uintptr(2)},
		"float32":    {float32(1.0), float32(2.0)},
		"float64":    {float64(1.0), float64(2.0)},
		"complex64":  {complex64(1i), complex64(2i)},
		"complex128": {complex128(1i), complex128(2i)},
	}

	It("returns true when the objects match", func() {
		someObject := map[string]interface{}{
			"a": 1,
			"b": []int{1, 2, 3, 4},
			"c": 3,
		}

		equal, difference := deepequal.Compare(someObject, someObject)
		Expect(equal).To(BeTrue())
		Expect(difference).To(Equal(diff.NoDifference{}))
	})

	It("returns a diff when the types are mismatched", func() {
		for expectedName, expectedValues := range types {
			for actualName, actualValues := range types {
				if expectedName != actualName {
					equal, difference := deepequal.Compare(expectedValues[0], actualValues[0])

					Expect(equal).To(BeFalse())
					Expect(difference).To(Equal(diff.PrimitiveTypeMismatch{
						ExpectedType: reflect.TypeOf(expectedValues[0]),
						ActualValue:  actualValues[0],
					}))