diff --git a/Control/Monad/Imperative/FunctionFactory.hs b/Control/Monad/Imperative/FunctionFactory.hs
--- a/Control/Monad/Imperative/FunctionFactory.hs
+++ b/Control/Monad/Imperative/FunctionFactory.hs
@@ -7,7 +7,7 @@
 -- Maintainer  :  Matthew Mirman <mmirman@andrew.cmu.edu>
 -- Stability   :  experimental
 -- Portability :  TemplateHaskell
--- A module which defines a function 'liftIO' which coverts pure functions 
+-- A module which defines a function 'liftOp' which coverts pure functions 
 -- into reference taking functions.
 -----------------------------------------------------------------------------
 
diff --git a/Control/Monad/Imperative/Internals.hs b/Control/Monad/Imperative/Internals.hs
--- a/Control/Monad/Imperative/Internals.hs
+++ b/Control/Monad/Imperative/Internals.hs
@@ -31,7 +31,7 @@
        , new
        , auto
        , runImperative
-       , V(Lit, C)
+       , V(Lit, C)       
        , ValTp
        , MIO()
        , Comp
@@ -45,9 +45,10 @@
 import Control.Monad.Cont
 import Control.Monad.Reader
 import Data.IORef
+import Data.String (IsString(..))
 
 newtype MIO r a = MIO { getMIO :: ReaderT (Control r) (ContT r IO) a }
-                deriving (Monad, MonadCont)
+                deriving (Monad, MonadCont, MonadIO)
 
 data Var
 data Val
@@ -128,7 +129,21 @@
   R :: IORef a -> V Var r a
   Lit :: a -> V Val r a
   C :: ValTp b => MIO r (V b r a) -> V Comp r a
+instance Eq a => Eq (V Val r a) where
+  (Lit a) == (Lit a') = a == a'
+instance Show a => Show (V Val r a) where
+  show (Lit a) = show a
+instance Num a => Num (V Val r a) where
+  (Lit a) + (Lit b) = Lit $ a + b
+  (Lit a) * (Lit b) = Lit $ a * b
+  abs (Lit a) = Lit $ abs a
+  signum (Lit a) = Lit $ signum a
+  fromInteger = Lit . fromInteger
+  
+instance IsString s => IsString (V Val r s) where
+  fromString = Lit . fromString
 
+
 val :: ValTp b => V b r a -> MIO r a
 val v = case v of
   R r -> MIO $ liftIO $ readIORef r
@@ -155,20 +170,22 @@
 
 -- | The 'Assignable' class is used to specify a value which can be 
 -- computed imperatively.
+
 class Assignable valt where 
   -- | @variable '=:' value@ executes @value@ and writes it  
   -- to the location pointed to by @variable@
-  (=:) :: V Var r a -> valt r a -> MIO r ()
-  
+  (=:) :: V Var r a -> valt r a -> MIO r () 
+
 instance ValTp b => Assignable (V b) where  
   (=:) (R ar) br = MIO $ do
     b <- getMIO $ val br
     liftIO $ writeIORef ar b
-    
+
 instance Assignable MIO where  
-  (=:) a br = do
+  (=:) (R ar) br = do
     b <- br
-    a =: Lit b
+    liftIO $ writeIORef ar b
+
 
 -- | @'for''(init, check, incr)@ acts like its imperative @for@ counterpart
 for' :: ValTp b => (MIO r irr1, V b r Bool, MIO r irr2) -> MIO r () -> MIO r ()
diff --git a/Control/Monad/Imperative/Operators.hs b/Control/Monad/Imperative/Operators.hs
--- a/Control/Monad/Imperative/Operators.hs
+++ b/Control/Monad/Imperative/Operators.hs
@@ -22,7 +22,7 @@
 (%=:) :: (ValTp k, Integral b) => V Var r b -> V k r b -> MIO r ()
 (%=:) a b = modifyOp mod a b
 
-(<.), (>.), (<=.),(<=.) :: (ValTp b1, ValTp b2, Ord b) => V b1 r b -> V b2 r b -> V Comp r Bool
+(<.), (>.), (>=.), (<=.) :: (ValTp b1, ValTp b2, Ord b) => V b1 r b -> V b2 r b -> V Comp r Bool
 (<.) a b = liftOp2 (<) a b
 (>.) a b = liftOp2 (>) a b
 (>=.) a b = liftOp2 (>=) a b
diff --git a/ImperativeHaskell.cabal b/ImperativeHaskell.cabal
--- a/ImperativeHaskell.cabal
+++ b/ImperativeHaskell.cabal
@@ -1,5 +1,5 @@
 Name:                ImperativeHaskell
-Version:             1.1.0.1
+Version:             1.1.1.0
 Description:         A monad that uses GADTs and continuations
                      to replicate what it is like to program
                      in an imperative language like C or Java
@@ -37,5 +37,5 @@
                       Control.Monad.Imperative.Operators,
                       Control.Monad.Imperative.FunctionFactory
   
-  Extensions: GADTs, EmptyDataDecls, GeneralizedNewtypeDeriving, MultiParamTypeClasses, FlexibleInstances, TemplateHaskell
+  Extensions: GADTs, EmptyDataDecls, GeneralizedNewtypeDeriving, MultiParamTypeClasses, FlexibleInstances, TemplateHaskell 
     
diff --git a/Main.hs b/Main.hs
--- a/Main.hs
+++ b/Main.hs
@@ -1,7 +1,9 @@
 {-# LANGUAGE
  GADTs,
  TemplateHaskell,
- ScopedTypeVariables
+ ScopedTypeVariables, 
+ OverloadedStrings,
+ RankNTypes
  #-}
 
 -----------------------------------------------------------------------------
@@ -44,13 +46,15 @@
     return' r1;
 };
 
-
+type NumLit = forall r a . Num a => V Val r a
 
 factorial = function $ do
 {
     a <- new 0;
     n <- new 1;
-        
+    
+    a =: (0 :: NumLit);
+    
     for' ( a =: Lit 1 , a <. Lit 11 , a +=: Lit 1 ) $ do
     {
         n *=: a;