diff --git a/changelog.md b/changelog.md
--- a/changelog.md
+++ b/changelog.md
@@ -1,5 +1,16 @@
 # Change Log
 
+## [1.4.0.0] - 2019-09-12
+
+- Remove Generic instance, see
+  https://github.com/expipiplus1/vector-sized/issues/79
+- Add Binary instance
+- Loosen bounds on dependencies
+
+## [1.3.0.0] - 2019-05-28
+
+- Correct type of accumulating fold functions
+
 ## [1.2.0.1] - 2019-05-22
 
 - Loosen upper bounds on dependencies
diff --git a/default.nix b/default.nix
--- a/default.nix
+++ b/default.nix
@@ -1,5 +1,6 @@
 { pkgs ? import <nixpkgs> {}
 , compiler ? "ghc864"
+, hoogle ? true
 }:
 
 let src = pkgs.nix-gitignore.gitignoreSource [] ./.;
@@ -8,6 +9,9 @@
     haskellPackages = with pkgs.haskell.lib;
       pkgs.haskell.packages.${compiler}.override {
       overrides = self: super: {
+      } // pkgs.lib.optionalAttrs hoogle {
+        ghc = super.ghc // { withPackages = super.ghc.withHoogle; };
+        ghcWithPackages = self.ghc.withPackages;
       };
     };
 
@@ -22,6 +26,10 @@
     # cabal2nix
     envWithExtras = pkgs.lib.overrideDerivation drv.env (attrs: {
       buildInputs = attrs.buildInputs ++ extraEnvPackages;
+    } // pkgs.lib.optionalAttrs hoogle {
+      shellHook   = attrs.shellHook + ''
+        export HIE_HOOGLE_DATABASE="$(cat $(which hoogle) | sed -n -e 's|.*--database \(.*\.hoo\).*|\1|p')"
+      '';
     });
 
 in
diff --git a/shell.nix b/shell.nix
--- a/shell.nix
+++ b/shell.nix
@@ -1,5 +1,6 @@
 { pkgs ? import <nixpkgs> {}
 , compiler ? "ghc864"
+, hoogle ? true
 }:
 
-(import ./default.nix { inherit pkgs compiler; }).env
+(import ./default.nix { inherit pkgs compiler hoogle; }).env
diff --git a/src/Data/Vector/Generic/Mutable/Sized/Internal.hs b/src/Data/Vector/Generic/Mutable/Sized/Internal.hs
--- a/src/Data/Vector/Generic/Mutable/Sized/Internal.hs
+++ b/src/Data/Vector/Generic/Mutable/Sized/Internal.hs
@@ -1,6 +1,5 @@
 {-# LANGUAGE DataKinds                  #-}
 {-# LANGUAGE DeriveDataTypeable         #-}
-{-# LANGUAGE DeriveGeneric              #-}
 {-# LANGUAGE GeneralizedNewtypeDeriving #-}
 {-# LANGUAGE KindSignatures             #-}
 {-# OPTIONS_HADDOCK not-home            #-}
@@ -10,7 +9,6 @@
   )
 where
 
-import           GHC.Generics                   ( Generic )
 import           GHC.TypeLits
 import           Control.DeepSeq                ( NFData )
 import           Data.Data
@@ -21,4 +19,4 @@
 -- Be careful when using the constructor here to not construct sized vectors
 -- which have a different length than that specified in the type parameter!
 newtype MVector v (n :: Nat) s a = MVector (v s a)
-  deriving ( Generic, Typeable, Data, Storable, NFData )
+  deriving ( Typeable, Data, Storable, NFData )
diff --git a/src/Data/Vector/Generic/Sized.hs b/src/Data/Vector/Generic/Sized.hs
--- a/src/Data/Vector/Generic/Sized.hs
+++ b/src/Data/Vector/Generic/Sized.hs
@@ -1,11 +1,7 @@
 {-# LANGUAGE DataKinds #-}
 {-# LANGUAGE FlexibleContexts #-}
 {-# LANGUAGE FlexibleInstances #-}
-{-# LANGUAGE DeriveGeneric #-}
-{-# LANGUAGE DeriveTraversable #-}
 {-# LANGUAGE ExistentialQuantification #-}
-{-# LANGUAGE GeneralizedNewtypeDeriving #-}
-{-# LANGUAGE KindSignatures #-}
 {-# LANGUAGE ScopedTypeVariables #-}
 {-# LANGUAGE TypeOperators #-}
 {-# LANGUAGE RankNTypes #-}
@@ -254,11 +250,13 @@
 import qualified Data.Vector.Unboxed as Unboxed
 import qualified Data.Vector.Generic.Mutable.Sized as SVGM
 import Data.Vector.Generic.Mutable.Sized.Internal
+import Data.Binary
 import GHC.TypeLits
 import Data.Bifunctor
 import Data.Finite
 import Data.Finite.Internal
 import Data.Proxy
+import Control.Monad (mzero)
 import Control.Monad.Primitive
 import Foreign.Storable
 import Data.Data
@@ -1620,23 +1618,23 @@
 {-# inline postscanl' #-}
 
 -- | /O(n)/ Haskell-style scan.
-scanl :: (VG.Vector v a, VG.Vector v b) => (a -> b -> a) -> a -> Vector v n b -> Vector v n a
-scanl f z = withVectorUnsafe (VG.scanl f z )
+scanl :: (VG.Vector v a, VG.Vector v b) => (a -> b -> a) -> a -> Vector v n b -> Vector v (1+n) a
+scanl f z (Vector v) = Vector (VG.scanl f z v)
 {-# inline scanl #-}
 
 -- | /O(n)/ Haskell-style scan with strict accumulator.
-scanl' :: (VG.Vector v a, VG.Vector v b) => (a -> b -> a) -> a -> Vector v n b -> Vector v n a
-scanl' f z = withVectorUnsafe (VG.scanl' f z )
+scanl' :: (VG.Vector v a, VG.Vector v b) => (a -> b -> a) -> a -> Vector v n b -> Vector v (1+n) a
+scanl' f z (Vector v) = Vector (VG.scanl' f z v)
 {-# inline scanl' #-}
 
 -- | /O(n)/ Scan over a non-empty vector.
-scanl1 :: VG.Vector v a => (a -> a -> a) -> Vector v (n+1) a -> Vector v (n+1) a
-scanl1 f = withVectorUnsafe (VG.scanl1 f )
+scanl1 :: VG.Vector v a => (a -> a -> a) -> Vector v (1+n) a -> Vector v (2+n) a
+scanl1 f (Vector v) = Vector (VG.scanl1 f v)
 {-# inline scanl1 #-}
 
 -- | /O(n)/ Scan over a non-empty vector with a strict accumulator.
-scanl1' :: VG.Vector v a => (a -> a -> a) -> Vector v (n+1) a -> Vector v (n+1) a
-scanl1' f = withVectorUnsafe (VG.scanl1' f )
+scanl1' :: VG.Vector v a => (a -> a -> a) -> Vector v (1+n) a -> Vector v (2+n) a
+scanl1' f (Vector v) = Vector (VG.scanl1' f v)
 {-# inline scanl1' #-}
 
 -- | /O(n)/ Right-to-left prescan.
@@ -1660,24 +1658,24 @@
 {-# inline postscanr' #-}
 
 -- | /O(n)/ Right-to-left Haskell-style scan.
-scanr :: (VG.Vector v a, VG.Vector v b) => (a -> b -> b) -> b -> Vector v n a -> Vector v n b
-scanr f z = withVectorUnsafe (VG.scanr f z )
+scanr :: (VG.Vector v a, VG.Vector v b) => (a -> b -> b) -> b -> Vector v n a -> Vector v (n+1) b
+scanr f z (Vector v) = Vector (VG.scanr f z v)
 {-# inline scanr #-}
 
 -- | /O(n)/ Right-to-left Haskell-style scan with strict accumulator.
-scanr' :: (VG.Vector v a, VG.Vector v b) => (a -> b -> b) -> b -> Vector v n a -> Vector v n b
-scanr' f z = withVectorUnsafe (VG.scanr' f z )
+scanr' :: (VG.Vector v a, VG.Vector v b) => (a -> b -> b) -> b -> Vector v n a -> Vector v (n+1) b
+scanr' f z (Vector v) = Vector (VG.scanr' f z v)
 {-# inline scanr' #-}
 
 -- | /O(n)/ Right-to-left scan over a non-empty vector.
-scanr1 :: VG.Vector v a => (a -> a -> a) -> Vector v (n+1) a -> Vector v (n+1) a
-scanr1 f = withVectorUnsafe (VG.scanr1 f )
+scanr1 :: VG.Vector v a => (a -> a -> a) -> Vector v (n+1) a -> Vector v (n+2) a
+scanr1 f (Vector v) = Vector (VG.scanr1 f v)
 {-# inline scanr1 #-}
 
 -- | /O(n)/ Right-to-left scan over a non-empty vector with a strict
 -- accumulator.
-scanr1' :: VG.Vector v a => (a -> a -> a) -> Vector v (n+1) a -> Vector v (n+1) a
-scanr1' f = withVectorUnsafe (VG.scanr1' f )
+scanr1' :: VG.Vector v a => (a -> a -> a) -> Vector v (n+1) a -> Vector v (n+2) a
+scanr1' f (Vector v) = Vector (VG.scanr1' f v)
 {-# inline scanr1' #-}
 
 
@@ -1928,3 +1926,7 @@
     asinh   = map asinh
     acosh   = map acosh
     atanh   = map atanh
+
+instance (VG.Vector v a, Binary a, KnownNat n) => Binary (Vector v n a) where
+  get = replicateM Data.Binary.get 
+  put = mapM_ put
diff --git a/src/Data/Vector/Generic/Sized/Internal.hs b/src/Data/Vector/Generic/Sized/Internal.hs
--- a/src/Data/Vector/Generic/Sized/Internal.hs
+++ b/src/Data/Vector/Generic/Sized/Internal.hs
@@ -1,6 +1,5 @@
 {-# LANGUAGE DataKinds                  #-}
 {-# LANGUAGE DeriveDataTypeable         #-}
-{-# LANGUAGE DeriveGeneric              #-}
 {-# LANGUAGE DeriveTraversable          #-}
 {-# LANGUAGE FlexibleInstances          #-}
 {-# LANGUAGE GeneralizedNewtypeDeriving #-}
@@ -41,7 +40,6 @@
                                                   , unsafeRangeSize
                                                   )
                                                 )
-import           GHC.Generics                   ( Generic )
 import           GHC.TypeLits                   ( Nat )
 
 -- | A wrapper to tag vectors with a type level length.
@@ -49,7 +47,7 @@
 -- Be careful when using the constructor here to not construct sized vectors
 -- which have a different length than that specified in the type parameter!
 newtype Vector v (n :: Nat) a = Vector (v a)
-  deriving ( Show, Eq, Ord, Functor, Foldable, Traversable, NFData, Generic
+  deriving ( Show, Eq, Ord, Functor, Foldable, Traversable, NFData
            , Show1, Eq1, Ord1
            , Data, Typeable
            )
diff --git a/src/Data/Vector/Sized.hs b/src/Data/Vector/Sized.hs
--- a/src/Data/Vector/Sized.hs
+++ b/src/Data/Vector/Sized.hs
@@ -1364,22 +1364,22 @@
 {-# inline postscanl' #-}
 
 -- | /O(n)/ Haskell-style scan.
-scanl ::  (a -> b -> a) -> a -> Vector n b -> Vector n a
+scanl ::  (a -> b -> a) -> a -> Vector n b -> Vector (1+n) a
 scanl = V.scanl
 {-# inline scanl #-}
 
 -- | /O(n)/ Haskell-style scan with strict accumulator.
-scanl' ::  (a -> b -> a) -> a -> Vector n b -> Vector n a
+scanl' ::  (a -> b -> a) -> a -> Vector n b -> Vector (1+n) a
 scanl' = V.scanl'
 {-# inline scanl' #-}
 
 -- | /O(n)/ Scan over a non-empty vector.
-scanl1 :: (a -> a -> a) -> Vector (n+1) a -> Vector (n+1) a
+scanl1 :: (a -> a -> a) -> Vector (1+n) a -> Vector (2+n) a
 scanl1 = V.scanl1
 {-# inline scanl1 #-}
 
 -- | /O(n)/ Scan over a non-empty vector with a strict accumulator.
-scanl1' :: (a -> a -> a) -> Vector (n+1) a -> Vector (n+1) a
+scanl1' :: (a -> a -> a) -> Vector (1+n) a -> Vector (2+n) a
 scanl1' = V.scanl1'
 {-# inline scanl1' #-}
 
@@ -1404,23 +1404,23 @@
 {-# inline postscanr' #-}
 
 -- | /O(n)/ Right-to-left Haskell-style scan.
-scanr ::  (a -> b -> b) -> b -> Vector n a -> Vector n b
+scanr ::  (a -> b -> b) -> b -> Vector n a -> Vector (n+1) b
 scanr = V.scanr
 {-# inline scanr #-}
 
 -- | /O(n)/ Right-to-left Haskell-style scan with strict accumulator.
-scanr' ::  (a -> b -> b) -> b -> Vector n a -> Vector n b
+scanr' ::  (a -> b -> b) -> b -> Vector n a -> Vector (n+1) b
 scanr' = V.scanr'
 {-# inline scanr' #-}
 
 -- | /O(n)/ Right-to-left scan over a non-empty vector.
-scanr1 :: (a -> a -> a) -> Vector (n+1) a -> Vector (n+1) a
+scanr1 :: (a -> a -> a) -> Vector (n+1) a -> Vector (n+2) a
 scanr1 = V.scanr1
 {-# inline scanr1 #-}
 
 -- | /O(n)/ Right-to-left scan over a non-empty vector with a strict
 -- accumulator.
-scanr1' :: (a -> a -> a) -> Vector (n+1) a -> Vector (n+1) a
+scanr1' :: (a -> a -> a) -> Vector (n+1) a -> Vector (n+2) a
 scanr1' = V.scanr1'
 {-# inline scanr1' #-}
 
diff --git a/src/Data/Vector/Storable/Sized.hs b/src/Data/Vector/Storable/Sized.hs
--- a/src/Data/Vector/Storable/Sized.hs
+++ b/src/Data/Vector/Storable/Sized.hs
@@ -1435,22 +1435,22 @@
 {-# inline postscanl' #-}
 
 -- | /O(n)/ Haskell-style scan.
-scanl :: (Storable a, Storable b) => (a -> b -> a) -> a -> Vector n b -> Vector n a
+scanl :: (Storable a, Storable b) => (a -> b -> a) -> a -> Vector n b -> Vector (1+n) a
 scanl = V.scanl
 {-# inline scanl #-}
 
 -- | /O(n)/ Haskell-style scan with strict accumulator.
-scanl' :: (Storable a, Storable b) => (a -> b -> a) -> a -> Vector n b -> Vector n a
+scanl' :: (Storable a, Storable b) => (a -> b -> a) -> a -> Vector n b -> Vector (1+n) a
 scanl' = V.scanl'
 {-# inline scanl' #-}
 
 -- | /O(n)/ Scan over a non-empty vector.
-scanl1 :: Storable a => (a -> a -> a) -> Vector (n+1) a -> Vector (n+1) a
+scanl1 :: Storable a => (a -> a -> a) -> Vector (1+n) a -> Vector (2+n) a
 scanl1 = V.scanl1
 {-# inline scanl1 #-}
 
 -- | /O(n)/ Scan over a non-empty vector with a strict accumulator.
-scanl1' :: Storable a => (a -> a -> a) -> Vector (n+1) a -> Vector (n+1) a
+scanl1' :: Storable a => (a -> a -> a) -> Vector (1+n) a -> Vector (2+n) a
 scanl1' = V.scanl1'
 {-# inline scanl1' #-}
 
@@ -1475,23 +1475,23 @@
 {-# inline postscanr' #-}
 
 -- | /O(n)/ Right-to-left Haskell-style scan.
-scanr :: (Storable a, Storable b) => (a -> b -> b) -> b -> Vector n a -> Vector n b
+scanr :: (Storable a, Storable b) => (a -> b -> b) -> b -> Vector n a -> Vector (n+1) b
 scanr = V.scanr
 {-# inline scanr #-}
 
 -- | /O(n)/ Right-to-left Haskell-style scan with strict accumulator.
-scanr' :: (Storable a, Storable b) => (a -> b -> b) -> b -> Vector n a -> Vector n b
+scanr' :: (Storable a, Storable b) => (a -> b -> b) -> b -> Vector n a -> Vector (n+1) b
 scanr' = V.scanr'
 {-# inline scanr' #-}
 
 -- | /O(n)/ Right-to-left scan over a non-empty vector.
-scanr1 :: Storable a => (a -> a -> a) -> Vector (n+1) a -> Vector (n+1) a
+scanr1 :: Storable a => (a -> a -> a) -> Vector (n+1) a -> Vector (n+2) a
 scanr1 = V.scanr1
 {-# inline scanr1 #-}
 
 -- | /O(n)/ Right-to-left scan over a non-empty vector with a strict
 -- accumulator.
-scanr1' :: Storable a => (a -> a -> a) -> Vector (n+1) a -> Vector (n+1) a
+scanr1' :: Storable a => (a -> a -> a) -> Vector (n+1) a -> Vector (n+2) a
 scanr1' = V.scanr1'
 {-# inline scanr1' #-}
 
diff --git a/src/Data/Vector/Unboxed/Sized.hs b/src/Data/Vector/Unboxed/Sized.hs
--- a/src/Data/Vector/Unboxed/Sized.hs
+++ b/src/Data/Vector/Unboxed/Sized.hs
@@ -1433,22 +1433,22 @@
 {-# inline postscanl' #-}
 
 -- | /O(n)/ Haskell-style scan.
-scanl :: (Unbox a, Unbox b) => (a -> b -> a) -> a -> Vector n b -> Vector n a
+scanl :: (Unbox a, Unbox b) => (a -> b -> a) -> a -> Vector n b -> Vector (1+n) a
 scanl = V.scanl
 {-# inline scanl #-}
 
 -- | /O(n)/ Haskell-style scan with strict accumulator.
-scanl' :: (Unbox a, Unbox b) => (a -> b -> a) -> a -> Vector n b -> Vector n a
+scanl' :: (Unbox a, Unbox b) => (a -> b -> a) -> a -> Vector n b -> Vector (1+n) a
 scanl' = V.scanl'
 {-# inline scanl' #-}
 
 -- | /O(n)/ Scan over a non-empty vector.
-scanl1 :: Unbox a => (a -> a -> a) -> Vector (n+1) a -> Vector (n+1) a
+scanl1 :: Unbox a => (a -> a -> a) -> Vector (1+n) a -> Vector (2+n) a
 scanl1 = V.scanl1
 {-# inline scanl1 #-}
 
 -- | /O(n)/ Scan over a non-empty vector with a strict accumulator.
-scanl1' :: Unbox a => (a -> a -> a) -> Vector (n+1) a -> Vector (n+1) a
+scanl1' :: Unbox a => (a -> a -> a) -> Vector (1+n) a -> Vector (2+n) a
 scanl1' = V.scanl1'
 {-# inline scanl1' #-}
 
@@ -1473,23 +1473,23 @@
 {-# inline postscanr' #-}
 
 -- | /O(n)/ Right-to-left Haskell-style scan.
-scanr :: (Unbox a, Unbox b) => (a -> b -> b) -> b -> Vector n a -> Vector n b
+scanr :: (Unbox a, Unbox b) => (a -> b -> b) -> b -> Vector n a -> Vector (n+1) b
 scanr = V.scanr
 {-# inline scanr #-}
 
 -- | /O(n)/ Right-to-left Haskell-style scan with strict accumulator.
-scanr' :: (Unbox a, Unbox b) => (a -> b -> b) -> b -> Vector n a -> Vector n b
+scanr' :: (Unbox a, Unbox b) => (a -> b -> b) -> b -> Vector n a -> Vector (n+1) b
 scanr' = V.scanr'
 {-# inline scanr' #-}
 
 -- | /O(n)/ Right-to-left scan over a non-empty vector.
-scanr1 :: Unbox a => (a -> a -> a) -> Vector (n+1) a -> Vector (n+1) a
+scanr1 :: Unbox a => (a -> a -> a) -> Vector (n+1) a -> Vector (n+2) a
 scanr1 = V.scanr1
 {-# inline scanr1 #-}
 
 -- | /O(n)/ Right-to-left scan over a non-empty vector with a strict
 -- accumulator.
-scanr1' :: Unbox a => (a -> a -> a) -> Vector (n+1) a -> Vector (n+1) a
+scanr1' :: Unbox a => (a -> a -> a) -> Vector (n+1) a -> Vector (n+2) a
 scanr1' = V.scanr1'
 {-# inline scanr1' #-}
 
diff --git a/vector-sized.cabal b/vector-sized.cabal
--- a/vector-sized.cabal
+++ b/vector-sized.cabal
@@ -1,11 +1,13 @@
--- This file has been generated from package.yaml by hpack version 0.27.0.
+cabal-version: 1.12
+
+-- This file has been generated from package.yaml by hpack version 0.31.2.
 --
 -- see: https://github.com/sol/hpack
 --
--- hash: 9e10d73204f28676f1b2ea3f9f268f3bc030536ef316caacf208ba554a7d0e14
+-- hash: a6e3b4ce977d92b06ce23ff21c540ce53032a023b9b0f55abcbefbe0e68786ac
 
 name:           vector-sized
-version:        1.2.0.1
+version:        1.4.0.0
 synopsis:       Size tagged vectors
 description:    Please see README.md
 category:       Data
@@ -17,12 +19,10 @@
 license:        BSD3
 license-file:   LICENSE
 build-type:     Simple
-cabal-version:  >= 1.10
-
 extra-source-files:
+    readme.md
     changelog.md
     default.nix
-    readme.md
     shell.nix
 
 source-repository head
@@ -48,11 +48,12 @@
   build-depends:
       adjunctions >=4.3 && <4.5
     , base >=4.9 && <5
+    , binary >=0.8.3.0
     , comonad >=4 && <6
     , deepseq >=1.1 && <1.5
     , distributive >=0.5 && <0.7
     , finite-typelits >=0.1
-    , hashable >=1.2.4.0 && <1.3
+    , hashable >=1.2.4.0
     , indexed-list-literals >=0.2.0.0
     , primitive >=0.5 && <0.8
     , vector >=0.11 && <0.13