diff --git a/predicate-transformers.cabal b/predicate-transformers.cabal
--- a/predicate-transformers.cabal
+++ b/predicate-transformers.cabal
@@ -1,7 +1,7 @@
 cabal-version:       2.4
 
 name:                predicate-transformers
-version:             0.6.0.0
+version:             0.7.0.0
 synopsis:            A library for writing predicates and transformations over predicates in Haskell
 description:
   This package provides ways to write predicates such that they compose nicely and are easy to debug.
@@ -25,5 +25,6 @@
                       ,lens ^>=4.17 || ^>=4.18
                       ,adjunctions ^>=4.2 || ^>=4.3 || ^>=4.4
                       ,mtl ^>= 2.2.2
+                      ,deepseq ^>= 1.4.4.0
   hs-source-dirs:      src
   default-language:    Haskell2010
diff --git a/src/PredicateTransformers.hs b/src/PredicateTransformers.hs
--- a/src/PredicateTransformers.hs
+++ b/src/PredicateTransformers.hs
@@ -1,4 +1,5 @@
 {-# language ViewPatterns #-}
+{-# language LambdaCase #-}
 
 -- | This library is based on the notion of a predicate transformer, the below
 -- type @PT a b@, which is a function from @a@ to predicates on @b@.
@@ -13,12 +14,15 @@
 
 module PredicateTransformers where
 
+import Control.DeepSeq(NFData, force)
+import Control.Exception(SomeException, evaluate, throwIO, try)
 import Control.Lens hiding (index, zoom)
 import Control.Monad.Writer(execWriter, tell)
 import Data.Foldable(toList)
 import Data.Functor.Rep(Representable(..))
 import Data.Semigroup(All(..), Any(..))
 import Debug.Trace
+import System.IO.Unsafe
 
 -- |A convenient alias for predicates.
 type Pred a = a -> Bool
@@ -32,27 +36,22 @@
 -- |Operate on the target of a prism, or fail.
 match :: APrism s t a b -> PT a s
 match p pred = either (const False) pred . matching p
-{-# inlinable match #-}
 
 -- |Invert a predicate.
 nay :: PT a a
 nay = (not .)
-{-# inlinable nay #-}
 
 -- |Operate on the `Just` branch of a `Maybe`, or fail.
 just :: PT a (Maybe a)
 just = match _Just
-{-# inlinable just #-}
 
 -- |Operate on the `Left` branch of an `Either`, or fail.
 left :: PT e (Either e a)
 left = match _Left
-{-# inlinable left #-}
 
 -- |Operate on the `Right` branch of an `Either`, or fail.
 right :: PT a (Either e a)
 right = match _Right
-{-# inlinable right #-}
 
 -- |Operate on the last value in a foldable, or fail if it's not present.
 endingWith :: Foldable f => PT a (f a)
@@ -83,7 +82,6 @@
 list (p:ps) (x:xs) = p x && dist ps xs
 list [] [] = True
 list _ _ = False
-{-# inlinable list #-}
 
 -- |Given a functor-full of predicates, and a functor-full of values, ensure that the structures
 -- of the two functors match and apply all of the predicates to all of the values.
@@ -106,40 +104,49 @@
 -- |Test all predicates against one value.
 allTrue :: [Pred a] -> Pred a
 allTrue ps a = all ($ a) ps
-{-# inlinable allTrue #-}
 
 -- |Check that a predicate is true for all values behind a generalized getter
 -- and that there's at least one value for which it's true.
 allOf1 :: Getting (All, Any) s a -> PT a s
 allOf1 g p (foldMapOf g (\x -> (All $ p x, Any $ p x)) -> (All a, Any y)) = a && y
-{-# inlinable allOf1 #-}
 
 -- |Sugar for tupling.
 (==>) :: a -> b -> (a, b)
 (==>) = (,)
-{-# inline conlike (==>) #-}
 
 pair :: Pred a -> Pred b -> Pred (a,b)
 pair f s (a,b) = f a && s b
-{-# inline conlike pair #-}
 
 -- |Flipped function composition; @f !@ for a function @f@ is a predicate transformer.
 (!) :: (b -> a) -> (a -> c) -> b -> c
 (!) = flip (.)
-{-# inline conlike (!) #-}
 
 -- |Prints the input of a predicate, for debugging.
 traced :: Show a => (a -> c) -> a -> c
 traced p a = traceShow a (p a)
-{-# inline traced #-}
 
 -- |Prints the input of a predicate, if the predicate fails.
-traceFailure :: Show a => PT a a
-traceFailure p a = if p a then True else traceShow a False
-{-# inline traceFailure #-}
+traceFail :: (a -> String) -> PT a a
+traceFail s p a = unsafePerformIO $ do
+  try (evaluate (p a)) >>= \case
+    Left ex -> do
+      traceIO (s a)
+      throwIO (ex :: SomeException)
+    Right True ->
+      pure True
+    Right False -> do
+      traceIO ("\n" <> s a)
+      pure False
 
+traceFailShow :: Show a => PT a a
+traceFailShow = traceFail show
+
 -- |Predicate which always succeeds.
 something :: Pred a
 something = const True
-{-# inline something #-}
+
+-- |Predicate which triggers full evaluation of its input.
+-- Useful for testing that an exception isn't thrown.
+forced :: NFData a => a -> Bool
+forced a = force a `seq` True