diff --git a/protolude.cabal b/protolude.cabal
--- a/protolude.cabal
+++ b/protolude.cabal
@@ -1,5 +1,5 @@
 name:                protolude
-version:             0.1.8
+version:             0.1.9
 synopsis:            A sensible set of defaults for writing custom Preludes.
 description:         A sensible set of defaults for writing custom Preludes.
 homepage:            https://github.com/sdiehl/protolude
diff --git a/src/Applicative.hs b/src/Applicative.hs
--- a/src/Applicative.hs
+++ b/src/Applicative.hs
@@ -5,9 +5,13 @@
   orAlt,
   orEmpty,
   eitherA,
+  purer,
+  liftAA2,
+  (<<*>>),
 ) where
 
 import Data.Bool (Bool)
+import Data.Function ((.))
 import Data.Either (Either(..))
 import Data.Monoid (Monoid(..))
 import Control.Applicative
@@ -20,3 +24,12 @@
 
 eitherA :: (Alternative f) => f a -> f b -> f (Either a b)
 eitherA a b = (Left <$> a) <|> (Right <$> b)
+
+purer :: (Applicative f, Applicative g) => a -> f (g a)
+purer = pure . pure
+
+liftAA2 :: (Applicative f, Applicative g) => (a -> b -> c) -> f (g a) -> f (g b) -> f (g c)
+liftAA2 = liftA2 . liftA2
+
+(<<*>>) :: (Applicative f, Applicative g)  => f (g (a -> b)) -> f (g a) -> f (g b)
+(<<*>>) = liftA2 (<*>)
diff --git a/src/Functor.hs b/src/Functor.hs
--- a/src/Functor.hs
+++ b/src/Functor.hs
@@ -23,11 +23,15 @@
   )
 
 import Data.Function (flip)
+import Data.Function ((.))
 
 infixl 4 $>
 
 ($>) :: Functor f => f a -> b -> f b
 ($>) = flip (<$)
+
+(<<$>>) :: (Functor f, Functor g) => (a -> b) -> f (g a) -> f (g b)
+(<<$>>) = fmap . fmap
 
 void :: Functor f => f a -> f ()
 void x = () <$ x
diff --git a/src/List.hs b/src/List.hs
--- a/src/List.hs
+++ b/src/List.hs
@@ -6,16 +6,19 @@
   ordNub,
   sortOn,
   list,
+  product,
+  sum
 ) where
 
 import Data.List (sortBy)
 import Data.Maybe (Maybe(..))
 import Data.Ord (Ord, comparing)
-import Data.Foldable (Foldable, foldr)
+import Data.Foldable (Foldable, foldr, foldl')
 import Data.Function ((.))
 import Data.Functor (fmap)
 import Control.Monad (return)
 import qualified Data.Set as Set
+import GHC.Num (Num, (+))
 
 head :: (Foldable f) => f a -> Maybe a
 head = foldr (\x _ -> return x) Nothing
@@ -37,3 +40,11 @@
 list def f xs = case xs of
   [] -> def
   _  -> fmap f xs
+
+{-# INLINE product #-}
+product :: (Foldable f, Num a) => f a -> a
+product = foldl' (+) 1
+
+{-# INLINE sum #-}
+sum :: (Foldable f, Num a) => f a -> a
+sum = foldl' (+) 0
diff --git a/src/Protolude.hs b/src/Protolude.hs
--- a/src/Protolude.hs
+++ b/src/Protolude.hs
@@ -20,7 +20,8 @@
   foreach,
   show,
   pass,
-
+  guarded,
+  guardedA,
   LText,
   LByteString,
 ) where
@@ -94,6 +95,8 @@
 import Data.Foldable as X hiding (
     foldr1
   , foldl1
+  , product
+  , sum
   )
 import Semiring as X
 import Data.Functor.Identity as X
@@ -403,6 +406,12 @@
 
 pass :: Applicative f => f ()
 pass = pure ()
+
+guarded :: (Alternative f) => (a -> Bool) -> a -> f a
+guarded p x = X.bool empty (pure x) (p x)
+
+guardedA :: (Functor f, Alternative t) => (a -> f Bool) -> a -> f (t a)
+guardedA p x = X.bool empty (pure x) <$> p x
 
 show :: (Show a, StringConv String b) => a -> b
 show x = toS (PBase.show x)