diff --git a/CHANGELOG.md b/CHANGELOG.md
--- a/CHANGELOG.md
+++ b/CHANGELOG.md
@@ -1,3 +1,8 @@
+# 1.2.0
+
+* Added `toVector`, `toUnboxedVector`, `toStorableVector`.
+* Added `NonEmpty` instances.
+
 # 1.1.0
 
 * Added `toMap`, `toSet`, `toIntMap`, `toIntSet`, `toHashMap`, `toHashSet`.
diff --git a/src/To.hs b/src/To.hs
--- a/src/To.hs
+++ b/src/To.hs
@@ -12,6 +12,14 @@
 -- into.
 module To
 (
+    -- * Sequences
+    -- ** 'V.Vector'
+    ToVector(..),
+    -- ** Unboxed 'VU.Vector'
+    ToUnboxedVector(..),
+    -- ** Storable 'VS.Vector'
+    ToStorableVector(..),
+
     -- * Maps
     -- ** 'ML.Map'
     ToMap(..),
@@ -52,6 +60,11 @@
 
 import GHC.TypeLits (TypeError, ErrorMessage(..))
 import Data.Hashable
+import qualified Data.List.NonEmpty as NE
+import qualified Data.Vector as V
+import qualified Data.Vector.Unboxed as VU
+import qualified Data.Vector.Storable as VS
+import qualified Data.Vector.Generic as VG
 import qualified Data.Map.Lazy as ML
 import qualified Data.IntMap.Lazy as IML
 import qualified Data.Set as S
@@ -70,6 +83,90 @@
 import qualified Data.ByteString.UTF8 as UTF8
 
 ----------------------------------------------------------------------------
+-- ToVector
+----------------------------------------------------------------------------
+
+class ToVector a e where
+    -- | Turn into a 'V.Vector'.
+    toVector :: a -> V.Vector e
+
+-- | @[a] -> Vector a@
+instance ToVector [a] a where
+    toVector = V.fromList
+    {-# INLINE toVector #-}
+
+-- | @NonEmpty a -> Vector a@
+instance ToVector (NE.NonEmpty a) a where
+    toVector = V.fromList . NE.toList
+    {-# INLINE toVector #-}
+
+-- | @unboxed Vector a -> Vector a@
+instance VU.Unbox a => ToVector (VU.Vector a) a where
+    toVector = VG.convert
+    {-# INLINE toVector #-}
+
+-- | @storable Vector a -> Vector a@
+instance VS.Storable a => ToVector (VS.Vector a) a where
+    toVector = VG.convert
+    {-# INLINE toVector #-}
+
+----------------------------------------------------------------------------
+-- ToUnboxedVector
+----------------------------------------------------------------------------
+
+class ToUnboxedVector a e where
+    -- | Turn into an unboxed 'VU.Vector'.
+    toUnboxedVector :: a -> VU.Vector e
+
+-- | @[a] -> unboxed Vector a@
+instance VU.Unbox a => ToUnboxedVector [a] a where
+    toUnboxedVector = VU.fromList
+    {-# INLINE toUnboxedVector #-}
+
+-- | @NonEmpty a -> unboxed Vector a@
+instance VU.Unbox a => ToUnboxedVector (NE.NonEmpty a) a where
+    toUnboxedVector = VU.fromList . NE.toList
+    {-# INLINE toUnboxedVector #-}
+
+-- | @Vector a -> unboxed Vector a@
+instance VU.Unbox a => ToUnboxedVector (V.Vector a) a where
+    toUnboxedVector = VG.convert
+    {-# INLINE toUnboxedVector #-}
+
+-- | @storable Vector a -> unboxed Vector a@
+instance (VU.Unbox a, VS.Storable a) => ToUnboxedVector (VS.Vector a) a where
+    toUnboxedVector = VG.convert
+    {-# INLINE toUnboxedVector #-}
+
+----------------------------------------------------------------------------
+-- ToStorableVector
+----------------------------------------------------------------------------
+
+class ToStorableVector a e where
+    -- | Turn into a storable 'VS.Vector'.
+    toStorableVector :: a -> VS.Vector e
+
+-- | @[a] -> storable Vector a@
+instance VS.Storable a => ToStorableVector [a] a where
+    toStorableVector = VS.fromList
+    {-# INLINE toStorableVector #-}
+
+-- | @NonEmpty a -> storable Vector a@
+instance VS.Storable a => ToStorableVector (NE.NonEmpty a) a where
+    toStorableVector = VS.fromList . NE.toList
+    {-# INLINE toStorableVector #-}
+
+-- | @Vector a -> storable Vector a@
+instance VS.Storable a => ToStorableVector (V.Vector a) a where
+    toStorableVector = VG.convert
+    {-# INLINE toStorableVector #-}
+
+-- | @unboxed Vector a -> storable Vector a@
+instance (VU.Unbox a, VS.Storable a) => ToStorableVector (VU.Vector a) a where
+    toStorableVector = VG.convert
+    {-# INLINE toStorableVector #-}
+
+----------------------------------------------------------------------------
 -- ToMap
 ----------------------------------------------------------------------------
 
@@ -82,6 +179,11 @@
     toMap = ML.fromList
     {-# INLINE toMap #-}
 
+-- | @NonEmpty (k, v) -> Map k v@
+instance (kv ~ (k, v), Ord k) => ToMap (NE.NonEmpty kv) k v where
+    toMap = ML.fromList . NE.toList
+    {-# INLINE toMap #-}
+
 -- | @HashMap k v -> Map k v@
 instance Ord k => ToMap (HML.HashMap k v) k v where
     toMap = HML.foldlWithKey' (\m k v -> ML.insert k v m) mempty
@@ -105,6 +207,11 @@
     toSet = S.fromList
     {-# INLINE toSet #-}
 
+-- | @NonEmpty k -> Set k@
+instance Ord k => ToSet (NE.NonEmpty k) k where
+    toSet = S.fromList . NE.toList
+    {-# INLINE toSet #-}
+
 -- | @HashSet k -> Set k@
 instance Ord k => ToSet (HS.HashSet k) k where
     toSet = HS.foldl' (flip S.insert) mempty
@@ -128,6 +235,11 @@
     toIntMap = IML.fromList
     {-# INLINE toIntMap #-}
 
+-- | @NonEmpty (Int, v) -> IntMap v@
+instance (kv ~ (Int, v)) => ToIntMap (NE.NonEmpty kv) v where
+    toIntMap = IML.fromList . NE.toList
+    {-# INLINE toIntMap #-}
+
 -- | @Map Int v -> IntMap v@
 instance ToIntMap (ML.Map Int v) v where
     toIntMap = IML.fromDistinctAscList . ML.toAscList
@@ -151,6 +263,11 @@
     toIntSet = IS.fromList
     {-# INLINE toIntSet #-}
 
+-- | @NonEmpty Int -> IntSet@
+instance (k ~ Int) => ToIntSet (NE.NonEmpty k) where
+    toIntSet = IS.fromList . NE.toList
+    {-# INLINE toIntSet #-}
+
 -- | @Set Int -> IntSet@
 instance ToIntSet (S.Set Int) where
     toIntSet = IS.fromDistinctAscList . S.toAscList
@@ -174,6 +291,11 @@
     toHashMap = HML.fromList
     {-# INLINE toHashMap #-}
 
+-- | @NonEmpty (k, v) -> HashMap k v@
+instance (kv ~ (k, v), Eq k, Hashable k) => ToHashMap (NE.NonEmpty kv) k v where
+    toHashMap = HML.fromList . NE.toList
+    {-# INLINE toHashMap #-}
+
 -- | @Map k v -> HashMap k v@
 instance (Eq k, Hashable k) => ToHashMap (ML.Map k v) k v where
     toHashMap = ML.foldlWithKey' (\m k v -> HML.insert k v m) mempty
@@ -192,9 +314,9 @@
     -- | Turn into a 'HS.HashSet'.
     toHashSet :: a -> HS.HashSet k
 
--- | @[k] -> HashSet k@
-instance (Eq k, Hashable k) => ToHashSet [k] k where
-    toHashSet = HS.fromList
+-- | @NonEmpty k -> HashSet k@
+instance (Eq k, Hashable k) => ToHashSet (NE.NonEmpty k) k where
+    toHashSet = HS.fromList . NE.toList
     {-# INLINE toHashSet #-}
 
 -- | @Set k -> HashSet k@
diff --git a/to.cabal b/to.cabal
--- a/to.cabal
+++ b/to.cabal
@@ -1,5 +1,5 @@
 name:                to
-version:             1.1.0
+version:             1.2.0
 synopsis:            Simple, safe, boring type conversions
 description:
   `to` contains type conversions for popular Haskell types. All provided
@@ -26,10 +26,11 @@
   build-depends:       base >=4.9 && <5,
                        bytestring,
                        containers,
-                       unordered-containers,
                        hashable,
                        text,
-                       utf8-string
+                       unordered-containers,
+                       utf8-string,
+                       vector
   hs-source-dirs:      src
   default-language:    Haskell2010
   ghc-options:         -Wall