module Data.Vector.HFixed (
Arity
, ArityC
, HVector(..)
, HVectorF(..)
, Wrap
, Proxy(..)
, ContVec
, asCVec
, convert
, head
, tail
, cons
, concat
, ValueAt
, Index
, index
, set
, element
, elementCh
#if __GLASGOW_HASKELL__ >= 708
, elementTy
, elementChTy
#endif
, mk0
, mk1
, mk2
, mk3
, mk4
, mk5
, fold
, foldr
, foldl
, mapM_
, unfoldr
, replicate
, replicateM
, zipMono
, zipMonoF
, zipFold
, monomorphize
, monomorphizeF
, mapFunctor
, sequence
, sequenceA
, sequenceF
, sequenceAF
, wrap
, unwrap
, distribute
, distributeF
, eq
, compare
, rnf
) where
import Control.Monad (liftM)
import Control.Applicative (Applicative,(<$>))
import qualified Control.DeepSeq as NF
import Data.Functor.Compose (Compose)
import Data.Monoid (Monoid,All(..))
import Prelude (Functor(..),Monad(..),Eq(..),Ord,Bool,Ordering,
id,(.),($),undefined,seq)
import qualified Prelude
import Data.Vector.HFixed.Class hiding (cons,consF)
import qualified Data.Vector.Fixed as F
import qualified Data.Vector.HFixed.Cont as C
asCVec :: ContVec xs -> ContVec xs
asCVec = id
convert :: (HVector v, HVector w, Elems v ~ Elems w)
=> v -> w
convert v = inspect v construct
tail :: (HVector v, HVector w, (a ': Elems w) ~ Elems v)
=> v -> w
tail = C.vector . C.tail . C.cvec
head :: (HVector v, Elems v ~ (a ': as), Arity as)
=> v -> a
head = C.head . C.cvec
cons :: (HVector v, HVector w, Elems w ~ (a ': Elems v))
=> a -> v -> w
cons a = C.vector . C.cons a . C.cvec
concat :: ( HVector v, HVector u, HVector w
, Elems w ~ (Elems v ++ Elems u)
)
=> v -> u -> w
concat v u = C.vector $ C.concat (C.cvec v) (C.cvec u)
index :: (Index n (Elems v), HVector v) => v -> n -> ValueAt n (Elems v)
index = C.index . C.cvec
set :: (Index n (Elems v), HVector v)
=> n -> ValueAt n (Elems v) -> v -> v
set n x = C.vector
. C.set n x
. C.cvec
element :: (Index n (Elems v), ValueAt n (Elems v) ~ a, HVector v, Functor f)
=> n -> (a -> f a) -> (v -> f v)
element n f v = inspect v
$ lensF n f construct
elementCh :: ( Index n (Elems v)
, a ~ ValueAt n (Elems v)
, HVector v
, HVector w
, Elems w ~ NewElems n (Elems v) b
, Functor f)
=> n -> (a -> f b) -> (v -> f w)
elementCh n f v = inspect v
$ lensChF n f construct
#if __GLASGOW_HASKELL__ >= 708
elementTy :: forall n a f v proxy.
( Index (ToPeano n) (Elems v)
, ValueAt (ToPeano n) (Elems v) ~ a
, NatIso (ToPeano n) n
, HVector v
, Functor f)
=> proxy n -> (a -> f a) -> (v -> f v)
elementTy _ = element (undefined :: ToPeano n)
elementChTy :: forall a b f n v w proxy.
( Index (ToPeano n) (Elems v)
, a ~ ValueAt (ToPeano n) (Elems v)
, HVector v
, HVector w
, Elems w ~ NewElems (ToPeano n) (Elems v) b
, Functor f)
=> proxy n -> (a -> f b) -> (v -> f w)
elementChTy _ = elementCh (undefined :: ToPeano n)
#endif
fold :: HVector v => v -> Fn (Elems v) r -> r
fold v f = inspect v (Fun f)
foldr :: (HVector v, ArityC c (Elems v))
=> Proxy c -> (forall a. c a => a -> b -> b) -> b -> v -> b
foldr c f b0 = C.foldr c f b0 . C.cvec
foldl :: (HVector v, ArityC c (Elems v))
=> Proxy c -> (forall a. c a => b -> a -> b) -> b -> v -> b
foldl c f b0 = C.foldl c f b0 . C.cvec
mapM_ :: (HVector v, ArityC c (Elems v), Monad m)
=> Proxy c -> (forall a. c a => a -> m ()) -> v -> m ()
mapM_ c f = foldl c (\m a -> m >> f a) (return ())
mk0 :: (HVector v, Elems v ~ '[]) => v
mk0 = C.vector C.mk0
mk1 :: (HVector v, Elems v ~ '[a]) => a -> v
mk1 a = C.vector $ C.mk1 a
mk2 :: (HVector v, Elems v ~ '[a,b]) => a -> b -> v
mk2 a b = C.vector $ C.mk2 a b
mk3 :: (HVector v, Elems v ~ '[a,b,c]) => a -> b -> c -> v
mk3 a b c = C.vector $ C.mk3 a b c
mk4 :: (HVector v, Elems v ~ '[a,b,c,d]) => a -> b -> c -> d -> v
mk4 a b c d = C.vector $ C.mk4 a b c d
mk5 :: (HVector v, Elems v ~ '[a,b,c,d,e]) => a -> b -> c -> d -> e -> v
mk5 a b c d e = C.vector $ C.mk5 a b c d e
mapFunctor :: (HVectorF v)
=> (forall a. f a -> g a) -> v f -> v g
mapFunctor f = C.vectorF . C.mapFunctor f . C.cvecF
sequence
:: ( Monad m, HVectorF v, HVector w, ElemsF v ~ Elems w )
=> v m -> m w
sequence v = do w <- C.sequence $ C.cvecF v
return $ C.vector w
sequenceA
:: ( Applicative f, HVectorF v, HVector w, ElemsF v ~ Elems w )
=> v f -> f w
sequenceA v = C.vector <$> C.sequenceA (C.cvecF v)
sequenceF :: ( Monad m, HVectorF v) => v (m `Compose` f) -> m (v f)
sequenceF v = do w <- C.sequenceF $ C.cvecF v
return $ C.vectorF w
sequenceAF :: ( Applicative f, HVectorF v) => v (f `Compose` g) -> f (v g)
sequenceAF v = C.vectorF <$> C.sequenceAF (C.cvecF v)
wrap :: ( HVector v, HVectorF w, Elems v ~ ElemsF w )
=> (forall a. a -> f a) -> v -> w f
wrap f = C.vectorF . C.wrap f . C.cvec
unwrap :: ( HVectorF v, HVector w, ElemsF v ~ Elems w )
=> (forall a. f a -> a) -> v f -> w
unwrap f = C.vector . C.unwrap f . C.cvecF
distribute
:: ( Functor f, HVector v, HVectorF w, Elems v ~ ElemsF w )
=> f v -> w f
distribute = C.vectorF . C.distribute . fmap C.cvec
distributeF
:: ( Functor f, HVectorF v)
=> f (v g) -> v (f `Compose` g)
distributeF = C.vectorF . C.distributeF . fmap C.cvecF
replicate :: (HVector v, ArityC c (Elems v))
=> Proxy c -> (forall x. c x => x) -> v
replicate c x = C.vector $ C.replicate c x
replicateM :: (HVector v, Monad m, ArityC c (Elems v))
=> Proxy c -> (forall x. c x => m x) -> m v
replicateM c x = liftM C.vector $ C.replicateM c x
unfoldr :: (HVector v, ArityC c (Elems v))
=> Proxy c -> (forall a. c a => b -> (a,b)) -> b -> v
unfoldr c f b0 = C.vector $ C.unfoldr c f b0
zipMono :: (HVector v, ArityC c (Elems v))
=> Proxy c -> (forall a. c a => a -> a -> a) -> v -> v -> v
zipMono c f v u
= C.vector $ C.zipMono c f (C.cvec v) (C.cvec u)
zipMonoF :: (HVectorF v, ArityC c (ElemsF v))
=> Proxy c -> (forall a. c a => f a -> f a -> f a) -> v f -> v f -> v f
zipMonoF c f v u
= C.vectorF $ C.zipMonoF c f (C.cvecF v) (C.cvecF u)
zipFold :: (HVector v, ArityC c (Elems v), Monoid m)
=> Proxy c -> (forall a. c a => a -> a -> m) -> v -> v -> m
zipFold c f v u
= C.zipFold c f (C.cvec v) (C.cvec u)
monomorphize :: (HVector v, ArityC c (Elems v))
=> Proxy c -> (forall a. c a => a -> x)
-> v -> F.ContVec (Len (Elems v)) x
monomorphize c f = C.monomorphize c f . C.cvec
monomorphizeF :: (HVectorF v, ArityC c (ElemsF v))
=> Proxy c -> (forall a. c a => f a -> x)
-> v f -> F.ContVec (Len (ElemsF v)) x
monomorphizeF c f = C.monomorphizeF c f . C.cvecF
eq :: (HVector v, ArityC Eq (Elems v)) => v -> v -> Bool
eq v u = getAll $ zipFold (Proxy :: Proxy Eq) (\x y -> All (x == y)) v u
compare :: (HVector v, ArityC Ord (Elems v)) => v -> v -> Ordering
compare = zipFold (Proxy :: Proxy Ord) Prelude.compare
rnf :: (HVector v, ArityC NF.NFData (Elems v)) => v -> ()
rnf = foldl (Proxy :: Proxy NF.NFData) (\r a -> NF.rnf a `seq` r) ()