diff --git a/CHANGELOG.md b/CHANGELOG.md
--- a/CHANGELOG.md
+++ b/CHANGELOG.md
@@ -1,5 +1,16 @@
 # Changelog for [`clash-prelude` package](http://hackage.haskell.org/package/clash-prelude)
 
+## 0.10.11 *August 3rd 2016*
+* New features:
+  * Add strict version of: `sample`, `sampleN`, `fromList`, and `simulate`
+  * Make `Signal`s `<*>` slightly stricter:
+    * Feedback loops still work with this new implementation
+    * No more space-leaks when used in combination with the strict version of `sample`, `sampleN`, and `simulate`
+  * Add `NFData` instances for the numeric types
+* Speed up arithmetic operations of `Signed`, `Unsigned` and `BitVector`
+* Fixes bugs:
+  * CLaSH compiler sees internals of numeric types in their `Lift` functions
+
 ## 0.10.10 *July 15th 2016*
 * Fixes bugs:
   * `shrink` functions for numeric types throw exceptions [#153](https://github.com/clash-lang/clash-compiler/issues/153)
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.10.10
+Version:              0.10.11
 Synopsis:             CAES Language for Synchronous Hardware - Prelude library
 Description:
   CλaSH (pronounced ‘clash’) is a functional hardware description language that
@@ -156,6 +156,7 @@
                       base                      >= 4.8.0.0 && < 5,
                       data-default              >= 0.5.3   && < 0.8,
                       integer-gmp               >= 0.5.1.0 && < 1.1,
+                      deepseq                   >= 1.4.1.0 && < 1.5,
                       ghc-prim                  >= 0.3.1.0 && < 0.6,
                       ghc-typelits-extra        >= 0.1     && < 0.2,
                       ghc-typelits-natnormalise >= 0.4.1   && < 0.5,
diff --git a/src/CLaSH/Signal.hs b/src/CLaSH/Signal.hs
--- a/src/CLaSH/Signal.hs
+++ b/src/CLaSH/Signal.hs
@@ -8,7 +8,7 @@
 
 {-# LANGUAGE Trustworthy #-}
 
-{-# OPTIONS_GHC -fno-warn-unused-imports #-}
+{-# OPTIONS_GHC -fno-warn-unused-imports -fno-warn-deprecations #-}
 {-# OPTIONS_HADDOCK show-extensions #-}
 
 module CLaSH.Signal
@@ -29,10 +29,17 @@
     -- * Simulation functions (not synthesisable)
   , simulate
   , simulateB
+    -- * Strict versions
+  , simulate_strict
+  , simulateB_strict
     -- * List \<-\> Signal conversion (not synthesisable)
   , sample
   , sampleN
   , fromList
+    -- ** Strict versions
+  , sample_strict
+  , sampleN_strict
+  , fromList_strict
     -- * QuickCheck combinators
   , testFor
     -- * Type classes
@@ -62,6 +69,7 @@
   )
 where
 
+import Control.DeepSeq       (NFData)
 import Data.Bits             (Bits) -- Haddock only
 
 import CLaSH.Signal.Internal (Signal', register#, regEn#, (.==.), (./=.),
@@ -70,8 +78,11 @@
                               shift1, rotate1, setBit1, clearBit1, shiftL1,
                               unsafeShiftL1, shiftR1, unsafeShiftR1, rotateL1,
                               rotateR1, (.||.), (.&&.), not1, mux, sample,
-                              sampleN, fromList, simulate, signal, testFor)
-import CLaSH.Signal.Explicit (SystemClock, systemClock, simulateB')
+                              sampleN, fromList, simulate, signal, testFor,
+                              sample_strict, sampleN_strict, simulate_strict,
+                              fromList_strict)
+import CLaSH.Signal.Explicit (SystemClock, systemClock, simulateB',
+                              simulateB'_strict)
 import CLaSH.Signal.Bundle   (Bundle (..), Unbundled')
 
 {- $setup
@@ -159,3 +170,12 @@
 -- __NB__: This function is not synthesisable
 simulateB :: (Bundle a, Bundle b) => (Unbundled a -> Unbundled b) -> [a] -> [b]
 simulateB = simulateB' systemClock systemClock
+
+-- | Version of 'simulateB' that strictly evaluates the input elements and the
+-- output elements
+--
+-- __N.B:__ Exceptions are lazily rethrown
+simulateB_strict :: (Bundle a, Bundle b, NFData a, NFData b)
+                 => (Unbundled a -> Unbundled b) -> [a] -> [b]
+simulateB_strict = simulateB'_strict systemClock systemClock
+{-# DEPRECATED simulateB_strict "'simulateB will be strict in CLaSH 1.0, and 'simulateB_strict' will be removed" #-}
diff --git a/src/CLaSH/Signal/Explicit.hs b/src/CLaSH/Signal/Explicit.hs
--- a/src/CLaSH/Signal/Explicit.hs
+++ b/src/CLaSH/Signal/Explicit.hs
@@ -10,6 +10,7 @@
 
 {-# LANGUAGE Trustworthy #-}
 
+{-# OPTIONS_GHC -fno-warn-deprecations #-}
 {-# OPTIONS_HADDOCK show-extensions #-}
 
 module CLaSH.Signal.Explicit
@@ -34,15 +35,18 @@
   , Bundle (..)
     -- * Simulation functions (not synthesisable)
   , simulateB'
+    -- ** Strict version
+  , simulateB'_strict
   )
 where
 
+import Control.DeepSeq        (NFData)
 import GHC.TypeLits           (KnownNat, KnownSymbol)
 
 import CLaSH.Promoted.Nat     (snat, snatToInteger)
 import CLaSH.Promoted.Symbol  (ssymbol)
 import CLaSH.Signal.Internal  (Signal' (..), Clock (..), SClock (..), register#,
-                               regEn#, simulate)
+                               regEn#, simulate, simulate_strict)
 import CLaSH.Signal.Bundle    (Bundle (..), Unbundled')
 
 {- $setup
@@ -341,3 +345,15 @@
            -> (Unbundled' clk1 a -> Unbundled' clk2 b) -- ^ Function to simulate
            -> [a] -> [b]
 simulateB' clk1 clk2 f = simulate (bundle' clk2 . f . unbundle' clk1)
+
+-- | Version of 'simulateB'' that strictly evaluates the input elements and the
+-- output elements
+--
+-- __N.B:__ Exceptions are lazily rethrown
+simulateB'_strict :: (Bundle a, Bundle b, NFData a, NFData b)
+                  => SClock clk1 -- ^ 'Clock' of the incoming signal
+                  -> SClock clk2 -- ^ 'Clock' of the outgoing signal
+                  -> (Unbundled' clk1 a -> Unbundled' clk2 b) -- ^ Function to simulate
+                  -> [a] -> [b]
+simulateB'_strict clk1 clk2 f = simulate_strict (bundle' clk2 . f . unbundle' clk1)
+{-# DEPRECATED simulateB'_strict "'simulateB'' will be strict in CLaSH 1.0, and 'simulateB'_strict' will be removed" #-}
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
@@ -39,10 +39,16 @@
   , (.&&.), (.||.), not1
     -- * Simulation functions (not synthesisable)
   , simulate
+    -- ** strict versions
+  , simulate_strict
     -- * List \<-\> Signal conversion (not synthesisable)
   , sample
   , sampleN
   , fromList
+    -- ** strict versions
+  , sample_strict
+  , sampleN_strict
+  , fromList_strict
     -- * QuickCheck combinators
   , testFor
     -- * Type classes
@@ -84,10 +90,13 @@
 where
 
 import Control.Applicative        (liftA2, liftA3)
+import Control.DeepSeq            (NFData,force)
+import Control.Exception          (SomeException,catch,evaluate,throw)
 import Data.Bits                  (Bits (..), FiniteBits (..))
 import Data.Default               (Default (..))
 import GHC.TypeLits               (Nat, Symbol)
 import Language.Haskell.TH.Syntax (Lift (..))
+import System.IO.Unsafe           (unsafeDupablePerformIO)
 import Test.QuickCheck            (Arbitrary (..), CoArbitrary(..), Property,
                                    property)
 
@@ -149,8 +158,30 @@
 
 {-# NOINLINE appSignal# #-}
 appSignal# :: Signal' clk (a -> b) -> Signal' clk a -> Signal' clk b
-appSignal# (f :- fs) ~(a :- as) = f a :- appSignal# fs as
+appSignal# (f :- fs) xs@(~(a :- as)) = f a :- (xs `seq` appSignal# fs as) -- See [NOTE: Lazy ap]
 
+{- NOTE: Lazy ap
+Signal's ap, i.e (Applicative.<*>), must be lazy in it's second argument:
+
+> appSignal :: Signal' clk (a -> b) -> Signal' clk a -> Signal' clk b
+> appSignal (f :- fs) ~(a :- as) = f a :- appSignal fs as
+
+because some feedback loops, such as the loop described in 'system' in the
+example at http://hackage.haskell.org/package/clash-prelude-0.10.10/docs/CLaSH-Prelude-BlockRam.html,
+will lead to "Exception <<loop>>".
+
+However, this "naive" lazy version is _too_ lazy and induces spaceleaks.
+The current version:
+
+> appSignal# :: Signal' clk (a -> b) -> Signal' clk a -> Signal' clk b
+> appSignal# (f :- fs) xs@(~(a :- as)) = f a :- (xs `seq` appSignal# fs as)
+
+Is lazy enough to handle the earlier mentioned feedback loops, but doesn't leak
+(as much) memory like the "naive" lazy version, because the Signal constructor
+of the second argument is evaluated as soon as the tail of the result is evaluated.
+-}
+
+
 {-# NOINLINE joinSignal# #-}
 -- | __WARNING: EXTREMELY EXPERIMENTAL__
 --
@@ -663,3 +694,43 @@
 -- __NB__: This function is not synthesisable
 simulate :: (Signal' clk1 a -> Signal' clk2 b) -> [a] -> [b]
 simulate f = sample . f . fromList
+
+-- | A 'force' that lazily returns exceptions
+forceNoException :: NFData a => a -> IO a
+forceNoException x = catch (evaluate (force x)) (\(e :: SomeException) -> return (throw e))
+
+headStrictCons :: NFData a => a -> [a] -> [a]
+headStrictCons x xs = unsafeDupablePerformIO ((:) <$> forceNoException x <*> pure xs)
+
+headStrictSignal :: NFData a => a -> Signal' clk a -> Signal' clk a
+headStrictSignal x xs = unsafeDupablePerformIO ((:-) <$> forceNoException x <*> pure xs)
+
+-- | Version of 'sample' that strictly evaluates the samples
+--
+-- __N.B:__ Exceptions are lazily rethrown
+sample_strict :: (Foldable f, NFData a) => f a -> [a]
+sample_strict = foldr headStrictCons []
+{-# DEPRECATED sample_strict "'sample' will be strict in CLaSH 1.0, and 'sample_strict' will be removed" #-}
+
+-- | Version of 'sampleN' that strictly evaluates the samples
+--
+-- __N.B:__ Exceptions are lazily rethrown
+sampleN_strict :: (Foldable f, NFData a) => Int -> f a -> [a]
+sampleN_strict n = take n . sample_strict
+{-# DEPRECATED sampleN_strict "'sampleN' will be strict in CLaSH 1.0, and 'sampleN_strict' will be removed" #-}
+
+-- | Version of 'fromList' that strictly evaluates the elements of the list
+--
+-- __N.B:__ Exceptions are lazily rethrown
+fromList_strict :: NFData a => [a] -> Signal' clk a
+fromList_strict = foldr headStrictSignal (error "finite list")
+{-# DEPRECATED fromList_strict "'fromList' will be strict in CLaSH 1.0, and 'fromList_strict' will be removed" #-}
+
+-- | Version of 'simulate' that strictly evaluates the input elements and the
+-- output elements
+--
+-- __N.B:__ Exceptions are lazily rethrown
+simulate_strict :: (NFData a, NFData b)
+                => (Signal' clk1 a -> Signal' clk2 b) -> [a] -> [b]
+simulate_strict f = sample_strict . f . fromList_strict
+{-# DEPRECATED simulate_strict "'simulate' will be strict in CLaSH 1.0, and 'simulate_strict' will be removed" #-}
diff --git a/src/CLaSH/Sized/Fixed.hs b/src/CLaSH/Sized/Fixed.hs
--- a/src/CLaSH/Sized/Fixed.hs
+++ b/src/CLaSH/Sized/Fixed.hs
@@ -67,6 +67,7 @@
   )
 where
 
+import Control.DeepSeq            (NFData)
 import Control.Arrow              ((***), second)
 import Data.Bits                  (Bits (..), FiniteBits)
 import Data.Data                  (Data)
@@ -115,6 +116,7 @@
 newtype Fixed (rep :: Nat -> *) (int :: Nat) (frac :: Nat) =
   Fixed { unFixed :: rep (int + frac) }
 
+deriving instance NFData (rep (int + frac)) => NFData (Fixed rep int frac)
 deriving instance (Typeable rep, Typeable int, Typeable frac
                   , Data (rep (int + frac))) => Data (Fixed rep int frac)
 deriving instance Eq (rep (int + frac))      => Eq (Fixed rep int frac)
diff --git a/src/CLaSH/Sized/Internal/BitVector.hs b/src/CLaSH/Sized/Internal/BitVector.hs
--- a/src/CLaSH/Sized/Internal/BitVector.hs
+++ b/src/CLaSH/Sized/Internal/BitVector.hs
@@ -10,6 +10,7 @@
 {-# LANGUAGE KindSignatures        #-}
 {-# LANGUAGE MagicHash             #-}
 {-# LANGUAGE MultiParamTypeClasses #-}
+{-# LANGUAGE ScopedTypeVariables   #-}
 {-# LANGUAGE TemplateHaskell       #-}
 {-# LANGUAGE TypeFamilies          #-}
 {-# LANGUAGE TypeOperators         #-}
@@ -94,12 +95,14 @@
   )
 where
 
+import Control.DeepSeq            (NFData (..))
 import Control.Lens               (Index, Ixed (..), IxValue)
 import Data.Bits                  (Bits (..), FiniteBits (..))
 import Data.Char                  (digitToInt)
 import Data.Data                  (Data)
 import Data.Default               (Default (..))
 import Data.Maybe                 (listToMaybe)
+import Data.Proxy                 (Proxy (..))
 import GHC.Integer                (smallInteger)
 import GHC.Prim                   (dataToTag#)
 import GHC.TypeLits               (KnownNat, Nat, type (+), type (-), natVal)
@@ -140,8 +143,14 @@
 type Bit = BitVector 1
 
 -- * Instances
+instance NFData (BitVector n) where
+  rnf (BV i) = rnf i `seq` ()
+  {-# NOINLINE rnf #-}
+  -- NOINLINE is needed so that CLaSH doesn't trip on the "BitVector ~# Integer"
+  -- coercion
+
 instance KnownNat n => Show (BitVector n) where
-  show bv = reverse . underScore . reverse $ showBV (natVal bv) (toInteger# bv) []
+  show bv@(BV i) = reverse . underScore . reverse $ showBV (natVal bv) i []
     where
       showBV 0 _ s = s
       showBV n v s = let (a,b) = divMod v 2
@@ -152,6 +161,7 @@
       underScore xs = case splitAt 5 xs of
                         ([a,b,c,d,e],rest) -> [a,b,c,d,'_'] ++ underScore (e:rest)
                         (rest,_)               -> rest
+  {-# NOINLINE show #-}
 
 -- | Create a binary literal
 --
@@ -269,7 +279,7 @@
 
 {-# NOINLINE negate# #-}
 negate# :: KnownNat n => BitVector n -> BitVector n
-negate# bv@(BV i) = BV (sz - i)
+negate# bv@(BV i) = sz `seq` BV (sz - i)
   where
     sz = 2 ^ natVal bv
 
@@ -278,8 +288,10 @@
 fromInteger# = fromInteger_INLINE
 
 {-# INLINE fromInteger_INLINE #-}
-fromInteger_INLINE :: KnownNat n => Integer -> BitVector n
-fromInteger_INLINE i = let res = BV (i `mod` (2 ^ natVal res)) in res
+fromInteger_INLINE :: forall n . KnownNat n => Integer -> BitVector n
+fromInteger_INLINE i = sz `seq` BV (i `mod` (shiftL 1 sz))
+  where
+    sz = fromInteger (natVal (Proxy :: Proxy n))
 
 instance (KnownNat (Max m n + 1), KnownNat (m + n)) =>
   ExtendingNum (BitVector m) (BitVector n) where
@@ -541,6 +553,7 @@
 
 instance KnownNat n => Lift (BitVector n) where
   lift bv@(BV i) = sigE [| fromInteger# i |] (decBitVector (natVal bv))
+  {-# NOINLINE lift #-}
 
 decBitVector :: Integer -> TypeQ
 decBitVector n = appT (conT ''BitVector) (litT $ numTyLit n)
diff --git a/src/CLaSH/Sized/Internal/Index.hs b/src/CLaSH/Sized/Internal/Index.hs
--- a/src/CLaSH/Sized/Internal/Index.hs
+++ b/src/CLaSH/Sized/Internal/Index.hs
@@ -8,6 +8,7 @@
 {-# LANGUAGE DeriveDataTypeable    #-}
 {-# LANGUAGE KindSignatures        #-}
 {-# LANGUAGE MagicHash             #-}
+{-# LANGUAGE ScopedTypeVariables   #-}
 {-# LANGUAGE MultiParamTypeClasses #-}
 {-# LANGUAGE TemplateHaskell       #-}
 {-# LANGUAGE TypeFamilies          #-}
@@ -58,8 +59,10 @@
   )
 where
 
+import Control.DeepSeq            (NFData (..))
 import Data.Data                  (Data)
 import Data.Default               (Default (..))
+import Data.Proxy                 (Proxy (..))
 import Text.Read                  (Read (..), ReadPrec)
 import Language.Haskell.TH        (TypeQ, appT, conT, litT, numTyLit, sigE)
 import Language.Haskell.TH.Syntax (Lift(..))
@@ -101,6 +104,12 @@
     I { unsafeToInteger :: Integer }
   deriving Data
 
+instance NFData (Index n) where
+  rnf (I i) = rnf i `seq` ()
+  {-# NOINLINE rnf #-}
+  -- NOINLINE is needed so that CLaSH doesn't trip on the "Index ~# Integer"
+  -- coercion
+
 instance KnownNat n => BitPack (Index n) where
   type BitSize (Index n) = CLog 2 n
   pack   = pack#
@@ -195,17 +204,17 @@
 {-# NOINLINE (*#) #-}
 (*#) (I a) (I b) = fromInteger_INLINE $ a * b
 
-fromInteger#,fromInteger_INLINE :: KnownNat n => Integer -> Index n
+fromInteger# :: KnownNat n => Integer -> Index n
 {-# NOINLINE fromInteger# #-}
 fromInteger# = fromInteger_INLINE
 {-# INLINE fromInteger_INLINE #-}
-fromInteger_INLINE i =
-  let bound = natVal res
-      i'    = i `mod` bound
-      err   = error ("CLaSH.Sized.Index: result " ++ show i ++
-                     " is out of bounds: [0.." ++ show (bound - 1) ++ "]")
-      res   = if i' /= i then err else I i
-  in  res
+fromInteger_INLINE :: forall n . KnownNat n => Integer -> Index n
+fromInteger_INLINE i = bound `seq` if i' == i then I i else err
+  where
+    bound = natVal (Proxy :: Proxy n)
+    i'    = i `mod` bound
+    err   = error ("CLaSH.Sized.Index: result " ++ show i ++
+                   " is out of bounds: [0.." ++ show (bound - 1) ++ "]")
 
 instance ExtendingNum (Index m) (Index n) where
   type AResult (Index m) (Index n) = Index (m + n - 1)
@@ -264,19 +273,14 @@
 
 instance KnownNat n => Lift (Index n) where
   lift u@(I i) = sigE [| fromInteger# i |] (decIndex (natVal u))
+  {-# NOINLINE lift #-}
 
 decIndex :: Integer -> TypeQ
 decIndex n = appT (conT ''Index) (litT $ numTyLit n)
 
 instance Show (Index n) where
-  showsPrec p ix = showsPrec p (toInteger# ix)
-  show ix = show (toInteger# ix)
-  -- We cannot say:
-  --
-  -- > show (I i) = show i
-  --
-  -- Because GHC translates that to a cast from Index to Integer,
-  -- which the CLaSH compiler can (currently) not handle.
+  show (I i) = show i
+  {-# NOINLINE show #-}
 
 -- | None of the 'Read' class' methods are synthesisable.
 instance KnownNat n => Read (Index n) where
diff --git a/src/CLaSH/Sized/Internal/Signed.hs b/src/CLaSH/Sized/Internal/Signed.hs
--- a/src/CLaSH/Sized/Internal/Signed.hs
+++ b/src/CLaSH/Sized/Internal/Signed.hs
@@ -10,6 +10,7 @@
 {-# LANGUAGE KindSignatures        #-}
 {-# LANGUAGE MagicHash             #-}
 {-# LANGUAGE MultiParamTypeClasses #-}
+{-# LANGUAGE ScopedTypeVariables   #-}
 {-# LANGUAGE TemplateHaskell       #-}
 {-# LANGUAGE TypeFamilies          #-}
 {-# LANGUAGE TypeOperators         #-}
@@ -79,10 +80,12 @@
   )
 where
 
+import Control.DeepSeq                (NFData (..))
 import Control.Lens                   (Index, Ixed (..), IxValue)
 import Data.Bits                      (Bits (..), FiniteBits (..))
 import Data.Data                      (Data)
 import Data.Default                   (Default (..))
+import Data.Proxy                     (Proxy (..))
 import Text.Read                      (Read (..), ReadPrec)
 import GHC.TypeLits                   (KnownNat, Nat, type (+), natVal)
 import Language.Haskell.TH            (TypeQ, appT, conT, litT, numTyLit, sigE)
@@ -146,15 +149,15 @@
 size# :: KnownNat n => Signed n -> Int
 size# bv = fromInteger (natVal bv)
 
+instance NFData (Signed n) where
+  rnf (S i) = rnf i `seq` ()
+  {-# NOINLINE rnf #-}
+  -- NOINLINE is needed so that CLaSH doesn't trip on the "Signed ~# Integer"
+  -- coercion
+
 instance Show (Signed n) where
-  showsPrec p s = showsPrec p (toInteger# s)
-  show s = show (toInteger# s)
-  -- We cannot say:
-  --
-  -- > show (S i) = show i
-  --
-  -- Because GHC translates that to a cast from Signed to Integer,
-  -- which the CLaSH compiler can (currently) not handle.
+  show (S i) = show i
+  {-# NOINLINE show #-}
 
 -- | None of the 'Read' class' methods are synthesisable.
 instance KnownNat n => Read (Signed n) where
@@ -272,16 +275,14 @@
 fromInteger# = fromInteger_INLINE
 
 {-# INLINE fromInteger_INLINE #-}
-fromInteger_INLINE :: KnownNat n => Integer -> Signed n
-fromInteger_INLINE i
-    | n == 0    = S 0
-    | otherwise = res
+fromInteger_INLINE :: forall n . KnownNat n => Integer -> Signed n
+fromInteger_INLINE i = sz `seq` if sz == 0 then S 0 else S res
   where
-    n   = natVal res
-    sz  = 2 ^ (n - 1)
-    res = case divMod i sz of
-            (s,i') | even s    -> S i'
-                   | otherwise -> S (i' - sz)
+    sz   = natVal (Proxy :: Proxy n)
+    mask = shiftL 1 (fromInteger sz - 1)
+    res  = case divMod i mask of
+             (s,i') | even s    -> i'
+                    | otherwise -> i' - mask
 
 instance (KnownNat (1 + Max m n), KnownNat (m + n)) =>
   ExtendingNum (Signed m) (Signed n) where
@@ -430,6 +431,7 @@
 
 instance KnownNat n => Lift (Signed n) where
   lift s@(S i) = sigE [| fromInteger# i |] (decSigned (natVal s))
+  {-# NOINLINE lift #-}
 
 decSigned :: Integer -> TypeQ
 decSigned n = appT (conT ''Signed) (litT $ numTyLit n)
diff --git a/src/CLaSH/Sized/Internal/Unsigned.hs b/src/CLaSH/Sized/Internal/Unsigned.hs
--- a/src/CLaSH/Sized/Internal/Unsigned.hs
+++ b/src/CLaSH/Sized/Internal/Unsigned.hs
@@ -9,6 +9,7 @@
 {-# LANGUAGE FlexibleContexts           #-}
 {-# LANGUAGE MagicHash                  #-}
 {-# LANGUAGE MultiParamTypeClasses      #-}
+{-# LANGUAGE ScopedTypeVariables        #-}
 {-# LANGUAGE TemplateHaskell            #-}
 {-# LANGUAGE TypeFamilies               #-}
 {-# LANGUAGE TypeOperators              #-}
@@ -72,10 +73,12 @@
   )
 where
 
+import Control.DeepSeq                (NFData (..))
 import Control.Lens                   (Index, Ixed (..), IxValue)
 import Data.Bits                      (Bits (..), FiniteBits (..))
 import Data.Data                      (Data)
 import Data.Default                   (Default (..))
+import Data.Proxy                     (Proxy (..))
 import Text.Read                      (Read (..), ReadPrec)
 import GHC.TypeLits                   (KnownNat, Nat, type (+), natVal)
 import Language.Haskell.TH            (TypeQ, appT, conT, litT, numTyLit, sigE)
@@ -135,15 +138,15 @@
 size# :: KnownNat n => Unsigned n -> Int
 size# u = fromInteger (natVal u)
 
+instance NFData (Unsigned n) where
+  rnf (U i) = rnf i `seq` ()
+  {-# NOINLINE rnf #-}
+  -- NOINLINE is needed so that CLaSH doesn't trip on the "Unsigned ~# Integer"
+  -- coercion
+
 instance Show (Unsigned n) where
-  showsPrec p u = showsPrec p (toInteger# u)
-  show u = show (toInteger# u)
-  -- We cannot say:
-  --
-  -- > show (U i) = show i
-  --
-  -- Because GHC translates that to a cast from Unsigned to Integer,
-  -- which the CLaSH compiler can (currently) not handle
+  show (U i) = show i
+  {-# NOINLINE show #-}
 
 -- | None of the 'Read' class' methods are synthesisable.
 instance KnownNat n => Read (Unsigned n) where
@@ -249,7 +252,7 @@
 
 {-# NOINLINE negate# #-}
 negate# :: KnownNat n => Unsigned n -> Unsigned n
-negate# u@(U i) = U (sz - i)
+negate# u@(U i) = sz `seq` U (sz - i)
   where
     sz = 2 ^ natVal u
 
@@ -258,8 +261,10 @@
 fromInteger# = fromInteger_INLINE
 
 {-# INLINE fromInteger_INLINE #-}
-fromInteger_INLINE :: KnownNat n => Integer -> Unsigned n
-fromInteger_INLINE i = let res = U (i `mod` (2 ^ natVal res)) in res
+fromInteger_INLINE :: forall n . KnownNat n => Integer -> Unsigned n
+fromInteger_INLINE i = sz `seq` U (i `mod` (shiftL 1 sz))
+  where
+    sz = fromInteger (natVal (Proxy :: Proxy n))
 
 instance (KnownNat (1 + Max m n), KnownNat (m + n)) =>
   ExtendingNum (Unsigned m) (Unsigned n) where
@@ -393,6 +398,7 @@
 
 instance KnownNat n => Lift (Unsigned n) where
   lift u@(U i) = sigE [| fromInteger# i |] (decUnsigned (natVal u))
+  {-# NOINLINE lift #-}
 
 decUnsigned :: Integer -> TypeQ
 decUnsigned n = appT (conT ''Unsigned) (litT $ numTyLit n)
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
@@ -97,6 +97,7 @@
   )
 where
 
+import Control.DeepSeq            (NFData (..))
 import qualified Control.Lens     as Lens
 import Data.Default               (Default (..))
 import qualified Data.Foldable    as F
@@ -179,6 +180,10 @@
   Nil  :: Vec 0 a
   Cons :: a -> Vec n a -> Vec (n + 1) a
 {-# WARNING Cons "Use ':>' instead of 'Cons'" #-}
+
+instance NFData a => NFData (Vec n a) where
+  rnf Nil         = ()
+  rnf (Cons x xs) = rnf x `seq` rnf xs
 
 -- | Add an element to the head of a vector.
 --