fixed-vector 0.3.0.1 → 0.4.0.0

raw patch · 9 files changed

+566/−52 lines, 9 filesPVP ok

version bump matches the API change (PVP)

API changes (from Hackage documentation)

Files

• Data/Vector/Fixed.hs +76/−2
• Data/Vector/Fixed/Boxed.hs +32/−3
• Data/Vector/Fixed/Cont.hs +32/−44
• Data/Vector/Fixed/Internal.hs +16/−2
• Data/Vector/Fixed/Monomorphic.hs +362/−0
• Data/Vector/Fixed/Primitive.hs +8/−0
• Data/Vector/Fixed/Storable.hs +8/−0
• Data/Vector/Fixed/Unboxed.hs +10/−0
• fixed-vector.cabal +22/−1

@@ -1,4 +1,10 @@ {-# OPTIONS_GHC -fno-warn-orphans #-}+{-# LANGUAGE TypeFamilies      #-}+{-# LANGUAGE FlexibleInstances #-}+{-# LANGUAGE MultiParamTypeClasses #-}+{-# LANGUAGE ScopedTypeVariables #-}+{-# LANGUAGE GADTs               #-}+{-# LANGUAGE DeriveDataTypeable  #-} -- | -- Generic API for vectors with fixed length. --@@ -25,6 +31,7 @@   , Fun(..)   , length     -- * Constructors+    -- $construction     -- ** Small dimensions     -- $smallDim   , mk1@@ -60,6 +67,8 @@   , imapM_   , sequence   , sequence_+  , sequenceA+  , traverse     -- * Folding   , foldl   , foldr@@ -86,11 +95,16 @@   , toList   , fromList     -- * Data types-  , VecList+  , VecList(..)   ) where +import Control.Applicative (Applicative(..))+import Data.Typeable       (Typeable)+import qualified Data.Foldable    as F+import qualified Data.Traversable as T+ import Data.Vector.Fixed.Internal.Arity-import Data.Vector.Fixed.Cont     (VecList,Vector(..),VectorN,Dim,length)+import Data.Vector.Fixed.Cont     (Vector(..),VectorN,Dim,length) import qualified Data.Vector.Fixed.Cont as C import Data.Vector.Fixed.Internal @@ -100,6 +114,21 @@                       , head,tail,mapM,mapM_,sequence,sequence_                       ) ++-- $construction+--+-- In addition to functions list above it's possible to use tuples in+-- conjunction with 'convert' function to create vectors. For example:+--+-- v = convert (x,y,z)+--+-- It will work on if type of @v@ is know from elsewhere. Same trick+-- could be used to pattern match on the vector with opaque+-- representation using view patterns+--+-- > function :: Vec N3 Double -> ...+-- > function (convert -> (x,y,z)) = ...+ -- $smallDim -- -- Constructors for vectors with small dimensions.@@ -128,3 +157,48 @@ "fixed-vector:index/basicIndex"[1] forall vv i.   runIndex i (C.cvec vv) = C.basicIndex vv i  #-}+++-- | Vector based on the lists. Not very useful by itself but is+--   necessary for implementation.+data VecList n a where+  Nil  :: VecList Z a+  Cons :: a -> VecList n a -> VecList (S n) a+  deriving (Typeable)++-- Vector instance+type instance Dim (VecList n) = n++instance Arity n => Vector (VecList n) a where+  construct = Fun $ accum+    (\(T_List f) a -> T_List (f . Cons a))+    (\(T_List f)   -> f Nil)+    (T_List id :: T_List a n n)+  inspect v (Fun f) = apply step (Flip v) f+    where+      step :: Flip VecList a (S k)  -> (a, Flip VecList a k)+      step (Flip (Cons a xs)) = (a, Flip xs)+  {-# INLINE construct #-}+  {-# INLINE inspect   #-}+instance Arity n => VectorN VecList n a++newtype Flip f a n = Flip (f n a)++newtype T_List a n k = T_List (VecList k a -> VecList n a)+++-- Standard instances+instance (Show a, Arity n) => Show (VecList n a) where+  show = show . foldr (:) []+instance (Eq a, Arity n) => Eq (VecList n a) where+  (==) = eq+instance Arity n => Functor (VecList n) where+  fmap = map+instance Arity n => Applicative (VecList n) where+  pure  = replicate+  (<*>) = zipWith ($)+instance Arity n => F.Foldable (VecList n) where+  foldr = foldr+instance Arity n => T.Traversable (VecList n) where+  sequenceA = sequenceA+  traverse  = traverse

@@ -1,7 +1,8 @@ {-# LANGUAGE TypeFamilies          #-} {-# LANGUAGE FlexibleInstances     #-} {-# LANGUAGE MultiParamTypeClasses #-}-{-# LANGUAGE ScopedTypeVariables #-}+{-# LANGUAGE ScopedTypeVariables   #-}+{-# LANGUAGE DeriveDataTypeable    #-} -- | -- Boxed vector. module Data.Vector.Fixed.Boxed (@@ -9,13 +10,18 @@     Vec   , Vec2   , Vec3+  , Vec4+  , Vec5     -- * Mutable   , MVec   ) where -import Control.Monad+import Control.Applicative  (Applicative(..)) import Data.Primitive.Array-import Prelude hiding (length,replicate,zipWith,map,foldl)+import Data.Typeable        (Typeable)+import qualified Data.Foldable    as F+import qualified Data.Traversable as T+import Prelude hiding (length,replicate,zipWith,map,foldl,foldr)  import Data.Vector.Fixed import Data.Vector.Fixed.Internal.Arity@@ -29,12 +35,16 @@  -- | Vector with fixed length which can hold any value. newtype Vec n a = Vec (Array a)+                  deriving (Typeable)  -- | Mutable unboxed vector with fixed length newtype MVec n s a = MVec (MutableArray s a)+                     deriving (Typeable)  type Vec2 = Vec (S (S Z)) type Vec3 = Vec (S (S (S Z)))+type Vec4 = Vec (S (S (S (S Z))))+type Vec5 = Vec (S (S (S (S (S Z)))))   @@ -90,6 +100,25 @@   (==) = eq   {-# INLINE (==) #-} +instance Arity n => Functor (Vec n) where+  {-# INLINE fmap #-}+  fmap = map++instance Arity n => Applicative (Vec n) where+  pure  = replicate+  (<*>) = zipWith ($)+  {-# INLINE pure  #-}+  {-# INLINE (<*>) #-}++instance Arity n => F.Foldable (Vec n) where+  foldr = foldr+  {-# INLINE foldr #-}++instance Arity n => T.Traversable (Vec n) where+  sequenceA = sequenceA+  traverse  = traverse+  {-# INLINE sequenceA #-}+  {-# INLINE traverse #-}  uninitialised :: a uninitialised = error "Data.Vector.Fixed.Boxed: uninitialised element"

@@ -13,7 +13,7 @@   , VectorN   , length     -- * Vector as continuation-  , ContVecT+  , ContVecT(..)   , ContVec     -- ** Synonyms for small numerals   , N1@@ -24,6 +24,7 @@   , N6     -- * Construction of ContVec   , cvec+  , empty   , fromList   , replicate   , replicateM@@ -77,12 +78,10 @@   , or   , all   , any-    -- * Data types-  , VecList   ) where -import Control.Applicative-import Data.Complex (Complex(..))+import Control.Applicative (Applicative(..))+import Data.Complex        (Complex(..)) import Data.Vector.Fixed.Internal.Arity import Data.Vector.Fixed.Internal.Id import Prelude hiding ( replicate,map,zipWith,maximum,minimum,and,or,any,all@@ -98,7 +97,11 @@ -- | Size of vector expressed as type-level natural. type family Dim (v :: * -> *) --- | Type class for vectors with fixed length.+-- | Type class for vectors with fixed length. Instance should provide+-- two functions: one to create vector and another for vector+-- deconstruction. They must obey following law:+--+-- > inspect v construct = v class Arity (Dim v) => Vector v a where   -- | N-ary function for creation of vectors.   construct :: Fun (Dim v) a (v a)@@ -145,7 +148,7 @@   {-# INLINE (<*>) #-}  -- | Change monad type for the continuation vector.-changeMonad :: (Monad p, Monad m, Arity n)+changeMonad :: (Monad p, Arity n)             => (forall x. p x -> x) -- ^ Function to extract result from monad             -> ContVecT p n a -> ContVecT m n a {-# INLINE changeMonad #-}@@ -172,6 +175,11 @@ cvec v = ContVecT (inspect v) {-# INLINE[0] cvec #-} +-- | Create empty vector.+empty :: ContVecT m Z a+{-# INLINE empty #-}+empty = ContVecT (\(Fun r) -> r)+ -- | Convert list to continuation-based vector. Will throw error if --   list is shorter than resulting vector. fromList :: forall m n a. Arity n => [a] -> ContVecT m n a@@ -359,34 +367,43 @@   --- FIXME: explain function izipWithF :: forall n a b c r. (Arity n)           => (Int -> a -> b -> c) -> Fun n c r -> Fun n a (Fun n b r) {-# INLINE izipWithF #-} izipWithF f (Fun g0) =   fmap (\v -> Fun $ accum-              (\(T_izip i (VecList (a:as)) g) b -> T_izip (i+1) (VecList as) (g $ f i a b)+              (\(T_izip i (a:as) g) b -> T_izip (i+1) as (g $ f i a b)               )               (\(T_izip _ _ x) -> x)               (T_izip 0 v g0 :: (T_izip a c r n))-       ) construct+       ) makeList  izipWithFM :: forall m n a b c r. (Arity n, Monad m)            => (Int -> a -> b -> m c) -> Fun n c (m r) -> Fun n a (Fun n b (m r)) {-# INLINE izipWithFM #-} izipWithFM f (Fun g0) =   fmap (\v -> Fun $ accumM-              (\(T_izip i (VecList (a:as)) g) b -> do x <- f i a b-                                                      return $ T_izip (i+1) (VecList as) (g x)+              (\(T_izip i (a:as) g) b -> do x <- f i a b+                                            return $ T_izip (i+1) as (g x)               )               (\(T_izip _ _ x) -> x)               (return $ T_izip 0 v g0 :: m (T_izip a c (m r) n))-       ) construct+       ) makeList -data T_izip a c r n = T_izip Int (VecList n a) (Fn n c r) +makeList :: forall n a. Arity n => Fun n a [a]+{-# INLINE makeList #-}+makeList = Fun $ accum+    (\(T_mkList xs) x -> T_mkList (xs . (x:)))+    (\(T_mkList xs) -> xs [])+    (T_mkList id :: T_mkList a n) +newtype T_mkList a n = T_mkList ([a] -> [a]) +data T_izip a c r n = T_izip Int [a] (Fn n c r)+++ ---------------------------------------------------------------- -- Running vector ----------------------------------------------------------------@@ -595,36 +612,7 @@   cvec (vector v) = changeMonad runID v   #-} -------------------------------------------------------------------- VecList--------------------------------------------------------------------- | Vector based on the lists. Not very useful by itself but is---   necessary for implementation.-newtype VecList n a = VecList [a]-                      deriving (Show,Eq)--type instance Dim (VecList n) = n--newtype Flip f a n = Flip (f n a)--newtype T_list a n = T_list ([a] -> [a])---- It's vital to avoid 'reverse' and build list using [a]->[a]--- functions. Reverse is recursive and interferes with inlining.-instance Arity n => Vector (VecList n) a where-  construct = Fun $ accum-    (\(T_list xs) x -> T_list (xs . (x:)))-    (\(T_list xs) -> VecList (xs []) :: VecList n a)-    (T_list id :: T_list a n)-  inspect v (Fun f) = apply-    (\(Flip (VecList (x:xs))) -> (x, Flip (VecList xs)))-    (Flip v)-    f-  {-# INLINE construct #-}-  {-# INLINE inspect   #-}-instance Arity n => VectorN VecList n a-+  ---------------------------------------------------------------- -- Instances ----------------------------------------------------------------

@@ -5,10 +5,12 @@ -- Implementation of fixed-vectors module Data.Vector.Fixed.Internal where +import Control.Applicative (Applicative)+import qualified Data.Traversable as T+ import Data.Vector.Fixed.Internal.Arity import Data.Vector.Fixed.Cont     (Vector(..),Dim) import qualified Data.Vector.Fixed.Cont as C- import qualified Prelude as P import Prelude hiding ( replicate,map,zipWith,maximum,minimum,and,or,all,any                       , foldl,foldr,foldl1,length,sum@@ -211,7 +213,7 @@ foldl f x = C.runContVec (C.foldl f x)           . C.cvec --- | Left fold over vector+-- | Right fold over vector foldr :: Vector v a => (a -> b -> b) -> b -> v a -> b {-# INLINE foldr #-} foldr f x = C.runContVec (C.foldr f x)@@ -381,6 +383,18 @@ {-# INLINE imapM_ #-} imapM_ f = ifoldl (\m i a -> m >> f i a >> return ()) (return ()) ++-- | Analog of 'T.sequenceA' from 'T.Traversable'.+sequenceA :: (Vector v a, Vector v (f a), Applicative f)+          => v (f a) -> f (v a)+{-# INLINE sequenceA #-}+sequenceA = fmap fromList . T.sequenceA . toList++-- | Analog of 'T.traverse' from 'T.Traversable'.+traverse :: (Vector v a, Vector v b, Applicative f)+          => (a -> f b) -> v a -> f (v b)+{-# INLINE traverse #-}+traverse f = fmap fromList . T.traverse f . toList  ---------------------------------------------------------------- 

@@ -0,0 +1,362 @@+{-# LANGUAGE MultiParamTypeClasses #-}+{-# LANGUAGE FlexibleInstances #-}+{-# LANGUAGE FlexibleContexts #-}+{-# LANGUAGE TypeFamilies #-}+-- |+-- Wrapper function for working with monomorphic vectors. Standard API+-- require vector to be parametric in their element type making it+-- impossible to work with vectors like+--+-- > data Vec3 = Vec3 Double Double Double+--+-- This module provides newtype wrapper which allows use of functions+-- from "Data.Vector.Fixed" with such data types and function which+-- works with such vectors.+--+-- Functions have same meaning as ones from "Data.Vector.Fixed" and+-- documented there.+module Data.Vector.Fixed.Monomorphic (+    -- * Vector type class+    -- ** Vector size+    DimMono+  , Z+  , S+    -- ** Synonyms for small numerals+  , F.N1+  , F.N2+  , F.N3+  , F.N4+  , F.N5+  , F.N6+    -- ** Type class+  , VectorMono(..)+  , Arity+  , Fun(..)+  , length+    -- * Constructors+    -- $construction+    -- ** Small dimensions+    -- $smallDim+  , mk1+  , mk2+  , mk3+  , mk4+  , mk5+    -- ** Functions+  , replicate+  , replicateM+  , generate+  , generateM+  , unfoldr+  , basis+    -- * Modifying vectors+    -- ** Transformations+  , head+  , tail+  , (!)+    -- ** Comparison+  , eq+    -- ** Maps+  , map+  , mapM+  , mapM_+  , imap+  , imapM+  , imapM_+    -- * Folding+  , foldl+  , foldr+  , foldl1+  , ifoldl+  , ifoldr+  , foldM+  , ifoldM+    -- ** Special folds+  , sum+  , maximum+  , minimum+  , and+  , or+  , all+  , any+    -- * Zips+  , zipWith+  , zipWithM+  , izipWith+  , izipWithM+    -- * Conversion+  , convert+  , toList+  , fromList+  ) where++import Control.Monad (liftM)+import Data.Vector.Fixed.Internal.Arity+import qualified Data.Vector.Fixed as F+import Prelude hiding ( replicate,map,zipWith,maximum,minimum,and,or,all,any+                      , foldl,foldr,foldl1,length,sum+                      , head,tail,mapM,mapM_,sequence,sequence_+                      )+++----------------------------------------------------------------+-- Wrappers for monomorphic vectors+----------------------------------------------------------------++-- | Wrapper for monomorphic vectors it provides 'Vector' instance for+--   monomorphic vectors. Trick is to restrict type parameter @a@ to+--   single possible value.+newtype Mono v a = Mono { getMono :: v }++type instance F.Dim (Mono v) = DimMono v++instance (VectorMono v, a ~ VectorElm v, Arity (DimMono v)) => F.Vector (Mono v) a where+  construct  = fmap Mono construct+  inspect    = inspect . getMono+  basicIndex = basicIndex . getMono+  {-# INLINE construct  #-}+  {-# INLINE inspect    #-}+  {-# INLINE basicIndex #-}+++-- | Dimensions of monomorphic vector.+type family DimMono v :: *++-- | Counterpart of 'Vector' type class for monomorphic vectors.+class Arity (DimMono v) => VectorMono v where+  -- | Type of vector elements.+  type VectorElm v :: *+  -- | Construct vector+  construct :: Fun (DimMono v) (VectorElm v) v+  -- | Inspect vector+  inspect   :: v -> Fun (DimMono v) (VectorElm v) r -> r+  -- | Optional more efficient implementation of indexing+  basicIndex :: v -> Int -> VectorElm v+  basicIndex v i = Mono v F.! i+  {-# INLINE basicIndex #-}++-- | Length of vector+length :: Arity (DimMono v) => v -> Int+length = F.length . Mono+{-# INLINE length #-}+++----------------------------------------------------------------+--+----------------------------------------------------------------++mk1 :: (VectorMono v, VectorElm v ~ a, DimMono v ~ F.N1)+    => a -> v+mk1 a1 = getMono $ F.mk1 a1+{-# INLINE mk1 #-}++mk2 :: (VectorMono v, VectorElm v ~ a, DimMono v ~ F.N2)+    => a -> a-> v+mk2 a1 a2 = getMono $ F.mk2 a1 a2+{-# INLINE mk2 #-}++mk3 :: (VectorMono v, VectorElm v ~ a, DimMono v ~ F.N3)+    => a -> a-> a -> v+mk3 a1 a2 a3 = getMono $ F.mk3 a1 a2 a3+{-# INLINE mk3 #-}++mk4 :: (VectorMono v, VectorElm v ~ a, DimMono v ~ F.N4)+    => a -> a-> a -> a -> v+mk4 a1 a2 a3 a4 = getMono $ F.mk4 a1 a2 a3 a4+{-# INLINE mk4 #-}++mk5 :: (VectorMono v, VectorElm v ~ a, DimMono v ~ F.N5)+    => a -> a-> a -> a -> a -> v+mk5 a1 a2 a3 a4 a5 = getMono $ F.mk5 a1 a2 a3 a4 a5+{-# INLINE mk5 #-}++replicate :: (VectorMono v, VectorElm v ~ a) => a -> v+{-# INLINE replicate #-}+replicate = getMono . F.replicate++replicateM :: (VectorMono v, VectorElm v ~ a, Monad m) => m a -> m v+{-# INLINE replicateM #-}+replicateM a = getMono `liftM` F.replicateM a++basis :: (VectorMono v, VectorElm v ~ a, Num a) => Int -> v+{-# INLINE basis #-}+basis = getMono . F.basis++unfoldr :: (VectorMono v, VectorElm v ~ a) => (b -> (a,b)) -> b -> v+{-# INLINE unfoldr #-}+unfoldr f = getMono . F.unfoldr f++generate :: (VectorMono v, VectorElm v ~ a) => (Int -> a) -> v+{-# INLINE generate #-}+generate = getMono . F.generate++generateM :: (Monad m, VectorMono v, VectorElm v ~ a) => (Int -> m a) -> m v+{-# INLINE generateM #-}+generateM f = getMono `liftM` F.generateM f++++----------------------------------------------------------------++head :: (VectorMono v, VectorElm v ~ a, DimMono v ~ S n) => v -> a+{-# INLINE head #-}+head = F.head . Mono++tail :: ( VectorMono v, VectorElm v ~ a+        , VectorMono w, VectorElm w ~ a+        , DimMono v ~ S (DimMono w))+     => v -> w+{-# INLINE tail #-}+tail v = getMono $ F.tail $ Mono v+++(!) :: (VectorMono v, VectorElm v ~ a) => v -> Int -> a+{-# INLINE (!) #-}+v ! n = Mono v F.! n++foldl :: (VectorMono v, VectorElm v ~ a)+      => (b -> a -> b) -> b -> v -> b+{-# INLINE foldl #-}+foldl f x = F.foldl f x . Mono++foldr :: (VectorMono v, VectorElm v ~ a)+      => (a -> b -> b) -> b -> v -> b+{-# INLINE foldr #-}+foldr f x = F.foldr f x . Mono+++foldl1 :: (VectorMono v, VectorElm v ~ a, DimMono v ~ S n)+       => (a -> a -> a) -> v -> a+{-# INLINE foldl1 #-}+foldl1 f = F.foldl1 f . Mono++ifoldr :: (VectorMono v, VectorElm v ~ a)+       => (Int -> a -> b -> b) -> b -> v -> b+{-# INLINE ifoldr #-}+ifoldr f x = F.ifoldr f x . Mono++ifoldl :: (VectorMono v, VectorElm v ~ a)+       => (b -> Int -> a -> b) -> b -> v -> b+{-# INLINE ifoldl #-}+ifoldl f z = F.ifoldl f z . Mono++-- | Monadic fold over vector.+foldM :: (VectorMono v, VectorElm v ~ a, Monad m)+      => (b -> a -> m b) -> b -> v -> m b+{-# INLINE foldM #-}+foldM f x = F.foldM f x . Mono++ifoldM :: (VectorMono v, VectorElm v ~ a, Monad m) => (b -> Int -> a -> m b) -> b -> v -> m b+{-# INLINE ifoldM #-}+ifoldM f x = F.ifoldM f x . Mono++++----------------------------------------------------------------++sum :: (VectorMono v, VectorElm v ~ a, Num a) => v -> a+sum = F.sum . Mono+{-# INLINE sum #-}++maximum :: (VectorMono v, VectorElm v ~ a, DimMono v ~ S n, Ord a) => v -> a+maximum = F.maximum . Mono+{-# INLINE maximum #-}++minimum :: (VectorMono v, VectorElm v ~ a, DimMono v ~ S n, Ord a) => v -> a+minimum = F.minimum . Mono+{-# INLINE minimum #-}++and :: (VectorMono v, VectorElm v ~ Bool) => v -> Bool+and = F.and . Mono+{-# INLINE and #-}++or :: (VectorMono v, VectorElm v ~ Bool) => v -> Bool+or = F.or . Mono+{-# INLINE or #-}++all :: (VectorMono v, VectorElm v ~ a) => (a -> Bool) -> v -> Bool+all f = F.all f . Mono+{-# INLINE all #-}++any :: (VectorMono v, VectorElm v ~ a) => (a -> Bool) -> v -> Bool+any f = F.any f . Mono+{-# INLINE any #-}+++----------------------------------------------------------------++eq :: (VectorMono v, VectorElm v ~ a, Eq a) => v -> v -> Bool+{-# INLINE eq #-}+eq v w = F.eq (Mono v) (Mono w)+++----------------------------------------------------------------++map :: (VectorMono v, VectorElm v ~ a) => (a -> a) -> v -> v+{-# INLINE map #-}+map f = getMono . F.map f . Mono++mapM :: (VectorMono v, VectorElm v ~ a, Monad m)+     => (a -> m a) -> v -> m v+{-# INLINE mapM #-}+mapM f v = getMono `liftM` F.mapM f (Mono v)++mapM_ :: (VectorMono v, VectorElm v ~ a, Monad m) => (a -> m b) -> v -> m ()+{-# INLINE mapM_ #-}+mapM_ f = F.mapM_ f . Mono+++imap :: (VectorMono v, VectorElm v ~ a) =>+    (Int -> a -> a) -> v -> v+{-# INLINE imap #-}+imap f = getMono . F.imap f . Mono++imapM :: (VectorMono v, VectorElm v ~ a, Monad m)+      => (Int -> a -> m a) -> v -> m v+{-# INLINE imapM #-}+imapM f v = getMono `liftM` F.imapM f (Mono v)++imapM_ :: (VectorMono v, VectorElm v ~ a, Monad m) => (Int -> a -> m b) -> v -> m ()+{-# INLINE imapM_ #-}+imapM_ f = F.imapM_ f . Mono+++----------------------------------------------------------------++zipWith :: (VectorMono v, VectorElm v ~ a)+        => (a -> a -> a) -> v -> v -> v+{-# INLINE zipWith #-}+zipWith f v u = getMono $ F.zipWith f (Mono v) (Mono u)+++zipWithM :: (VectorMono v, VectorElm v ~ a, Monad m)+         => (a -> a -> m a) -> v -> v -> m v+{-# INLINE zipWithM #-}+zipWithM f v u = getMono `liftM` F.zipWithM f (Mono v) (Mono u)++izipWith :: (VectorMono v, VectorElm v ~ a)+         => (Int -> a -> a -> a) -> v -> v -> v+{-# INLINE izipWith #-}+izipWith f v u = getMono $ F.izipWith f (Mono v) (Mono u)++izipWithM :: (VectorMono v, VectorElm v ~ a, Monad m)+          => (Int -> a -> a -> m a) -> v -> v -> m v+{-# INLINE izipWithM #-}+izipWithM f v u = getMono `liftM` F.izipWithM f (Mono v) (Mono u)++++----------------------------------------------------------------++convert :: (VectorMono v, VectorMono w, VectorElm v ~ VectorElm w, DimMono v ~ DimMono w)+        => v -> w+{-# INLINE convert #-}+convert = getMono . F.convert . Mono++toList :: (VectorMono v, VectorElm v ~ a) => v -> [a]+toList = foldr (:) []++fromList :: (VectorMono v, VectorElm v ~ a) => [a] -> v+{-# INLINE fromList #-}+fromList = getMono . F.fromList+

@@ -2,6 +2,7 @@ {-# LANGUAGE FlexibleInstances     #-} {-# LANGUAGE MultiParamTypeClasses #-} {-# LANGUAGE ScopedTypeVariables   #-}+{-# LANGUAGE DeriveDataTypeable    #-} -- | -- Unboxed vectors with fixed length. Vectors from -- "Data.Vector.Fixed.Unboxed" provide more flexibility at no@@ -11,6 +12,8 @@     Vec   , Vec2   , Vec3+  , Vec4+  , Vec5     -- * Mutable   , MVec     -- * Type classes@@ -18,6 +21,7 @@   ) where  import Control.Monad+import Data.Typeable            (Typeable) import Data.Primitive.ByteArray import Data.Primitive import Prelude hiding (length,replicate,zipWith,map,foldl)@@ -34,12 +38,16 @@  -- | Unboxed vector with fixed length newtype Vec n a = Vec ByteArray+                  deriving (Typeable)  -- | Mutable unboxed vector with fixed length newtype MVec n s a = MVec (MutableByteArray s)+                     deriving (Typeable)  type Vec2 = Vec (S (S Z)) type Vec3 = Vec (S (S (S Z)))+type Vec4 = Vec (S (S (S (S Z))))+type Vec5 = Vec (S (S (S (S (S Z)))))   

@@ -2,6 +2,7 @@ {-# LANGUAGE FlexibleInstances     #-} {-# LANGUAGE MultiParamTypeClasses #-} {-# LANGUAGE ScopedTypeVariables   #-}+{-# LANGUAGE DeriveDataTypeable    #-} -- | -- Storable-based unboxed vectors. module Data.Vector.Fixed.Storable (@@ -9,6 +10,8 @@     Vec   , Vec2   , Vec3+  , Vec4+  , Vec5     -- * Raw pointers   , unsafeFromForeignPtr   , unsafeToForeignPtr@@ -20,6 +23,7 @@   ) where  import Control.Monad.Primitive+import Data.Typeable         (Typeable) import Foreign.Storable import Foreign.ForeignPtr import Foreign.Marshal.Array ( advancePtr, copyArray, moveArray )@@ -40,12 +44,16 @@  -- | Storable-based vector with fixed length newtype Vec n a = Vec (ForeignPtr a)+                  deriving (Typeable)  -- | Storable-based mutable vector with fixed length newtype MVec n s a = MVec (ForeignPtr a)+                     deriving (Typeable)  type Vec2 = Vec (S (S Z)) type Vec3 = Vec (S (S (S Z)))+type Vec4 = Vec (S (S (S (S Z))))+type Vec5 = Vec (S (S (S (S (S Z)))))   

@@ -5,6 +5,8 @@ {-# LANGUAGE MultiParamTypeClasses #-} {-# LANGUAGE ScopedTypeVariables   #-} {-# LANGUAGE UndecidableInstances  #-}+{-# LANGUAGE StandaloneDeriving #-}+{-# LANGUAGE DeriveDataTypeable #-} -- | -- Unboxed vectors with fixed length. module Data.Vector.Fixed.Unboxed(@@ -12,6 +14,8 @@     Vec   , Vec2   , Vec3+  , Vec4+  , Vec5     -- * Mutable   , MVec     -- * Type classes@@ -20,6 +24,7 @@  import Control.Monad import Data.Complex+import Data.Typeable (Typeable2,Typeable3) import Data.Int  (     Int8, Int16, Int32, Int64 ) import Data.Word (Word,Word8,Word16,Word32,Word64) import Prelude hiding (length,replicate,zipWith,map,foldl)@@ -36,8 +41,13 @@ data family Vec  n a data family MVec n s a +deriving instance Typeable2 Vec+deriving instance Typeable3 MVec+ type Vec2 = Vec (S (S Z)) type Vec3 = Vec (S (S (S Z)))+type Vec4 = Vec (S (S (S (S Z))))+type Vec5 = Vec (S (S (S (S (S Z)))))  class (IVector (Vec n) a, MVector (MVec n) a) => Unbox n a 

@@ -1,5 +1,5 @@ Name:           fixed-vector-Version:        0.3.0.1+Version:        0.4.0.0 Synopsis:       Generic vectors with statically known size. Description:   Generic library for vectors with statically known@@ -42,8 +42,28 @@   [@Data.Vector.Fixed.Primitive@]   Unboxed vectors based on pritimive package.   .+  [@Data.Vector.Fixed.Monomorphic@]+  Wrappers for monomorphic vectors+  .+  Changes in 0.4.0.0+  .+  * Wrapper for monomorphics vectors is added.+  .+  * @VecList@ is reimplemented as GADT and constructors are exported.+  .+  * Constructor of ContVecT is exported+  .+  * Empty @ContVecT@ is implemented as @empty@.+  .+  * @Typeable@, @Foldable@ and @Traversable@ instances are added where+    appropriate+  .   Changes in 0.3.0.0   .+  * Wrappers for monomorphic types added.+  .+  Changes in 0.3.0.0+  .   * @Vector@ type class definition is moved to the @D.V.F.Cont@ module.   .   * Indexing function restored.@@ -101,6 +121,7 @@     Data.Vector.Fixed.Internal.Id     Data.Vector.Fixed.Cont     Data.Vector.Fixed+    Data.Vector.Fixed.Monomorphic     -- Arrays     Data.Vector.Fixed.Mutable     Data.Vector.Fixed.Boxed