to 1.1.0 → 1.2.0

raw patch · 3 files changed

+134/−6 lines, 3 filesdep +vectorPVP ok

version bump matches the API change (PVP)

Dependencies added: vector

API changes (from Hackage documentation)

Files

• CHANGELOG.md +5/−0
• src/To.hs +125/−3
• to.cabal +4/−3

@@ -1,3 +1,8 @@+# 1.2.0++* Added `toVector`, `toUnboxedVector`, `toStorableVector`.+* Added `NonEmpty` instances.+ # 1.1.0  * Added `toMap`, `toSet`, `toIntMap`, `toIntSet`, `toHashMap`, `toHashSet`.

@@ -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@

@@ -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