 /// nil arguments indicates that the matcher should not attempt to match against
 /// that parameter.
 public func throwError() -> Predicate<Any> {
-    return Predicate.fromDeprecatedClosure { actualExpression, failureMessage in
-
-        var actualError: Error?
-        do {
-            _ = try actualExpression.evaluate()
-        } catch let catchedError {
-            actualError = catchedError
-        }
-
-        failureMessage.postfixMessage = "throw any error"
+    return Predicate { actualExpression in
+        var actualError: Error?
+        do {
+            _ = try actualExpression.evaluate()
+        } catch {
+            actualError = error
+        }
+
         if let actualError = actualError {
-            failureMessage.actualValue = "<\(actualError)>"
+            return PredicateResult(bool: true, message: .expectedCustomValueTo("throw any error", "<\(actualError)>"))
         } else {
-            failureMessage.actualValue = "no error"
-        }
-        return actualError != nil
+            return PredicateResult(bool: false, message: .expectedCustomValueTo("throw any error", "no error"))
+        }
     }
 }
 

                        }
                    }
                    let messages = assertions.map { $0.message }
                    if messages.count > 0 {
                        matches = false
                    }
                }
            }
        }

        return matches
    }
}


///
/// The closure only gets called when an error was thrown.
public func throwError(closure: @escaping ((Error) -> Void)) -> Predicate<Any> {
    return Predicate { actualExpression in
        var actualError: Error?
        do {
            _ = try actualExpression.evaluate()
        } catch {
            actualError = error
        }

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

        var matches = false
