diff --git a/Data/SecureMem.hs b/Data/SecureMem.hs
--- a/Data/SecureMem.hs
+++ b/Data/SecureMem.hs
@@ -34,6 +34,7 @@
 import Data.Word (Word8)
 import Data.Monoid
 import Control.Applicative ((<$>))
+import Control.Monad (foldM, void)
 import Data.ByteString (ByteString)
 import Data.Byteable
 import qualified Data.ByteString.Internal as B
@@ -52,36 +53,53 @@
         MallocPtr mba _ -> I# (sizeofMutableByteArray# mba)
         _               -> error "cannot happen"
 
+secureMemEq :: SecureMem -> SecureMem -> Bool
+secureMemEq sm1 sm2 = sz1 == sz2 && B.inlinePerformIO meq
+  where meq = withSecureMemPtr sm1 $ \ptr1 ->
+              withSecureMemPtr sm2 $ \ptr2 ->
+              feq ptr1 ptr2
+        !sz1 = secureMemGetSize sm1
+        !sz2 = secureMemGetSize sm2
+        feq | sz1 == 8   = compareEq8
+            | sz1 == 16  = compareEq16
+            | sz1 == 24  = compareEq24
+            | sz1 == 32  = compareEq32
+            | sz1 == 64  = compareEq64
+            | sz1 == 128 = compareEq128
+            | sz1 == 256 = compareEq256
+            | otherwise  = compareEq (fromIntegral sz1)
+
+secureMemAppend :: SecureMem -> SecureMem -> SecureMem
+secureMemAppend s1 s2 =
+    unsafeCreateSecureMem (sz1+sz2) $ \dst -> do
+        withSecureMemPtr s1 $ \sp1 -> B.memcpy dst sp1 (fromIntegral sz1)
+        withSecureMemPtr s2 $ \sp2 -> B.memcpy (dst `plusPtr` sz1) sp2 (fromIntegral sz2)
+  where !sz1 = secureMemGetSize s1
+        !sz2 = secureMemGetSize s2
+
+secureMemConcat :: [SecureMem] -> SecureMem
+secureMemConcat l = unsafeCreateSecureMem total $ \dst -> void $ foldM copy dst l
+  where total = sum $ map secureMemGetSize l
+        copy dst s = withSecureMemPtr s $ \sp -> do
+                    B.memcpy dst sp sz
+                    return (dst `plusPtr` sz)
+          where sz = secureMemGetSize s
+
 instance Show SecureMem where
     show _ = "<secure-mem>"
 
 instance Byteable SecureMem where
-    toBytes = secureMemToByteString
+    toBytes        = secureMemToByteString
+    byteableLength = secureMemGetSize
+    withBytePtr    = withSecureMemPtr
 
 instance Eq SecureMem where
-    sm1 == sm2 = sz1 == sz2 && B.inlinePerformIO meq
-        where meq = withSecureMemPtr sm1 $ \ptr1 ->
-                    withSecureMemPtr sm2 $ \ptr2 ->
-                    feq ptr1 ptr2
-              !sz1 = secureMemGetSize sm1
-              !sz2 = secureMemGetSize sm2
-              feq | sz1 == 8   = compareEq8
-                  | sz1 == 16  = compareEq16
-                  | sz1 == 24  = compareEq24
-                  | sz1 == 32  = compareEq32
-                  | sz1 == 64  = compareEq64
-                  | sz1 == 128 = compareEq128
-                  | sz1 == 256 = compareEq256
-                  | otherwise  = compareEq (fromIntegral sz1)
+    (==) = secureMemEq
 
 instance Monoid SecureMem where
-    mempty        = unsafeCreateSecureMem 0 (\_ -> return ())
-    mappend s1 s2 = unsafeCreateSecureMem (sz1+sz2) $ \dst -> do
-                        withSecureMemPtr s1 $ \sp1 -> B.memcpy dst sp1 (fromIntegral sz1)
-                        withSecureMemPtr s2 $ \sp2 -> B.memcpy (dst `plusPtr` sz1) sp2 (fromIntegral sz2)
-                    where 
-                          !sz1 = secureMemGetSize s1
-                          !sz2 = secureMemGetSize s2
+    mempty  = unsafeCreateSecureMem 0 (\_ -> return ())
+    mappend = secureMemAppend
+    mconcat = secureMemConcat
 
 type Finalizer = Ptr Word8 -> IO ()
 type FinalizerWithSize = CInt -> Ptr Word8 -> IO ()
@@ -135,7 +153,7 @@
     fptr@(ForeignPtr addr _) <- mallocForeignPtrBytes sz
     addForeignPtrConcFinalizer fptr (scruber (Ptr addr))
     return fptr
-    where !scruber = szToScruber sz
+  where !scruber = szToScruber sz
 
 -- | Allocate a new SecureMem
 --
@@ -178,7 +196,7 @@
     B.unsafeCreate sz $ \dst ->
     withSecureMemPtr sm $ \src ->
     B.memcpy dst src (fromIntegral sz)
-    where !sz = secureMemGetSize sm
+  where !sz = secureMemGetSize sm
 
 -- | Create a SecureMem from a bytestring
 secureMemFromByteString :: ByteString -> SecureMem
@@ -186,5 +204,5 @@
     sm <- allocateSecureMem len 
     withSecureMemPtr sm $ \dst -> withBytestringPtr $ \src -> B.memcpy dst src (fromIntegral len)
     return sm
-    where (fp, off, !len) = B.toForeignPtr b
-          withBytestringPtr f = withForeignPtr fp $ \p -> f (p `plusPtr` off)
+  where (fp, off, !len) = B.toForeignPtr b
+        withBytestringPtr f = withForeignPtr fp $ \p -> f (p `plusPtr` off)
diff --git a/securemem.cabal b/securemem.cabal
--- a/securemem.cabal
+++ b/securemem.cabal
@@ -1,5 +1,5 @@
 Name:                securemem
-Version:             0.1.0
+Version:             0.1.1
 Synopsis:            abstraction to an auto scrubbing and const time eq, memory chunk.
 Description:
     SecureMem is similar to ByteString, except that it provides a memory chunk that
@@ -20,7 +20,7 @@
   Exposed-modules:   Data.SecureMem
   Build-depends:     base >= 4 && < 5
                    , bytestring
-                   , byteable
+                   , byteable >= 0.1.1
                    , ghc-prim
   C-sources:         cbits/utils.c
   ghc-options:       -Wall -fwarn-tabs