diff --git a/cmonad.cabal b/cmonad.cabal
--- a/cmonad.cabal
+++ b/cmonad.cabal
@@ -1,5 +1,5 @@
 Name:		cmonad
-Version:	0.1.0.1
+Version:	0.1.1.0
 License:	BSD3
 Author:		Lennart Augustsson
 Maintainer:	Lennart Augustsson
@@ -7,7 +7,7 @@
 Synopsis:	A library for C-like programming
 Stability:      experimental
 Build-type:	Simple
-Description:	A library for C-like programming
+Description:	A library for C-like programming.  The code looks imperative, and you might think it would be efficient, but GHC lacks certain optimizations that makes it very slow.
 Hs-Source-Dirs: src
 Build-Depends:	base, array
 Exposed-modules:
diff --git a/examples/Makefile b/examples/Makefile
--- a/examples/Makefile
+++ b/examples/Makefile
@@ -1,22 +1,14 @@
 GHC=ghc
 GHCFLAGS= -O --make -i../src -odir build -hidir build
 
-run:	Inf.run QSort.run
-
-build:
-	mkdir -p build
-
-Inf.run:	Inf.exe
-	./Inf.exe
-
-Inf.exe:	build Inf.hs
-	$(GHC) $(GHCFLAGS) -main-is Inf.main Inf.hs -o Inf.exe
+run:	Fac.run Fib.run Inf.run QSort.run Array2.run Cat.run
 
-QSort.run:	QSort.exe
-	./QSort.exe
+.SUFFIXES: .hs .run
 
-QSort.exe:	build QSort.hs
-	$(GHC) $(GHCFLAGS) -main-is QSort.main QSort.hs -o QSort.exe
+.hs.run:
+	@mkdir -p build
+	$(GHC) $(GHCFLAGS) -main-is $*.main $*.hs -o $*.exe
+	echo Hello | ./$*.exe
 
 clean:
 	rm -rf *.exe* build
diff --git a/src/Language/CMonad/MonadRef.hs b/src/Language/CMonad/MonadRef.hs
--- a/src/Language/CMonad/MonadRef.hs
+++ b/src/Language/CMonad/MonadRef.hs
@@ -1,8 +1,10 @@
-{-# LANGUAGE MultiParamTypeClasses, FunctionalDependencies #-}
+{-# LANGUAGE MultiParamTypeClasses, FunctionalDependencies, KindSignatures #-}
 module Language.CMonad.MonadRef where
+import Control.Monad.ST
 import Data.IORef
 import Data.STRef
-import Control.Monad.ST(ST)
+import Data.Array.ST
+import Data.Array.IO
 
 class (Monad m) => MonadRef m r | m -> r, r -> m where
     newRef :: a -> m (r a)
@@ -24,3 +26,8 @@
     readRef = readSTRef
     {-# INLINE writeRef #-}
     writeRef = writeSTRef
+
+class TheArray (m :: * -> *) (arr :: * -> * -> *) | m -> arr
+
+instance TheArray IO IOArray
+instance TheArray (ST s) (STArray s)
diff --git a/src/Language/CMonad/Ops.hs b/src/Language/CMonad/Ops.hs
--- a/src/Language/CMonad/Ops.hs
+++ b/src/Language/CMonad/Ops.hs
@@ -3,6 +3,7 @@
 -- XXX Despite what I think should be enough LANGUAGE options I still need -fglasgow-exts.
 module Language.CMonad.Ops(module Language.CMonad.Ops) where
 import qualified Prelude as P
+import System.IO
 import Language.CMonad.CPrelude
 import Language.CMonad.MonadRef(MonadRef)
 import Language.CMonad.Prim
@@ -89,6 +90,9 @@
     y =: t
     return ()
 
+autoU :: (MonadRef m r) => E m (forall v . E' v m a)
+autoU = auto undefined
+
 -----------------------------
 
 while :: (Monad m) => E m Bool -> E m a -> E m ()
@@ -129,3 +133,21 @@
 {-# INLINE retrn #-}
 retrn :: E m a -> E m a
 retrn x = x
+
+-----------------------------
+
+type EIO a = E IO a
+
+getchar :: () -> EIO Int
+getchar () = embed $ do
+    eof <- hIsEOF stdin
+    if eof then
+        return (-1)
+     else
+        fmap fromEnum $ hGetChar stdin
+ 
+putchar :: EIO Int -> EIO Int
+putchar c = embed $ do
+    c' <- runE c
+    hPutChar stdout (toEnum c')
+    return 0
diff --git a/src/Language/CMonad/Prim.hs b/src/Language/CMonad/Prim.hs
--- a/src/Language/CMonad/Prim.hs
+++ b/src/Language/CMonad/Prim.hs
@@ -60,7 +60,7 @@
   )
 
 -- |A un-initialized multi-dimensional array.  E.g., @arrayU [2,3]@ is a 2x3 array.
-arrayU :: forall arr m a i . (Ix i, Num i, MArray arr a m) =>
+arrayU :: forall arr m a i . (Ix i, Num i, MArray arr a m, TheArray m arr) =>
        [E m i] -> E m (forall v . [E m i] -> E' v m a)
 arrayU ss = E ( do
     ss' <- mapM runE ss
@@ -77,7 +77,7 @@
   )
 
 -- |An C array initialized with a normal array.
-arrayA :: forall arr m a i . (Ix i, MArray arr a m) =>
+arrayA :: forall arr m a i . (Ix i, MArray arr a m, TheArray m arr) =>
        Array i a -> E m (forall v . [E m i] -> E' v m a)
 arrayA aa = E ( do
     a <- thaw aa :: m (arr i a)