diff --git a/logict-state.cabal b/logict-state.cabal
--- a/logict-state.cabal
+++ b/logict-state.cabal
@@ -2,7 +2,7 @@
 -- documentation, see http://haskell.org/cabal/users-guide/
 
 name:                logict-state
-version:             0.1.0.4
+version:             0.1.0.5
 synopsis:            Library for logic programming based on haskell package logict
 description:         Logic programming built on top of part of logict library, in particular for dealing with backtrackable state
 homepage:            https://github.com/atzedijkstra/logict-state
diff --git a/src/Control/Monad/LogicState.hs b/src/Control/Monad/LogicState.hs
--- a/src/Control/Monad/LogicState.hs
+++ b/src/Control/Monad/LogicState.hs
@@ -115,26 +115,11 @@
 
 instance TransLogicState (gs,bs) (LogicStateT gs bs) where
   observeT s lt = evalStateT (unLogicStateT lt (\a _ -> return a) (fail "No answer.")) s
-  
-  -- observeAllT s m = evalStateT (unLogicStateT m
-  --   (\a fk -> fk >>= \as -> return (a:as))
-  --   (return []))
-  --   s
-  
+    
   observeStateAllT s m = runStateT (unLogicStateT m
     (\a fk -> fk >>= \as -> return (a:as))
     (return []))
     s
-  
-  -- observeManyT s n m = evalStateT (obs n m) s
-  --  where
-  --    obs n m
-  --       | n <= 0 = return []
-  --       | n == 1 = unLogicStateT m (\a _ -> return [a]) (return [])
-  --       | otherwise = unLogicStateT (msplit m) sk (return [])
-  --    
-  --    sk Nothing _ = return []
-  --    sk (Just (a, m')) _ = StateT $ \s -> (\as -> (a:as,s)) `liftM` observeManyT s (n-1) m'
 
   observeStateManyT s n m = runStateT (obs n m) s
    where
@@ -153,8 +138,13 @@
     get   = LogicStateT $ \sk fk -> get >>= \s -> sk s fk
     put s = LogicStateT $ \sk fk -> put s >>= \a -> sk a fk
 
-instance (Monad m) => MonadLogicState (gs,bs) (LogicStateT gs bs m) where
-    backtrack m = get >>= \(_::gs,bs) -> return $ LogicStateT $ \sk fk -> StateT $ \(gs,_) -> runStateT (unLogicStateT m sk fk) (gs,bs)
+instance (Monad m) => MonadLogicState (,) gs bs m (LogicStateT gs bs m) where
+    backtrackWithRoll roll m = do
+      (_,bs1) <- get
+      return $ LogicStateT $ \sk fk ->
+        StateT $ \(gs2,bs2) -> do
+          bs <- roll gs2 bs2 bs1
+          runStateT (unLogicStateT m sk fk) (gs2,bs)
 
 
 -------------------------------------------------------------------------
diff --git a/src/Control/Monad/LogicState/Class.hs b/src/Control/Monad/LogicState/Class.hs
--- a/src/Control/Monad/LogicState/Class.hs
+++ b/src/Control/Monad/LogicState/Class.hs
@@ -11,11 +11,21 @@
 
 -------------------------------------------------------------------------------
 -- | API for MonadLogic which allows state and backtracking on it.
-class (MonadLogic m, MonadState s m) => MonadLogicState s m where
+class (MonadLogic m, Monad ms, MonadState (f gs bs) m) => MonadLogicState f gs bs ms m | m -> ms where
     
     -- | Return argument monad with the current backtrackable part of the state remembered.
     -- If the default def is not overridden this a no-op.
     -- This function complements 'mplus' for 'LogicT', 'mplus' backtracks on results, not on state, which is what this function should do.
+    -- 'roll' accepts the end state of the backtrack attempt resp the state to backtrack to, returns to state to backtrack to.
+    backtrackWithRoll
+      :: (gs -> bs -> bs -> ms bs) -- ^ roll
+      -> m a
+      -> m (m a)
+    backtrackWithRoll _ = backtrack
+    
+    -- | special case of 'backtrackWith'
     backtrack :: m a -> m (m a)
-    backtrack = return
+    backtrack = backtrackWithRoll (\_ _ bs -> return bs)
+    
+