diff --git a/simple-effects.cabal b/simple-effects.cabal
--- a/simple-effects.cabal
+++ b/simple-effects.cabal
@@ -1,5 +1,5 @@
 name:                simple-effects
-version:             0.2.0.0
+version:             0.2.0.1
 synopsis:            A simple effect system that integrates with MTL
 description:         Please see README.md
 homepage:            https://gitlab.com/LukaHorvat/simple-effects
@@ -17,15 +17,18 @@
                      , Control.Effects1
                      , Control.Effects.State
                      , Control.Effects.Reader
+                     , Control.Effects.List
   hs-source-dirs:      src
   default-language:    Haskell2010
   build-depends:       base >= 4.7 && < 5
                      , transformers
                      , mtl
-                     , interlude-l
+                     , interlude-l >= 0.1.0.6
                      , monad-control == 1.0.*
                      , transformers-base == 0.4.*
+                     , list-t
                      , lens
+  default-extensions:  NoImplicitPrelude
 
 benchmark bench-effects
   type:                exitcode-stdio-1.0
diff --git a/src/Control/Effects/List.hs b/src/Control/Effects/List.hs
new file mode 100644
--- /dev/null
+++ b/src/Control/Effects/List.hs
@@ -0,0 +1,60 @@
+{-# LANGUAGE ScopedTypeVariables, TypeFamilies, FlexibleContexts #-}
+module Control.Effects.List
+    ( module Control.Effects.List
+    , module ListT ) where
+
+import Interlude hiding (toList, traverse_, fold, foldMaybe, splitAt, head)
+
+import ListT hiding (take)
+
+import Control.Effects
+
+data List
+
+type instance EffectMsg1 List = []
+type instance EffectRes1 List = Identity
+type instance EffectCon1 List a = ()
+
+-- | Runs the rest of the computation for every value in the list
+choose :: MonadEffect1 List m => [a] -> m a
+choose = fmap runIdentity . effect1 (Proxy :: Proxy List)
+
+-- | Signals that this branch of execution failed to produce a result.
+deadEnd :: MonadEffect1 List m => m a
+deadEnd = choose []
+
+-- | A generic handler for the List effect. Takes a handler for the ListT transformer as a param.
+handleList :: Monad m => (ListT m a -> m b) -> EffectHandler1 List (ListT m) a -> m b
+handleList f = f . handleEffect1 (fmap Identity . fromFoldable)
+
+-- | Execute all the effects and collect the result in a list.
+--   Note that this forces all the results, no matter which elements of the result list you end
+--   up actually using. For lazyer behavior use the other handlers.
+evaluateToList :: Monad m => EffectHandler1 List (ListT m) a -> m [a]
+evaluateToList = handleList toList
+
+-- | Given a function, apply it to all the results.
+traverseAllResults :: Monad m => (a -> m ()) -> EffectHandler1 List (ListT m) a -> m ()
+traverseAllResults handler = handleList (traverse_ handler)
+
+-- | Given a folding function, fold over every result. If you want to terminate eary, use the
+--   `foldWithEarlyTermination` instead.
+foldAllResults :: Monad m => (r -> a -> m r) -> r -> EffectHandler1 List (ListT m) a -> m r
+foldAllResults f i = handleList (fold f i)
+
+-- | Same as `foldAllResults` but the folding function has the ability to terminate eary by
+--   returning Nothing.
+foldWithEarlyTermination :: Monad m => (r -> a -> m (Maybe r)) -> r
+                                    -> EffectHandler1 List (ListT m) a -> m r
+foldWithEarlyTermination f i = handleList (foldMaybe f i)
+
+-- | Executes only the effects needed to produce the first n results.
+evaluateNResults :: Monad m => Int -> EffectHandler1 List (ListT m) a -> m [a]
+evaluateNResults n = handleList (fmap fst . splitAt n)
+
+-- | Executes only the effects needed to produce a single result.
+evaluateOneResult :: Monad m => EffectHandler1 List (ListT m) a -> m (Maybe a)
+evaluateOneResult = handleList head
+
+test :: IO (Maybe Int)
+test = evaluateOneResult (return 1)
diff --git a/src/Control/Effects1.hs b/src/Control/Effects1.hs
--- a/src/Control/Effects1.hs
+++ b/src/Control/Effects1.hs
@@ -11,7 +11,7 @@
 
 type family EffectMsg1 eff :: * -> *
 type family EffectRes1 eff :: * -> *
-type family EffectCon1 eff :: * -> Constraint
+type family EffectCon1 eff a :: Constraint
 
 class Monad m => MonadEffect1 eff m where
     -- | Use the effect described by 'eff'.