                 closure(actualError)
             }
             let messages = assertions.map { $0.message }
-            if messages.count > 0 {
+            if !messages.isEmpty {
                 matches = false
             }
         }
-        return matches
-    }
-}
+
+        return PredicateResult(bool: matches, message: failureMessage.toExpectationMessage())
+    }
+}

            errorType: nil,
            closure: closure
        )
        var matches = false
        if let actualError = actualError as? T, error == actualError {
            matches = true

/// nil arguments indicates that the matcher should not attempt to match against
/// that parameter.
public func throwError<T: Error & Equatable>(_ error: T, closure: ((T) -> Void)? = nil) -> Predicate<Any> {
    return Predicate { actualExpression in
        var actualError: Error?
        do {
            _ = try actualExpression.evaluate()
        } catch {
            actualError = error
        }

        let failureMessage = FailureMessage()
        setFailureMessageForError(
            failureMessage,
            actualError: actualError,
