vector-sized 0.5.1.0 → 0.6.1.0

raw patch · 5 files changed

+262/−154 lines, 5 filesPVP ok

version bump matches the API change (PVP)

API changes (from Hackage documentation)

Files

• changelog.md +7/−0
• src/Data/Vector/Generic/Sized.hs +104/−47
• src/Data/Vector/Sized.hs +75/−53
• src/Data/Vector/Storable/Sized.hs +75/−53
• vector-sized.cabal +1/−1

@@ -1,5 +1,12 @@ # Change Log +## [0.6.1.0] - 2017-08-04+- Add lenses ix, _head and _last++## [0.6.0.0] - 2017-06-07+- Make ordering of additions in types be more consistent+- Make slice more general+ ## [0.5.1.0] - 2017-02-01 - Loosen upper bound on `vector` 

@@ -100,6 +100,10 @@   , reverse   , backpermute   , unsafeBackpermute+    -- * Lenses+  , ix+  , _head+  , _last     -- * Elementwise operations     -- ** Indexing   , indexed@@ -303,8 +307,8 @@ {-# inline index #-}  -- | /O(1)/ Safe indexing using a 'Proxy'.-index' :: forall v n m a. (KnownNat n, KnownNat m, VG.Vector v a)-       => Vector v (n+m+1) a -> Proxy n -> a+index' :: forall v n m a p. (KnownNat n, KnownNat m, VG.Vector v a)+       => Vector v (n+m+1) a -> p n -> a index' (Vector v) p = v `VG.unsafeIndex` i   where i = fromInteger (natVal p) {-# inline index' #-}@@ -317,7 +321,7 @@  -- | /O(1)/ Yield the first element of a non-empty vector. head :: forall v n a. (VG.Vector v a)-     => Vector v (n+1) a -> a+     => Vector v (1+n) a -> a head (Vector v) = VG.unsafeHead v {-# inline head #-} @@ -327,6 +331,24 @@ last (Vector v) = VG.unsafeLast v {-# inline last #-} +-- | Lens to access (/O(1)/) and update (/O(n)/) an arbitrary element by its index.+ix :: forall v n a f. (KnownNat n, VG.Vector v a, Functor f)+   => Finite n -> (a -> f a) -> Vector v n a -> f (Vector v n a)+ix n f vector = (\x -> vector // [(fromInteger $ getFinite n, x)]) <$> f (index vector n)+{-# inline ix #-}++-- | Lens to access (/O(1)/) and update (/O(n)/) the first element of a non-empty vector.+_head :: forall v n a f. (KnownNat n, VG.Vector v a, Functor f)+      => (a -> f a) -> Vector v (1+n) a -> f (Vector v (1+n) a)+_head f vector = (\x -> cons x $ tail vector) <$> f (head vector)+{-# inline _head #-}++-- | Lens to access (/O(1)/) and update (/O(n)/) the last element of a non-empty vector.+_last :: forall v n a f. (KnownNat n, VG.Vector v a, Functor f)+       => (a -> f a) -> Vector v (n+1) a -> f (Vector v (n+1) a)+_last f vector = (\x -> snoc (init vector) x) <$> f (last vector)+{-# inline _last #-}+ -- | /O(1)/ Safe indexing in a monad. See the documentation for 'VG.indexM' for -- an explanation of why this is useful. indexM :: forall v n a m. (KnownNat n, VG.Vector v a, Monad m)@@ -336,8 +358,8 @@  -- | /O(1)/ Safe indexing in a monad using a 'Proxy'. See the documentation for -- 'VG.indexM' for an explanation of why this is useful.-indexM' :: forall v n k a m. (KnownNat n, KnownNat k, VG.Vector v a, Monad m)-      => Vector v (n+k) a -> Proxy n -> m a+indexM' :: forall v n k a m p. (KnownNat n, KnownNat k, VG.Vector v a, Monad m)+      => Vector v (n+k) a -> p n -> m a indexM' (Vector v) p = v `VG.indexM` i   where i = fromInteger (natVal p) {-# inline indexM' #-}@@ -352,7 +374,7 @@ -- | /O(1)/ Yield the first element of a non-empty vector in a monad. See the -- documentation for 'VG.indexM' for an explanation of why this is useful. headM :: forall v n a m. (KnownNat n, VG.Vector v a, Monad m)-      => Vector v (n+1) a -> m a+      => Vector v (1+n) a -> m a headM (Vector v) = VG.unsafeHeadM v {-# inline headM #-} @@ -365,9 +387,9 @@  -- | /O(1)/ Yield a slice of the vector without copying it with an inferred -- length argument.-slice :: forall v i n a. (KnownNat i, KnownNat n, VG.Vector v a)-      => Proxy i -- ^ starting index-      -> Vector v (i+n) a+slice :: forall v i n m a p. (KnownNat i, KnownNat n, KnownNat m, VG.Vector v a)+      => p i -- ^ starting index+      -> Vector v (i+n+m) a       -> Vector v n a slice start (Vector v) = Vector (VG.unsafeSlice i n v)   where i = fromInteger (natVal start)@@ -376,10 +398,11 @@  -- | /O(1)/ Yield a slice of the vector without copying it with an explicit -- length argument.-slice' :: forall v i n a. (KnownNat i, KnownNat n, VG.Vector v a)-       => Proxy i -- ^ starting index-       -> Proxy n -- ^ length-       -> Vector v (i+n) a+slice' :: forall v i n m a p+        . (KnownNat i, KnownNat n, KnownNat m, VG.Vector v a)+       => p i -- ^ starting index+       -> p n -- ^ length+       -> Vector v (i+n+m) a        -> Vector v n a slice' start _ = slice start {-# inline slice' #-}@@ -394,7 +417,7 @@ -- | /O(1)/ Yield all but the first element of a non-empty vector without -- copying. tail :: forall v n a. (VG.Vector v a)-     => Vector v (n+1) a -> Vector v n a+     => Vector v (1+n) a -> Vector v n a tail (Vector v) = Vector (VG.unsafeTail v) {-# inline tail #-} @@ -402,7 +425,7 @@ -- this many elements. The length of the resultant vector is inferred from the -- type. take :: forall v n m a. (KnownNat n, KnownNat m, VG.Vector v a)-     => Vector v (m+n) a -> Vector v n a+     => Vector v (n+m) a -> Vector v n a take (Vector v) = Vector (VG.unsafeTake i v)   where i = fromInteger (natVal (Proxy :: Proxy n)) {-# inline take #-}@@ -410,8 +433,8 @@ -- | /O(1)/ Yield the first n elements. The resultant vector always contains -- this many elements. The length of the resultant vector is given explicitly -- as a 'Proxy' argument.-take' :: forall v n m a. (KnownNat n, KnownNat m, VG.Vector v a)-      => Proxy n -> Vector v (m+n) a -> Vector v n a+take' :: forall v n m a p. (KnownNat n, KnownNat m, VG.Vector v a)+      => p n -> Vector v (n+m) a -> Vector v n a take' _ = take {-# inline take' #-} @@ -419,7 +442,7 @@ -- contain at least this many elements The length of the resultant vector is -- inferred from the type. drop :: forall v n m a. (KnownNat n, KnownNat m, VG.Vector v a)-     => Vector v (m+n) a -> Vector v m a+     => Vector v (n+m) a -> Vector v m a drop (Vector v) = Vector (VG.unsafeDrop i v)   where i = fromInteger (natVal (Proxy :: Proxy n)) {-# inline drop #-}@@ -427,8 +450,8 @@ -- | /O(1)/ Yield all but the the first n elements. The given vector must -- contain at least this many elements The length of the resultant vector is -- givel explicitly as a 'Proxy' argument.-drop' :: forall v n m a. (KnownNat n, KnownNat m, VG.Vector v a)-      => Proxy n -> Vector v (m+n) a -> Vector v m a+drop' :: forall v n m a p. (KnownNat n, KnownNat m, VG.Vector v a)+      => p n -> Vector v (n+m) a -> Vector v m a drop' _ = drop {-# inline drop' #-} @@ -444,8 +467,8 @@ -- | /O(1)/ Yield the first n elements paired with the remainder without -- copying.  The length of the first resultant vector is passed explicitly as a -- 'Proxy' argument.-splitAt' :: forall v n m a. (KnownNat n, KnownNat m, VG.Vector v a)-         => Proxy n -> Vector v (n+m) a -> (Vector v n a, Vector v m a)+splitAt' :: forall v n m a p. (KnownNat n, KnownNat m, VG.Vector v a)+         => p n -> Vector v (n+m) a -> (Vector v n a, Vector v m a) splitAt' _ = splitAt {-# inline splitAt' #-} @@ -479,8 +502,8 @@  -- | /O(n)/ Construct a vector with the same element in each position where the -- length is given explicitly as a 'Proxy' argument.-replicate' :: forall v n a. (KnownNat n, VG.Vector v a)-           => Proxy n -> a -> Vector v n a+replicate' :: forall v n a p. (KnownNat n, VG.Vector v a)+           => p n -> a -> Vector v n a replicate' _ = replicate {-# inline replicate' #-} @@ -494,8 +517,8 @@  -- | /O(n)/ construct a vector of the given length by applying the function to -- each index where the length is given explicitly as a 'Proxy' argument.-generate' :: forall v n a. (KnownNat n, VG.Vector v a)-          => Proxy n -> (Int -> a) -> Vector v n a+generate' :: forall v n a p. (KnownNat n, VG.Vector v a)+          => p n -> (Int -> a) -> Vector v n a generate' _ = generate {-# inline generate' #-} @@ -520,8 +543,8 @@  -- | /O(n)/ Apply function n times to value. Zeroth element is original value. -- The length is given explicitly as a 'Proxy' argument.-iterateN' :: forall v n a. (KnownNat n, VG.Vector v a)-          => Proxy n -> (a -> a) -> a -> Vector v n a+iterateN' :: forall v n a p. (KnownNat n, VG.Vector v a)+          => p n -> (a -> a) -> a -> Vector v n a iterateN' _ = iterateN {-# inline iterateN' #-} @@ -539,8 +562,8 @@  -- | /O(n)/ Execute the monadic action @n@ times and store the results in a -- vector where @n@ is given explicitly as a 'Proxy' argument.-replicateM' :: forall v n m a. (KnownNat n, VG.Vector v a, Monad m)-            => Proxy n -> m a -> m (Vector v n a)+replicateM' :: forall v n m a p. (KnownNat n, VG.Vector v a, Monad m)+            => p n -> m a -> m (Vector v n a) replicateM' _ = replicateM {-# inline replicateM' #-} @@ -554,8 +577,8 @@  -- | /O(n)/ Construct a vector of length @n@ by applying the monadic action to -- each index where n is given explicitly as a 'Proxy' argument.-generateM' :: forall v n m a. (KnownNat n, VG.Vector v a, Monad m)-           => Proxy n -> (Int -> m a) -> m (Vector v n a)+generateM' :: forall v n m a p. (KnownNat n, VG.Vector v a, Monad m)+           => p n -> (Int -> m a) -> m (Vector v n a) generateM' _ = generateM {-# inline generateM' #-} @@ -586,14 +609,14 @@ -- | /O(n)/ Construct a vector with exactly @n@ elements by repeatedly applying -- the generator function to the a seed. The length, @n@, is given explicitly -- as a 'Proxy' argument.-unfoldrN' :: forall v n a b. (KnownNat n, VG.Vector v a)-          => Proxy n -> (b -> (a, b)) -> b -> Vector v n a+unfoldrN' :: forall v n a b p. (KnownNat n, VG.Vector v a)+          => p n -> (b -> (a, b)) -> b -> Vector v n a unfoldrN' _ = unfoldrN {-# inline unfoldrN' #-}  -- -- ** Enumeration--- +--  -- | /O(n)/ Yield a vector of length @n@ containing the values @x@, @x+1@ -- etc. The length, @n@, is inferred from the type.@@ -605,8 +628,8 @@  -- | /O(n)/ Yield a vector of length @n@ containing the values @x@, @x+1@ -- etc. The length, @n@, is given explicitly as a 'Proxy' argument.-enumFromN' :: forall v n a. (KnownNat n, VG.Vector v a, Num a)-           => a -> Proxy n -> Vector v n a+enumFromN' :: forall v n a p. (KnownNat n, VG.Vector v a, Num a)+           => a -> p n -> Vector v n a enumFromN' a _ = enumFromN a {-# inline enumFromN' #-} @@ -620,8 +643,8 @@  -- | /O(n)/ Yield a vector of the given length containing the values @x@, @x+y@, -- @x+y+y@ etc. The length, @n@, is given explicitly as a 'Proxy' argument.-enumFromStepN' :: forall v n a. (KnownNat n, VG.Vector v a, Num a)-               => a -> a -> Proxy n -> Vector v n a+enumFromStepN' :: forall v n a p. (KnownNat n, VG.Vector v a, Num a)+               => a -> a -> p n -> Vector v n a enumFromStepN' a a' _ = enumFromStepN a a' {-# inline enumFromStepN' #-} @@ -631,7 +654,7 @@  -- | /O(n)/ Prepend an element. cons :: forall v n a. VG.Vector v a-     => a -> Vector v n a -> Vector v (n+1) a+     => a -> Vector v n a -> Vector v (1+n) a cons x (Vector xs) = Vector (VG.cons x xs) {-# inline cons #-} @@ -1208,7 +1231,7 @@ {-# inline foldl #-}  -- | /O(n)/ Left fold on non-empty vectors-foldl1 :: (VG.Vector v a, KnownNat n) => (a -> a -> a) -> Vector v (n+1) a -> a+foldl1 :: (VG.Vector v a, KnownNat n) => (a -> a -> a) -> Vector v (1+n) a -> a foldl1 f = VG.foldl1 f . fromSized {-# inline foldl1 #-} @@ -1218,7 +1241,7 @@ {-# inline foldl' #-}  -- | /O(n)/ Left fold on non-empty vectors with strict accumulator-foldl1' :: (VG.Vector v a, KnownNat n) => (a -> a -> a) -> Vector v (n+1) a -> a+foldl1' :: (VG.Vector v a, KnownNat n) => (a -> a -> a) -> Vector v (1+n) a -> a foldl1' f = VG.foldl1' f . fromSized {-# inline foldl1' #-} @@ -1358,7 +1381,7 @@  -- | /O(n)/ Monadic fold over non-empty vectors fold1M :: (Monad m, VG.Vector v a, KnownNat n)-       => (a -> a -> m a) -> Vector v (n+1) a -> m a+       => (a -> a -> m a) -> Vector v (1+n) a -> m a fold1M m = VG.fold1M m . fromSized {-# inline fold1M #-} @@ -1536,12 +1559,12 @@  -- | /O(n)/ Convert a list to a vector fromList :: (VG.Vector v a, KnownNat n) => [a] -> Maybe (Vector v n a)-fromList = toSized . VG.fromList +fromList = toSized . VG.fromList {-# inline fromList #-}  -- | /O(n)/ Convert the first @n@ elements of a list to a vector. The length of -- the resultant vector is inferred from the type.-fromListN :: forall v n a. (VG.Vector v a, KnownNat n) +fromListN :: forall v n a. (VG.Vector v a, KnownNat n)           => [a] -> Maybe (Vector v n a) fromListN = toSized . VG.fromListN i   where i = fromInteger (natVal (Proxy :: Proxy n))@@ -1549,8 +1572,8 @@  -- | /O(n)/ Convert the first @n@ elements of a list to a vector. The length of -- the resultant vector is given explicitly as a 'Proxy' argument.-fromListN' :: forall v n a. (VG.Vector v a, KnownNat n) -           => Proxy n -> [a] -> Maybe (Vector v n a)+fromListN' :: forall v n a p. (VG.Vector v a, KnownNat n)+           => p n -> [a] -> Maybe (Vector v n a) fromListN' _ = fromListN {-# inline fromListN' #-} @@ -1608,3 +1631,37 @@                  => (v a -> w b) -> Vector v n a -> Vector w n b withVectorUnsafe f (Vector v) = Vector (f v) {-# inline withVectorUnsafe #-}++instance (VG.Vector v a, Num a, KnownNat n) => Num (Vector v n a) where+    (+)         = zipWith (+)+    (-)         = zipWith (-)+    (*)         = zipWith (*)+    negate      = map negate+    abs         = map abs+    signum      = map signum+    fromInteger = replicate . fromInteger++instance (VG.Vector v a, Fractional a, KnownNat n) => Fractional (Vector v n a) where+    (/)          = zipWith (/)+    recip        = map recip+    fromRational = replicate . fromRational++instance (VG.Vector v a, Floating a, KnownNat n) => Floating (Vector v n a) where+    pi      = replicate pi+    exp     = map exp+    log     = map log+    sqrt    = map sqrt+    (**)    = zipWith (**)+    logBase = zipWith logBase+    sin     = map sin+    cos     = map cos+    tan     = map tan+    asin    = map asin+    acos    = map acos+    atan    = map atan+    sinh    = map sinh+    cosh    = map cosh+    tanh    = map tanh+    asinh   = map asinh+    acosh   = map acosh+    atanh   = map atanh

@@ -1,11 +1,11 @@-{-# LANGUAGE DataKinds #-}-{-# LANGUAGE FlexibleContexts #-}-{-# LANGUAGE FlexibleInstances #-}+{-# LANGUAGE DataKinds                  #-}+{-# LANGUAGE FlexibleContexts           #-}+{-# LANGUAGE FlexibleInstances          #-} {-# LANGUAGE GeneralizedNewtypeDeriving #-}-{-# LANGUAGE KindSignatures #-}-{-# LANGUAGE ScopedTypeVariables #-}-{-# LANGUAGE TypeOperators #-}-{-# LANGUAGE RankNTypes #-}+{-# LANGUAGE KindSignatures             #-}+{-# LANGUAGE RankNTypes                 #-}+{-# LANGUAGE ScopedTypeVariables        #-}+{-# LANGUAGE TypeOperators              #-}  {-| This module re-exports the functionality in 'Data.Vector.Generic.Sized'@@ -97,6 +97,10 @@   , reverse   , backpermute   , unsafeBackpermute+  -- * Lenses+  , ix+  , _head+  , _last     -- * Elementwise operations     -- ** Indexing   , indexed@@ -263,8 +267,8 @@ {-# inline index #-}  -- | /O(1)/ Safe indexing using a 'Proxy'.-index' :: forall n m a. (KnownNat n, KnownNat m)-       => Vector (n+m+1) a -> Proxy n -> a+index' :: forall n m a p. (KnownNat n, KnownNat m)+       => Vector (n+m+1) a -> p n -> a index' = V.index' {-# inline index' #-} @@ -275,7 +279,7 @@ {-# inline unsafeIndex #-}  -- | /O(1)/ Yield the first element of a non-empty vector.-head :: forall n a. Vector (n+1) a -> a+head :: forall n a. Vector (1+n) a -> a head = V.head {-# inline head #-} @@ -284,6 +288,24 @@ last = V.last {-# inline last #-} +-- | Lens to access (/O(1)/) and update (/O(n)/) an arbitrary element by its index.+ix :: forall n a f. (KnownNat n, Functor f)+   => Finite n -> (a -> f a) -> Vector n a -> f (Vector n a)+ix = V.ix+{-# inline ix #-}++-- | Lens to access (/O(1)/) and update (/O(n)/) the first element of a non-empty vector.+_head :: forall n a f. (KnownNat n, Functor f)+   => (a -> f a) -> Vector (1+n) a -> f (Vector (1+n) a)+_head = V._head+{-# inline _head #-}++-- | Lens to access (/O(1)/) and update (/O(n)/) the last element of a non-empty vector.+_last :: forall n a f. (KnownNat n, Functor f)+      => (a -> f a) -> Vector (n+1) a -> f (Vector (n+1) a)+_last = V._last+{-# inline _last #-}+ -- | /O(1)/ Safe indexing in a monad. See the documentation for 'VG.indexM' for -- an explanation of why this is useful. indexM :: forall n a m. (KnownNat n, Monad m)@@ -293,8 +315,8 @@  -- | /O(1)/ Safe indexing in a monad using a 'Proxy'. See the documentation for -- 'VG.indexM' for an explanation of why this is useful.-indexM' :: forall n k a m. (KnownNat n, KnownNat k, Monad m)-      => Vector (n+k) a -> Proxy n -> m a+indexM' :: forall n k a m p. (KnownNat n, KnownNat k, Monad m)+      => Vector (n+k) a -> p n -> m a indexM' = V.indexM' {-# inline indexM' #-} @@ -308,7 +330,7 @@ -- | /O(1)/ Yield the first element of a non-empty vector in a monad. See the -- documentation for 'VG.indexM' for an explanation of why this is useful. headM :: forall n a m. (KnownNat n, Monad m)-      => Vector (n+1) a -> m a+      => Vector (1+n) a -> m a headM = V.headM {-# inline headM #-} @@ -321,19 +343,19 @@  -- | /O(1)/ Yield a slice of the vector without copying it with an inferred -- length argument.-slice :: forall i n a. (KnownNat i, KnownNat n)-      => Proxy i -- ^ starting index-      -> Vector (i+n) a+slice :: forall i n m a p. (KnownNat i, KnownNat n, KnownNat m)+      => p i -- ^ starting index+      -> Vector (i+n+m) a       -> Vector n a slice = V.slice {-# inline slice #-}  -- | /O(1)/ Yield a slice of the vector without copying it with an explicit -- length argument.-slice' :: forall i n a. (KnownNat i, KnownNat n)-       => Proxy i -- ^ starting index-       -> Proxy n -- ^ length-       -> Vector (i+n) a+slice' :: forall i n m a p. (KnownNat i, KnownNat n, KnownNat m)+       => p i -- ^ starting index+       -> p n -- ^ length+       -> Vector (i+n+m) a        -> Vector n a slice' = V.slice' {-# inline slice' #-}@@ -346,7 +368,7 @@  -- | /O(1)/ Yield all but the first element of a non-empty vector without -- copying.-tail :: forall n a. Vector (n+1) a -> Vector n a+tail :: forall n a. Vector (1+n) a -> Vector n a tail = V.tail {-# inline tail #-} @@ -354,15 +376,15 @@ -- this many elements. The length of the resultant vector is inferred from the -- type. take :: forall n m a. (KnownNat n, KnownNat m)-     => Vector (m+n) a -> Vector n a+     => Vector (n+m) a -> Vector n a take = V.take {-# inline take #-}  -- | /O(1)/ Yield the first n elements. The resultant vector always contains -- this many elements. The length of the resultant vector is given explicitly -- as a 'Proxy' argument.-take' :: forall n m a. (KnownNat n, KnownNat m)-      => Proxy n -> Vector (m+n) a -> Vector n a+take' :: forall n m a p. (KnownNat n, KnownNat m)+      => p n -> Vector (n+m) a -> Vector n a take' = V.take' {-# inline take' #-} @@ -370,15 +392,15 @@ -- contain at least this many elements The length of the resultant vector is -- inferred from the type. drop :: forall n m a. (KnownNat n, KnownNat m)-     => Vector (m+n) a -> Vector m a+     => Vector (n+m) a -> Vector m a drop = V.drop {-# inline drop #-}  -- | /O(1)/ Yield all but the the first n elements. The given vector must -- contain at least this many elements The length of the resultant vector is -- givel explicitly as a 'Proxy' argument.-drop' :: forall n m a. (KnownNat n, KnownNat m)-      => Proxy n -> Vector (m+n) a -> Vector m a+drop' :: forall n m a p. (KnownNat n, KnownNat m)+      => p n -> Vector (n+m) a -> Vector m a drop' = V.drop' {-# inline drop' #-} @@ -392,8 +414,8 @@ -- | /O(1)/ Yield the first n elements paired with the remainder without -- copying.  The length of the first resultant vector is passed explicitly as a -- 'Proxy' argument.-splitAt' :: forall n m a. (KnownNat n, KnownNat m)-         => Proxy n -> Vector (n+m) a -> (Vector n a, Vector m a)+splitAt' :: forall n m a p. (KnownNat n, KnownNat m)+         => p n -> Vector (n+m) a -> (Vector n a, Vector m a) splitAt' = V.splitAt' {-# inline splitAt' #-} @@ -424,8 +446,8 @@  -- | /O(n)/ Construct a vector with the same element in each position where the -- length is given explicitly as a 'Proxy' argument.-replicate' :: forall n a. KnownNat n-           => Proxy n -> a -> Vector n a+replicate' :: forall n a p. KnownNat n+           => p n -> a -> Vector n a replicate' = V.replicate' {-# inline replicate' #-} @@ -438,8 +460,8 @@  -- | /O(n)/ construct a vector of the given length by applying the function to -- each index where the length is given explicitly as a 'Proxy' argument.-generate' :: forall n a. KnownNat n-          => Proxy n -> (Int -> a) -> Vector n a+generate' :: forall n a p. KnownNat n+          => p n -> (Int -> a) -> Vector n a generate' = V.generate' {-# inline generate' #-} @@ -462,8 +484,8 @@  -- | /O(n)/ Apply function n times to value. Zeroth element is original value. -- The length is given explicitly as a 'Proxy' argument.-iterateN' :: forall n a. KnownNat n-          => Proxy n -> (a -> a) -> a -> Vector n a+iterateN' :: forall n a p. KnownNat n+          => p n -> (a -> a) -> a -> Vector n a iterateN' = V.iterateN' {-# inline iterateN' #-} @@ -480,8 +502,8 @@  -- | /O(n)/ Execute the monadic action @n@ times and store the results in a -- vector where @n@ is given explicitly as a 'Proxy' argument.-replicateM' :: forall n m a. (KnownNat n, Monad m)-            => Proxy n -> m a -> m (Vector n a)+replicateM' :: forall n m a p. (KnownNat n, Monad m)+            => p n -> m a -> m (Vector n a) replicateM' = V.replicateM' {-# inline replicateM' #-} @@ -504,8 +526,8 @@  -- | /O(n)/ Construct a vector of length @n@ by applying the monadic action to -- each index where n is given explicitly as a 'Proxy' argument.-generateM' :: forall n m a. (KnownNat n, Monad m)-           => Proxy n -> (Int -> m a) -> m (Vector n a)+generateM' :: forall n m a p. (KnownNat n, Monad m)+           => p n -> (Int -> m a) -> m (Vector n a) generateM' = V.generateM' {-# inline generateM' #-} @@ -524,14 +546,14 @@ -- | /O(n)/ Construct a vector with exactly @n@ elements by repeatedly applying -- the generator function to the a seed. The length, @n@, is given explicitly -- as a 'Proxy' argument.-unfoldrN' :: forall n a b. KnownNat n-          => Proxy n -> (b -> (a, b)) -> b -> Vector n a+unfoldrN' :: forall n a b p. KnownNat n+          => p n -> (b -> (a, b)) -> b -> Vector n a unfoldrN' = V.unfoldrN' {-# inline unfoldrN' #-}  -- -- ** Enumeration--- +--  -- | /O(n)/ Yield a vector of length @n@ containing the values @x@, @x+1@ -- etc. The length, @n@, is inferred from the type.@@ -542,8 +564,8 @@  -- | /O(n)/ Yield a vector of length @n@ containing the values @x@, @x+1@ -- etc. The length, @n@, is given explicitly as a 'Proxy' argument.-enumFromN' :: forall n a. (KnownNat n, Num a)-           => a -> Proxy n -> Vector n a+enumFromN' :: forall n a p. (KnownNat n, Num a)+           => a -> p n -> Vector n a enumFromN' = V.enumFromN' {-# inline enumFromN' #-} @@ -556,8 +578,8 @@  -- | /O(n)/ Yield a vector of the given length containing the values @x@, @x+y@, -- @x+y+y@ etc. The length, @n@, is given explicitly as a 'Proxy' argument.-enumFromStepN' :: forall n a. (KnownNat n, Num a)-               => a -> a -> Proxy n -> Vector n a+enumFromStepN' :: forall n a p. (KnownNat n, Num a)+               => a -> a -> p n -> Vector n a enumFromStepN' = V.enumFromStepN' {-# inline enumFromStepN' #-} @@ -566,7 +588,7 @@ --  -- | /O(n)/ Prepend an element.-cons :: forall n a. a -> Vector n a -> Vector (n+1) a+cons :: forall n a. a -> Vector n a -> Vector (1+n) a cons = V.cons {-# inline cons #-} @@ -862,7 +884,7 @@          -> Vector n c          -> Vector n d          -> Vector n e-zipWith4 = V.zipWith4 +zipWith4 = V.zipWith4 {-# inline zipWith4 #-}  zipWith5 :: (a -> b -> c -> d -> e -> f)@@ -1074,7 +1096,7 @@ {-# inline foldl #-}  -- | /O(n)/ Left fold on non-empty vectors-foldl1 :: KnownNat n => (a -> a -> a) -> Vector (n+1) a -> a+foldl1 :: KnownNat n => (a -> a -> a) -> Vector (1+n) a -> a foldl1 = V.foldl1 {-# inline foldl1 #-} @@ -1084,7 +1106,7 @@ {-# inline foldl' #-}  -- | /O(n)/ Left fold on non-empty vectors with strict accumulator-foldl1' :: KnownNat n => (a -> a -> a) -> Vector (n+1) a -> a+foldl1' :: KnownNat n => (a -> a -> a) -> Vector (1+n) a -> a foldl1' = V.foldl1' {-# inline foldl1' #-} @@ -1224,7 +1246,7 @@  -- | /O(n)/ Monadic fold over non-empty vectors fold1M :: (Monad m, KnownNat n)-       => (a -> a -> m a) -> Vector (n+1) a -> m a+       => (a -> a -> m a) -> Vector (1+n) a -> m a fold1M = V.fold1M {-# inline fold1M #-} @@ -1413,8 +1435,8 @@  -- | /O(n)/ Convert the first @n@ elements of a list to a vector. The length of -- the resultant vector is given explicitly as a 'Proxy' argument.-fromListN' :: forall n a. KnownNat n-           => Proxy n -> [a] -> Maybe (Vector n a)+fromListN' :: forall n a p. KnownNat n+           => p n -> [a] -> Maybe (Vector n a) fromListN' = V.fromListN' {-# inline fromListN' #-} 

@@ -1,11 +1,10 @@-{-# LANGUAGE DataKinds #-}-{-# LANGUAGE FlexibleContexts #-}-{-# LANGUAGE FlexibleInstances #-}-{-# LANGUAGE GeneralizedNewtypeDeriving #-}-{-# LANGUAGE KindSignatures #-}+{-# LANGUAGE DataKinds           #-}+{-# LANGUAGE FlexibleContexts    #-}+{-# LANGUAGE FlexibleInstances   #-}+{-# LANGUAGE KindSignatures      #-}+{-# LANGUAGE RankNTypes          #-} {-# LANGUAGE ScopedTypeVariables #-}-{-# LANGUAGE TypeOperators #-}-{-# LANGUAGE RankNTypes #-}+{-# LANGUAGE TypeOperators       #-}  {-| This module re-exports the functionality in 'Data.Vector.Generic.Sized'@@ -97,6 +96,10 @@   , reverse   , backpermute   , unsafeBackpermute+    -- * Lenses+  , ix+  , _head+  , _last     -- * Elementwise operations     -- ** Indexing   , indexed@@ -264,8 +267,8 @@ {-# inline index #-}  -- | /O(1)/ Safe indexing using a 'Proxy'.-index' :: forall n m a. (KnownNat n, KnownNat m, Storable a)-       => Vector (n+m+1) a -> Proxy n -> a+index' :: forall n m a p. (KnownNat n, KnownNat m, Storable a)+       => Vector (n+m+1) a -> p n -> a index' = V.index' {-# inline index' #-} @@ -277,7 +280,7 @@  -- | /O(1)/ Yield the first element of a non-empty vector. head :: forall n a. (Storable a)-     => Vector (n+1) a -> a+     => Vector (1+n) a -> a head = V.head {-# inline head #-} @@ -287,6 +290,25 @@ last = V.last {-# inline last #-} +-- | Lens to access (/O(1)/) and update (/O(n)/) an arbitrary element by its index.+ix :: forall n a f. (KnownNat n, Storable a, Functor f)+   => Finite n -> (a -> f a) -> Vector n a -> f (Vector n a)+ix = V.ix+{-# inline ix #-}++-- | Lens to access (/O(1)/) and update (/O(n)/) the first element of a non-empty vector.+_head :: forall n a f. (KnownNat n, Storable a, Functor f)+      => (a -> f a) -> Vector (1+n) a -> f (Vector (1+n) a)+_head = V._head+{-# inline _head #-}++-- | Lens to access (/O(1)/) and update (/O(n)/) the last element of a non-empty vector.+_last :: forall n a f. (KnownNat n, Storable a, Functor f)+       => (a -> f a) -> Vector (n+1) a -> f (Vector (n+1) a)+_last = V._last+{-# inline _last #-}++ -- | /O(1)/ Safe indexing in a monad. See the documentation for 'VG.indexM' for -- an explanation of why this is useful. indexM :: forall n a m. (KnownNat n, Storable a, Monad m)@@ -296,8 +318,8 @@  -- | /O(1)/ Safe indexing in a monad using a 'Proxy'. See the documentation for -- 'VG.indexM' for an explanation of why this is useful.-indexM' :: forall n k a m. (KnownNat n, KnownNat k, Storable a, Monad m)-      => Vector (n+k) a -> Proxy n -> m a+indexM' :: forall n k a m p. (KnownNat n, KnownNat k, Storable a, Monad m)+      => Vector (n+k) a -> p n -> m a indexM' = V.indexM' {-# inline indexM' #-} @@ -311,7 +333,7 @@ -- | /O(1)/ Yield the first element of a non-empty vector in a monad. See the -- documentation for 'VG.indexM' for an explanation of why this is useful. headM :: forall n a m. (KnownNat n, Storable a, Monad m)-      => Vector (n+1) a -> m a+      => Vector (1+n) a -> m a headM = V.headM {-# inline headM #-} @@ -324,19 +346,19 @@  -- | /O(1)/ Yield a slice of the vector without copying it with an inferred -- length argument.-slice :: forall i n a. (KnownNat i, KnownNat n, Storable a)-      => Proxy i -- ^ starting index-      -> Vector (i+n) a+slice :: forall i n m a p. (KnownNat i, KnownNat n, KnownNat m, Storable a)+      => p i -- ^ starting index+      -> Vector (i+n+m) a       -> Vector n a slice = V.slice {-# inline slice #-}  -- | /O(1)/ Yield a slice of the vector without copying it with an explicit -- length argument.-slice' :: forall i n a. (KnownNat i, KnownNat n, Storable a)-       => Proxy i -- ^ starting index-       -> Proxy n -- ^ length-       -> Vector (i+n) a+slice' :: forall i n m a p. (KnownNat i, KnownNat n, KnownNat m, Storable a)+       => p i -- ^ starting index+       -> p n -- ^ length+       -> Vector (i+n+m) a        -> Vector n a slice' = V.slice' {-# inline slice' #-}@@ -351,7 +373,7 @@ -- | /O(1)/ Yield all but the first element of a non-empty vector without -- copying. tail :: forall n a. (Storable a)-     => Vector (n+1) a -> Vector n a+     => Vector (1+n) a -> Vector n a tail = V.tail {-# inline tail #-} @@ -359,15 +381,15 @@ -- this many elements. The length of the resultant vector is inferred from the -- type. take :: forall n m a. (KnownNat n, KnownNat m, Storable a)-     => Vector (m+n) a -> Vector n a+     => Vector (n+m) a -> Vector n a take = V.take {-# inline take #-}  -- | /O(1)/ Yield the first n elements. The resultant vector always contains -- this many elements. The length of the resultant vector is given explicitly -- as a 'Proxy' argument.-take' :: forall n m a. (KnownNat n, KnownNat m, Storable a)-      => Proxy n -> Vector (m+n) a -> Vector n a+take' :: forall n m a p. (KnownNat n, KnownNat m, Storable a)+      => p n -> Vector (n+m) a -> Vector n a take' = V.take' {-# inline take' #-} @@ -375,15 +397,15 @@ -- contain at least this many elements The length of the resultant vector is -- inferred from the type. drop :: forall n m a. (KnownNat n, KnownNat m, Storable a)-     => Vector (m+n) a -> Vector m a+     => Vector (n+m) a -> Vector m a drop = V.drop {-# inline drop #-}  -- | /O(1)/ Yield all but the the first n elements. The given vector must -- contain at least this many elements The length of the resultant vector is -- givel explicitly as a 'Proxy' argument.-drop' :: forall n m a. (KnownNat n, KnownNat m, Storable a)-      => Proxy n -> Vector (m+n) a -> Vector m a+drop' :: forall n m a p. (KnownNat n, KnownNat m, Storable a)+      => p n -> Vector (n+m) a -> Vector m a drop' = V.drop' {-# inline drop' #-} @@ -397,8 +419,8 @@ -- | /O(1)/ Yield the first n elements paired with the remainder without -- copying.  The length of the first resultant vector is passed explicitly as a -- 'Proxy' argument.-splitAt' :: forall n m a. (KnownNat n, KnownNat m, Storable a)-         => Proxy n -> Vector (n+m) a -> (Vector n a, Vector m a)+splitAt' :: forall n m a p. (KnownNat n, KnownNat m, Storable a)+         => p n -> Vector (n+m) a -> (Vector n a, Vector m a) splitAt' = V.splitAt' {-# inline splitAt' #-} @@ -431,8 +453,8 @@  -- | /O(n)/ Construct a vector with the same element in each position where the -- length is given explicitly as a 'Proxy' argument.-replicate' :: forall n a. (KnownNat n, Storable a)-           => Proxy n -> a -> Vector n a+replicate' :: forall n a p. (KnownNat n, Storable a)+           => p n -> a -> Vector n a replicate' = V.replicate' {-# inline replicate' #-} @@ -445,8 +467,8 @@  -- | /O(n)/ construct a vector of the given length by applying the function to -- each index where the length is given explicitly as a 'Proxy' argument.-generate' :: forall n a. (KnownNat n, Storable a)-          => Proxy n -> (Int -> a) -> Vector n a+generate' :: forall n a p. (KnownNat n, Storable a)+          => p n -> (Int -> a) -> Vector n a generate' = V.generate' {-# inline generate' #-} @@ -469,8 +491,8 @@  -- | /O(n)/ Apply function n times to value. Zeroth element is original value. -- The length is given explicitly as a 'Proxy' argument.-iterateN' :: forall n a. (KnownNat n, Storable a)-          => Proxy n -> (a -> a) -> a -> Vector n a+iterateN' :: forall n a p. (KnownNat n, Storable a)+          => p n -> (a -> a) -> a -> Vector n a iterateN' = V.iterateN' {-# inline iterateN' #-} @@ -487,8 +509,8 @@  -- | /O(n)/ Execute the monadic action @n@ times and store the results in a -- vector where @n@ is given explicitly as a 'Proxy' argument.-replicateM' :: forall n m a. (KnownNat n, Storable a, Monad m)-            => Proxy n -> m a -> m (Vector n a)+replicateM' :: forall n m a p. (KnownNat n, Storable a, Monad m)+            => p n -> m a -> m (Vector n a) replicateM' = V.replicateM' {-# inline replicateM' #-} @@ -501,8 +523,8 @@  -- | /O(n)/ Construct a vector of length @n@ by applying the monadic action to -- each index where n is given explicitly as a 'Proxy' argument.-generateM' :: forall n m a. (KnownNat n, Storable a, Monad m)-           => Proxy n -> (Int -> m a) -> m (Vector n a)+generateM' :: forall n m a p. (KnownNat n, Storable a, Monad m)+           => p n -> (Int -> m a) -> m (Vector n a) generateM' = V.generateM' {-# inline generateM' #-} @@ -531,14 +553,14 @@ -- | /O(n)/ Construct a vector with exactly @n@ elements by repeatedly applying -- the generator function to the a seed. The length, @n@, is given explicitly -- as a 'Proxy' argument.-unfoldrN' :: forall n a b. (KnownNat n, Storable a)-          => Proxy n -> (b -> (a, b)) -> b -> Vector n a+unfoldrN' :: forall n a b p. (KnownNat n, Storable a)+          => p n -> (b -> (a, b)) -> b -> Vector n a unfoldrN' = V.unfoldrN' {-# inline unfoldrN' #-}  -- -- ** Enumeration--- +--  -- | /O(n)/ Yield a vector of length @n@ containing the values @x@, @x+1@ -- etc. The length, @n@, is inferred from the type.@@ -549,8 +571,8 @@  -- | /O(n)/ Yield a vector of length @n@ containing the values @x@, @x+1@ -- etc. The length, @n@, is given explicitly as a 'Proxy' argument.-enumFromN' :: forall n a. (KnownNat n, Storable a, Num a)-           => a -> Proxy n -> Vector n a+enumFromN' :: forall n a p. (KnownNat n, Storable a, Num a)+           => a -> p n -> Vector n a enumFromN' = V.enumFromN' {-# inline enumFromN' #-} @@ -563,8 +585,8 @@  -- | /O(n)/ Yield a vector of the given length containing the values @x@, @x+y@, -- @x+y+y@ etc. The length, @n@, is given explicitly as a 'Proxy' argument.-enumFromStepN' :: forall n a. (KnownNat n, Storable a, Num a)-               => a -> a -> Proxy n -> Vector n a+enumFromStepN' :: forall n a p. (KnownNat n, Storable a, Num a)+               => a -> a -> p n -> Vector n a enumFromStepN' = V.enumFromStepN' {-# inline enumFromStepN' #-} @@ -574,7 +596,7 @@  -- | /O(n)/ Prepend an element. cons :: forall n a. Storable a-     => a -> Vector n a -> Vector (n+1) a+     => a -> Vector n a -> Vector (1+n) a cons = V.cons {-# inline cons #-} @@ -896,7 +918,7 @@          -> Vector n c          -> Vector n d          -> Vector n e-zipWith4 = V.zipWith4 +zipWith4 = V.zipWith4 {-# inline zipWith4 #-}  zipWith5 :: (Storable a,Storable b,Storable c,Storable d,Storable e,Storable f)@@ -1128,7 +1150,7 @@ {-# inline foldl #-}  -- | /O(n)/ Left fold on non-empty vectors-foldl1 :: (Storable a, KnownNat n) => (a -> a -> a) -> Vector (n+1) a -> a+foldl1 :: (Storable a, KnownNat n) => (a -> a -> a) -> Vector (1+n) a -> a foldl1 = V.foldl1 {-# inline foldl1 #-} @@ -1138,7 +1160,7 @@ {-# inline foldl' #-}  -- | /O(n)/ Left fold on non-empty vectors with strict accumulator-foldl1' :: (Storable a, KnownNat n) => (a -> a -> a) -> Vector (n+1) a -> a+foldl1' :: (Storable a, KnownNat n) => (a -> a -> a) -> Vector (1+n) a -> a foldl1' = V.foldl1' {-# inline foldl1' #-} @@ -1278,7 +1300,7 @@  -- | /O(n)/ Monadic fold over non-empty vectors fold1M :: (Monad m, Storable a, KnownNat n)-       => (a -> a -> m a) -> Vector (n+1) a -> m a+       => (a -> a -> m a) -> Vector (1+n) a -> m a fold1M = V.fold1M {-# inline fold1M #-} @@ -1468,8 +1490,8 @@  -- | /O(n)/ Convert the first @n@ elements of a list to a vector. The length of -- the resultant vector is given explicitly as a 'Proxy' argument.-fromListN' :: forall n a. (Storable a, KnownNat n)-           => Proxy n -> [a] -> Maybe (Vector n a)+fromListN' :: forall n a p. (Storable a, KnownNat n)+           => p n -> [a] -> Maybe (Vector n a) fromListN' = V.fromListN' {-# inline fromListN' #-} 

@@ -1,5 +1,5 @@ name:                vector-sized-version:             0.5.1.0+version:             0.6.1.0 synopsis:            Size tagged vectors description:         Please see README.md homepage:            http://github.com/expipiplus1/vector-sized#readme