diff --git a/Demo/Podfile.lock b/Demo/Podfile.lock
index 5d3092f..9e95643 100644
--- a/Demo/Podfile.lock
+++ b/Demo/Podfile.lock
@@ -1,10 +1,10 @@
 PODS:
-  - Nimble (6.1.0)
+  - Nimble (7.0.0)
   - Quick (1.0.0)
   - RxBlocking (3.0.1):
     - RxSwift (~> 3.0)
   - RxNimble (2.0.0):
-    - Nimble (~> 6.0)
+    - Nimble (~> 7.0)
     - RxBlocking (~> 3.0)
     - RxSwift (~> 3.0)
   - RxSwift (3.0.1)
@@ -19,10 +19,10 @@ EXTERNAL SOURCES:
     :path: ../
 
 SPEC CHECKSUMS:
-  Nimble: c53e6903fee94041b90ded74f135820437d8bf59
+  Nimble: 874982b605d4d752fcac6be695d13c502de84b1b
   Quick: 8024e4a47e6cc03a9d5245ef0948264fc6d27cff
   RxBlocking: 5de082d09d1ab45b49173f309f1a97d6b50f34c4
-  RxNimble: 50a9da5852b298b2ec632cb00b79fa20be9f31b8
+  RxNimble: 0a187f22441eca11779f17ffd6565f03a3f5b1fb
   RxSwift: af5680055c4ad04480189c52d28385b1029493a6
 
 PODFILE CHECKSUM: 7405369509db0cbd242146add66181ab5ab0efb0
diff --git a/RxNimble.podspec b/RxNimble.podspec
index cdb8e81..545117b 100644
--- a/RxNimble.podspec
+++ b/RxNimble.podspec
@@ -1,6 +1,6 @@
 Pod::Spec.new do |s|
   s.name         = "RxNimble"
-  s.version      = "2.0.0"
+  s.version      = "3.0.0"
   s.summary      = "Nimble extensions that making unit testing with RxSwift easier 🎉"
   s.description  = <<-DESC
     This library includes functions that make testing RxSwift projects easier with Nimble.
@@ -14,7 +14,7 @@ Pod::Spec.new do |s|
   s.tvos.deployment_target = "9.0"
   s.source       = { :git => "https://github.com/ashfurrow/RxNimble.git", :tag => s.version }
   s.source_files  = "Source/**/*.swift"
-  s.dependency "Nimble", "~> 6.0"
+  s.dependency "Nimble", "~> 7.0"
   s.dependency "RxSwift", "~> 3.0"
   s.dependency "RxBlocking", "~> 3.0"
   
diff --git a/Source/RxNimble.swift b/Source/RxNimble.swift
index cc23b00..4b4b413 100644
--- a/Source/RxNimble.swift
+++ b/Source/RxNimble.swift
@@ -3,55 +3,58 @@ import RxBlocking
 import Nimble
 
 // This is handy so we can write expect(o) == 1 instead of expect(o.value) == 1 or whatever.
-public func equalFirst<T: Equatable, O: ObservableType>(_ expectedValue: T?) -> MatcherFunc<O> where O.E == T {
-    return MatcherFunc { actualExpression, failureMessage in
-
-        failureMessage.postfixMessage = "equal <\(String(describing: expectedValue))>"
+public func equalFirst<T: Equatable, O: ObservableType>(_ expectedValue: T?) -> Predicate<O> where O.E == T {
+    return Predicate.define { actualExpression in
         let actualValue = try actualExpression.evaluate()?.toBlocking().first()
 
-        let matches = actualValue == expectedValue
-        return matches
+        let matches = (actualValue == expectedValue)
+        return PredicateResult(bool: matches,
+                               message: .expectedTo("equal <\(String(describing: expectedValue))>"))
     }
 }
 
-public func equalFirst<T: Equatable>(_ expectedValue: T?) -> MatcherFunc<Variable<T>> {
-    return MatcherFunc { actualExpression, failureMessage in
-
-        failureMessage.postfixMessage = "equal <\(String(describing: expectedValue))>"
+public func equalFirst<T: Equatable>(_ expectedValue: T?) -> Predicate<Variable<T>> {
+    return Predicate.define { actualExpression in
         let actualValue = try actualExpression.evaluate()?.value
 
-        let matches = actualValue == expectedValue && expectedValue != nil
-        return matches
+        let matches = (actualValue == expectedValue) && (expectedValue != nil)
+        return PredicateResult(bool: matches,
+                               message: .expectedTo("equal <\(String(describing: expectedValue))>"))
     }
 }
 
-public func equalFirst<T: Equatable, O: ObservableType>(_ expectedValue: T?) -> MatcherFunc<O> where O.E == T? {
-    return MatcherFunc { actualExpression, failureMessage in
-
-        failureMessage.postfixMessage = "equal <\(String(describing: expectedValue))>"
+public func equalFirst<T: Equatable, O: ObservableType>(_ expectedValue: T?) -> Predicate<O> where O.E == T? {
+    return Predicate.define { actualExpression in
         let actualValue = try actualExpression.evaluate()?.toBlocking().first()
 
+        let matches: Bool
         switch actualValue {
         case .none:
-            return expectedValue == nil
+            matches = (expectedValue == nil)
         case .some(let wrapped):
-            return wrapped == expectedValue
+            matches = (wrapped == expectedValue)
         }
+
+        return PredicateResult(bool: matches,
+                               message: .expectedTo("equal <\(String(describing: expectedValue))>"))
     }
 }
 
-public func equalFirst<T: Equatable>(_ expectedValue: T?) -> MatcherFunc<Variable<T?>> {
-    return MatcherFunc { actualExpression, failureMessage in
+public func equalFirst<T: Equatable>(_ expectedValue: T?) -> Predicate<Variable<T?>> {
+    return Predicate.define { actualExpression in
 
-        failureMessage.postfixMessage = "equal <\(String(describing: expectedValue))>"
         let actualValue = try actualExpression.evaluate()?.value
 
+        let matches: Bool
         switch actualValue {
         case .none:
-            return expectedValue == nil
+            matches = (expectedValue == nil)
         case .some(let wrapped):
-            return wrapped == expectedValue
+            matches = (wrapped == expectedValue)
         }
+
+        return PredicateResult(bool: matches,
+                               message: .expectedTo("equal <\(String(describing: expectedValue))>"))
     }
 }