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.2.0.0
+version:             0.3.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.
@@ -24,5 +24,6 @@
   build-depends:       base ^>=4.11 || ^>=4.12 || ^>=4.13
                       ,lens ^>=4.17 || ^>=4.18
                       ,adjunctions ^>=4.2 || ^>=4.3 || ^>=4.4
+                      ,mtl ^>= 2.2.2
   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,3 +1,5 @@
+{-# language ViewPatterns #-}
+
 -- | 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@.
 -- They act as a sort of compositional "matcher language".
@@ -6,30 +8,32 @@
 module PredicateTransformers where
 
 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(..))
 import Debug.Trace
 
 -- |A convenient alias for predicates.
 type Pred a = a -> Bool
 
+-- |Close to a CPS transform of `b -> a`, except that `c` isn't quantified over.
+-- Stands for "function transformer".
+type FT c a b = (a -> c) -> (b -> c)
+
 -- |Predicate transformers form a category where composition is ordinary function
 -- composition.
 -- Multiple are already provided by the standard library,
 -- for instance `Data.Foldable.all` and `Data.Foldable.any`.
-type PT a b = Pred a -> Pred b
-
--- |Functor from Hask^op to PT.
-function :: (b -> a) -> PT a b
-function = flip (.)
+type PT a b = FT Bool a b
 
 -- |Operate on the target of a prism, or fail.
 match :: APrism s t a b -> PT a s
 match p pred s = either (const False) pred (matching p s)
 
 -- |Operate on the target of a getter.
-getter :: Getting a s a -> PT a s
-getter g = function (view g)
+getter :: Getting a s a -> FT c a s
+getter g = (view g !)
 
 -- |Invert a predicate.
 nay :: PT a a
@@ -48,24 +52,20 @@
 right = match _Right
 
 -- |Operate on the last value in a list, or fail if it's not present.
-endingWith :: PT a [a]
-endingWith _ [] = False
-endingWith p xs = p $ last xs
+endingWith :: Foldable f => PT a (f a)
+endingWith _ (toList -> []) = False
+endingWith p (toList -> xs) = p $ last xs
 
 -- |Operate on the first value in a list, or fail if it's not present.
-startingWith :: PT a [a]
-startingWith p (x:_) = p x
-startingWith _ [] = False
+startingWith :: Foldable f => PT a (f a)
+startingWith p (toList -> (x:_)) = p x
+startingWith _ (toList -> []) = False
 
 -- |Require that a list has a single element, and operate on that element.
-only :: PT a [a]
-only p [x] = p x
+only :: Foldable f => PT a (f a)
+only p (toList -> [x]) = p x
 only _ _ = False
 
--- |Test all predicates against one value.
-allTrue :: [Pred a] -> Pred a
-allTrue ps a = all ($ a) ps
-
 -- |Given a list of predicates and a list of values, ensure that each predicate holds for each respective value.
 -- Fails if the two lists have different lengths.
 dist :: [Pred a] -> Pred [a]
@@ -89,6 +89,14 @@
     f (a -> Bool) -> f a -> f Bool
 distRep pr fa = tabulate (\r -> index pr r $ index fa r)
 
+-- |Test all predicates against one value.
+checkAll :: Monoid m => [a -> m] -> a -> m
+checkAll ps a = foldMap ($ a) ps
+
+-- |Given a plated type, take a monoidal sum over every child recursively, bottom-up.
+sumOver :: (Monoid m, Plated a) => FT m a a
+sumOver p = execWriter . transformM (\a -> a <$ tell (p a))
+
 -- |Sugar for tupling.
 (==>) :: a -> b -> (a, b)
 (==>) = (,)
@@ -96,14 +104,10 @@
 pair :: Pred a -> Pred b -> Pred (a,b)
 pair f s (a,b) = f a && s b
 
-eitherWay :: Pred a -> Pred b -> Pred (Either a b)
-eitherWay f _ (Left a) = f a
-eitherWay _ g (Right b) = g b
-
--- |Flipped function composition, meant to be used postfix.
-(!) :: (b -> a) -> (a -> c) -> b -> c
+-- |Flipped function composition; `f !` for a function `f` is a predicate transformer.
+(!) :: (b -> a) -> FT c a b
 (!) = flip (.)
 
 -- |Prints the input of a predicate, for debugging.
-traced :: Show a => PT a a
+traced :: Show a => FT c a a
 traced p a = traceShow a (p a)