diff --git a/hw-excess.cabal b/hw-excess.cabal
--- a/hw-excess.cabal
+++ b/hw-excess.cabal
@@ -1,5 +1,5 @@
 name:                   hw-excess
-version:                0.1.0.1
+version:                0.2.0.0
 synopsis:               Excess
 description:            Please see README.md
 homepage:               http://github.com/haskell-works/hw-excess#readme
@@ -20,11 +20,13 @@
                       , HaskellWorks.Data.Excess.Excess1
                       , HaskellWorks.Data.Excess.MinMaxExcess0
                       , HaskellWorks.Data.Excess.MinMaxExcess1
+                      , HaskellWorks.Data.Excess.Triplet
   build-depends:        base                          >= 4          && < 5
                       , hw-bits                       >= 0.4.0.0
                       , hw-prim                       >= 0.4.0.0
                       , hw-rankselect-base            >= 0.2.0.0
                       , safe
+                      , storable-record
                       , vector
 
   default-language:     Haskell2010
diff --git a/src/HaskellWorks/Data/Excess/Excess0.hs b/src/HaskellWorks/Data/Excess/Excess0.hs
--- a/src/HaskellWorks/Data/Excess/Excess0.hs
+++ b/src/HaskellWorks/Data/Excess/Excess0.hs
@@ -1,14 +1,15 @@
-{-# LANGUAGE FlexibleInstances     #-}
+{-# LANGUAGE FlexibleInstances #-}
 
 module HaskellWorks.Data.Excess.Excess0
     ( Excess0(..)
     ) where
 
-import           Data.Word
+import Data.Word
+import HaskellWorks.Data.Positioning
+import HaskellWorks.Data.RankSelect.Base.Rank0
+import HaskellWorks.Data.RankSelect.Base.Rank1
+
 import qualified Data.Vector.Storable as DVS
-import           HaskellWorks.Data.Positioning
-import           HaskellWorks.Data.RankSelect.Base.Rank0
-import           HaskellWorks.Data.RankSelect.Base.Rank1
 
 class Excess0 v where
   excess0 :: v -> Count -> Int
diff --git a/src/HaskellWorks/Data/Excess/Excess1.hs b/src/HaskellWorks/Data/Excess/Excess1.hs
--- a/src/HaskellWorks/Data/Excess/Excess1.hs
+++ b/src/HaskellWorks/Data/Excess/Excess1.hs
@@ -1,14 +1,15 @@
-{-# LANGUAGE FlexibleInstances     #-}
+{-# LANGUAGE FlexibleInstances #-}
 
 module HaskellWorks.Data.Excess.Excess1
     ( Excess1(..)
     ) where
 
-import           Data.Word
+import Data.Word
+import HaskellWorks.Data.Positioning
+import HaskellWorks.Data.RankSelect.Base.Rank0
+import HaskellWorks.Data.RankSelect.Base.Rank1
+
 import qualified Data.Vector.Storable as DVS
-import           HaskellWorks.Data.Positioning
-import           HaskellWorks.Data.RankSelect.Base.Rank0
-import           HaskellWorks.Data.RankSelect.Base.Rank1
 
 class Excess1 v where
   excess1 :: v -> Count -> Int
diff --git a/src/HaskellWorks/Data/Excess/MinMaxExcess0.hs b/src/HaskellWorks/Data/Excess/MinMaxExcess0.hs
--- a/src/HaskellWorks/Data/Excess/MinMaxExcess0.hs
+++ b/src/HaskellWorks/Data/Excess/MinMaxExcess0.hs
@@ -1,4 +1,4 @@
-{-# LANGUAGE FlexibleInstances          #-}
+{-# LANGUAGE FlexibleInstances #-}
 
 module HaskellWorks.Data.Excess.MinMaxExcess0
   ( MinMaxExcess0(..)
@@ -6,111 +6,119 @@
   , MinExcess
   ) where
 
-import qualified Data.Vector.Storable                 as DVS
-import           Data.Word
-import           HaskellWorks.Data.Bits.BitWise
-import           HaskellWorks.Data.Bits.FixedBitSize
-import           HaskellWorks.Data.Naive
+import Data.Word
+import HaskellWorks.Data.Bits.BitWise
+import HaskellWorks.Data.Bits.FixedBitSize
+import HaskellWorks.Data.Excess.Triplet
+import HaskellWorks.Data.Naive
 
+import qualified Data.Vector.Storable as DVS
+
 type MinExcess = Int
 type MaxExcess = Int
-type Excess    = Int
 
 class MinMaxExcess0 a where
-  minMaxExcess0 :: a -> (MinExcess, Excess, MaxExcess)
+  minMaxExcess0 :: a -> Triplet
 
 instance MinMaxExcess0 [Bool] where
   minMaxExcess0 = go 0 0 0
-    where go minE maxE e (x:xs)                   = let ne = if x then e - 1 else e + 1 in
+    where go minE maxE allE (x:xs)                    = let ne = if x then allE - 1 else allE + 1 in
                                                         go (minE `min` ne) (maxE `max` ne) ne xs
-          go minE maxE e _                        = (minE, e, maxE)
+          go minE maxE allE _                         = Triplet minE allE maxE
   {-# INLINE minMaxExcess0 #-}
 
 instance MinMaxExcess0 (Naive Word8) where
   minMaxExcess0 = go 0 0 0 0 . naive
-    where go minE maxE e n w | n < fixedBitSize w = let ne = if w .?. fromIntegral n then e - 1 else e + 1 in
+    where go minE maxE allE n w | n < fixedBitSize w  = let ne = if w .?. fromIntegral n then allE - 1 else allE + 1 in
                                                         go (minE `min` ne) (maxE `max` ne) ne (n + 1) w
-          go minE maxE e _ _                       = (minE, e, maxE)
+          go minE maxE allE _ _                       = Triplet minE allE maxE
   {-# INLINE minMaxExcess0 #-}
 
 instance MinMaxExcess0 (Naive Word16) where
   minMaxExcess0 = go 0 0 0 0 . naive
-    where go minE maxE e n w | n < fixedBitSize w = let ne = if w .?. fromIntegral n then e - 1 else e + 1 in
+    where go minE maxE allE n w | n < fixedBitSize w  = let ne = if w .?. fromIntegral n then allE - 1 else allE + 1 in
                                                         go (minE `min` ne) (maxE `max` ne) ne (n + 1) w
-          go minE maxE e _ _                      = (minE, e, maxE)
+          go minE maxE allE _ _                       = Triplet minE allE maxE
   {-# INLINE minMaxExcess0 #-}
 
 instance MinMaxExcess0 (Naive Word32) where
   minMaxExcess0 = go 0 0 0 0 . naive
-    where go minE maxE e n w | n < fixedBitSize w = let ne = if w .?. fromIntegral n then e - 1 else e + 1 in
+    where go minE maxE allE n w | n < fixedBitSize w  = let ne = if w .?. fromIntegral n then allE - 1 else allE + 1 in
                                                         go (minE `min` ne) (maxE `max` ne) ne (n + 1) w
-          go minE maxE e _ _                      = (minE, e, maxE)
+          go minE maxE allE _ _                       = Triplet minE allE maxE
   {-# INLINE minMaxExcess0 #-}
 
 instance MinMaxExcess0 (Naive Word64) where
   minMaxExcess0 = go 0 0 0 0 . naive
-    where go minE maxE e n w | n < fixedBitSize w = let ne = if w .?. fromIntegral n then e - 1 else e + 1 in
+    where go minE maxE allE n w | n < fixedBitSize w  = let ne = if w .?. fromIntegral n then allE - 1 else allE + 1 in
                                                         go (minE `min` ne) (maxE `max` ne) ne (n + 1) w
-          go minE maxE e _ _                      = (minE, e, maxE)
+          go minE maxE allE _ _                       = Triplet minE allE maxE
   {-# INLINE minMaxExcess0 #-}
 
 instance MinMaxExcess0 Word8 where
-  minMaxExcess0 w = ( word8Excess0Min DVS.! fromIntegral w
-                    , word8Excess0    DVS.! fromIntegral w
-                    , word8Excess0Max DVS.! fromIntegral w
-                    )
+  minMaxExcess0 w = Triplet (word8Excess0Min DVS.! fromIntegral w)
+                            (word8Excess0    DVS.! fromIntegral w)
+                            (word8Excess0Max DVS.! fromIntegral w)
   {-# INLINE minMaxExcess0 #-}
 
 instance MinMaxExcess0 Word16 where
-  minMaxExcess0 w = ( minExcessA `min` (minExcessB + allExcessA)
-                    , allExcessA + allExcessB
-                    , maxExcessA `max` (maxExcessB + allExcessA))
-    where (minExcessA, allExcessA, maxExcessA) = minMaxExcess0 (fromIntegral  w        :: Word8)
-          (minExcessB, allExcessB, maxExcessB) = minMaxExcess0 (fromIntegral (w .>. 8) :: Word8)
+  minMaxExcess0 w = Triplet (minExcessA `min` (minExcessB + allExcessA))
+                            (allExcessA + allExcessB)
+                            (maxExcessA `max` (maxExcessB + allExcessA))
+    where Triplet minExcessA allExcessA maxExcessA = minMaxExcess0 (fromIntegral  w        :: Word8)
+          Triplet minExcessB allExcessB maxExcessB = minMaxExcess0 (fromIntegral (w .>. 8) :: Word8)
   {-# INLINE minMaxExcess0 #-}
 
 instance MinMaxExcess0 Word32 where
-  minMaxExcess0 w = ( minExcessA `min` (minExcessB + allExcessA)
-                    , allExcessA + allExcessB
-                    , maxExcessA `max` (maxExcessB + allExcessA))
-    where (minExcessA, allExcessA, maxExcessA) = minMaxExcess0 (fromIntegral  w         :: Word16)
-          (minExcessB, allExcessB, maxExcessB) = minMaxExcess0 (fromIntegral (w .>. 16) :: Word16)
+  minMaxExcess0 w = Triplet (minExcessA `min` (minExcessB + allExcessA))
+                            (allExcessA + allExcessB)
+                            (maxExcessA `max` (maxExcessB + allExcessA))
+    where Triplet minExcessA allExcessA maxExcessA = minMaxExcess0 (fromIntegral  w         :: Word16)
+          Triplet minExcessB allExcessB maxExcessB = minMaxExcess0 (fromIntegral (w .>. 16) :: Word16)
   {-# INLINE minMaxExcess0 #-}
 
 instance MinMaxExcess0 Word64 where
-  minMaxExcess0 w = ( minExcessA `min` (minExcessB + allExcessA)
-                    , allExcessA + allExcessB
-                    , maxExcessA `max` (maxExcessB + allExcessA))
-    where (minExcessA, allExcessA, maxExcessA) = minMaxExcess0 (fromIntegral  w         :: Word32)
-          (minExcessB, allExcessB, maxExcessB) = minMaxExcess0 (fromIntegral (w .>. 32) :: Word32)
+  minMaxExcess0 w = Triplet (minExcessA `min` (minExcessB + allExcessA))
+                            (allExcessA + allExcessB)
+                            (maxExcessA `max` (maxExcessB + allExcessA))
+    where Triplet minExcessA allExcessA maxExcessA = minMaxExcess0 (fromIntegral  w         :: Word32)
+          Triplet minExcessB allExcessB maxExcessB = minMaxExcess0 (fromIntegral (w .>. 32) :: Word32)
   {-# INLINE minMaxExcess0 #-}
 
 instance MinMaxExcess0 (DVS.Vector Word8) where
-  minMaxExcess0 = DVS.foldl' gen (0, 0, 0)
-    where gen :: (MinExcess, Excess, MaxExcess) -> Word8 -> (MinExcess, Excess, MaxExcess)
-          gen (minE, e, maxE) w = let (wMinE, wE, wMaxE) = minMaxExcess0 w  in
-                                  (minE `min` (wMinE + e), e + wE, maxE `max` (wMaxE + e))
+  minMaxExcess0 = DVS.foldl' gen (Triplet 0 0 0)
+    where gen :: Triplet -> Word8 -> Triplet
+          gen (Triplet minE allE maxE) w  = let Triplet wMinE wAllE wMaxE = minMaxExcess0 w  in
+                                            Triplet (minE `min` (wMinE + allE))
+                                                    (            wAllE + allE )
+                                                    (maxE `max` (wMaxE + allE))
   {-# INLINE minMaxExcess0 #-}
 
 instance MinMaxExcess0 (DVS.Vector Word16) where
-  minMaxExcess0 = DVS.foldl' gen (0, 0, 0)
-    where gen :: (MinExcess, Excess, MaxExcess) -> Word16 -> (MinExcess, Excess, MaxExcess)
-          gen (minE, e, maxE) w = let (wMinE, wE, wMaxE) = minMaxExcess0 w  in
-                                  (minE `min` (wMinE + e), e + wE, maxE `max` (wMaxE + e))
+  minMaxExcess0 = DVS.foldl' gen (Triplet 0 0 0)
+    where gen :: Triplet -> Word16 -> Triplet
+          gen (Triplet minE allE maxE) w  = let Triplet wMinE wAllE wMaxE = minMaxExcess0 w  in
+                                            Triplet (minE `min` (wMinE + allE))
+                                                    (            wAllE + allE )
+                                                    (maxE `max` (wMaxE + allE))
   {-# INLINE minMaxExcess0 #-}
 
 instance MinMaxExcess0 (DVS.Vector Word32) where
-  minMaxExcess0 = DVS.foldl' gen (0, 0, 0)
-    where gen :: (MinExcess, Excess, MaxExcess) -> Word32 -> (MinExcess, Excess, MaxExcess)
-          gen (minE, e, maxE) w = let (wMinE, wE, wMaxE) = minMaxExcess0 w  in
-                                  (minE `min` (wMinE + e), e + wE, maxE `max` (wMaxE + e))
+  minMaxExcess0 = DVS.foldl' gen (Triplet 0 0 0)
+    where gen :: Triplet -> Word32 -> Triplet
+          gen (Triplet minE allE maxE) w  = let Triplet wMinE wAllE wMaxE = minMaxExcess0 w  in
+                                            Triplet (minE `min` (wMinE + allE))
+                                                    (            wAllE + allE )
+                                                    (maxE `max` (wMaxE + allE))
   {-# INLINE minMaxExcess0 #-}
 
 instance MinMaxExcess0 (DVS.Vector Word64) where
-  minMaxExcess0 = DVS.foldl' gen (0, 0, 0)
-    where gen :: (MinExcess, Excess, MaxExcess) -> Word64 -> (MinExcess, Excess, MaxExcess)
-          gen (minE, e, maxE) w = let (wMinE, wE, wMaxE) = minMaxExcess0 w  in
-                                  (minE `min` (wMinE + e), e + wE, maxE `max` (wMaxE + e))
+  minMaxExcess0 = DVS.foldl' gen (Triplet 0 0 0)
+    where gen :: Triplet -> Word64 -> Triplet
+          gen (Triplet minE allE maxE) w  = let Triplet wMinE wAllE wMaxE = minMaxExcess0 w  in
+                                            Triplet (minE `min` (wMinE + allE))
+                                                    (            wAllE + allE )
+                                                    (maxE `max` (wMaxE + allE))
   {-# INLINE minMaxExcess0 #-}
 
 word8Excess0Min :: DVS.Vector Int
diff --git a/src/HaskellWorks/Data/Excess/MinMaxExcess1.hs b/src/HaskellWorks/Data/Excess/MinMaxExcess1.hs
--- a/src/HaskellWorks/Data/Excess/MinMaxExcess1.hs
+++ b/src/HaskellWorks/Data/Excess/MinMaxExcess1.hs
@@ -1,4 +1,4 @@
-{-# LANGUAGE FlexibleInstances          #-}
+{-# LANGUAGE FlexibleInstances #-}
 
 module HaskellWorks.Data.Excess.MinMaxExcess1
   ( MinMaxExcess1(..)
@@ -6,111 +6,119 @@
   , MinExcess
   ) where
 
-import qualified Data.Vector.Storable                 as DVS
-import           Data.Word
-import           HaskellWorks.Data.Bits.BitWise
-import           HaskellWorks.Data.Bits.FixedBitSize
-import           HaskellWorks.Data.Naive
+import Data.Word
+import HaskellWorks.Data.Bits.BitWise
+import HaskellWorks.Data.Bits.FixedBitSize
+import HaskellWorks.Data.Excess.Triplet
+import HaskellWorks.Data.Naive
 
+import qualified Data.Vector.Storable as DVS
+
 type MinExcess = Int
 type MaxExcess = Int
-type Excess    = Int
 
 class MinMaxExcess1 a where
-  minMaxExcess1 :: a -> (MinExcess, Excess, MaxExcess)
+  minMaxExcess1 :: a -> Triplet
 
 instance MinMaxExcess1 [Bool] where
   minMaxExcess1 = go 0 0 0
-    where go minE maxE e (x:xs)                   = let ne = if x then e + 1 else e - 1 in
+    where go minE maxE allE (x:xs)                    = let ne = if x then allE + 1 else allE - 1 in
                                                         go (minE `min` ne) (maxE `max` ne) ne xs
-          go minE maxE e _                        = (minE, e, maxE)
+          go minE maxE allE _                         = Triplet minE allE maxE
   {-# INLINE minMaxExcess1 #-}
 
 instance MinMaxExcess1 (Naive Word8) where
   minMaxExcess1 = go 0 0 0 0 . naive
-    where go minE maxE e n w | n < fixedBitSize w = let ne = if w .?. fromIntegral n then e + 1 else e - 1 in
+    where go minE maxE allE n w | n < fixedBitSize w  = let ne = if w .?. fromIntegral n then allE + 1 else allE - 1 in
                                                         go (minE `min` ne) (maxE `max` ne) ne (n + 1) w
-          go minE maxE e _ _                       = (minE, e, maxE)
+          go minE maxE allE _ _                       = Triplet minE allE maxE
   {-# INLINE minMaxExcess1 #-}
 
 instance MinMaxExcess1 (Naive Word16) where
   minMaxExcess1 = go 0 0 0 0 . naive
-    where go minE maxE e n w | n < fixedBitSize w = let ne = if w .?. fromIntegral n then e + 1 else e - 1 in
+    where go minE maxE allE n w | n < fixedBitSize w  = let ne = if w .?. fromIntegral n then allE + 1 else allE - 1 in
                                                         go (minE `min` ne) (maxE `max` ne) ne (n + 1) w
-          go minE maxE e _ _                      = (minE, e, maxE)
+          go minE maxE allE _ _                       = Triplet minE allE maxE
   {-# INLINE minMaxExcess1 #-}
 
 instance MinMaxExcess1 (Naive Word32) where
   minMaxExcess1 = go 0 0 0 0 . naive
-    where go minE maxE e n w | n < fixedBitSize w = let ne = if w .?. fromIntegral n then e + 1 else e - 1 in
+    where go minE maxE allE n w | n < fixedBitSize w  = let ne = if w .?. fromIntegral n then allE + 1 else allE - 1 in
                                                         go (minE `min` ne) (maxE `max` ne) ne (n + 1) w
-          go minE maxE e _ _                      = (minE, e, maxE)
+          go minE maxE allE _ _                       = Triplet minE allE maxE
   {-# INLINE minMaxExcess1 #-}
 
 instance MinMaxExcess1 (Naive Word64) where
   minMaxExcess1 = go 0 0 0 0 . naive
-    where go minE maxE e n w | n < fixedBitSize w = let ne = if w .?. fromIntegral n then e + 1 else e - 1 in
+    where go minE maxE allE n w | n < fixedBitSize w  = let ne = if w .?. fromIntegral n then allE + 1 else allE - 1 in
                                                         go (minE `min` ne) (maxE `max` ne) ne (n + 1) w
-          go minE maxE e _ _                      = (minE, e, maxE)
+          go minE maxE allE _ _                       = Triplet minE allE maxE
   {-# INLINE minMaxExcess1 #-}
 
 instance MinMaxExcess1 Word8 where
-  minMaxExcess1 w = ( word8Excess1Min DVS.! fromIntegral w
-                    , word8Excess1    DVS.! fromIntegral w
-                    , word8Excess1Max DVS.! fromIntegral w
-                    )
+  minMaxExcess1 w = Triplet (word8Excess1Min DVS.! fromIntegral w)
+                            (word8Excess1    DVS.! fromIntegral w)
+                            (word8Excess1Max DVS.! fromIntegral w)
   {-# INLINE minMaxExcess1 #-}
 
 instance MinMaxExcess1 Word16 where
-  minMaxExcess1 w = ( minExcessA `min` (minExcessB + allExcessA)
-                    , allExcessA + allExcessB
-                    , maxExcessA `max` (maxExcessB + allExcessA))
-    where (minExcessA, allExcessA, maxExcessA) = minMaxExcess1 (fromIntegral  w        :: Word8)
-          (minExcessB, allExcessB, maxExcessB) = minMaxExcess1 (fromIntegral (w .>. 8) :: Word8)
+  minMaxExcess1 w = Triplet (minExcessA `min` (minExcessB + allExcessA))
+                            (allExcessA + allExcessB)
+                            (maxExcessA `max` (maxExcessB + allExcessA))
+    where Triplet minExcessA allExcessA maxExcessA = minMaxExcess1 (fromIntegral  w        :: Word8)
+          Triplet minExcessB allExcessB maxExcessB = minMaxExcess1 (fromIntegral (w .>. 8) :: Word8)
   {-# INLINE minMaxExcess1 #-}
 
 instance MinMaxExcess1 Word32 where
-  minMaxExcess1 w = ( minExcessA `min` (minExcessB + allExcessA)
-                    , allExcessA + allExcessB
-                    , maxExcessA `max` (maxExcessB + allExcessA))
-    where (minExcessA, allExcessA, maxExcessA) = minMaxExcess1 (fromIntegral  w         :: Word16)
-          (minExcessB, allExcessB, maxExcessB) = minMaxExcess1 (fromIntegral (w .>. 16) :: Word16)
+  minMaxExcess1 w = Triplet (minExcessA `min` (minExcessB + allExcessA))
+                            (allExcessA + allExcessB)
+                            (maxExcessA `max` (maxExcessB + allExcessA))
+    where Triplet minExcessA allExcessA maxExcessA = minMaxExcess1 (fromIntegral  w         :: Word16)
+          Triplet minExcessB allExcessB maxExcessB = minMaxExcess1 (fromIntegral (w .>. 16) :: Word16)
   {-# INLINE minMaxExcess1 #-}
 
 instance MinMaxExcess1 Word64 where
-  minMaxExcess1 w = ( minExcessA `min` (minExcessB + allExcessA)
-                    , allExcessA + allExcessB
-                    , maxExcessA `max` (maxExcessB + allExcessA))
-    where (minExcessA, allExcessA, maxExcessA) = minMaxExcess1 (fromIntegral  w         :: Word32)
-          (minExcessB, allExcessB, maxExcessB) = minMaxExcess1 (fromIntegral (w .>. 32) :: Word32)
+  minMaxExcess1 w = Triplet (minExcessA `min` (minExcessB + allExcessA))
+                            (allExcessA + allExcessB)
+                            (maxExcessA `max` (maxExcessB + allExcessA))
+    where Triplet minExcessA allExcessA maxExcessA = minMaxExcess1 (fromIntegral  w         :: Word32)
+          Triplet minExcessB allExcessB maxExcessB = minMaxExcess1 (fromIntegral (w .>. 32) :: Word32)
   {-# INLINE minMaxExcess1 #-}
 
 instance MinMaxExcess1 (DVS.Vector Word8) where
-  minMaxExcess1 = DVS.foldl' gen (0, 0, 0)
-    where gen :: (MinExcess, Excess, MaxExcess) -> Word8 -> (MinExcess, Excess, MaxExcess)
-          gen (minE, e, maxE) w = let (wMinE, wE, wMaxE) = minMaxExcess1 w  in
-                                  (minE `min` (wMinE + e), e + wE, maxE `max` (wMaxE + e))
+  minMaxExcess1 = DVS.foldl' gen (Triplet 0 0 0)
+    where gen :: Triplet -> Word8 -> Triplet
+          gen (Triplet minE allE maxE) w  = let Triplet wMinE wAllE wMaxE = minMaxExcess1 w  in
+                                            Triplet (minE `min` (wMinE + allE))
+                                                    (            wAllE + allE )
+                                                    (maxE `max` (wMaxE + allE))
   {-# INLINE minMaxExcess1 #-}
 
 instance MinMaxExcess1 (DVS.Vector Word16) where
-  minMaxExcess1 = DVS.foldl' gen (0, 0, 0)
-    where gen :: (MinExcess, Excess, MaxExcess) -> Word16 -> (MinExcess, Excess, MaxExcess)
-          gen (minE, e, maxE) w = let (wMinE, wE, wMaxE) = minMaxExcess1 w  in
-                                  (minE `min` (wMinE + e), e + wE, maxE `max` (wMaxE + e))
+  minMaxExcess1 = DVS.foldl' gen (Triplet 0 0 0)
+    where gen :: Triplet -> Word16 -> Triplet
+          gen (Triplet minE allE maxE) w  = let Triplet wMinE wAllE wMaxE = minMaxExcess1 w  in
+                                            Triplet (minE `min` (wMinE + allE))
+                                                    (            wAllE + allE )
+                                                    (maxE `max` (wMaxE + allE))
   {-# INLINE minMaxExcess1 #-}
 
 instance MinMaxExcess1 (DVS.Vector Word32) where
-  minMaxExcess1 = DVS.foldl' gen (0, 0, 0)
-    where gen :: (MinExcess, Excess, MaxExcess) -> Word32 -> (MinExcess, Excess, MaxExcess)
-          gen (minE, e, maxE) w = let (wMinE, wE, wMaxE) = minMaxExcess1 w  in
-                                  (minE `min` (wMinE + e), e + wE, maxE `max` (wMaxE + e))
+  minMaxExcess1 = DVS.foldl' gen (Triplet 0 0 0)
+    where gen :: Triplet -> Word32 -> Triplet
+          gen (Triplet minE allE maxE) w  = let Triplet wMinE wAllE wMaxE = minMaxExcess1 w  in
+                                            Triplet (minE `min` (wMinE + allE))
+                                                    (            wAllE + allE )
+                                                    (maxE `max` (wMaxE + allE))
   {-# INLINE minMaxExcess1 #-}
 
 instance MinMaxExcess1 (DVS.Vector Word64) where
-  minMaxExcess1 = DVS.foldl' gen (0, 0, 0)
-    where gen :: (MinExcess, Excess, MaxExcess) -> Word64 -> (MinExcess, Excess, MaxExcess)
-          gen (minE, e, maxE) w = let (wMinE, wE, wMaxE) = minMaxExcess1 w  in
-                                  (minE `min` (wMinE + e), e + wE, maxE `max` (wMaxE + e))
+  minMaxExcess1 = DVS.foldl' gen (Triplet 0 0 0)
+    where gen :: Triplet -> Word64 -> Triplet
+          gen (Triplet minE allE maxE) w  = let Triplet wMinE wAllE wMaxE = minMaxExcess1 w  in
+                                            Triplet (minE `min` (wMinE + allE))
+                                                    (            wAllE + allE )
+                                                    (maxE `max` (wMaxE + allE))
   {-# INLINE minMaxExcess1 #-}
 
 word8Excess1Min :: DVS.Vector Int
diff --git a/src/HaskellWorks/Data/Excess/Triplet.hs b/src/HaskellWorks/Data/Excess/Triplet.hs
new file mode 100644
--- /dev/null
+++ b/src/HaskellWorks/Data/Excess/Triplet.hs
@@ -0,0 +1,28 @@
+{-# OPTIONS_GHC-funbox-strict-fields #-}
+
+module HaskellWorks.Data.Excess.Triplet
+  ( Triplet(..)
+  ) where
+
+import Control.Applicative (liftA3)
+import Foreign.Storable    (Storable (..))
+
+import qualified Foreign.Storable.Record as Store
+
+data Triplet = Triplet
+  { tripletMinExcess :: !Int
+  , tripletAllExcess :: !Int
+  , tripletMaxExcess :: !Int
+  } deriving (Eq, Show)
+
+instance Storable Triplet where
+  sizeOf    = Store.sizeOf storeTriple
+  alignment = Store.alignment storeTriple
+  peek      = Store.peek storeTriple
+  poke      = Store.poke storeTriple
+
+storeTriple :: Store.Dictionary Triplet
+storeTriple = Store.run $ liftA3 Triplet
+  (Store.element tripletMinExcess)
+  (Store.element tripletAllExcess)
+  (Store.element tripletMaxExcess)
diff --git a/test/HaskellWorks/Data/Excess/MinMaxExcess0Spec.hs b/test/HaskellWorks/Data/Excess/MinMaxExcess0Spec.hs
--- a/test/HaskellWorks/Data/Excess/MinMaxExcess0Spec.hs
+++ b/test/HaskellWorks/Data/Excess/MinMaxExcess0Spec.hs
@@ -3,13 +3,15 @@
 
 module HaskellWorks.Data.Excess.MinMaxExcess0Spec (spec) where
 
+import Data.Word
+import HaskellWorks.Data.Bits.Word
+import HaskellWorks.Data.Naive
+import HaskellWorks.Data.Excess.MinMaxExcess0
+import HaskellWorks.Data.Excess.Triplet
+import Test.Hspec
+import Test.QuickCheck
+
 import qualified Data.Vector.Storable                             as DVS
-import           Data.Word
-import           HaskellWorks.Data.Bits.Word
-import           HaskellWorks.Data.Naive
-import           HaskellWorks.Data.Excess.MinMaxExcess0
-import           Test.Hspec
-import           Test.QuickCheck
 
 {-# ANN module ("HLint: Ignore Redundant do" :: String) #-}
 {-# ANN module ("HLint: Ignore Reduce duplication"  :: String) #-}
@@ -19,120 +21,120 @@
   describe "For Word8" $ do
     it "Excess should be between min excess and max excess" $
       property $ \(w :: Word8) ->
-        let (minE, e, maxE) = minMaxExcess0 w in
+        let Triplet minE e maxE = minMaxExcess0 w in
         minE <= e && e <= maxE
     it "minE2 == minE0 `min` (minE1 + e0)" $
       property $ \(w0 :: Word8, w1 :: Word8) ->
         let w2 = leConcat w0 w1 in
-        let (minE0, e0, _) = minMaxExcess0 w0 in
-        let (minE1, _ , _) = minMaxExcess0 w1 in
-        let (minE2, _ , _) = minMaxExcess0 w2 in
+        let Triplet minE0 e0 _ = minMaxExcess0 w0 in
+        let Triplet minE1 _  _ = minMaxExcess0 w1 in
+        let Triplet minE2 _  _ = minMaxExcess0 w2 in
         minE2 == minE0 `min` (minE1 + e0)
     it "maxE2 == maxE0 `max` (maxE1 + e0)" $
       property $ \(w0 :: Word8, w1 :: Word8) ->
         let w2 = leConcat w0 w1 in
-        let (_, e0, maxE0) = minMaxExcess0 w0 in
-        let (_, _ , maxE1) = minMaxExcess0 w1 in
-        let (_, _ , maxE2) = minMaxExcess0 w2 in
+        let Triplet _ e0 maxE0 = minMaxExcess0 w0 in
+        let Triplet _ _  maxE1 = minMaxExcess0 w1 in
+        let Triplet _ _  maxE2 = minMaxExcess0 w2 in
         maxE2 == maxE0 `max` (maxE1 + e0)
     it "minE2 == minE0 `min` (minE1 + e0) via vector" $
       property $ \(w0 :: Word8, w1 :: Word8) ->
         let w2 = DVS.fromList [w0, w1] in
-        let (minE0, e0, _) = minMaxExcess0 w0 in
-        let (minE1, _ , _) = minMaxExcess0 w1 in
-        let (minE2, _ , _) = minMaxExcess0 w2 in
+        let Triplet minE0 e0 _ = minMaxExcess0 w0 in
+        let Triplet minE1 _  _ = minMaxExcess0 w1 in
+        let Triplet minE2 _  _ = minMaxExcess0 w2 in
         minE2 == minE0 `min` (minE1 + e0)
     it "maxE2 == maxE0 `max` (maxE1 + e0) via vector" $
       property $ \(w0 :: Word8, w1 :: Word8) ->
         let w2 = DVS.fromList [w0, w1] in
-        let (_, e0, maxE0) = minMaxExcess0 w0 in
-        let (_, _ , maxE1) = minMaxExcess0 w1 in
-        let (_, _ , maxE2) = minMaxExcess0 w2 in
+        let Triplet _ e0 maxE0 = minMaxExcess0 w0 in
+        let Triplet _ _  maxE1 = minMaxExcess0 w1 in
+        let Triplet _ _  maxE2 = minMaxExcess0 w2 in
         maxE2 == maxE0 `max` (maxE1 + e0)
   describe "For Word16" $ do
     it "Excess should be between min excess and max excess" $
       property $ \(w :: Word16) ->
-        let (minE, e, maxE) = minMaxExcess0 w in
+        let Triplet minE e maxE = minMaxExcess0 w in
         minE <= e && e <= maxE
     it "minE2 == minE0 `min` (minE1 + e0)" $
       property $ \(w0 :: Word16, w1 :: Word16) ->
         let w2 = leConcat w0 w1 in
-        let (minE0, e0, _) = minMaxExcess0 w0 in
-        let (minE1, _ , _) = minMaxExcess0 w1 in
-        let (minE2, _ , _) = minMaxExcess0 w2 in
+        let Triplet minE0 e0 _ = minMaxExcess0 w0 in
+        let Triplet minE1 _  _ = minMaxExcess0 w1 in
+        let Triplet minE2 _  _ = minMaxExcess0 w2 in
         minE2 == minE0 `min` (minE1 + e0)
     it "maxE2 == maxE0 `max` (maxE1 + e0)" $
       property $ \(w0 :: Word16, w1 :: Word16) ->
         let w2 = leConcat w0 w1 in
-        let (_, e0, maxE0) = minMaxExcess0 w0 in
-        let (_, _ , maxE1) = minMaxExcess0 w1 in
-        let (_, _ , maxE2) = minMaxExcess0 w2 in
+        let Triplet _ e0 maxE0 = minMaxExcess0 w0 in
+        let Triplet _ _  maxE1 = minMaxExcess0 w1 in
+        let Triplet _ _  maxE2 = minMaxExcess0 w2 in
         maxE2 == maxE0 `max` (maxE1 + e0)
     it "minE2 == minE0 `min` (minE1 + e0) via vector" $
       property $ \(w0 :: Word16, w1 :: Word16) ->
         let w2 = DVS.fromList [w0, w1] in
-        let (minE0, e0, _) = minMaxExcess0 w0 in
-        let (minE1, _ , _) = minMaxExcess0 w1 in
-        let (minE2, _ , _) = minMaxExcess0 w2 in
+        let Triplet minE0 e0 _ = minMaxExcess0 w0 in
+        let Triplet minE1 _  _ = minMaxExcess0 w1 in
+        let Triplet minE2 _  _ = minMaxExcess0 w2 in
         minE2 == minE0 `min` (minE1 + e0)
     it "maxE2 == maxE0 `max` (maxE1 + e0) via vector" $
       property $ \(w0 :: Word16, w1 :: Word16) ->
         let w2 = DVS.fromList [w0, w1] in
-        let (_, e0, maxE0) = minMaxExcess0 w0 in
-        let (_, _ , maxE1) = minMaxExcess0 w1 in
-        let (_, _ , maxE2) = minMaxExcess0 w2 in
+        let Triplet _ e0 maxE0 = minMaxExcess0 w0 in
+        let Triplet _ _  maxE1 = minMaxExcess0 w1 in
+        let Triplet _ _  maxE2 = minMaxExcess0 w2 in
         maxE2 == maxE0 `max` (maxE1 + e0)
     describe "For Word32" $ do
       it "Excess should be between min excess and max excess" $
         property $ \(w :: Word32) ->
-          let (minE, e, maxE) = minMaxExcess0 w in
+          let Triplet minE e maxE = minMaxExcess0 w in
           minE <= e && e <= maxE
       it "minE2 == minE0 `min` (minE1 + e0)" $
         property $ \(w0 :: Word32, w1 :: Word32) ->
           let w2 = leConcat w0 w1 in
-          let (minE0, e0, _) = minMaxExcess0 w0 in
-          let (minE1, _ , _) = minMaxExcess0 w1 in
-          let (minE2, _ , _) = minMaxExcess0 w2 in
+          let Triplet minE0 e0 _ = minMaxExcess0 w0 in
+          let Triplet minE1 _  _ = minMaxExcess0 w1 in
+          let Triplet minE2 _  _ = minMaxExcess0 w2 in
           minE2 == minE0 `min` (minE1 + e0)
       it "maxE2 == maxE0 `max` (maxE1 + e0)" $
         property $ \(w0 :: Word32, w1 :: Word32) ->
           let w2 = leConcat w0 w1 in
-          let (_, e0, maxE0) = minMaxExcess0 w0 in
-          let (_, _ , maxE1) = minMaxExcess0 w1 in
-          let (_, _ , maxE2) = minMaxExcess0 w2 in
+          let Triplet _ e0 maxE0 = minMaxExcess0 w0 in
+          let Triplet _ _  maxE1 = minMaxExcess0 w1 in
+          let Triplet _ _  maxE2 = minMaxExcess0 w2 in
           maxE2 == maxE0 `max` (maxE1 + e0)
       it "minE2 == minE0 `min` (minE1 + e0) via vector" $
         property $ \(w0 :: Word32, w1 :: Word32) ->
           let w2 = DVS.fromList [w0, w1] in
-          let (minE0, e0, _) = minMaxExcess0 w0 in
-          let (minE1, _ , _) = minMaxExcess0 w1 in
-          let (minE2, _ , _) = minMaxExcess0 w2 in
+          let Triplet minE0 e0 _ = minMaxExcess0 w0 in
+          let Triplet minE1 _  _ = minMaxExcess0 w1 in
+          let Triplet minE2 _  _ = minMaxExcess0 w2 in
           minE2 == minE0 `min` (minE1 + e0)
       it "maxE2 == maxE0 `max` (maxE1 + e0) via vector" $
         property $ \(w0 :: Word32, w1 :: Word32) ->
           let w2 = DVS.fromList [w0, w1] in
-          let (_, e0, maxE0) = minMaxExcess0 w0 in
-          let (_, _ , maxE1) = minMaxExcess0 w1 in
-          let (_, _ , maxE2) = minMaxExcess0 w2 in
+          let Triplet _ e0 maxE0 = minMaxExcess0 w0 in
+          let Triplet _ _  maxE1 = minMaxExcess0 w1 in
+          let Triplet _ _  maxE2 = minMaxExcess0 w2 in
           maxE2 == maxE0 `max` (maxE1 + e0)
   describe "For Word64" $ do
     it "Excess should be between min excess and max excess" $
       property $ \(w :: Word64) ->
-        let (minE, e, maxE) = minMaxExcess0 w in
+        let Triplet minE e maxE = minMaxExcess0 w in
         minE <= e && e <= maxE
     it "minE2 == minE0 `min` (minE1 + e0) via vector" $
       property $ \(w0 :: Word64, w1 :: Word64) ->
         let w2 = DVS.fromList [w0, w1] in
-        let (minE0, e0, _) = minMaxExcess0 w0 in
-        let (minE1, _ , _) = minMaxExcess0 w1 in
-        let (minE2, _ , _) = minMaxExcess0 w2 in
+        let Triplet minE0 e0 _ = minMaxExcess0 w0 in
+        let Triplet minE1 _  _ = minMaxExcess0 w1 in
+        let Triplet minE2 _  _ = minMaxExcess0 w2 in
         minE2 == minE0 `min` (minE1 + e0)
     it "maxE2 == maxE0 `max` (maxE1 + e0) via vector" $
       property $ \(w0 :: Word64, w1 :: Word64) ->
         let w2 = DVS.fromList [w0, w1] in
-        let (_, e0, maxE0) = minMaxExcess0 w0 in
-        let (_, _ , maxE1) = minMaxExcess0 w1 in
-        let (_, _ , maxE2) = minMaxExcess0 w2 in
+        let Triplet _ e0 maxE0 = minMaxExcess0 w0 in
+        let Triplet _ _  maxE1 = minMaxExcess0 w1 in
+        let Triplet _ _  maxE2 = minMaxExcess0 w2 in
         maxE2 == maxE0 `max` (maxE1 + e0)
     describe "Equivalent to native implementation" $ do
       it "For Word8" $ do
diff --git a/test/HaskellWorks/Data/Excess/MinMaxExcess1Spec.hs b/test/HaskellWorks/Data/Excess/MinMaxExcess1Spec.hs
--- a/test/HaskellWorks/Data/Excess/MinMaxExcess1Spec.hs
+++ b/test/HaskellWorks/Data/Excess/MinMaxExcess1Spec.hs
@@ -3,13 +3,15 @@
 
 module HaskellWorks.Data.Excess.MinMaxExcess1Spec (spec) where
 
+import Data.Word
+import HaskellWorks.Data.Bits.Word
+import HaskellWorks.Data.Excess.MinMaxExcess1
+import HaskellWorks.Data.Excess.Triplet
+import HaskellWorks.Data.Naive
+import Test.Hspec
+import Test.QuickCheck
+
 import qualified Data.Vector.Storable                             as DVS
-import           Data.Word
-import           HaskellWorks.Data.Bits.Word
-import           HaskellWorks.Data.Excess.MinMaxExcess1
-import           HaskellWorks.Data.Naive
-import           Test.Hspec
-import           Test.QuickCheck
 
 {-# ANN module ("HLint: Ignore Redundant do" :: String) #-}
 {-# ANN module ("HLint: Ignore Reduce duplication"  :: String) #-}
@@ -19,120 +21,120 @@
   describe "For Word8" $ do
     it "Excess should be between min excess and max excess" $
       property $ \(w :: Word8) ->
-        let (minE, e, maxE) = minMaxExcess1 w in
+        let Triplet minE e maxE = minMaxExcess1 w in
         minE <= e && e <= maxE
     it "minE2 == minE0 `min` (minE1 + e0)" $
       property $ \(w0 :: Word8, w1 :: Word8) ->
         let w2 = leConcat w0 w1 in
-        let (minE0, e0, _) = minMaxExcess1 w0 in
-        let (minE1, _ , _) = minMaxExcess1 w1 in
-        let (minE2, _ , _) = minMaxExcess1 w2 in
+        let Triplet minE0 e0 _ = minMaxExcess1 w0 in
+        let Triplet minE1 _  _ = minMaxExcess1 w1 in
+        let Triplet minE2 _  _ = minMaxExcess1 w2 in
         minE2 == minE0 `min` (minE1 + e0)
     it "maxE2 == maxE0 `max` (maxE1 + e0)" $
       property $ \(w0 :: Word8, w1 :: Word8) ->
         let w2 = leConcat w0 w1 in
-        let (_, e0, maxE0) = minMaxExcess1 w0 in
-        let (_, _ , maxE1) = minMaxExcess1 w1 in
-        let (_, _ , maxE2) = minMaxExcess1 w2 in
+        let Triplet _ e0 maxE0 = minMaxExcess1 w0 in
+        let Triplet _ _  maxE1 = minMaxExcess1 w1 in
+        let Triplet _ _  maxE2 = minMaxExcess1 w2 in
         maxE2 == maxE0 `max` (maxE1 + e0)
     it "minE2 == minE0 `min` (minE1 + e0) via vector" $
       property $ \(w0 :: Word8, w1 :: Word8) ->
         let w2 = DVS.fromList [w0, w1] in
-        let (minE0, e0, _) = minMaxExcess1 w0 in
-        let (minE1, _ , _) = minMaxExcess1 w1 in
-        let (minE2, _ , _) = minMaxExcess1 w2 in
+        let Triplet minE0 e0 _ = minMaxExcess1 w0 in
+        let Triplet minE1 _  _ = minMaxExcess1 w1 in
+        let Triplet minE2 _  _ = minMaxExcess1 w2 in
         minE2 == minE0 `min` (minE1 + e0)
     it "maxE2 == maxE0 `max` (maxE1 + e0) via vector" $
       property $ \(w0 :: Word8, w1 :: Word8) ->
         let w2 = DVS.fromList [w0, w1] in
-        let (_, e0, maxE0) = minMaxExcess1 w0 in
-        let (_, _ , maxE1) = minMaxExcess1 w1 in
-        let (_, _ , maxE2) = minMaxExcess1 w2 in
+        let Triplet _ e0 maxE0 = minMaxExcess1 w0 in
+        let Triplet _ _  maxE1 = minMaxExcess1 w1 in
+        let Triplet _ _  maxE2 = minMaxExcess1 w2 in
         maxE2 == maxE0 `max` (maxE1 + e0)
   describe "For Word16" $ do
     it "Excess should be between min excess and max excess" $
       property $ \(w :: Word16) ->
-        let (minE, e, maxE) = minMaxExcess1 w in
+        let Triplet minE e maxE = minMaxExcess1 w in
         minE <= e && e <= maxE
     it "minE2 == minE0 `min` (minE1 + e0)" $
       property $ \(w0 :: Word16, w1 :: Word16) ->
         let w2 = leConcat w0 w1 in
-        let (minE0, e0, _) = minMaxExcess1 w0 in
-        let (minE1, _ , _) = minMaxExcess1 w1 in
-        let (minE2, _ , _) = minMaxExcess1 w2 in
+        let Triplet minE0 e0 _ = minMaxExcess1 w0 in
+        let Triplet minE1 _  _ = minMaxExcess1 w1 in
+        let Triplet minE2 _  _ = minMaxExcess1 w2 in
         minE2 == minE0 `min` (minE1 + e0)
     it "maxE2 == maxE0 `max` (maxE1 + e0)" $
       property $ \(w0 :: Word16, w1 :: Word16) ->
         let w2 = leConcat w0 w1 in
-        let (_, e0, maxE0) = minMaxExcess1 w0 in
-        let (_, _ , maxE1) = minMaxExcess1 w1 in
-        let (_, _ , maxE2) = minMaxExcess1 w2 in
+        let Triplet _ e0 maxE0 = minMaxExcess1 w0 in
+        let Triplet _ _  maxE1 = minMaxExcess1 w1 in
+        let Triplet _ _  maxE2 = minMaxExcess1 w2 in
         maxE2 == maxE0 `max` (maxE1 + e0)
     it "minE2 == minE0 `min` (minE1 + e0) via vector" $
       property $ \(w0 :: Word16, w1 :: Word16) ->
         let w2 = DVS.fromList [w0, w1] in
-        let (minE0, e0, _) = minMaxExcess1 w0 in
-        let (minE1, _ , _) = minMaxExcess1 w1 in
-        let (minE2, _ , _) = minMaxExcess1 w2 in
+        let Triplet minE0 e0 _ = minMaxExcess1 w0 in
+        let Triplet minE1 _  _ = minMaxExcess1 w1 in
+        let Triplet minE2 _  _ = minMaxExcess1 w2 in
         minE2 == minE0 `min` (minE1 + e0)
     it "maxE2 == maxE0 `max` (maxE1 + e0) via vector" $
       property $ \(w0 :: Word16, w1 :: Word16) ->
         let w2 = DVS.fromList [w0, w1] in
-        let (_, e0, maxE0) = minMaxExcess1 w0 in
-        let (_, _ , maxE1) = minMaxExcess1 w1 in
-        let (_, _ , maxE2) = minMaxExcess1 w2 in
+        let Triplet _ e0 maxE0 = minMaxExcess1 w0 in
+        let Triplet _ _  maxE1 = minMaxExcess1 w1 in
+        let Triplet _ _  maxE2 = minMaxExcess1 w2 in
         maxE2 == maxE0 `max` (maxE1 + e0)
     describe "For Word32" $ do
       it "Excess should be between min excess and max excess" $
         property $ \(w :: Word32) ->
-          let (minE, e, maxE) = minMaxExcess1 w in
+          let Triplet minE e maxE = minMaxExcess1 w in
           minE <= e && e <= maxE
       it "minE2 == minE0 `min` (minE1 + e0)" $
         property $ \(w0 :: Word32, w1 :: Word32) ->
           let w2 = leConcat w0 w1 in
-          let (minE0, e0, _) = minMaxExcess1 w0 in
-          let (minE1, _ , _) = minMaxExcess1 w1 in
-          let (minE2, _ , _) = minMaxExcess1 w2 in
+          let Triplet minE0 e0 _ = minMaxExcess1 w0 in
+          let Triplet minE1 _  _ = minMaxExcess1 w1 in
+          let Triplet minE2 _  _ = minMaxExcess1 w2 in
           minE2 == minE0 `min` (minE1 + e0)
       it "maxE2 == maxE0 `max` (maxE1 + e0)" $
         property $ \(w0 :: Word32, w1 :: Word32) ->
           let w2 = leConcat w0 w1 in
-          let (_, e0, maxE0) = minMaxExcess1 w0 in
-          let (_, _ , maxE1) = minMaxExcess1 w1 in
-          let (_, _ , maxE2) = minMaxExcess1 w2 in
+          let Triplet _ e0 maxE0 = minMaxExcess1 w0 in
+          let Triplet _ _  maxE1 = minMaxExcess1 w1 in
+          let Triplet _ _  maxE2 = minMaxExcess1 w2 in
           maxE2 == maxE0 `max` (maxE1 + e0)
       it "minE2 == minE0 `min` (minE1 + e0) via vector" $
         property $ \(w0 :: Word32, w1 :: Word32) ->
           let w2 = DVS.fromList [w0, w1] in
-          let (minE0, e0, _) = minMaxExcess1 w0 in
-          let (minE1, _ , _) = minMaxExcess1 w1 in
-          let (minE2, _ , _) = minMaxExcess1 w2 in
+          let Triplet minE0 e0 _ = minMaxExcess1 w0 in
+          let Triplet minE1 _  _ = minMaxExcess1 w1 in
+          let Triplet minE2 _  _ = minMaxExcess1 w2 in
           minE2 == minE0 `min` (minE1 + e0)
       it "maxE2 == maxE0 `max` (maxE1 + e0) via vector" $
         property $ \(w0 :: Word32, w1 :: Word32) ->
           let w2 = DVS.fromList [w0, w1] in
-          let (_, e0, maxE0) = minMaxExcess1 w0 in
-          let (_, _ , maxE1) = minMaxExcess1 w1 in
-          let (_, _ , maxE2) = minMaxExcess1 w2 in
+          let Triplet _ e0 maxE0 = minMaxExcess1 w0 in
+          let Triplet _ _  maxE1 = minMaxExcess1 w1 in
+          let Triplet _ _  maxE2 = minMaxExcess1 w2 in
           maxE2 == maxE0 `max` (maxE1 + e0)
   describe "For Word64" $ do
     it "Excess should be between min excess and max excess" $
       property $ \(w :: Word64) ->
-        let (minE, e, maxE) = minMaxExcess1 w in
+        let Triplet minE e maxE = minMaxExcess1 w in
         minE <= e && e <= maxE
     it "minE2 == minE0 `min` (minE1 + e0) via vector" $
       property $ \(w0 :: Word64, w1 :: Word64) ->
         let w2 = DVS.fromList [w0, w1] in
-        let (minE0, e0, _) = minMaxExcess1 w0 in
-        let (minE1, _ , _) = minMaxExcess1 w1 in
-        let (minE2, _ , _) = minMaxExcess1 w2 in
+        let Triplet minE0 e0 _ = minMaxExcess1 w0 in
+        let Triplet minE1 _  _ = minMaxExcess1 w1 in
+        let Triplet minE2 _  _ = minMaxExcess1 w2 in
         minE2 == minE0 `min` (minE1 + e0)
     it "maxE2 == maxE0 `max` (maxE1 + e0) via vector" $
       property $ \(w0 :: Word64, w1 :: Word64) ->
         let w2 = DVS.fromList [w0, w1] in
-        let (_, e0, maxE0) = minMaxExcess1 w0 in
-        let (_, _ , maxE1) = minMaxExcess1 w1 in
-        let (_, _ , maxE2) = minMaxExcess1 w2 in
+        let Triplet _ e0 maxE0 = minMaxExcess1 w0 in
+        let Triplet _ _  maxE1 = minMaxExcess1 w1 in
+        let Triplet _ _  maxE2 = minMaxExcess1 w2 in
         maxE2 == maxE0 `max` (maxE1 + e0)
   describe "Equivalent to native implementation" $ do
     it "For Word8" $ do