diff --git a/Control/Monad/Logic.hs b/Control/Monad/Logic.hs
--- a/Control/Monad/Logic.hs
+++ b/Control/Monad/Logic.hs
@@ -1,4 +1,4 @@
-{-# LANGUAGE UndecidableInstances #-}
+{-# LANGUAGE UndecidableInstances, Rank2Types, FlexibleInstances, MultiParamTypeClasses #-}
 
 -------------------------------------------------------------------------
 -- |
@@ -159,7 +159,7 @@
 
 instance T.Traversable Logic where
     traverse g l = runLogic l (\a ft -> cons <$> g a <*> ft) (pure mzero)
-     where cons a l = return a `mplus` l
+     where cons a l' = return a `mplus` l'
 
 -- haddock doesn't like generalized newtype deriving, so I'm writing
 -- instances by hand
diff --git a/Control/Monad/Logic/Class.hs b/Control/Monad/Logic/Class.hs
--- a/Control/Monad/Logic/Class.hs
+++ b/Control/Monad/Logic/Class.hs
@@ -20,8 +20,6 @@
 
 module Control.Monad.Logic.Class (MonadLogic(..), reflect) where
 
-import Control.Monad
-
 import qualified Control.Monad.State.Lazy as LazyST
 import qualified Control.Monad.State.Strict as StrictST
 
@@ -132,6 +130,18 @@
                             Just ((a,s'), m) ->
                                 return (Just (a, StrictST.StateT (\_ -> m)), s')
 
+    interleave ma mb = StrictST.StateT $ \s ->
+                        StrictST.runStateT ma s `interleave` StrictST.runStateT mb s
+
+    ma >>- f = StrictST.StateT $ \s ->
+                StrictST.runStateT ma s >>- \(a,s') -> StrictST.runStateT (f a) s'
+
+    ifte t th el = StrictST.StateT $ \s -> ifte (StrictST.runStateT t s)
+                                                (\(a,s') -> StrictST.runStateT (th a) s')
+                                                (StrictST.runStateT el s)
+
+    once ma = StrictST.StateT $ \s -> once (StrictST.runStateT ma s)
+
 instance (MonadLogic m) => MonadLogic (LazyST.StateT s m) where
     msplit sm = LazyST.StateT $ \s ->
                     do r <- msplit (LazyST.runStateT sm s)
@@ -140,6 +150,18 @@
                             Just ((a,s'), m) ->
                                 return (Just (a, LazyST.StateT (\_ -> m)), s')
 
+    interleave ma mb = LazyST.StateT $ \s ->
+                        LazyST.runStateT ma s `interleave` LazyST.runStateT mb s
+
+    ma >>- f = LazyST.StateT $ \s ->
+                LazyST.runStateT ma s >>- \(a,s') -> LazyST.runStateT (f a) s'
+
+    ifte t th el = LazyST.StateT $ \s -> ifte (LazyST.runStateT t s)
+                                              (\(a,s') -> LazyST.runStateT (th a) s')
+                                              (LazyST.runStateT el s)
+
+    once ma = LazyST.StateT $ \s -> once (LazyST.runStateT ma s)
+
 instance (MonadLogic m, Monoid w) => MonadLogic (StrictWT.WriterT w m) where
     msplit wm = StrictWT.WriterT $
                     do r <- msplit (StrictWT.runWriterT wm)
@@ -148,6 +170,20 @@
                             Just ((a,w), m) ->
                                 return (Just (a, StrictWT.WriterT m), w)
 
+    interleave ma mb = StrictWT.WriterT $
+                        StrictWT.runWriterT ma `interleave` StrictWT.runWriterT mb
+
+    ma >>- f = StrictWT.WriterT $
+                StrictWT.runWriterT ma >>- \(a,w) ->
+                    StrictWT.runWriterT (StrictWT.tell w >> f a)
+
+    ifte t th el = StrictWT.WriterT $
+                    ifte (StrictWT.runWriterT t)
+                         (\(a,w) -> StrictWT.runWriterT (StrictWT.tell w >> th a))
+                         (StrictWT.runWriterT el)
+
+    once ma = StrictWT.WriterT $ once (StrictWT.runWriterT ma)
+
 instance (MonadLogic m, Monoid w) => MonadLogic (LazyWT.WriterT w m) where
     msplit wm = LazyWT.WriterT $
                     do r <- msplit (LazyWT.runWriterT wm)
@@ -155,3 +191,17 @@
                             Nothing -> return (Nothing, mempty)
                             Just ((a,w), m) ->
                                 return (Just (a, LazyWT.WriterT m), w)
+
+    interleave ma mb = LazyWT.WriterT $
+                        LazyWT.runWriterT ma `interleave` LazyWT.runWriterT mb
+
+    ma >>- f = LazyWT.WriterT $
+                LazyWT.runWriterT ma >>- \(a,w) ->
+                    LazyWT.runWriterT (LazyWT.tell w >> f a)
+
+    ifte t th el = LazyWT.WriterT $
+                    ifte (LazyWT.runWriterT t)
+                         (\(a,w) -> LazyWT.runWriterT (LazyWT.tell w >> th a))
+                         (LazyWT.runWriterT el)
+
+    once ma = LazyWT.WriterT $ once (LazyWT.runWriterT ma)
diff --git a/logict.cabal b/logict.cabal
--- a/logict.cabal
+++ b/logict.cabal
@@ -1,5 +1,5 @@
 Name:                   logict
-Version:                0.2.2
+Version:                0.2.3
 Description:            A continuation-based, backtracking, logic programming monad.
                         An adaptation of the two-continuation implementation found
                         in the paper "Backtracking, Interleaving, and Terminating
@@ -13,12 +13,17 @@
 Author:                 Dan Doel
 Maintainer:             dan.doel@gmail.com
 Homepage:               http://code.haskell.org/~dolio/logict
-Stability:              Experimental, based on paper
+
+Stability:              Experimental
 Tested-With:            GHC
 Build-Depends:          base, mtl>=1.0.1
+Build-Type:             Simple
+
 Exposed-Modules:        Control.Monad.Logic,
                         Control.Monad.Logic.Class
 Extensions:             MultiParamTypeClasses,
-                        UndecidableInstances
-GHC-Options:            -O2
+                        UndecidableInstances,
+                        Rank2Types,
+                        FlexibleInstances
+GHC-Options:            -O2 -Wall