diff --git a/CHANGELOG.md b/CHANGELOG.md
--- a/CHANGELOG.md
+++ b/CHANGELOG.md
@@ -1,5 +1,10 @@
 # Changelog for [`clash-prelude` package](http://hackage.haskell.org/package/clash-prelude)
 
+## 0.99.3 *July 26th 2018*
+* Bundle and BitPack instances up to and including 62-tuples
+* Handle undefined writes to RAM properly
+* Handle undefined clock enables properly
+
 ## 0.99.1 *May 12th 2018*
 * Support for `ghc-typelits-natnormalise-0.6.1`
 * `Lift` instances for `TopEntity` and `PortName`
diff --git a/README.md b/README.md
--- a/README.md
+++ b/README.md
@@ -5,7 +5,7 @@
 [![Hackage Dependencies](https://img.shields.io/hackage-deps/v/clash-prelude.svg?style=flat)](http://packdeps.haskellers.com/feed?needle=exact%3Aclash-prelude)
 
 __WARNING__
-Only works with GHC-8.2 or higher (http://www.haskell.org/ghc/download_ghc_8_4_2)!
+Only works with GHC-8.2 or higher (http://www.haskell.org/ghc/download_ghc_8_4_3)!
 
 CλaSH (pronounced ‘clash’) is a functional hardware description language that
 borrows both its syntax and semantics from the functional programming language
diff --git a/clash-prelude.cabal b/clash-prelude.cabal
--- a/clash-prelude.cabal
+++ b/clash-prelude.cabal
@@ -1,5 +1,5 @@
 Name:                 clash-prelude
-Version:              0.99.2
+Version:              0.99.3
 Synopsis:             CAES Language for Synchronous Hardware - Prelude library
 Description:
   CλaSH (pronounced ‘clash’) is a functional hardware description language that
@@ -158,6 +158,9 @@
 
                       Clash.Tutorial
                       Clash.Examples
+
+  other-modules:      Clash.Class.BitPack.Internal
+                      Clash.Signal.Bundle.Internal
 
   other-extensions:   CPP
                       BangPatterns
diff --git a/src/Clash/Class/BitPack.hs b/src/Clash/Class/BitPack.hs
--- a/src/Clash/Class/BitPack.hs
+++ b/src/Clash/Class/BitPack.hs
@@ -11,6 +11,7 @@
 {-# LANGUAGE FlexibleContexts     #-}
 {-# LANGUAGE MagicHash            #-}
 {-# LANGUAGE ScopedTypeVariables  #-}
+{-# LANGUAGE TemplateHaskell      #-}
 {-# LANGUAGE TypeFamilies         #-}
 {-# LANGUAGE TypeOperators        #-}
 {-# LANGUAGE UndecidableInstances #-}
@@ -42,6 +43,7 @@
 import GHC.Generics
 import Prelude                        hiding (map)
 
+import Clash.Class.BitPack.Internal   (deriveBitPackTuples)
 import Clash.Class.Resize             (zeroExtend)
 import Clash.Sized.BitVector
   (Bit, BitVector, (++#), high, low)
@@ -224,42 +226,6 @@
   pack (a,b) = pack a ++# pack b
   unpack ab  = let (a,b) = split# ab in (unpack a, unpack b)
 
-instance (KnownNat (BitSize c), BitPack (a,b), BitPack c) =>
-    BitPack (a,b,c) where
-  type BitSize (a,b,c) = BitSize (a,b) + BitSize c
-  pack (a,b,c) = pack (a,b) ++# pack c
-  unpack (unpack -> ((a,b), c)) = (a,b,c)
-
-instance (KnownNat (BitSize d), BitPack (a,b,c), BitPack d) =>
-    BitPack (a,b,c,d) where
-  type BitSize (a,b,c,d) = BitSize (a,b,c) + BitSize d
-  pack (a,b,c,d) = pack (a,b,c) ++# pack d
-  unpack (unpack -> ((a,b,c), d)) = (a,b,c,d)
-
-instance (KnownNat (BitSize e), BitPack (a,b,c,d), BitPack e) =>
-    BitPack (a,b,c,d,e) where
-  type BitSize (a,b,c,d,e) = BitSize (a,b,c,d) + BitSize e
-  pack (a,b,c,d,e) = pack (a,b,c,d) ++# pack e
-  unpack (unpack -> ((a,b,c,d), e)) = (a,b,c,d,e)
-
-instance (KnownNat (BitSize f), BitPack (a,b,c,d,e), BitPack f) =>
-    BitPack (a,b,c,d,e,f) where
-  type BitSize (a,b,c,d,e,f) = BitSize (a,b,c,d,e) + BitSize f
-  pack (a,b,c,d,e,f) = pack (a,b,c,d,e) ++# pack f
-  unpack (unpack -> ((a,b,c,d,e), f)) = (a,b,c,d,e,f)
-
-instance (KnownNat (BitSize g), BitPack (a,b,c,d,e,f), BitPack g) =>
-    BitPack (a,b,c,d,e,f,g) where
-  type BitSize (a,b,c,d,e,f,g) = BitSize (a,b,c,d,e,f) + BitSize g
-  pack (a,b,c,d,e,f,g) = pack (a,b,c,d,e,f) ++# pack g
-  unpack (unpack -> ((a,b,c,d,e,f), g)) = (a,b,c,d,e,f,g)
-
-instance (KnownNat (BitSize h), BitPack (a,b,c,d,e,f,g), BitPack h) =>
-    BitPack (a,b,c,d,e,f,g,h) where
-  type BitSize (a,b,c,d,e,f,g,h) = BitSize (a,b,c,d,e,f,g) + BitSize h
-  pack (a,b,c,d,e,f,g,h) = pack (a,b,c,d,e,f,g) ++# pack h
-  unpack (unpack -> ((a,b,c,d,e,f,g), h)) = (a,b,c,d,e,f,g,h)
-
 instance (BitPack a, KnownNat (BitSize a)) => BitPack (Maybe a) where
   type BitSize (Maybe a) = 1 + BitSize a
   pack Nothing  = pack# low ++# 0
@@ -309,3 +275,6 @@
 -- | Convert a Bool to a Bit
 bitToBool :: Bit -> Bool
 bitToBool = bitCoerce
+
+-- Derive the BitPack instance for tuples of size 3 to 62
+deriveBitPackTuples ''BitPack ''BitSize 'pack 'unpack '(++#)
diff --git a/src/Clash/Class/BitPack/Internal.hs b/src/Clash/Class/BitPack/Internal.hs
new file mode 100644
--- /dev/null
+++ b/src/Clash/Class/BitPack/Internal.hs
@@ -0,0 +1,91 @@
+{-# LANGUAGE TemplateHaskell #-}
+
+module Clash.Class.BitPack.Internal where
+
+import           Control.Monad         (replicateM)
+import           Data.List             (foldl')
+import           GHC.TypeLits          (KnownNat)
+import           Language.Haskell.TH
+
+-- | Contruct all the tuple (starting at size 3) instances for BitPack.
+deriveBitPackTuples
+  :: Name
+  -- ^ BitPack
+  -> Name
+  -- ^ BitSize
+  -> Name
+  -- ^ pack
+  -> Name
+  -- ^ unpack
+  -> Name
+  -- ^ append (++#)
+  -> DecsQ
+deriveBitPackTuples bitPackName bitSizeName packName unpackName appendName = do
+  let bitPack  = ConT bitPackName
+      bitSize  = ConT bitSizeName
+      knownNat = ConT ''KnownNat
+      plus     = ConT $ mkName "+"
+
+  allNames <- replicateM 62 (newName "a")
+  x <- newName "x"
+  y <- newName "y"
+
+  pure $ flip map [3..62] $ \tupleNum ->
+    let names  = take tupleNum allNames
+        (v:vs) = fmap VarT names
+        tuple xs = foldl' AppT (TupleT $ length xs) xs
+
+        -- Instance declaration
+        context =
+          [ bitPack `AppT` v
+          , knownNat `AppT` (bitSize `AppT` v)
+          , bitPack `AppT` tuple vs
+          , knownNat `AppT` (bitSize `AppT` tuple vs)
+          ]
+        instTy = AppT bitPack $ tuple (v:vs)
+
+        -- Associated type BitSize
+        bitSizeTypeEq =
+          TySynEqn
+            [ tuple (v:vs) ]
+            $ plus `AppT` (bitSize `AppT` v) `AppT`
+              (bitSize `AppT` foldl AppT (TupleT $ tupleNum - 1) vs)
+        bitSizeType = TySynInstD bitSizeName bitSizeTypeEq
+
+        pack =
+          FunD
+            packName
+            [ Clause
+                [ TupP $ map VarP names ]
+                ( let (e:es) = map VarE names
+                  in NormalB $ AppE
+                    (VarE appendName `AppE` (VarE packName `AppE` e))
+                    (VarE packName `AppE` TupE es)
+                )
+                []
+            ]
+
+        unpack =
+          FunD
+            unpackName
+            [ Clause
+                [ VarP x ]
+                ( NormalB $
+                    let (p:ps) = map VarP names
+                    in
+                    LetE
+                      [ ValD
+                          ( TupP [ p, VarP y ] )
+                          ( NormalB $ VarE unpackName `AppE` VarE x )
+                          []
+                      , ValD
+                          ( TupP ps )
+                          ( NormalB $ VarE unpackName `AppE` VarE y )
+                          []
+                      ]
+                      ( TupE $ map VarE names )
+                )
+                []
+            ]
+
+    in InstanceD Nothing context instTy [bitSizeType, pack, unpack]
diff --git a/src/Clash/Explicit/BlockRam.hs b/src/Clash/Explicit/BlockRam.hs
--- a/src/Clash/Explicit/BlockRam.hs
+++ b/src/Clash/Explicit/BlockRam.hs
@@ -403,7 +403,7 @@
 import Clash.Signal.Bundle    (unbundle)
 import Clash.Sized.Unsigned   (Unsigned)
 import Clash.Sized.Vector     (Vec, toList)
-import Clash.XException       (errorX, seqX)
+import Clash.XException       (errorX, maybeX, seqX)
 
 {- $setup
 >>> import Clash.Explicit.Prelude as C
@@ -761,21 +761,27 @@
   Just ena ->
     go' (V.fromList (toList content))
        (withFrozenCallStack (errorX "blockRam: intial value undefined"))
-       ena rd (wen .&&. ena)
+       ena rd (ena .&&. wen)
   where
     -- no clock enable
     go !ram o (r :- rs) (e :- en) (w :- wr) (d :- din) =
-      let ram' = upd ram e w d
+      let ram' = upd ram e (fromEnum w) d
           o'   = ram V.! r
       in  o `seqX` o :- go ram' o' rs en wr din
     -- clock enable
     go' !ram o (re :- res) (r :- rs) (e :- en) (w :- wr) (d :- din) =
-      let ram' = upd ram e w d
+      let ram' = upd ram e (fromEnum w) d
           o'   = if re then ram V.! r else o
       in  o `seqX` o :- go' ram' o' res rs en wr din
 
-    upd ram True  addr d = ram V.// [(addr,d)]
-    upd ram False _    _ = ram
+    upd ram we waddr d = case maybeX we of
+      Nothing -> case maybeX waddr of
+        Nothing -> V.map (const (seq waddr d)) ram
+        Just wa -> ram V.// [(wa,d)]
+      Just True -> case maybeX waddr of
+        Nothing -> V.map (const (seq waddr d)) ram
+        Just wa -> ram V.// [(wa,d)]
+      _ -> ram
 {-# NOINLINE blockRam# #-}
 
 -- | Create read-after-write blockRAM from a read-before-write one
diff --git a/src/Clash/Explicit/BlockRam/File.hs b/src/Clash/Explicit/BlockRam/File.hs
--- a/src/Clash/Explicit/BlockRam/File.hs
+++ b/src/Clash/Explicit/BlockRam/File.hs
@@ -110,7 +110,7 @@
 import Clash.Signal.Internal (Clock, Signal (..), (.&&.), clockEnable)
 import Clash.Signal.Bundle   (unbundle)
 import Clash.Sized.Unsigned  (Unsigned)
-import Clash.XException      (errorX, seqX)
+import Clash.XException      (errorX, maybeX, seqX)
 
 
 -- | Create a blockRAM with space for 2^@n@ elements
@@ -230,21 +230,27 @@
   Just ena ->
     go' ramI
        (withFrozenCallStack (errorX "blockRamFile#: intial value undefined"))
-       ena rd (wen .&&. ena)
+       ena rd (ena .&&. wen)
   where
     -- no clock enable
     go !ram o (r :- rs) (e :- en) (w :- wr) (d :- din) =
-      let ram' = upd ram e w d
+      let ram' = upd ram e (fromEnum w) d
           o'   = ram V.! r
       in  o `seqX` o :- go ram' o' rs en wr din
     -- clock enable
     go' !ram o (re :- res) (r :- rs) (e :- en) (w :- wr) (d :- din) =
-      let ram' = upd ram e w d
+      let ram' = upd ram e (fromEnum w) d
           o'   = if re then ram V.! r else o
       in  o `seqX` o :- go' ram' o' res rs en wr din
 
-    upd ram True  addr d = ram V.// [(addr,d)]
-    upd ram False _    _ = ram
+    upd ram we waddr d = case maybeX we of
+      Nothing -> case maybeX waddr of
+        Nothing -> V.map (const (seq waddr d)) ram
+        Just wa -> ram V.// [(wa,d)]
+      Just True -> case maybeX waddr of
+        Nothing -> V.map (const (seq waddr d)) ram
+        Just wa -> ram V.// [(wa,d)]
+      _ -> ram
 
     content = unsafePerformIO (initMem file)
     ramI    = V.fromList content
diff --git a/src/Clash/Explicit/RAM.hs b/src/Clash/Explicit/RAM.hs
--- a/src/Clash/Explicit/RAM.hs
+++ b/src/Clash/Explicit/RAM.hs
@@ -43,7 +43,7 @@
 import Clash.Promoted.Nat    (SNat (..), snatToNum, pow2SNat)
 import Clash.Signal.Internal (Clock (..), Signal (..), clockEnable)
 import Clash.Sized.Unsigned  (Unsigned)
-import Clash.XException      (errorX)
+import Clash.XException      (errorX, maybeX)
 
 -- | Create a RAM with space for 2^@n@ elements
 --
@@ -122,16 +122,22 @@
               (withFrozenCallStack (errorX "asyncRam#: initial value undefined"))
     en'  = case clockEnable wclk of
              Nothing  -> en
-             Just wgt -> en .&&. wgt
+             Just wgt -> wgt .&&. en
     dout = go ramI rd' en' wr din
 
     go :: V.Vector a -> Signal wdom Int -> Signal wdom Bool
        -> Signal wdom Int -> Signal wdom a -> Signal wdom a
     go !ram (r :- rs) (e :- es) (w :- ws) (d :- ds) =
-      let ram' = upd ram e w d
+      let ram' = upd ram e (fromEnum w) d
           o    = ram V.! r
       in  o :- go ram' rs es ws ds
 
-    upd ram True  addr d = ram V.// [(addr,d)]
-    upd ram False _    _ = ram
+    upd ram we waddr d = case maybeX we of
+      Nothing -> case maybeX waddr of
+        Nothing -> V.map (const (seq waddr d)) ram
+        Just wa -> ram V.// [(wa,d)]
+      Just True -> case maybeX waddr of
+        Nothing -> V.map (const (seq waddr d)) ram
+        Just wa -> ram V.// [(wa,d)]
+      _ -> ram
 {-# NOINLINE asyncRam# #-}
diff --git a/src/Clash/Signal/Bundle.hs b/src/Clash/Signal/Bundle.hs
--- a/src/Clash/Signal/Bundle.hs
+++ b/src/Clash/Signal/Bundle.hs
@@ -11,6 +11,7 @@
 {-# LANGUAGE DefaultSignatures      #-}
 {-# LANGUAGE KindSignatures         #-}
 {-# LANGUAGE MagicHash              #-}
+{-# LANGUAGE TemplateHaskell        #-}
 {-# LANGUAGE TypeFamilies           #-}
 {-# LANGUAGE TypeFamilyDependencies #-}
 {-# LANGUAGE TypeOperators          #-}
@@ -24,19 +25,20 @@
   )
 where
 
-import Control.Applicative   (liftA2)
-import GHC.TypeLits          (KnownNat)
-import Prelude               hiding (head, map, tail)
+import Control.Applicative          (liftA2)
+import GHC.TypeLits                 (KnownNat)
+import Prelude                      hiding (head, map, tail)
 
-import Clash.NamedTypes      ((:::))
-import Clash.Signal.Internal (Domain, Signal (..))
-import Clash.Sized.BitVector (Bit, BitVector)
-import Clash.Sized.Fixed     (Fixed)
-import Clash.Sized.Index     (Index)
-import Clash.Sized.Signed    (Signed)
-import Clash.Sized.Unsigned  (Unsigned)
-import Clash.Sized.Vector    (Vec, traverse#, lazyV)
-import Clash.Sized.RTree     (RTree, lazyT)
+import Clash.NamedTypes             ((:::))
+import Clash.Signal.Bundle.Internal (deriveBundleTuples)
+import Clash.Signal.Internal        (Domain, Signal (..))
+import Clash.Sized.BitVector        (Bit, BitVector)
+import Clash.Sized.Fixed            (Fixed)
+import Clash.Sized.Index            (Index)
+import Clash.Sized.Signed           (Signed)
+import Clash.Sized.Unsigned         (Unsigned)
+import Clash.Sized.Vector           (Vec, traverse#, lazyV)
+import Clash.Sized.RTree            (RTree, lazyT)
 
 -- | Isomorphism between a 'Clash.Signal.Signal' of a product type (e.g. a tuple) and a
 -- product type of 'Clash.Signal.Signal''s.
@@ -74,7 +76,7 @@
   -- | Example:
   --
   -- @
-  -- __bundle__ :: ('Signal' domain a, 'Signal' domain b) -> 'Signal' clk (a,b)
+  -- __bundle__ :: ('Signal' domain a, 'Signal' domain b) -> 'Signal' domain (a,b)
   -- @
   --
   -- However:
@@ -131,87 +133,7 @@
   bundle   u = pure u
   unbundle _ = ()
 
-instance Bundle (a,b) where
-  type Unbundled t (a,b) = (Signal t a, Signal t b)
-  bundle       = uncurry (liftA2 (,))
-  unbundle tup = (fmap fst tup, fmap snd tup)
-
-instance Bundle (a,b,c) where
-  type Unbundled t (a,b,c) = (Signal t a, Signal t b, Signal t c)
-  bundle   (a,b,c) = (,,) <$> a <*> b <*> c
-  unbundle tup     = (fmap (\(x,_,_) -> x) tup
-                     ,fmap (\(_,x,_) -> x) tup
-                     ,fmap (\(_,_,x) -> x) tup
-                     )
-
-instance Bundle (a,b,c,d) where
-  type Unbundled t (a,b,c,d) = ( Signal t a, Signal t b, Signal t c
-                               , Signal t d
-                               )
-  bundle   (a,b,c,d) = (,,,) <$> a <*> b <*> c <*> d
-  unbundle tup       = (fmap (\(x,_,_,_) -> x) tup
-                       ,fmap (\(_,x,_,_) -> x) tup
-                       ,fmap (\(_,_,x,_) -> x) tup
-                       ,fmap (\(_,_,_,x) -> x) tup
-                       )
-
-instance Bundle (a,b,c,d,e) where
-  type Unbundled t (a,b,c,d,e) = ( Signal t a, Signal t b, Signal t c
-                                 , Signal t d, Signal t e
-                                 )
-  bundle   (a,b,c,d,e) = (,,,,) <$> a <*> b <*> c <*> d <*> e
-  unbundle tup         = (fmap (\(x,_,_,_,_) -> x) tup
-                         ,fmap (\(_,x,_,_,_) -> x) tup
-                         ,fmap (\(_,_,x,_,_) -> x) tup
-                         ,fmap (\(_,_,_,x,_) -> x) tup
-                         ,fmap (\(_,_,_,_,x) -> x) tup
-                         )
-
-instance Bundle (a,b,c,d,e,f) where
-  type Unbundled t (a,b,c,d,e,f) = ( Signal t a, Signal t b, Signal t c
-                                   , Signal t d, Signal t e, Signal t f
-                                   )
-  bundle   (a,b,c,d,e,f) = (,,,,,) <$> a <*> b <*> c <*> d <*> e <*> f
-  unbundle tup           = (fmap (\(x,_,_,_,_,_) -> x) tup
-                           ,fmap (\(_,x,_,_,_,_) -> x) tup
-                           ,fmap (\(_,_,x,_,_,_) -> x) tup
-                           ,fmap (\(_,_,_,x,_,_) -> x) tup
-                           ,fmap (\(_,_,_,_,x,_) -> x) tup
-                           ,fmap (\(_,_,_,_,_,x) -> x) tup
-                           )
-
-instance Bundle (a,b,c,d,e,f,g) where
-  type Unbundled t (a,b,c,d,e,f,g) = ( Signal t a, Signal t b, Signal t c
-                                     , Signal t d, Signal t e, Signal t f
-                                     , Signal t g
-                                     )
-  bundle   (a,b,c,d,e,f,g) = (,,,,,,) <$> a <*> b <*> c <*> d <*> e <*> f
-                                      <*> g
-  unbundle tup             = (fmap (\(x,_,_,_,_,_,_) -> x) tup
-                             ,fmap (\(_,x,_,_,_,_,_) -> x) tup
-                             ,fmap (\(_,_,x,_,_,_,_) -> x) tup
-                             ,fmap (\(_,_,_,x,_,_,_) -> x) tup
-                             ,fmap (\(_,_,_,_,x,_,_) -> x) tup
-                             ,fmap (\(_,_,_,_,_,x,_) -> x) tup
-                             ,fmap (\(_,_,_,_,_,_,x) -> x) tup
-                             )
-
-instance Bundle (a,b,c,d,e,f,g,h) where
-  type Unbundled t (a,b,c,d,e,f,g,h) = ( Signal t a, Signal t b, Signal t c
-                                       , Signal t d, Signal t e, Signal t f
-                                       , Signal t g, Signal t h
-                                       )
-  bundle   (a,b,c,d,e,f,g,h) = (,,,,,,,) <$> a <*> b <*> c <*> d <*> e <*> f
-                                         <*> g <*> h
-  unbundle tup               = (fmap (\(x,_,_,_,_,_,_,_) -> x) tup
-                               ,fmap (\(_,x,_,_,_,_,_,_) -> x) tup
-                               ,fmap (\(_,_,x,_,_,_,_,_) -> x) tup
-                               ,fmap (\(_,_,_,x,_,_,_,_) -> x) tup
-                               ,fmap (\(_,_,_,_,x,_,_,_) -> x) tup
-                               ,fmap (\(_,_,_,_,_,x,_,_) -> x) tup
-                               ,fmap (\(_,_,_,_,_,_,x,_) -> x) tup
-                               ,fmap (\(_,_,_,_,_,_,_,x) -> x) tup
-                               )
+deriveBundleTuples ''Bundle ''Unbundled 'bundle 'unbundle
 
 instance KnownNat n => Bundle (Vec n a) where
   type Unbundled t (Vec n a) = Vec n (Signal t a)
diff --git a/src/Clash/Signal/Bundle/Internal.hs b/src/Clash/Signal/Bundle/Internal.hs
new file mode 100644
--- /dev/null
+++ b/src/Clash/Signal/Bundle/Internal.hs
@@ -0,0 +1,81 @@
+{-# LANGUAGE TemplateHaskell #-}
+
+module Clash.Signal.Bundle.Internal where
+
+import           Clash.Signal.Internal (Signal)
+import           Control.Monad         (replicateM)
+import           Data.List             (foldl')
+import           Language.Haskell.TH
+
+-- | Contruct all the tuple instances for Bundle.
+deriveBundleTuples
+  :: Name
+  -- ^ Bundle
+  -> Name
+  -- ^ Unbundled
+  -> Name
+  -- ^ bundle
+  -> Name
+  -- ^ unbundle
+  -> DecsQ
+deriveBundleTuples bundleTyName unbundledTyName bundleName unbundleName = do
+  let bundleTy = ConT bundleTyName
+      signal   = ConT ''Signal
+
+  allNames <- replicateM 62 (newName "a")
+  tempNames <- replicateM 62 (newName "b")
+  t <- newName "t"
+  x <- newName "x"
+  tup <- newName "tup"
+
+  pure $ flip map [2..62] $ \tupleNum ->
+    let names = take tupleNum allNames
+        temps = take tupleNum tempNames
+        vars  = fmap VarT names
+        tuple = foldl' AppT (TupleT tupleNum)
+
+        -- Instance declaration
+        instTy = AppT bundleTy $ tuple vars
+
+        -- Associated type Unbundled
+        unbundledTypeEq =
+          TySynEqn
+            [ VarT t, tuple vars ]
+            $ tuple $ map (AppT (signal `AppT` VarT t)) vars
+        unbundledType = TySynInstD unbundledTyName unbundledTypeEq
+
+        bundleLambda = LamE (map VarP temps) (TupE $ map VarE temps)
+        applicatives = VarE '(<$>) : repeat (VarE '(<*>))
+        bundle =
+          FunD
+            bundleName
+            [ Clause
+                [ TupP $ map VarP names ]
+                ( NormalB
+                $ foldl'
+                    (\f (a, b) -> a `AppE` f `AppE` b)
+                    bundleLambda
+                    (zip applicatives $ map VarE names)
+                )
+                []
+            ]
+
+        unbundleLambda n =
+          LamE
+            [ TupP [ if i == n then VarP x else WildP | i <- [0..tupleNum-1] ] ]
+            (VarE x)
+
+        unbundle =
+          FunD
+            unbundleName
+            [ Clause
+                [ VarP tup ]
+                ( NormalB . TupE $
+                    map 
+                      (\n -> VarE 'fmap `AppE` unbundleLambda n `AppE` VarE tup)
+                      [0..tupleNum-1]
+                )
+                []
+            ]
+
+    in InstanceD Nothing [] instTy [unbundledType, bundle, unbundle]
diff --git a/src/Clash/Signal/Internal.hs b/src/Clash/Signal/Internal.hs
--- a/src/Clash/Signal/Internal.hs
+++ b/src/Clash/Signal/Internal.hs
@@ -586,7 +586,7 @@
 register# Clock {} (Async rst) i =
     go (withFrozenCallStack (errorX "register: initial value undefined")) rst
   where
-    go o ~(r :- rs) as@(~(x :- xs)) =
+    go o (r :- rs) as@(~(x :- xs)) =
       let o' = if r then i else o
           -- [Note: register strictness annotations]
       in  o' `seqX` o' :- (as `seq` go x rs xs)
@@ -594,20 +594,20 @@
 register# (GatedClock _ _ ena) (Sync rst)  i =
     go (withFrozenCallStack (errorX "register: initial value undefined")) rst ena
   where
-    go o rt@(~(r :- rs)) ~(e :- es) as@(~(x :- xs)) =
-      let o' = if r then i else x
+    go o rt@(~(r :- rs)) enas@(~(e :- es)) as@(~(x :- xs)) =
+      let oE = if e then x else o
+          oR = if r then i else oE
           -- [Note: register strictness annotations]
-      in  o `seqX` o :- (rt `seq` as `seq` if e then go o' rs es xs
-                                                else go o  rs es xs)
+      in  o `seqX` o :- (rt `seq` enas `seq` as `seq` go oR rs es xs)
 
 register# (GatedClock _ _ ena) (Async rst) i =
     go (withFrozenCallStack (errorX "register: initial value undefined")) rst ena
   where
-    go o ~(r :- rs) ~(e :- es) as@(~(x :- xs)) =
-      let o' = if r then i else o
+    go o (r :- rs) enas@(~(e :- es)) as@(~(x :- xs)) =
+      let oR = if r then i else o
+          oE = if e then x else oR
           -- [Note: register strictness annotations]
-      in  o' `seqX` o' :- (as `seq` if e then go x  rs es xs
-                                         else go o' rs es xs)
+      in  oR `seqX` oR :- (as `seq` enas `seq` go oE rs es xs)
 {-# NOINLINE register# #-}
 
 {-# INLINE mux #-}
diff --git a/src/Clash/Sized/RTree.hs b/src/Clash/Sized/RTree.hs
--- a/src/Clash/Sized/RTree.hs
+++ b/src/Clash/Sized/RTree.hs
@@ -276,7 +276,7 @@
 --
 -- In order to accommodate the type of our 'Clash.Class.Num.plus', where the
 -- result is larger than the arguments, we must use a dependently typed fold in
--- the the form of 'dtfold':
+-- the form of 'dtfold':
 --
 -- @
 -- {\-\# LANGUAGE UndecidableInstances \#-\}
diff --git a/src/Clash/Sized/Vector.hs b/src/Clash/Sized/Vector.hs
--- a/src/Clash/Sized/Vector.hs
+++ b/src/Clash/Sized/Vector.hs
@@ -1792,7 +1792,7 @@
 --
 -- In order to accommodate the type of our 'Clash.Class.Num.plus', where the
 -- result is larger than the arguments, we must use a dependently typed fold in
--- the the form of 'dtfold':
+-- the form of 'dtfold':
 --
 -- @
 -- {\-\# LANGUAGE UndecidableInstances \#-\}
diff --git a/src/Clash/Tutorial.hs b/src/Clash/Tutorial.hs
--- a/src/Clash/Tutorial.hs
+++ b/src/Clash/Tutorial.hs
@@ -607,7 +607,7 @@
 after which warnings are being reported. The reason is that 'stimuliGenerator'
 will keep on producing the last sample, (4,4), while the 'outputVerifier' will
 keep on expecting the last sample, 14. In the VHDL testbench these errors won't
-show, as the the global clock will be stopped after 4 ticks.
+show, as the global clock will be stopped after 4 ticks.
 
 You should now again run @:vhdl@ in the interpreter; this time the compiler
 will take a bit longer to generate all the circuits. Inside the @.\/vhdl\/MAC@
@@ -801,7 +801,7 @@
 
 Instances of this 'Bundle' type-class are defined as /isomorphisms/ for:
 
-  * All tuples until and including 8-tuples
+  * All tuples up to and including 62-tuples (GHC limit)
   * The 'Vec'tor type
 
 But they are defined as /identities/ for:
@@ -1235,13 +1235,13 @@
 * @~SIGDO[\<HOLE\>]@: Create a signal declaration, using @\<HOLE\>@ as the name
   of the signal, and the type of the result.
 * @~TYPELEM[\<HOLE\>]@: The element type of the vector type represented by @\<HOLE\>@.
-  The content of @\<HOLE\>@ must either be: @TYPM[N]@, @TYPO@, or @TYPELEM[\<HOLE\>]@.
+  The content of @\<HOLE\>@ must either be: @TYP[N]@, @TYPO@, or @TYPELEM[\<HOLE\>]@.
 * @~COMPNAME@: The name of the component in which the primitive is instantiated.
 * @~LENGTH[\<HOLE\>]@: The vector length of the type represented by @\<HOLE\>@.
 * @~DEPTH[\<HOLE\>]@: The tree depth of the type represented by @\<HOLE\>@.
-  The content of @\<HOLE\>@ must either be: @TYPM[N]@, @TYPO@, or @TYPELEM[\<HOLE\>]@.
+  The content of @\<HOLE\>@ must either be: @TYP[N]@, @TYPO@, or @TYPELEM[\<HOLE\>]@.
 * @~SIZE[\<HOLE\>]@: The number of bits needed to encode the type represented by @\<HOLE\>@.
-  The content of @\<HOLE\>@ must either be: @TYPM[N]@, @TYPO@, or @TYPELEM[\<HOLE\>]@.
+  The content of @\<HOLE\>@ must either be: @TYP[N]@, @TYPO@, or @TYPELEM[\<HOLE\>]@.
 * @~IF \<CONDITION\> ~THEN \<THEN\> ~ELSE \<ELSE\> ~FI@: renders the \<ELSE\>
   part when \<CONDITION\> evaluates to /0/, and renders the \<THEN\> in all
   other cases. Valid @\<CONDITION\>@s are @~LENGTH[\<HOLE\>]@, @~SIZE[\<HOLE\>]@,
@@ -1258,7 +1258,7 @@
   expression in @\<HOLE\>@, which has a bit vector (@std_logic_vector@) type, is
   converted to type indicated by @\<TYPE\>@. The @\<TYPE\>@ hole indicates the
   must be either @~TYP[N]@, @~TYPO@, or @~TYPELEM[\<HOLE\>]@.
-* @~INCLUDENAME@: the generated name of the included component.
+* @~INCLUDENAME[N]@: the generated name of the @N@'th included component.
 * @~FILEPATH[\<HOLE\>]@: The argument mentioned in @\<HOLE\>@ is a file which
   must be copied to the location of the generated HDL.
 * @~GENERATE@: Verilog: create a /generate/ statement, except when already in
@@ -1452,7 +1452,7 @@
       cnt = 'Clash.Explicit.Signal.register' clk rst 0 (cnt + 1)
   @
 
-  As it is not possible to convert the the individual bits to a 'Clock'.
+  As it is not possible to convert the individual bits to a 'Clock'.
 
   However! What is possible is to do the following:
 
@@ -1805,7 +1805,7 @@
 
     Product types supported by 'bundle' are:
 
-    * All tuples until and including 8-tuples
+    * All tuples up to and including 62-tuples (GHC limit)
     * The 'Vec'tor type
 
 * __Type error: Couldn't match expected type @('Signal' domain a, 'Signal' domain b)@ with__
@@ -1828,7 +1828,7 @@
 
     Product types supported by 'unbundle' are:
 
-    * All tuples until and including 8-tuples
+    * All tuples up to and including 62-tuples (GHC limit)
     * The 'Vec'tor type
 
 * __Clash.Netlist(..): Not in normal form: \<REASON\>: \<EXPR\>__: