     }
 }
 
-public func match<T: Equatable>(_ expected: T) -> Predicate<T> {
+public func match<T>(_ expected: T) -> Predicate<T> where T: Equatable {
     return Predicate { events in
         
         guard let source = try events.evaluate() else {
             return PredicateResult.evaluationFailed
         }
         guard source == expected else {
-            return PredicateResult(status: .doesNotMatch, message: .expectedCustomValueTo("get <\(expected)> events", "<\(source)> events"))
+            return PredicateResult(status: .doesNotMatch,
+                                   message: .expectedCustomValueTo("get <\(expected)> events", "<\(source)> events"))
         }
         
         

        for (lhs, rhs) in zip(errorEvents, expectedErrors) {
            guard lhs.time == rhs.time,
                lhs.value.error.asString() == rhs.value.error.asString() else {
                return PredicateResult(bool: false, message: .fail("did not error"))
            }
            continue
        }

            return PredicateResult.evaluationFailed
        }
        guard source.count == expected.count else {
            return PredicateResult(bool: false,
                                   message: .expectedCustomValueTo("get <\(expected.count)> events", "<\(source.count)> events"))
        }
        
        for (lhs, rhs) in zip(source, expected) {
            guard lhs.time == rhs.time,
                lhs.value == rhs.value else {
                    return PredicateResult(bool: rhs == lhs,
                                           message: .expectedCustomValueTo("match <\(rhs)>", "<\(lhs)>"))
            }
            continue
        }
