-- Hoogle documentation, generated by Haddock -- See Hoogle, http://www.haskell.org/hoogle/ -- | Generic vectors with statically known size. -- -- Generic library for vectors with statically known size. Implementation -- is based on -- http://unlines.wordpress.com/2010/11/15/generics-for-small-fixed-size-vectors/ -- Same functions could be used to work with both ADT based vector like -- -- 
--   data Vec3 a = a a a
--
-- -- Tuples are vectors too: -- -- 
--   >>> sum (1,2,3)
--   6
--
-- -- Vectors which are represented internally by arrays are provided by -- library. Both boxed and unboxed arrays are supported. -- -- Library is structured as follows: -- -- -- -- Changes in 0.4.3.0 -- -- -- -- Changes in 0.4.2.0 -- -- -- -- Changes in 0.4.1.0 -- -- -- -- Changes in 0.4.0.0 -- -- -- -- Changes in 0.3.0.0 -- -- -- -- Changes in 0.3.0.0 -- -- -- -- Changes in 0.2.0.0 -- -- -- -- Changes in 0.1.2 -- -- -- -- Changes in 0.1.1 -- -- @package fixed-vector @version 0.4.3.0 -- | Strict identity monad module Data.Vector.Fixed.Internal.Id -- | Strict identity monad newtype Id a Id :: a -> Id a runID :: Id a -> a instance Monad Id -- | Type class for working with N-ary functions module Data.Vector.Fixed.Internal.Arity -- | Type level zero data Z -- | Successor of n data S n type N1 = S Z type N2 = S N1 type N3 = S N2 type N4 = S N3 type N5 = S N4 type N6 = S N5 -- | Type family for n-ary functions. -- | Newtype wrapper which is used to make Fn injective. newtype Fun n a b Fun :: Fn n a b -> Fun n a b unFun :: Fun n a b -> Fn n a b -- | Type class for handling n-ary functions. class Arity n accum :: Arity n => (forall k. t (S k) -> a -> t k) -> (t Z -> b) -> t n -> Fn n a b accumM :: (Arity n, Monad m) => (forall k. t (S k) -> a -> m (t k)) -> (t Z -> m b) -> m (t n) -> Fn n a (m b) applyFun :: Arity n => (forall k. t (S k) -> (a, t k)) -> t n -> Fn n a b -> (b, t Z) applyFunM :: (Arity n, Monad m) => (forall k. t (S k) -> m (a, t k)) -> t n -> Fn n a (m b) -> m (b, t Z) arity :: Arity n => n -> Int -- | Apply all parameters to the function. apply :: Arity n => (forall k. t (S k) -> (a, t k)) -> t n -> Fn n a b -> b -- | Apply all parameters to the function. applyM :: (Arity n, Monad m) => (forall k. t (S k) -> m (a, t k)) -> t n -> Fn n a (m b) -> m b instance Typeable Z instance Typeable1 S instance Arity n => Arity (S n) instance Arity Z instance Arity n => Functor (Fun n a) -- | Continuations-based API module Data.Vector.Fixed.Cont -- | Size of vector expressed as type-level natural. -- | 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 basicIndex v i = runContVec (index i) (cvec v) construct :: Vector v a => Fun (Dim v) a (v a) inspect :: Vector v a => v a -> Fun (Dim v) a b -> b basicIndex :: Vector v a => v a -> Int -> a -- | Vector parametrized by length. In ideal world it should be: -- -- 
--   forall n. (Arity n, Vector (v n) a, Dim (v n) ~ n) => VectorN v a
--
-- -- Alas polymorphic constraints aren't allowed in haskell. class (Vector (v n) a, Dim (v n) ~ n) => VectorN v n a -- | Length of vector. Function doesn't evaluate its argument. length :: Arity (Dim v) => v a -> Int -- | Vector represented as continuation. newtype ContVecT m n a ContVecT :: (forall r. Fun n a (m r) -> m r) -> ContVecT m n a -- | Vector as continuation without monadic context. type ContVec = ContVecT Id type N1 = S Z type N2 = S N1 type N3 = S N2 type N4 = S N3 type N5 = S N4 type N6 = S N5 -- | Convert regular vector to continuation cvec :: (Vector v a, Dim v ~ n, Monad m) => v a -> ContVecT m n a -- | Create empty vector. empty :: ContVecT m Z a -- | Convert list to continuation-based vector. Will throw error if list is -- shorter than resulting vector. fromList :: Arity n => [a] -> ContVecT m n a -- | Same as fromList bu throws error is list doesn't have same -- length as vector. fromList' :: Arity n => [a] -> ContVecT m n a -- | Convert list to continuation-based vector. Will fail with -- Nothing if list doesn't have right length. fromListM :: Arity n => [a] -> ContVecT Maybe n a -- | Execute monadic action for every element of vector. Synonym for -- pure. replicate :: Arity n => a -> ContVecT m n a -- | Execute monadic action for every element of vector. replicateM :: (Arity n, Monad m) => m a -> ContVecT m n a -- | Generate vector from function which maps element's index to its value. generate :: Arity n => (Int -> a) -> ContVecT m n a -- | Generate vector from monadic function which maps element's index to -- its value. generateM :: (Monad m, Arity n) => (Int -> m a) -> ContVecT m n a -- | Unfold vector. unfoldr :: Arity n => (b -> (a, b)) -> b -> ContVecT m n a -- | Unit vector along Nth axis. basis :: (Num a, Arity n) => Int -> ContVecT m n a mk1 :: a -> ContVecT m N1 a mk2 :: a -> a -> ContVecT m N2 a mk3 :: a -> a -> a -> ContVecT m N3 a mk4 :: a -> a -> a -> a -> ContVecT m N4 a mk5 :: a -> a -> a -> a -> a -> ContVecT m N5 a -- | Map over vector. Synonym for fmap map :: Arity n => (a -> b) -> ContVecT m n a -> ContVecT m n b -- | Apply function to every element of the vector and its index. imap :: Arity n => (Int -> a -> b) -> ContVecT m n a -> ContVecT m n b -- | Monadic map over vector. mapM :: (Arity n, Monad m) => (a -> m b) -> ContVecT m n a -> ContVecT m n b -- | Apply monadic function to every element of the vector and its index. imapM :: (Arity n, Monad m) => (Int -> a -> m b) -> ContVecT m n a -> ContVecT m n b -- | O(1) Tail of vector. tail :: ContVecT m (S n) a -> ContVecT m n a -- | O(1) Prepend element to vector cons :: a -> ContVecT m n a -> ContVecT m (S n) a -- | Change monad type for the continuation vector. changeMonad :: (Monad p, Arity n) => (forall x. p x -> x) -> ContVecT p n a -> ContVecT m n a -- | Zip two vector together using function. zipWith :: Arity n => (a -> b -> c) -> ContVecT m n a -> ContVecT m n b -> ContVecT m n c -- | Zip two vector together using function which takes element index as -- well. izipWith :: Arity n => (Int -> a -> b -> c) -> ContVecT m n a -> ContVecT m n b -> ContVecT m n c -- | Zip two vector together using monadic function. zipWithM :: (Arity n, Monad m) => (a -> b -> m c) -> ContVecT m n a -> ContVecT m n b -> ContVecT m n c -- | Zip two vector together using monadic function which takes element -- index as well.. izipWithM :: (Arity n, Monad m) => (Int -> a -> b -> m c) -> ContVecT m n a -> ContVecT m n b -> ContVecT m n c -- | Run continuation vector using non-monadic finalizer. runContVecT :: (Monad m, Arity n) => Fun n a r -> ContVecT m n a -> m r -- | Run continuation vector using monadic finalizer. runContVecM :: Arity n => Fun n a (m r) -> ContVecT m n a -> m r -- | Run continuation vector. runContVec :: Arity n => Fun n a r -> ContVec n a -> r -- | Finalizer function for getting head of the vector. head :: Arity (S n) => Fun (S n) a a -- | O(n) Get value at specified index. index :: Arity n => Int -> Fun n a a -- | Convert continuation to the vector. vector :: (Vector v a, Dim v ~ n) => ContVec n a -> v a -- | Convert continuation to the vector. vectorM :: (Vector v a, Dim v ~ n, Monad m) => ContVecT m n a -> m (v a) -- | Left fold over continuation vector. foldl :: Arity n => (b -> a -> b) -> b -> Fun n a b -- | Left fold. foldl1 :: Arity (S n) => (a -> a -> a) -> Fun (S n) a a -- | Right fold over continuation vector foldr :: Arity n => (a -> b -> b) -> b -> Fun n a b -- | Left fold over continuation vector. ifoldl :: Arity n => (b -> Int -> a -> b) -> b -> Fun n a b -- | Right fold over continuation vector ifoldr :: Arity n => (Int -> a -> b -> b) -> b -> Fun n a b -- | Monadic left fold over continuation vector. foldM :: (Arity n, Monad m) => (b -> a -> m b) -> b -> Fun n a (m b) -- | Monadic left fold over continuation vector. ifoldM :: (Arity n, Monad m) => (b -> Int -> a -> m b) -> b -> Fun n a (m b) -- | Sum all elements in the vector. sum :: (Num a, Arity n) => Fun n a a -- | Minimal element of vector. minimum :: (Ord a, Arity (S n)) => Fun (S n) a a -- | Maximal element of vector. maximum :: (Ord a, Arity (S n)) => Fun (S n) a a -- | Conjunction of elements of a vector. and :: Arity n => Fun n Bool Bool -- | Disjunction of all elements of a vector. or :: Arity n => Fun n Bool Bool -- | Determines whether all elements of vector satisfy predicate. all :: Arity n => (a -> Bool) -> Fun n a Bool -- | Determines whether any of element of vector satisfy predicate. any :: Arity n => (a -> Bool) -> Fun n a Bool instance (b ~ a, c ~ a, d ~ a, e ~ a, f ~ a, g ~ a) => Vector ((,,,,,,) b c d e f g) a instance (b ~ a, c ~ a, d ~ a, e ~ a, f ~ a) => Vector ((,,,,,) b c d e f) a instance (b ~ a, c ~ a, d ~ a, e ~ a) => Vector ((,,,,) b c d e) a instance (b ~ a, c ~ a, d ~ a) => Vector ((,,,) b c d) a instance (b ~ a, c ~ a) => Vector ((,,) b c) a instance b ~ a => Vector ((,) b) a instance RealFloat a => Vector Complex a instance Arity n => Applicative (ContVecT m n) instance Arity n => Functor (ContVecT m n) -- | Type classes for array based vector. They are quite similar to ones -- from vector package but those only suitable for vectors with -- variable length. module Data.Vector.Fixed.Mutable -- | Mutable counterpart of fixed-length vector -- | Dimension for mutable vector -- | Type class for mutable vectors class Arity (DimM v) => MVector v a overlaps :: MVector v a => v s a -> v s a -> Bool copy :: (MVector v a, PrimMonad m) => v (PrimState m) a -> v (PrimState m) a -> m () move :: (MVector v a, PrimMonad m) => v (PrimState m) a -> v (PrimState m) a -> m () new :: (MVector v a, PrimMonad m) => m (v (PrimState m) a) unsafeRead :: (MVector v a, PrimMonad m) => v (PrimState m) a -> Int -> m a unsafeWrite :: (MVector v a, PrimMonad m) => v (PrimState m) a -> Int -> a -> m () -- | Length of mutable vector lengthM :: Arity (DimM v) => v s a -> Int -- | Read value at index with bound checks. read :: (PrimMonad m, MVector v a) => v (PrimState m) a -> Int -> m a -- | Write value at index with bound checks. write :: (PrimMonad m, MVector v a) => v (PrimState m) a -> Int -> a -> m () -- | Clone vector clone :: (PrimMonad m, MVector v a) => v (PrimState m) a -> m (v (PrimState m) a) -- | Type class for immutable vectors class (Dim v ~ DimM (Mutable v), MVector (Mutable v) a) => IVector v a unsafeFreeze :: (IVector v a, PrimMonad m) => Mutable v (PrimState m) a -> m (v a) unsafeThaw :: (IVector v a, PrimMonad m) => v a -> m (Mutable v (PrimState m) a) unsafeIndex :: IVector v a => v a -> Int -> a index :: IVector v a => v a -> Int -> a -- | Length of immutable vector lengthI :: IVector v a => v a -> Int -- | Safely convert mutable vector to immutable. freeze :: (PrimMonad m, IVector v a) => Mutable v (PrimState m) a -> m (v a) -- | Safely convert immutable vector to mutable. thaw :: (PrimMonad m, IVector v a) => v a -> m (Mutable v (PrimState m) a) -- | Generic construct constructVec :: (Arity (Dim v), IVector v a) => Fun (Dim v) a (v a) -- | Generic inspect inspectVec :: (Arity (Dim v), IVector v a) => v a -> Fun (Dim v) a b -> b -- | Generic API for vectors with fixed length. -- -- For encoding of vector size library uses Peano naturals defined in the -- library. At come point in the future it would make sense to switch to -- new GHC type level numerals. module Data.Vector.Fixed -- | Size of vector expressed as type-level natural. -- | Type level zero data Z -- | Successor of n data S n type N1 = S Z type N2 = S N1 type N3 = S N2 type N4 = S N3 type N5 = S N4 type N6 = S N5 -- | 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 basicIndex v i = runContVec (index i) (cvec v) construct :: Vector v a => Fun (Dim v) a (v a) inspect :: Vector v a => v a -> Fun (Dim v) a b -> b basicIndex :: Vector v a => v a -> Int -> a -- | Vector parametrized by length. In ideal world it should be: -- -- 
--   forall n. (Arity n, Vector (v n) a, Dim (v n) ~ n) => VectorN v a
--
-- -- Alas polymorphic constraints aren't allowed in haskell. class (Vector (v n) a, Dim (v n) ~ n) => VectorN v n a -- | Type class for handling n-ary functions. class Arity n -- | Newtype wrapper which is used to make Fn injective. newtype Fun n a b Fun :: Fn n a b -> Fun n a b unFun :: Fun n a b -> Fn n a b -- | Length of vector. Function doesn't evaluate its argument. length :: Arity (Dim v) => v a -> Int mk1 :: (Vector v a, Dim v ~ N1) => a -> v a mk2 :: (Vector v a, Dim v ~ N2) => a -> a -> v a mk3 :: (Vector v a, Dim v ~ N3) => a -> a -> a -> v a mk4 :: (Vector v a, Dim v ~ N4) => a -> a -> a -> a -> v a mk5 :: (Vector v a, Dim v ~ N5) => a -> a -> a -> a -> a -> v a -- | Generic function for construction of arbitrary vectors. It represents -- partially constructed vector where n is number of uninitialized -- elements, v is type of vector and a element type. -- -- Uninitialized vector could be obtained from con and vector -- elements could be added from left to right using |> -- operator. Finally it could be converted to vector using vec -- function. -- -- Construction of complex number which could be seen as 2-element -- vector: -- -- 
--   >>> import Data.Complex
--   
--   >>> vec $ con |> 1 |> 3 :: Complex Double
--   1.0 :+ 3.0
--
data New n v a -- | Convert fully applied constructor to vector vec :: New Z v a -> v a -- | Seed constructor con :: Vector v a => New (Dim v) v a -- | Apply another element to vector (|>) :: New (S n) v a -> a -> New n v a -- | Replicate value n times. -- -- Examples: -- -- 
--   >>> import Data.Vector.Fixed.Boxed (Vec2)
--   
--   >>> replicate 1 :: Vec2 Int
--   fromList [1,1]
--
-- -- 
--   >>> replicate 2 :: (Double,Double,Double)
--   (2.0,2.0,2.0)
--
-- -- 
--   >>> import Data.Vector.Fixed.Boxed (Vec)
--   
--   >>> replicate "foo" :: Vec N5 String
--   fromList ["foo","foo","foo","foo","foo"]
--
replicate :: Vector v a => a -> v a -- | Execute monadic action for every element of vector. -- -- Examples: -- -- 
--   >>> import Data.Vector.Fixed.Boxed (Vec2,Vec3)
--   
--   >>> replicateM (Just 3) :: Maybe (Vec3 Int)
--   Just fromList [3,3,3]
--   
--   >>> replicateM (putStrLn "Hi!") :: IO (Vec2 ())
--   Hi!
--   Hi!
--   fromList [(),()]
--
replicateM :: (Vector v a, Monad m) => m a -> m (v a) -- | Generate vector from function which maps element's index to its value. -- -- Examples: -- -- 
--   >>> import Data.Vector.Fixed.Unboxed (Vec)
--   
--   >>> generate (^2) :: Vec N4 Int
--   fromList [0,1,4,9]
--
generate :: Vector v a => (Int -> a) -> v a -- | Generate vector from monadic function which maps element's index to -- its value. generateM :: (Monad m, Vector v a) => (Int -> m a) -> m (v a) -- | Unfold vector. unfoldr :: Vector v a => (b -> (a, b)) -> b -> v a -- | Unit vector along Nth axis. If index is larger than vector dimensions -- returns zero vector. -- -- Examples: -- -- 
--   >>> import Data.Vector.Fixed.Boxed (Vec3)
--   
--   >>> basis 0 :: Vec3 Int
--   fromList [1,0,0]
--   
--   >>> basis 1 :: Vec3 Int
--   fromList [0,1,0]
--   
--   >>> basis 3 :: Vec3 Int
--   fromList [0,0,0]
--
basis :: (Vector v a, Num a) => Int -> v a -- | First element of vector. -- -- Examples: -- -- 
--   >>> import Data.Vector.Fixed.Boxed (Vec3)
--   
--   >>> let x = mk3 1 2 3 :: Vec3 Int
--   
--   >>> head x
--   1
--
head :: (Vector v a, Dim v ~ S n) => v a -> a -- | Tail of vector. -- -- Examples: -- -- 
--   >>> import Data.Complex
--   
--   >>> tail (1,2,3) :: Complex Double
--   2.0 :+ 3.0
--
tail :: (Vector v a, Vector w a, Dim v ~ S (Dim w)) => v a -> w a -- | Cons element to the vector cons :: (Vector v a, Vector w a, S (Dim v) ~ Dim w) => a -> v a -> w a -- | Retrieve vector's element at index. Generic implementation is -- O(n) but more efficient one is used when possible. (!) :: Vector v a => v a -> Int -> a -- | Test two vectors for equality. -- -- Examples: -- -- 
--   >>> import Data.Vector.Fixed.Boxed (Vec2)
--   
--   >>> let v0 = basis 0 :: Vec2 Int
--   
--   >>> let v1 = basis 1 :: Vec2 Int
--   
--   >>> v0 `eq` v0
--   True
--   
--   >>> v0 `eq` v1
--   False
--
eq :: (Vector v a, Eq a) => v a -> v a -> Bool -- | Map over vector map :: (Vector v a, Vector v b) => (a -> b) -> v a -> v b -- | Monadic map over vector. mapM :: (Vector v a, Vector v b, Monad m) => (a -> m b) -> v a -> m (v b) -- | Apply monadic action to each element of vector and ignore result. mapM_ :: (Vector v a, Monad m) => (a -> m b) -> v a -> m () -- | Apply function to every element of the vector and its index. imap :: (Vector v a, Vector v b) => (Int -> a -> b) -> v a -> v b -- | Apply monadic function to every element of the vector and its index. imapM :: (Vector v a, Vector v b, Monad m) => (Int -> a -> m b) -> v a -> m (v b) -- | Apply monadic function to every element of the vector and its index -- and discard result. imapM_ :: (Vector v a, Monad m) => (Int -> a -> m b) -> v a -> m () -- | Evaluate every action in the vector from left to right. sequence :: (Vector v a, Vector v (m a), Monad m) => v (m a) -> m (v a) -- | Evaluate every action in the vector from left to right and ignore -- result sequence_ :: (Vector v (m a), Monad m) => v (m a) -> m () -- | Analog of sequenceA from Traversable. sequenceA :: (Vector v a, Vector v (f a), Applicative f) => v (f a) -> f (v a) -- | Analog of traverse from Traversable. traverse :: (Vector v a, Vector v b, Applicative f) => (a -> f b) -> v a -> f (v b) -- | Left fold over vector foldl :: Vector v a => (b -> a -> b) -> b -> v a -> b -- | Right fold over vector foldr :: Vector v a => (a -> b -> b) -> b -> v a -> b -- | Left fold over vector foldl1 :: (Vector v a, Dim v ~ S n) => (a -> a -> a) -> v a -> a -- | Left fold over vector. Function is applied to each element and its -- index. ifoldl :: Vector v a => (b -> Int -> a -> b) -> b -> v a -> b -- | Left fold over vector ifoldr :: Vector v a => (Int -> a -> b -> b) -> b -> v a -> b -- | Monadic fold over vector. foldM :: (Vector v a, Monad m) => (b -> a -> m b) -> b -> v a -> m b -- | Left monadic fold over vector. Function is applied to each element and -- its index. ifoldM :: (Vector v a, Monad m) => (b -> Int -> a -> m b) -> b -> v a -> m b -- | Sum all elements in the vector. sum :: (Vector v a, Num a) => v a -> a -- | Maximal element of vector. -- -- Examples: -- -- 
--   >>> import Data.Vector.Fixed.Boxed (Vec3)
--   
--   >>> let x = mk3 1 2 3 :: Vec3 Int
--   
--   >>> maximum x
--   3
--
maximum :: (Vector v a, Dim v ~ S n, Ord a) => v a -> a -- | Minimal element of vector. -- -- Examples: -- -- 
--   >>> import Data.Vector.Fixed.Boxed (Vec3)
--   
--   >>> let x = mk3 1 2 3 :: Vec3 Int
--   
--   >>> minimum x
--   1
--
minimum :: (Vector v a, Dim v ~ S n, Ord a) => v a -> a -- | Conjunction of all elements of a vector. and :: Vector v Bool => v Bool -> Bool -- | Disjunction of all elements of a vector. or :: Vector v Bool => v Bool -> Bool -- | Determines whether all elements of vector satisfy predicate. all :: Vector v a => (a -> Bool) -> v a -> Bool -- | Determines whether any of element of vector satisfy predicate. any :: Vector v a => (a -> Bool) -> v a -> Bool -- | Zip two vector together using function. -- -- Examples: -- -- 
--   >>> import Data.Vector.Fixed.Boxed (Vec3)
--   
--   >>> let b0 = basis 0 :: Vec3 Int
--   
--   >>> let b1 = basis 1 :: Vec3 Int
--   
--   >>> let b2 = basis 2 :: Vec3 Int
--   
--   >>> let vplus x y = zipWith (+) x y
--   
--   >>> vplus b0 b1
--   fromList [1,1,0]
--   
--   >>> vplus b0 b2
--   fromList [1,0,1]
--   
--   >>> vplus b1 b2
--   fromList [0,1,1]
--
zipWith :: (Vector v a, Vector v b, Vector v c) => (a -> b -> c) -> v a -> v b -> v c -- | Zip two vector together using monadic function. zipWithM :: (Vector v a, Vector v b, Vector v c, Monad m) => (a -> b -> m c) -> v a -> v b -> m (v c) -- | Zip two vector together using function which takes element index as -- well. izipWith :: (Vector v a, Vector v b, Vector v c) => (Int -> a -> b -> c) -> v a -> v b -> v c -- | Zip two vector together using monadic function which takes element -- index as well.. izipWithM :: (Vector v a, Vector v b, Vector v c, Monad m) => (Int -> a -> b -> m c) -> v a -> v b -> m (v c) -- | Convert between different vector types convert :: (Vector v a, Vector w a, Dim v ~ Dim w) => v a -> w a -- | Convert vector to the list toList :: Vector v a => v a -> [a] -- | Create vector form list. Will throw error if list is shorter than -- resulting vector. fromList :: Vector v a => [a] -> v a -- | Create vector form list. Will throw error if list has different length -- from resulting vector. fromList' :: Vector v a => [a] -> v a -- | Create vector form list. Will return Nothing if list has -- different length from resulting vector. fromListM :: Vector v a => [a] -> Maybe (v a) -- | Create vector from Foldable data type. Will return -- Nothing if data type different number of elements that -- resulting vector. fromFoldable :: (Vector v a, Foldable f) => f a -> Maybe (v a) -- | Vector based on the lists. Not very useful by itself but is necessary -- for implementation. data VecList n a Nil :: VecList Z a Cons :: a -> VecList n a -> VecList (S n) a -- | Single-element tuple. newtype Only a Only :: a -> Only a instance Typeable2 VecList instance Typeable1 Only instance Show a => Show (Only a) instance Eq a => Eq (Only a) instance Ord a => Ord (Only a) instance Data a => Data (Only a) instance Vector Only a instance Traversable Only instance Foldable Only instance Functor Only instance Arity n => Traversable (VecList n) instance Arity n => Foldable (VecList n) instance Arity n => Applicative (VecList n) instance Arity n => Functor (VecList n) instance (Eq a, Arity n) => Eq (VecList n a) instance (Show a, Arity n) => Show (VecList n a) instance Arity n => VectorN VecList n a instance Arity n => Vector (VecList n) a -- | 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 -- | Dimensions of monomorphic vector. -- | Type level zero data Z -- | Successor of n data S n type N1 = S Z type N2 = S N1 type N3 = S N2 type N4 = S N3 type N5 = S N4 type N6 = S N5 -- | Counterpart of Vector type class for monomorphic vectors. class Arity (DimMono v) => VectorMono v where type family VectorElm v :: * basicIndex v i = Mono v ! i construct :: VectorMono v => Fun (DimMono v) (VectorElm v) v inspect :: VectorMono v => v -> Fun (DimMono v) (VectorElm v) r -> r basicIndex :: VectorMono v => v -> Int -> VectorElm v -- | Type class for handling n-ary functions. class Arity n -- | Newtype wrapper which is used to make Fn injective. newtype Fun n a b Fun :: Fn n a b -> Fun n a b unFun :: Fun n a b -> Fn n a b -- | Length of vector length :: Arity (DimMono v) => v -> Int mk1 :: (VectorMono v, VectorElm v ~ a, DimMono v ~ N1) => a -> v mk2 :: (VectorMono v, VectorElm v ~ a, DimMono v ~ N2) => a -> a -> v mk3 :: (VectorMono v, VectorElm v ~ a, DimMono v ~ N3) => a -> a -> a -> v mk4 :: (VectorMono v, VectorElm v ~ a, DimMono v ~ N4) => a -> a -> a -> a -> v mk5 :: (VectorMono v, VectorElm v ~ a, DimMono v ~ N5) => a -> a -> a -> a -> a -> v replicate :: (VectorMono v, VectorElm v ~ a) => a -> v replicateM :: (VectorMono v, VectorElm v ~ a, Monad m) => m a -> m v generate :: (VectorMono v, VectorElm v ~ a) => (Int -> a) -> v generateM :: (Monad m, VectorMono v, VectorElm v ~ a) => (Int -> m a) -> m v unfoldr :: (VectorMono v, VectorElm v ~ a) => (b -> (a, b)) -> b -> v basis :: (VectorMono v, VectorElm v ~ a, Num a) => Int -> v head :: (VectorMono v, VectorElm v ~ a, DimMono v ~ S n) => v -> a tail :: (VectorMono v, VectorElm v ~ a, VectorMono w, VectorElm w ~ a, DimMono v ~ S (DimMono w)) => v -> w (!) :: (VectorMono v, VectorElm v ~ a) => v -> Int -> a eq :: (VectorMono v, VectorElm v ~ a, Eq a) => v -> v -> Bool map :: (VectorMono v, VectorElm v ~ a) => (a -> a) -> v -> v mapM :: (VectorMono v, VectorElm v ~ a, Monad m) => (a -> m a) -> v -> m v mapM_ :: (VectorMono v, VectorElm v ~ a, Monad m) => (a -> m b) -> v -> m () imap :: (VectorMono v, VectorElm v ~ a) => (Int -> a -> a) -> v -> v imapM :: (VectorMono v, VectorElm v ~ a, Monad m) => (Int -> a -> m a) -> v -> m v imapM_ :: (VectorMono v, VectorElm v ~ a, Monad m) => (Int -> a -> m b) -> v -> m () foldl :: (VectorMono v, VectorElm v ~ a) => (b -> a -> b) -> b -> v -> b foldr :: (VectorMono v, VectorElm v ~ a) => (a -> b -> b) -> b -> v -> b foldl1 :: (VectorMono v, VectorElm v ~ a, DimMono v ~ S n) => (a -> a -> a) -> v -> a ifoldl :: (VectorMono v, VectorElm v ~ a) => (b -> Int -> a -> b) -> b -> v -> b ifoldr :: (VectorMono v, VectorElm v ~ a) => (Int -> a -> b -> b) -> b -> v -> b -- | Monadic fold over vector. foldM :: (VectorMono v, VectorElm v ~ a, Monad m) => (b -> a -> m b) -> b -> v -> m b ifoldM :: (VectorMono v, VectorElm v ~ a, Monad m) => (b -> Int -> a -> m b) -> b -> v -> m b sum :: (VectorMono v, VectorElm v ~ a, Num a) => v -> a maximum :: (VectorMono v, VectorElm v ~ a, DimMono v ~ S n, Ord a) => v -> a minimum :: (VectorMono v, VectorElm v ~ a, DimMono v ~ S n, Ord a) => v -> a and :: (VectorMono v, VectorElm v ~ Bool) => v -> Bool or :: (VectorMono v, VectorElm v ~ Bool) => v -> Bool all :: (VectorMono v, VectorElm v ~ a) => (a -> Bool) -> v -> Bool any :: (VectorMono v, VectorElm v ~ a) => (a -> Bool) -> v -> Bool zipWith :: (VectorMono v, VectorElm v ~ a) => (a -> a -> a) -> v -> v -> v zipWithM :: (VectorMono v, VectorElm v ~ a, Monad m) => (a -> a -> m a) -> v -> v -> m v izipWith :: (VectorMono v, VectorElm v ~ a) => (Int -> a -> a -> a) -> v -> v -> v izipWithM :: (VectorMono v, VectorElm v ~ a, Monad m) => (Int -> a -> a -> m a) -> v -> v -> m v convert :: (VectorMono v, VectorMono w, VectorElm v ~ VectorElm w, DimMono v ~ DimMono w) => v -> w toList :: (VectorMono v, VectorElm v ~ a) => v -> [a] fromList :: (VectorMono v, VectorElm v ~ a) => [a] -> v instance (VectorMono v, a ~ VectorElm v, Arity (DimMono v)) => Vector (Mono v) a -- | Boxed vector. module Data.Vector.Fixed.Boxed -- | Vector with fixed length which can hold any value. data Vec n a 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))))) -- | Mutable unboxed vector with fixed length data MVec n s a instance Typeable2 Vec instance Typeable3 MVec instance Arity n => Traversable (Vec n) instance Arity n => Foldable (Vec n) instance Arity n => Applicative (Vec n) instance Arity n => Functor (Vec n) instance (Arity n, Eq a) => Eq (Vec n a) instance Arity n => VectorN Vec n a instance Arity n => Vector (Vec n) a instance Arity n => IVector (Vec n) a instance Arity n => MVector (MVec n) a instance (Arity n, Show a) => Show (Vec n a) -- | Unboxed vectors with fixed length. Vectors from -- Data.Vector.Fixed.Unboxed provide more flexibility at no -- performeance cost. module Data.Vector.Fixed.Primitive -- | Unboxed vector with fixed length data Vec n a 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))))) -- | Mutable unboxed vector with fixed length data MVec n s a -- | Class of types supporting primitive array operations class Prim a instance Typeable2 Vec instance Typeable3 MVec instance (Arity n, Prim a, Eq a) => Eq (Vec n a) instance (Arity n, Prim a) => VectorN Vec n a instance (Arity n, Prim a) => Vector (Vec n) a instance (Arity n, Prim a) => IVector (Vec n) a instance (Arity n, Prim a) => MVector (MVec n) a instance (Arity n, Prim a, Show a) => Show (Vec n a) -- | Unboxed vectors with fixed length. module Data.Vector.Fixed.Unboxed 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 instance Typeable3 MVec instance Typeable2 Vec instance (Arity n, Vector (Vec n) a, Vector (Vec n) b, Vector (Vec n) c, IVector (Vec n) a, IVector (Vec n) b, IVector (Vec n) c) => IVector (Vec n) (a, b, c) instance (Arity n, MVector (MVec n) a, MVector (MVec n) b, MVector (MVec n) c) => MVector (MVec n) (a, b, c) instance (Unbox n a, Unbox n b, Unbox n c) => Unbox n (a, b, c) instance (Arity n, IVector (Vec n) a, IVector (Vec n) b) => IVector (Vec n) (a, b) instance (Arity n, MVector (MVec n) a, MVector (MVec n) b) => MVector (MVec n) (a, b) instance (Unbox n a, Unbox n b) => Unbox n (a, b) instance (Arity n, IVector (Vec n) a) => IVector (Vec n) (Complex a) instance (Arity n, MVector (MVec n) a) => MVector (MVec n) (Complex a) instance Unbox n a => Unbox n (Complex a) instance Arity n => IVector (Vec n) Double instance Arity n => MVector (MVec n) Double instance Arity n => Unbox n Double instance Arity n => IVector (Vec n) Float instance Arity n => MVector (MVec n) Float instance Arity n => Unbox n Float instance Arity n => IVector (Vec n) Char instance Arity n => MVector (MVec n) Char instance Arity n => Unbox n Char instance Arity n => IVector (Vec n) Word64 instance Arity n => MVector (MVec n) Word64 instance Arity n => Unbox n Word64 instance Arity n => IVector (Vec n) Word32 instance Arity n => MVector (MVec n) Word32 instance Arity n => Unbox n Word32 instance Arity n => IVector (Vec n) Word16 instance Arity n => MVector (MVec n) Word16 instance Arity n => Unbox n Word16 instance Arity n => IVector (Vec n) Word8 instance Arity n => MVector (MVec n) Word8 instance Arity n => Unbox n Word8 instance Arity n => IVector (Vec n) Word instance Arity n => MVector (MVec n) Word instance Arity n => Unbox n Word instance Arity n => IVector (Vec n) Int64 instance Arity n => MVector (MVec n) Int64 instance Arity n => Unbox n Int64 instance Arity n => IVector (Vec n) Int32 instance Arity n => MVector (MVec n) Int32 instance Arity n => Unbox n Int32 instance Arity n => IVector (Vec n) Int16 instance Arity n => MVector (MVec n) Int16 instance Arity n => Unbox n Int16 instance Arity n => IVector (Vec n) Int8 instance Arity n => MVector (MVec n) Int8 instance Arity n => Unbox n Int8 instance Arity n => IVector (Vec n) Int instance Arity n => MVector (MVec n) Int instance Arity n => Unbox n Int instance Arity n => IVector (Vec n) Bool instance Arity n => MVector (MVec n) Bool instance Arity n => Unbox n Bool instance Arity n => IVector (Vec n) () instance Arity n => MVector (MVec n) () instance Arity n => Unbox n () instance (Unbox n a, Eq a) => Eq (Vec n a) instance Unbox n a => VectorN Vec n a instance Unbox n a => Vector (Vec n) a instance (Arity n, Show a, Unbox n a) => Show (Vec n a) -- | Storable-based unboxed vectors. module Data.Vector.Fixed.Storable -- | Storable-based vector with fixed length data Vec n a 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))))) -- | Construct vector from foreign pointer. unsafeFromForeignPtr :: Storable a => ForeignPtr a -> Vec n a -- | Get underlying pointer. Data may not be modified through pointer. unsafeToForeignPtr :: Storable a => Vec n a -> ForeignPtr a unsafeWith :: Storable a => (Ptr a -> IO b) -> Vec n a -> IO b -- | Storable-based mutable vector with fixed length newtype MVec n s a MVec :: (ForeignPtr a) -> MVec n s a -- | The member functions of this class facilitate writing values of -- primitive types to raw memory (which may have been allocated with the -- above mentioned routines) and reading values from blocks of raw -- memory. The class, furthermore, includes support for computing the -- storage requirements and alignment restrictions of storable types. -- -- Memory addresses are represented as values of type Ptr -- a, for some a which is an instance of class -- Storable. The type argument to Ptr helps provide some -- valuable type safety in FFI code (you can't mix pointers of different -- types without an explicit cast), while helping the Haskell type system -- figure out which marshalling method is needed for a given pointer. -- -- All marshalling between Haskell and a foreign language ultimately -- boils down to translating Haskell data structures into the binary -- representation of a corresponding data structure of the foreign -- language and vice versa. To code this marshalling in Haskell, it is -- necessary to manipulate primitive data types stored in unstructured -- memory blocks. The class Storable facilitates this manipulation -- on all types for which it is instantiated, which are the standard -- basic types of Haskell, the fixed size Int types -- (Int8, Int16, Int32, Int64), the fixed -- size Word types (Word8, Word16, Word32, -- Word64), StablePtr, all types from -- Foreign.C.Types, as well as Ptr. -- -- Minimal complete definition: sizeOf, alignment, one of -- peek, peekElemOff and peekByteOff, and one of -- poke, pokeElemOff and pokeByteOff. class Storable a instance Typeable2 Vec instance Typeable3 MVec instance (Arity n, Storable a, Eq a) => Eq (Vec n a) instance (Arity n, Storable a) => VectorN Vec n a instance (Arity n, Storable a) => Vector (Vec n) a instance (Arity n, Storable a) => IVector (Vec n) a instance (Arity n, Storable a) => MVector (MVec n) a instance (Arity n, Storable a, Show a) => Show (Vec n a)