{-# LANGUAGE KindSignatures #-}
{-# LANGUAGE DataKinds #-}
{-# LANGUAGE FlexibleContexts #-}
{-# LANGUAGE FlexibleInstances #-}
{-# LANGUAGE RankNTypes #-}
{-# LANGUAGE ScopedTypeVariables #-}
{-# LANGUAGE TypeOperators #-}
{-# LANGUAGE PatternSynonyms #-}
{-# LANGUAGE GADTs #-}
{-# LANGUAGE TypeApplications #-}
{-# LANGUAGE AllowAmbiguousTypes #-}
{-# LANGUAGE NoStarIsType #-}
module Data.Vector.Unboxed.Sized
( Vector
, pattern SomeSized
, VUM.MVector
, length
, length'
, knownLength
, knownLength'
, index
, index'
, unsafeIndex
, head
, last
, indexM
, indexM'
, unsafeIndexM
, headM
, lastM
, slice
, slice'
, init
, tail
, take
, take'
, drop
, drop'
, splitAt
, splitAt'
, empty
, singleton
, fromTuple
, pattern Build
, replicate
, replicate'
, generate
, generate'
, iterateN
, iterateN'
, replicateM
, replicateM'
, generateM
, generateM'
, unfoldrN
, unfoldrN'
, enumFromN
, enumFromN'
, enumFromStepN
, enumFromStepN'
, cons
, snoc
, (++)
, force
, (//)
, update
, update_
, unsafeUpd
, unsafeUpdate
, unsafeUpdate_
, accum
, accumulate
, accumulate_
, unsafeAccum
, unsafeAccumulate
, unsafeAccumulate_
, reverse
, backpermute
, unsafeBackpermute
, ix
, ix'
, _head
, _last
, indexed
, map
, imap
, concatMap
, mapM
, imapM
, mapM_
, imapM_
, forM
, forM_
, zipWith
, zipWith3
, zipWith4
, zipWith5
, zipWith6
, izipWith
, izipWith3
, izipWith4
, izipWith5
, izipWith6
, zip
, zip3
, zip4
, zip5
, zip6
, zipWithM
, izipWithM
, zipWithM_
, izipWithM_
, unzip
, unzip3
, unzip4
, unzip5
, unzip6
, elem
, notElem
, find
, findIndex
, elemIndex
, foldl
, foldl1
, foldl'
, foldl1'
, foldr
, foldr1
, foldr'
, foldr1'
, ifoldl
, ifoldl'
, ifoldr
, ifoldr'
, all
, any
, and
, or
, sum
, product
, maximum
, maximumBy
, minimum
, minimumBy
, maxIndex
, maxIndexBy
, minIndex
, minIndexBy
, foldM
, ifoldM
, fold1M
, foldM'
, ifoldM'
, fold1M'
, foldM_
, ifoldM_
, fold1M_
, foldM'_
, ifoldM'_
, fold1M'_
, sequence
, sequence_
, prescanl
, prescanl'
, postscanl
, postscanl'
, scanl
, scanl'
, scanl1
, scanl1'
, prescanr
, prescanr'
, postscanr
, postscanr'
, scanr
, scanr'
, scanr1
, scanr1'
, toList
, fromList
, fromListN
, fromListN'
, withSizedList
, freeze
, thaw
, copy
, unsafeFreeze
, unsafeThaw
, toSized
, withSized
, fromSized
, withVectorUnsafe
, zipVectorsUnsafe
, Unbox
) where
import qualified Data.Vector.Generic.Sized as V
import qualified Data.Vector.Unboxed as VU
import Data.IndexedListLiterals (IndexedListLiterals)
import qualified Data.Vector.Unboxed.Mutable.Sized as VUM
import GHC.TypeLits
import Data.Finite
import Data.Proxy
import Control.Monad.Primitive
import Data.Vector.Unboxed (Unbox)
import Prelude hiding ( Foldable(..),
replicate, (++), concat,
head, last,
init, tail, take, drop, splitAt, reverse,
map, concat, concatMap,
zipWith, zipWith3, zip, zip3, unzip, unzip3,
filter, takeWhile, dropWhile, span, break,
notElem,
all, any, and, or,
scanl, scanl1, scanr, scanr1,
enumFromTo, enumFromThenTo,
mapM, mapM_, sequence, sequence_,
showsPrec )
type Vector = V.Vector VU.Vector
length :: forall n a. KnownNat n
=> Vector n a -> Int
length :: forall (n :: Nat) a. KnownNat n => Vector n a -> Int
length = Vector Vector n a -> Int
forall (v :: Type -> Type) (n :: Nat) a.
KnownNat n =>
Vector v n a -> Int
V.length
{-# inline length #-}
length' :: forall n a.
Vector n a -> Proxy n
length' :: forall (n :: Nat) a. Vector n a -> Proxy n
length' = Vector Vector n a -> Proxy n
forall (v :: Type -> Type) (n :: Nat) a. Vector v n a -> Proxy n
V.length'
{-# inline length' #-}
knownLength :: forall n a r. Unbox a
=> Vector n a
-> (KnownNat n => r)
-> r
knownLength :: forall (n :: Nat) a r.
Unbox a =>
Vector n a -> (KnownNat n => r) -> r
knownLength = Vector Vector n a -> (KnownNat n => r) -> r
forall (v :: Type -> Type) (n :: Nat) a r.
Vector v a =>
Vector v n a -> (KnownNat n => r) -> r
V.knownLength
knownLength' :: forall n a r. Unbox a
=> Vector n a
-> (KnownNat n => Proxy n -> r)
-> r
knownLength' :: forall (n :: Nat) a r.
Unbox a =>
Vector n a -> (KnownNat n => Proxy n -> r) -> r
knownLength' = Vector Vector n a -> (KnownNat n => Proxy n -> r) -> r
forall (v :: Type -> Type) (n :: Nat) a r.
Vector v a =>
Vector v n a -> (KnownNat n => Proxy n -> r) -> r
V.knownLength'
index :: forall n a. Unbox a
=> Vector n a -> Finite n -> a
index :: forall (n :: Nat) a. Unbox a => Vector n a -> Finite n -> a
index = Vector Vector n a -> Finite n -> a
forall (v :: Type -> Type) (n :: Nat) a.
Vector v a =>
Vector v n a -> Finite n -> a
V.index
{-# inline index #-}
index' :: forall n m a p. (KnownNat n, Unbox a)
=> Vector (n+m+1) a -> p n -> a
index' :: forall (n :: Nat) (m :: Nat) a (p :: Nat -> Type).
(KnownNat n, Unbox a) =>
Vector ((n + m) + 1) a -> p n -> a
index' = Vector Vector ((n + m) + 1) a -> p n -> a
forall (v :: Type -> Type) (n :: Nat) (m :: Nat) a
(p :: Nat -> Type).
(KnownNat n, Vector v a) =>
Vector v ((n + m) + 1) a -> p n -> a
V.index'
{-# inline index' #-}
unsafeIndex :: forall n a. Unbox a
=> Vector n a -> Int -> a
unsafeIndex :: forall (n :: Nat) a. Unbox a => Vector n a -> Int -> a
unsafeIndex = Vector Vector n a -> Int -> a
forall (v :: Type -> Type) (n :: Nat) a.
Vector v a =>
Vector v n a -> Int -> a
V.unsafeIndex
{-# inline unsafeIndex #-}
head :: forall n a. (Unbox a)
=> Vector (1+n) a -> a
head :: forall (n :: Nat) a. Unbox a => Vector (1 + n) a -> a
head = Vector Vector (1 + n) a -> a
forall (v :: Type -> Type) (n :: Nat) a.
Vector v a =>
Vector v (1 + n) a -> a
V.head
{-# inline head #-}
last :: forall n a. (Unbox a)
=> Vector (n+1) a -> a
last :: forall (n :: Nat) a. Unbox a => Vector (n + 1) a -> a
last = Vector Vector (n + 1) a -> a
forall (v :: Type -> Type) (n :: Nat) a.
Vector v a =>
Vector v (n + 1) a -> a
V.last
{-# inline last #-}
ix :: forall n a f. (Unbox a, Functor f)
=> Finite n -> (a -> f a) -> Vector n a -> f (Vector n a)
ix :: forall (n :: Nat) a (f :: Type -> Type).
(Unbox a, Functor f) =>
Finite n -> (a -> f a) -> Vector n a -> f (Vector n a)
ix = Finite n
-> (a -> f a) -> Vector Vector n a -> f (Vector Vector n a)
forall (v :: Type -> Type) (n :: Nat) a (f :: Type -> Type).
(Vector v a, Functor f) =>
Finite n -> (a -> f a) -> Vector v n a -> f (Vector v n a)
V.ix
{-# inline ix #-}
ix' :: forall i n a f. (Unbox a, Functor f,
KnownNat i, KnownNat n, i+1 <= n)
=> (a -> f a) -> Vector n a -> f (Vector n a)
ix' :: forall (i :: Nat) (n :: Nat) a (f :: Type -> Type).
(Unbox a, Functor f, KnownNat i, KnownNat n, (i + 1) <= n) =>
(a -> f a) -> Vector n a -> f (Vector n a)
ix' = forall (i :: Nat) (v :: Type -> Type) (n :: Nat) a
(f :: Type -> Type).
(Vector v a, Functor f, KnownNat i, KnownNat n, (i + 1) <= n) =>
(a -> f a) -> Vector v n a -> f (Vector v n a)
V.ix' @i
{-# inline ix' #-}
_head :: forall n a f. (Unbox a, Functor f)
=> (a -> f a) -> Vector (1+n) a -> f (Vector (1+n) a)
_head :: forall (n :: Nat) a (f :: Type -> Type).
(Unbox a, Functor f) =>
(a -> f a) -> Vector (1 + n) a -> f (Vector (1 + n) a)
_head = (a -> f a)
-> Vector Vector (1 + n) a -> f (Vector Vector (1 + n) a)
forall (v :: Type -> Type) (n :: Nat) a (f :: Type -> Type).
(Vector v a, Functor f) =>
(a -> f a) -> Vector v (1 + n) a -> f (Vector v (1 + n) a)
V._head
{-# inline _head #-}
_last :: forall n a f. (Unbox a, Functor f)
=> (a -> f a) -> Vector (n+1) a -> f (Vector (n+1) a)
_last :: forall (n :: Nat) a (f :: Type -> Type).
(Unbox a, Functor f) =>
(a -> f a) -> Vector (n + 1) a -> f (Vector (n + 1) a)
_last = (a -> f a)
-> Vector Vector (n + 1) a -> f (Vector Vector (n + 1) a)
forall (v :: Type -> Type) (n :: Nat) a (f :: Type -> Type).
(Vector v a, Functor f) =>
(a -> f a) -> Vector v (n + 1) a -> f (Vector v (n + 1) a)
V._last
{-# inline _last #-}
indexM :: forall n a m. (Unbox a, Monad m)
=> Vector n a -> Finite n -> m a
indexM :: forall (n :: Nat) a (m :: Type -> Type).
(Unbox a, Monad m) =>
Vector n a -> Finite n -> m a
indexM = Vector Vector n a -> Finite n -> m a
forall (v :: Type -> Type) (n :: Nat) a (m :: Type -> Type).
(Vector v a, Monad m) =>
Vector v n a -> Finite n -> m a
V.indexM
{-# inline indexM #-}
indexM' :: forall n k a m p. (KnownNat n, Unbox a, Monad m)
=> Vector (n+k) a -> p n -> m a
indexM' :: forall (n :: Nat) (k :: Nat) a (m :: Type -> Type)
(p :: Nat -> Type).
(KnownNat n, Unbox a, Monad m) =>
Vector (n + k) a -> p n -> m a
indexM' = Vector Vector (n + k) a -> p n -> m a
forall (v :: Type -> Type) (n :: Nat) (k :: Nat) a
(m :: Type -> Type) (p :: Nat -> Type).
(KnownNat n, Vector v a, Monad m) =>
Vector v (n + k) a -> p n -> m a
V.indexM'
{-# inline indexM' #-}
unsafeIndexM :: forall n a m. (Unbox a, Monad m)
=> Vector n a -> Int -> m a
unsafeIndexM :: forall (n :: Nat) a (m :: Type -> Type).
(Unbox a, Monad m) =>
Vector n a -> Int -> m a
unsafeIndexM = Vector Vector n a -> Int -> m a
forall (v :: Type -> Type) (n :: Nat) a (m :: Type -> Type).
(Vector v a, Monad m) =>
Vector v n a -> Int -> m a
V.unsafeIndexM
{-# inline unsafeIndexM #-}
headM :: forall n a m. (Unbox a, Monad m)
=> Vector (1+n) a -> m a
headM :: forall (n :: Nat) a (m :: Type -> Type).
(Unbox a, Monad m) =>
Vector (1 + n) a -> m a
headM = Vector Vector (1 + n) a -> m a
forall (v :: Type -> Type) (n :: Nat) a (m :: Type -> Type).
(Vector v a, Monad m) =>
Vector v (1 + n) a -> m a
V.headM
{-# inline headM #-}
lastM :: forall n a m. (Unbox a, Monad m)
=> Vector (n+1) a -> m a
lastM :: forall (n :: Nat) a (m :: Type -> Type).
(Unbox a, Monad m) =>
Vector (n + 1) a -> m a
lastM = Vector Vector (n + 1) a -> m a
forall (v :: Type -> Type) (n :: Nat) a (m :: Type -> Type).
(Vector v a, Monad m) =>
Vector v (n + 1) a -> m a
V.lastM
{-# inline lastM #-}
slice :: forall i n m a p. (KnownNat i, KnownNat n, Unbox a)
=> p i
-> Vector (i+n+m) a
-> Vector n a
slice :: forall (i :: Nat) (n :: Nat) (m :: Nat) a (p :: Nat -> Type).
(KnownNat i, KnownNat n, Unbox a) =>
p i -> Vector ((i + n) + m) a -> Vector n a
slice = p i -> Vector Vector ((i + n) + m) a -> Vector Vector n a
forall (v :: Type -> Type) (i :: Nat) (n :: Nat) (m :: Nat) a
(p :: Nat -> Type).
(KnownNat i, KnownNat n, Vector v a) =>
p i -> Vector v ((i + n) + m) a -> Vector v n a
V.slice
{-# inline slice #-}
slice' :: forall i n m a p. (KnownNat i, KnownNat n, Unbox a)
=> p i
-> p n
-> Vector (i+n+m) a
-> Vector n a
slice' :: forall (i :: Nat) (n :: Nat) (m :: Nat) a (p :: Nat -> Type).
(KnownNat i, KnownNat n, Unbox a) =>
p i -> p n -> Vector ((i + n) + m) a -> Vector n a
slice' = p i -> p n -> Vector Vector ((i + n) + m) a -> Vector Vector n a
forall (v :: Type -> Type) (i :: Nat) (n :: Nat) (m :: Nat) a
(p :: Nat -> Type).
(KnownNat i, KnownNat n, Vector v a) =>
p i -> p n -> Vector v ((i + n) + m) a -> Vector v n a
V.slice'
{-# inline slice' #-}
init :: forall n a. (Unbox a)
=> Vector (n+1) a -> Vector n a
init :: forall (n :: Nat) a. Unbox a => Vector (n + 1) a -> Vector n a
init = Vector Vector (n + 1) a -> Vector Vector n a
forall (v :: Type -> Type) (n :: Nat) a.
Vector v a =>
Vector v (n + 1) a -> Vector v n a
V.init
{-# inline init #-}
tail :: forall n a. (Unbox a)
=> Vector (1+n) a -> Vector n a
tail :: forall (n :: Nat) a. Unbox a => Vector (1 + n) a -> Vector n a
tail = Vector Vector (1 + n) a -> Vector Vector n a
forall (v :: Type -> Type) (n :: Nat) a.
Vector v a =>
Vector v (1 + n) a -> Vector v n a
V.tail
{-# inline tail #-}
take :: forall n m a. (KnownNat n, Unbox a)
=> Vector (n+m) a -> Vector n a
take :: forall (n :: Nat) (m :: Nat) a.
(KnownNat n, Unbox a) =>
Vector (n + m) a -> Vector n a
take = Vector Vector (n + m) a -> Vector Vector n a
forall (v :: Type -> Type) (n :: Nat) (m :: Nat) a.
(KnownNat n, Vector v a) =>
Vector v (n + m) a -> Vector v n a
V.take
{-# inline take #-}
take' :: forall n m a p. (KnownNat n, Unbox a)
=> p n -> Vector (n+m) a -> Vector n a
take' :: forall (n :: Nat) (m :: Nat) a (p :: Nat -> Type).
(KnownNat n, Unbox a) =>
p n -> Vector (n + m) a -> Vector n a
take' = p n -> Vector Vector (n + m) a -> Vector Vector n a
forall (v :: Type -> Type) (n :: Nat) (m :: Nat) a
(p :: Nat -> Type).
(KnownNat n, Vector v a) =>
p n -> Vector v (n + m) a -> Vector v n a
V.take'
{-# inline take' #-}
drop :: forall n m a. (KnownNat n, Unbox a)
=> Vector (n+m) a -> Vector m a
drop :: forall (n :: Nat) (m :: Nat) a.
(KnownNat n, Unbox a) =>
Vector (n + m) a -> Vector m a
drop = Vector Vector (n + m) a -> Vector Vector m a
forall (v :: Type -> Type) (n :: Nat) (m :: Nat) a.
(KnownNat n, Vector v a) =>
Vector v (n + m) a -> Vector v m a
V.drop
{-# inline drop #-}
drop' :: forall n m a p. (KnownNat n, Unbox a)
=> p n -> Vector (n+m) a -> Vector m a
drop' :: forall (n :: Nat) (m :: Nat) a (p :: Nat -> Type).
(KnownNat n, Unbox a) =>
p n -> Vector (n + m) a -> Vector m a
drop' = p n -> Vector Vector (n + m) a -> Vector Vector m a
forall (v :: Type -> Type) (n :: Nat) (m :: Nat) a
(p :: Nat -> Type).
(KnownNat n, Vector v a) =>
p n -> Vector v (n + m) a -> Vector v m a
V.drop'
{-# inline drop' #-}
splitAt :: forall n m a. (KnownNat n, Unbox a)
=> Vector (n+m) a -> (Vector n a, Vector m a)
splitAt :: forall (n :: Nat) (m :: Nat) a.
(KnownNat n, Unbox a) =>
Vector (n + m) a -> (Vector n a, Vector m a)
splitAt = Vector Vector (n + m) a -> (Vector Vector n a, Vector Vector m a)
forall (v :: Type -> Type) (n :: Nat) (m :: Nat) a.
(KnownNat n, Vector v a) =>
Vector v (n + m) a -> (Vector v n a, Vector v m a)
V.splitAt
{-# inline splitAt #-}
splitAt' :: forall n m a p. (KnownNat n, Unbox a)
=> p n -> Vector (n+m) a -> (Vector n a, Vector m a)
splitAt' :: forall (n :: Nat) (m :: Nat) a (p :: Nat -> Type).
(KnownNat n, Unbox a) =>
p n -> Vector (n + m) a -> (Vector n a, Vector m a)
splitAt' = p n
-> Vector Vector (n + m) a
-> (Vector Vector n a, Vector Vector m a)
forall (v :: Type -> Type) (n :: Nat) (m :: Nat) a
(p :: Nat -> Type).
(KnownNat n, Vector v a) =>
p n -> Vector v (n + m) a -> (Vector v n a, Vector v m a)
V.splitAt'
{-# inline splitAt' #-}
empty :: forall a. (Unbox a)
=> Vector 0 a
empty :: forall a. Unbox a => Vector 0 a
empty = Vector Vector 0 a
forall (v :: Type -> Type) a. Vector v a => Vector v 0 a
V.empty
{-# inline empty #-}
singleton :: forall a. (Unbox a)
=> a -> Vector 1 a
singleton :: forall a. Unbox a => a -> Vector 1 a
singleton = a -> Vector Vector 1 a
forall (v :: Type -> Type) a. Vector v a => a -> Vector v 1 a
V.singleton
{-# inline singleton #-}
fromTuple :: forall a input length.
(Unbox a, IndexedListLiterals input length a, KnownNat length)
=> input -> Vector length a
fromTuple :: forall a input (length :: Nat).
(Unbox a, IndexedListLiterals input length a, KnownNat length) =>
input -> Vector length a
fromTuple = input -> Vector Vector length a
forall (v :: Type -> Type) a input (length :: Nat).
(Vector v a, IndexedListLiterals input length a,
KnownNat length) =>
input -> Vector v length a
V.fromTuple
{-# inline fromTuple #-}
pattern Build :: Unbox a => V.BuildVector n a -> Vector n a
pattern $mBuild :: forall {r} {a} {n :: Nat}.
Unbox a =>
Vector n a -> (BuildVector n a -> r) -> ((# #) -> r) -> r
$bBuild :: forall a (n :: Nat). Unbox a => BuildVector n a -> Vector n a
Build vec = V.Build vec
replicate :: forall n a. (KnownNat n, Unbox a)
=> a -> Vector n a
replicate :: forall (n :: Nat) a. (KnownNat n, Unbox a) => a -> Vector n a
replicate = a -> Vector Vector n a
forall (v :: Type -> Type) (n :: Nat) a.
(KnownNat n, Vector v a) =>
a -> Vector v n a
V.replicate
{-# inline replicate #-}
replicate' :: forall n a p. (KnownNat n, Unbox a)
=> p n -> a -> Vector n a
replicate' :: forall (n :: Nat) a (p :: Nat -> Type).
(KnownNat n, Unbox a) =>
p n -> a -> Vector n a
replicate' = p n -> a -> Vector Vector n a
forall (v :: Type -> Type) (n :: Nat) a (p :: Nat -> Type).
(KnownNat n, Vector v a) =>
p n -> a -> Vector v n a
V.replicate'
{-# inline replicate' #-}
generate :: forall n a. (KnownNat n, Unbox a)
=> (Finite n -> a) -> Vector n a
generate :: forall (n :: Nat) a.
(KnownNat n, Unbox a) =>
(Finite n -> a) -> Vector n a
generate = (Finite n -> a) -> Vector Vector n a
forall (v :: Type -> Type) (n :: Nat) a.
(KnownNat n, Vector v a) =>
(Finite n -> a) -> Vector v n a
V.generate
{-# inline generate #-}
generate' :: forall n a p. (KnownNat n, Unbox a)
=> p n -> (Finite n -> a) -> Vector n a
generate' :: forall (n :: Nat) a (p :: Nat -> Type).
(KnownNat n, Unbox a) =>
p n -> (Finite n -> a) -> Vector n a
generate' = p n -> (Finite n -> a) -> Vector Vector n a
forall (v :: Type -> Type) (n :: Nat) a (p :: Nat -> Type).
(KnownNat n, Vector v a) =>
p n -> (Finite n -> a) -> Vector v n a
V.generate'
{-# inline generate' #-}
iterateN :: forall n a. (KnownNat n, Unbox a)
=> (a -> a) -> a -> Vector n a
iterateN :: forall (n :: Nat) a.
(KnownNat n, Unbox a) =>
(a -> a) -> a -> Vector n a
iterateN = (a -> a) -> a -> Vector Vector n a
forall (v :: Type -> Type) (n :: Nat) a.
(KnownNat n, Vector v a) =>
(a -> a) -> a -> Vector v n a
V.iterateN
{-# inline iterateN #-}
iterateN' :: forall n a p. (KnownNat n, Unbox a)
=> p n -> (a -> a) -> a -> Vector n a
iterateN' :: forall (n :: Nat) a (p :: Nat -> Type).
(KnownNat n, Unbox a) =>
p n -> (a -> a) -> a -> Vector n a
iterateN' = p n -> (a -> a) -> a -> Vector Vector n a
forall (v :: Type -> Type) (n :: Nat) a (p :: Nat -> Type).
(KnownNat n, Vector v a) =>
p n -> (a -> a) -> a -> Vector v n a
V.iterateN'
{-# inline iterateN' #-}
replicateM :: forall n m a. (KnownNat n, Unbox a, Monad m)
=> m a -> m (Vector n a)
replicateM :: forall (n :: Nat) (m :: Type -> Type) a.
(KnownNat n, Unbox a, Monad m) =>
m a -> m (Vector n a)
replicateM = m a -> m (Vector Vector n a)
forall (v :: Type -> Type) (n :: Nat) (m :: Type -> Type) a.
(KnownNat n, Vector v a, Monad m) =>
m a -> m (Vector v n a)
V.replicateM
{-# inline replicateM #-}
replicateM' :: forall n m a p. (KnownNat n, Unbox a, Monad m)
=> p n -> m a -> m (Vector n a)
replicateM' :: forall (n :: Nat) (m :: Type -> Type) a (p :: Nat -> Type).
(KnownNat n, Unbox a, Monad m) =>
p n -> m a -> m (Vector n a)
replicateM' = p n -> m a -> m (Vector Vector n a)
forall (v :: Type -> Type) (n :: Nat) (m :: Type -> Type) a
(p :: Nat -> Type).
(KnownNat n, Vector v a, Monad m) =>
p n -> m a -> m (Vector v n a)
V.replicateM'
{-# inline replicateM' #-}
generateM :: forall n m a. (KnownNat n, Unbox a, Monad m)
=> (Finite n -> m a) -> m (Vector n a)
generateM :: forall (n :: Nat) (m :: Type -> Type) a.
(KnownNat n, Unbox a, Monad m) =>
(Finite n -> m a) -> m (Vector n a)
generateM = (Finite n -> m a) -> m (Vector Vector n a)
forall (v :: Type -> Type) (n :: Nat) (m :: Type -> Type) a.
(KnownNat n, Vector v a, Monad m) =>
(Finite n -> m a) -> m (Vector v n a)
V.generateM
{-# inline generateM #-}
generateM' :: forall n m a p. (KnownNat n, Unbox a, Monad m)
=> p n -> (Finite n -> m a) -> m (Vector n a)
generateM' :: forall (n :: Nat) (m :: Type -> Type) a (p :: Nat -> Type).
(KnownNat n, Unbox a, Monad m) =>
p n -> (Finite n -> m a) -> m (Vector n a)
generateM' = p n -> (Finite n -> m a) -> m (Vector Vector n a)
forall (v :: Type -> Type) (n :: Nat) (m :: Type -> Type) a
(p :: Nat -> Type).
(KnownNat n, Vector v a, Monad m) =>
p n -> (Finite n -> m a) -> m (Vector v n a)
V.generateM'
{-# inline generateM' #-}
unfoldrN :: forall n a b. (KnownNat n, Unbox a)
=> (b -> (a, b)) -> b -> Vector n a
unfoldrN :: forall (n :: Nat) a b.
(KnownNat n, Unbox a) =>
(b -> (a, b)) -> b -> Vector n a
unfoldrN = (b -> (a, b)) -> b -> Vector Vector n a
forall (v :: Type -> Type) (n :: Nat) a b.
(KnownNat n, Vector v a) =>
(b -> (a, b)) -> b -> Vector v n a
V.unfoldrN
{-# inline unfoldrN #-}
unfoldrN' :: forall n a b p. (KnownNat n, Unbox a)
=> p n -> (b -> (a, b)) -> b -> Vector n a
unfoldrN' :: forall (n :: Nat) a b (p :: Nat -> Type).
(KnownNat n, Unbox a) =>
p n -> (b -> (a, b)) -> b -> Vector n a
unfoldrN' = p n -> (b -> (a, b)) -> b -> Vector Vector n a
forall (v :: Type -> Type) (n :: Nat) a b (p :: Nat -> Type).
(KnownNat n, Vector v a) =>
p n -> (b -> (a, b)) -> b -> Vector v n a
V.unfoldrN'
{-# inline unfoldrN' #-}
enumFromN :: forall n a. (KnownNat n, Unbox a, Num a)
=> a -> Vector n a
enumFromN :: forall (n :: Nat) a.
(KnownNat n, Unbox a, Num a) =>
a -> Vector n a
enumFromN = a -> Vector Vector n a
forall (v :: Type -> Type) (n :: Nat) a.
(KnownNat n, Vector v a, Num a) =>
a -> Vector v n a
V.enumFromN
{-# inline enumFromN #-}
enumFromN' :: forall n a p. (KnownNat n, Unbox a, Num a)
=> a -> p n -> Vector n a
enumFromN' :: forall (n :: Nat) a (p :: Nat -> Type).
(KnownNat n, Unbox a, Num a) =>
a -> p n -> Vector n a
enumFromN' = a -> p n -> Vector Vector n a
forall (v :: Type -> Type) (n :: Nat) a (p :: Nat -> Type).
(KnownNat n, Vector v a, Num a) =>
a -> p n -> Vector v n a
V.enumFromN'
{-# inline enumFromN' #-}
enumFromStepN :: forall n a. (KnownNat n, Unbox a, Num a)
=> a -> a -> Vector n a
enumFromStepN :: forall (n :: Nat) a.
(KnownNat n, Unbox a, Num a) =>
a -> a -> Vector n a
enumFromStepN = a -> a -> Vector Vector n a
forall (v :: Type -> Type) (n :: Nat) a.
(KnownNat n, Vector v a, Num a) =>
a -> a -> Vector v n a
V.enumFromStepN
{-# inline enumFromStepN #-}
enumFromStepN' :: forall n a p. (KnownNat n, Unbox a, Num a)
=> a -> a -> p n -> Vector n a
enumFromStepN' :: forall (n :: Nat) a (p :: Nat -> Type).
(KnownNat n, Unbox a, Num a) =>
a -> a -> p n -> Vector n a
enumFromStepN' = a -> a -> p n -> Vector Vector n a
forall (v :: Type -> Type) (n :: Nat) a (p :: Nat -> Type).
(KnownNat n, Vector v a, Num a) =>
a -> a -> p n -> Vector v n a
V.enumFromStepN'
{-# inline enumFromStepN' #-}
cons :: forall n a. Unbox a
=> a -> Vector n a -> Vector (1+n) a
cons :: forall (n :: Nat) a. Unbox a => a -> Vector n a -> Vector (1 + n) a
cons = a -> Vector Vector n a -> Vector Vector (1 + n) a
forall (v :: Type -> Type) (n :: Nat) a.
Vector v a =>
a -> Vector v n a -> Vector v (1 + n) a
V.cons
{-# inline cons #-}
snoc :: forall n a. Unbox a
=> Vector n a -> a -> Vector (n+1) a
snoc :: forall (n :: Nat) a. Unbox a => Vector n a -> a -> Vector (n + 1) a
snoc = Vector Vector n a -> a -> Vector Vector (n + 1) a
forall (v :: Type -> Type) (n :: Nat) a.
Vector v a =>
Vector v n a -> a -> Vector v (n + 1) a
V.snoc
{-# inline snoc #-}
(++) :: forall n m a. Unbox a
=> Vector n a -> Vector m a -> Vector (n+m) a
++ :: forall (n :: Nat) (m :: Nat) a.
Unbox a =>
Vector n a -> Vector m a -> Vector (n + m) a
(++) = Vector Vector n a -> Vector Vector m a -> Vector Vector (n + m) a
forall (v :: Type -> Type) (n :: Nat) (m :: Nat) a.
Vector v a =>
Vector v n a -> Vector v m a -> Vector v (n + m) a
(V.++)
{-# inline (++) #-}
force :: Unbox a => Vector n a -> Vector n a
force :: forall a (n :: Nat). Unbox a => Vector n a -> Vector n a
force = Vector Vector n a -> Vector Vector n a
forall (v :: Type -> Type) a (n :: Nat).
Vector v a =>
Vector v n a -> Vector v n a
V.force
{-# inline force #-}
(//) :: (Unbox a)
=> Vector m a
-> [(Finite m, a)]
-> Vector m a
// :: forall a (m :: Nat).
Unbox a =>
Vector m a -> [(Finite m, a)] -> Vector m a
(//) = Vector Vector m a -> [(Finite m, a)] -> Vector Vector m a
forall (v :: Type -> Type) a (m :: Nat).
Vector v a =>
Vector v m a -> [(Finite m, a)] -> Vector v m a
(V.//)
{-# inline (//) #-}
update :: (Unbox a)
=> Vector m a
-> Vector n (Int, a)
-> Vector m a
update :: forall a (m :: Nat) (n :: Nat).
Unbox a =>
Vector m a -> Vector n (Int, a) -> Vector m a
update = Vector Vector m a -> Vector Vector n (Int, a) -> Vector Vector m a
forall (v :: Type -> Type) a (m :: Nat) (n :: Nat).
(Vector v a, Vector v (Int, a)) =>
Vector v m a -> Vector v n (Int, a) -> Vector v m a
V.update
{-# inline update #-}
update_ :: Unbox a
=> Vector m a
-> Vector n Int
-> Vector n a
-> Vector m a
update_ :: forall a (m :: Nat) (n :: Nat).
Unbox a =>
Vector m a -> Vector n Int -> Vector n a -> Vector m a
update_ = Vector Vector m a
-> Vector Vector n Int -> Vector Vector n a -> Vector Vector m a
forall (v :: Type -> Type) a (m :: Nat) (n :: Nat).
(Vector v a, Vector v Int) =>
Vector v m a -> Vector v n Int -> Vector v n a -> Vector v m a
V.update_
{-# inline update_ #-}
unsafeUpd :: (Unbox a)
=> Vector m a
-> [(Int, a)]
-> Vector m a
unsafeUpd :: forall a (m :: Nat).
Unbox a =>
Vector m a -> [(Int, a)] -> Vector m a
unsafeUpd = Vector Vector m a -> [(Int, a)] -> Vector Vector m a
forall (v :: Type -> Type) a (m :: Nat).
Vector v a =>
Vector v m a -> [(Int, a)] -> Vector v m a
V.unsafeUpd
{-# inline unsafeUpd #-}
unsafeUpdate :: (Unbox a)
=> Vector m a
-> Vector n (Int, a)
-> Vector m a
unsafeUpdate :: forall a (m :: Nat) (n :: Nat).
Unbox a =>
Vector m a -> Vector n (Int, a) -> Vector m a
unsafeUpdate = Vector Vector m a -> Vector Vector n (Int, a) -> Vector Vector m a
forall (v :: Type -> Type) a (m :: Nat) (n :: Nat).
(Vector v a, Vector v (Int, a)) =>
Vector v m a -> Vector v n (Int, a) -> Vector v m a
V.unsafeUpdate
{-# inline unsafeUpdate #-}
unsafeUpdate_ :: Unbox a
=> Vector m a
-> Vector n Int
-> Vector n a
-> Vector m a
unsafeUpdate_ :: forall a (m :: Nat) (n :: Nat).
Unbox a =>
Vector m a -> Vector n Int -> Vector n a -> Vector m a
unsafeUpdate_ = Vector Vector m a
-> Vector Vector n Int -> Vector Vector n a -> Vector Vector m a
forall (v :: Type -> Type) a (m :: Nat) (n :: Nat).
(Vector v a, Vector v Int) =>
Vector v m a -> Vector v n Int -> Vector v n a -> Vector v m a
V.unsafeUpdate_
{-# inline unsafeUpdate_ #-}
accum :: Unbox a
=> (a -> b -> a)
-> Vector m a
-> [(Finite m,b)]
-> Vector m a
accum :: forall a b (m :: Nat).
Unbox a =>
(a -> b -> a) -> Vector m a -> [(Finite m, b)] -> Vector m a
accum = (a -> b -> a)
-> Vector Vector m a -> [(Finite m, b)] -> Vector Vector m a
forall (v :: Type -> Type) a b (m :: Nat).
Vector v a =>
(a -> b -> a) -> Vector v m a -> [(Finite m, b)] -> Vector v m a
V.accum
{-# inline accum #-}
accumulate :: (Unbox a, Unbox b)
=> (a -> b -> a)
-> Vector m a
-> Vector n (Int,b)
-> Vector m a
accumulate :: forall a b (m :: Nat) (n :: Nat).
(Unbox a, Unbox b) =>
(a -> b -> a) -> Vector m a -> Vector n (Int, b) -> Vector m a
accumulate = (a -> b -> a)
-> Vector Vector m a
-> Vector Vector n (Int, b)
-> Vector Vector m a
forall (v :: Type -> Type) a b (m :: Nat) (n :: Nat).
(Vector v a, Vector v (Int, b)) =>
(a -> b -> a)
-> Vector v m a -> Vector v n (Int, b) -> Vector v m a
V.accumulate
{-# inline accumulate #-}
accumulate_ :: (Unbox a, Unbox b)
=> (a -> b -> a)
-> Vector m a
-> Vector n Int
-> Vector n b
-> Vector m a
accumulate_ :: forall a b (m :: Nat) (n :: Nat).
(Unbox a, Unbox b) =>
(a -> b -> a)
-> Vector m a -> Vector n Int -> Vector n b -> Vector m a
accumulate_ = (a -> b -> a)
-> Vector Vector m a
-> Vector Vector n Int
-> Vector Vector n b
-> Vector Vector m a
forall (v :: Type -> Type) a b (m :: Nat) (n :: Nat).
(Vector v a, Vector v Int, Vector v b) =>
(a -> b -> a)
-> Vector v m a -> Vector v n Int -> Vector v n b -> Vector v m a
V.accumulate_
{-# inline accumulate_ #-}
unsafeAccum :: Unbox a
=> (a -> b -> a)
-> Vector m a
-> [(Int,b)]
-> Vector m a
unsafeAccum :: forall a b (m :: Nat).
Unbox a =>
(a -> b -> a) -> Vector m a -> [(Int, b)] -> Vector m a
unsafeAccum = (a -> b -> a)
-> Vector Vector m a -> [(Int, b)] -> Vector Vector m a
forall (v :: Type -> Type) a b (m :: Nat).
Vector v a =>
(a -> b -> a) -> Vector v m a -> [(Int, b)] -> Vector v m a
V.unsafeAccum
{-# inline unsafeAccum #-}
unsafeAccumulate :: (Unbox a, Unbox b)
=> (a -> b -> a)
-> Vector m a
-> Vector n (Int,b)
-> Vector m a
unsafeAccumulate :: forall a b (m :: Nat) (n :: Nat).
(Unbox a, Unbox b) =>
(a -> b -> a) -> Vector m a -> Vector n (Int, b) -> Vector m a
unsafeAccumulate = (a -> b -> a)
-> Vector Vector m a
-> Vector Vector n (Int, b)
-> Vector Vector m a
forall (v :: Type -> Type) a b (m :: Nat) (n :: Nat).
(Vector v a, Vector v (Int, b)) =>
(a -> b -> a)
-> Vector v m a -> Vector v n (Int, b) -> Vector v m a
V.unsafeAccumulate
{-# inline unsafeAccumulate #-}
unsafeAccumulate_ :: (Unbox a, Unbox b)
=> (a -> b -> a)
-> Vector m a
-> Vector n Int
-> Vector n b
-> Vector m a
unsafeAccumulate_ :: forall a b (m :: Nat) (n :: Nat).
(Unbox a, Unbox b) =>
(a -> b -> a)
-> Vector m a -> Vector n Int -> Vector n b -> Vector m a
unsafeAccumulate_ = (a -> b -> a)
-> Vector Vector m a
-> Vector Vector n Int
-> Vector Vector n b
-> Vector Vector m a
forall (v :: Type -> Type) a b (m :: Nat) (n :: Nat).
(Vector v a, Vector v Int, Vector v b) =>
(a -> b -> a)
-> Vector v m a -> Vector v n Int -> Vector v n b -> Vector v m a
V.unsafeAccumulate_
{-# inline unsafeAccumulate_ #-}
reverse :: (Unbox a) => Vector n a -> Vector n a
reverse :: forall a (n :: Nat). Unbox a => Vector n a -> Vector n a
reverse = Vector Vector n a -> Vector Vector n a
forall (v :: Type -> Type) a (n :: Nat).
Vector v a =>
Vector v n a -> Vector v n a
V.reverse
{-# inline reverse #-}
backpermute :: Unbox a
=> Vector m a
-> Vector n Int
-> Vector n a
backpermute :: forall a (m :: Nat) (n :: Nat).
Unbox a =>
Vector m a -> Vector n Int -> Vector n a
backpermute = Vector Vector m a -> Vector Vector n Int -> Vector Vector n a
forall (v :: Type -> Type) a (m :: Nat) (n :: Nat).
(Vector v a, Vector v Int) =>
Vector v m a -> Vector v n Int -> Vector v n a
V.backpermute
{-# inline backpermute #-}
unsafeBackpermute :: Unbox a
=> Vector m a
-> Vector n Int
-> Vector n a
unsafeBackpermute :: forall a (m :: Nat) (n :: Nat).
Unbox a =>
Vector m a -> Vector n Int -> Vector n a
unsafeBackpermute = Vector Vector m a -> Vector Vector n Int -> Vector Vector n a
forall (v :: Type -> Type) a (m :: Nat) (n :: Nat).
(Vector v a, Vector v Int) =>
Vector v m a -> Vector v n Int -> Vector v n a
V.unsafeBackpermute
{-# inline unsafeBackpermute #-}
indexed :: (Unbox a, Unbox (Finite n))
=> Vector n a -> Vector n (Finite n,a)
indexed :: forall a (n :: Nat).
(Unbox a, Unbox (Finite n)) =>
Vector n a -> Vector n (Finite n, a)
indexed = Vector Vector n a -> Vector Vector n (Finite n, a)
forall (v :: Type -> Type) a (n :: Nat).
(Vector v a, Vector v (Int, a), Vector v (Finite n, a)) =>
Vector v n a -> Vector v n (Finite n, a)
V.indexed
{-# inline indexed #-}
map :: (Unbox a, Unbox b)
=> (a -> b) -> Vector n a -> Vector n b
map :: forall a b (n :: Nat).
(Unbox a, Unbox b) =>
(a -> b) -> Vector n a -> Vector n b
map = (a -> b) -> Vector Vector n a -> Vector Vector n b
forall (v :: Type -> Type) a b (n :: Nat).
(Vector v a, Vector v b) =>
(a -> b) -> Vector v n a -> Vector v n b
V.map
{-# inline map #-}
imap :: (Unbox a, Unbox b)
=> (Finite n -> a -> b) -> Vector n a -> Vector n b
imap :: forall a b (n :: Nat).
(Unbox a, Unbox b) =>
(Finite n -> a -> b) -> Vector n a -> Vector n b
imap = (Finite n -> a -> b) -> Vector Vector n a -> Vector Vector n b
forall (v :: Type -> Type) a b (n :: Nat).
(Vector v a, Vector v b) =>
(Finite n -> a -> b) -> Vector v n a -> Vector v n b
V.imap
{-# inline imap #-}
concatMap :: (Unbox a, Unbox b)
=> (a -> Vector m b) -> Vector n a -> Vector (n * m) b
concatMap :: forall a b (m :: Nat) (n :: Nat).
(Unbox a, Unbox b) =>
(a -> Vector m b) -> Vector n a -> Vector (n * m) b
concatMap = (a -> Vector Vector m b)
-> Vector Vector n a -> Vector Vector (n * m) b
forall (v :: Type -> Type) a (v' :: Type -> Type) b (m :: Nat)
(n :: Nat).
(Vector v a, Vector v' b) =>
(a -> Vector v' m b) -> Vector v n a -> Vector v' (n * m) b
V.concatMap
{-# inline concatMap #-}
mapM :: (Monad m, Unbox a, Unbox b)
=> (a -> m b) -> Vector n a -> m (Vector n b)
mapM :: forall (m :: Type -> Type) a b (n :: Nat).
(Monad m, Unbox a, Unbox b) =>
(a -> m b) -> Vector n a -> m (Vector n b)
mapM = (a -> m b) -> Vector Vector n a -> m (Vector Vector n b)
forall (m :: Type -> Type) (v :: Type -> Type) a b (n :: Nat).
(Monad m, Vector v a, Vector v b) =>
(a -> m b) -> Vector v n a -> m (Vector v n b)
V.mapM
{-# inline mapM #-}
imapM :: (Monad m, Unbox a, Unbox b)
=> (Finite n -> a -> m b) -> Vector n a -> m (Vector n b)
imapM :: forall (m :: Type -> Type) a b (n :: Nat).
(Monad m, Unbox a, Unbox b) =>
(Finite n -> a -> m b) -> Vector n a -> m (Vector n b)
imapM = (Finite n -> a -> m b)
-> Vector Vector n a -> m (Vector Vector n b)
forall (m :: Type -> Type) (v :: Type -> Type) a b (n :: Nat).
(Monad m, Vector v a, Vector v b) =>
(Finite n -> a -> m b) -> Vector v n a -> m (Vector v n b)
V.imapM
{-# inline imapM #-}
mapM_ :: (Monad m, Unbox a) => (a -> m b) -> Vector n a -> m ()
mapM_ :: forall (m :: Type -> Type) a b (n :: Nat).
(Monad m, Unbox a) =>
(a -> m b) -> Vector n a -> m ()
mapM_ = (a -> m b) -> Vector Vector n a -> m ()
forall (m :: Type -> Type) (v :: Type -> Type) a b (n :: Nat).
(Monad m, Vector v a) =>
(a -> m b) -> Vector v n a -> m ()
V.mapM_
{-# inline mapM_ #-}
imapM_ :: (Monad m, Unbox a) => (Finite n -> a -> m b) -> Vector n a -> m ()
imapM_ :: forall (m :: Type -> Type) a (n :: Nat) b.
(Monad m, Unbox a) =>
(Finite n -> a -> m b) -> Vector n a -> m ()
imapM_ = (Finite n -> a -> m b) -> Vector Vector n a -> m ()
forall (m :: Type -> Type) (v :: Type -> Type) a (n :: Nat) b.
(Monad m, Vector v a) =>
(Finite n -> a -> m b) -> Vector v n a -> m ()
V.imapM_
{-# inline imapM_ #-}
forM :: (Monad m, Unbox a, Unbox b)
=> Vector n a -> (a -> m b) -> m (Vector n b)
forM :: forall (m :: Type -> Type) a b (n :: Nat).
(Monad m, Unbox a, Unbox b) =>
Vector n a -> (a -> m b) -> m (Vector n b)
forM = Vector Vector n a -> (a -> m b) -> m (Vector Vector n b)
forall (m :: Type -> Type) (v :: Type -> Type) a b (n :: Nat).
(Monad m, Vector v a, Vector v b) =>
Vector v n a -> (a -> m b) -> m (Vector v n b)
V.forM
{-# inline forM #-}
forM_ :: (Monad m, Unbox a) => Vector n a -> (a -> m b) -> m ()
forM_ :: forall (m :: Type -> Type) a (n :: Nat) b.
(Monad m, Unbox a) =>
Vector n a -> (a -> m b) -> m ()
forM_ = Vector Vector n a -> (a -> m b) -> m ()
forall (m :: Type -> Type) (v :: Type -> Type) a (n :: Nat) b.
(Monad m, Vector v a) =>
Vector v n a -> (a -> m b) -> m ()
V.forM_
{-# inline forM_ #-}
zipWith :: (Unbox a, Unbox b, Unbox c)
=> (a -> b -> c) -> Vector n a -> Vector n b -> Vector n c
zipWith :: forall a b c (n :: Nat).
(Unbox a, Unbox b, Unbox c) =>
(a -> b -> c) -> Vector n a -> Vector n b -> Vector n c
zipWith = (a -> b -> c)
-> Vector Vector n a -> Vector Vector n b -> Vector Vector n c
forall (v :: Type -> Type) a b c (n :: Nat).
(Vector v a, Vector v b, Vector v c) =>
(a -> b -> c) -> Vector v n a -> Vector v n b -> Vector v n c
V.zipWith
{-# inline zipWith #-}
zipWith3 :: (Unbox a, Unbox b, Unbox c, Unbox d)
=> (a -> b -> c -> d) -> Vector n a -> Vector n b -> Vector n c -> Vector n d
zipWith3 :: forall a b c d (n :: Nat).
(Unbox a, Unbox b, Unbox c, Unbox d) =>
(a -> b -> c -> d)
-> Vector n a -> Vector n b -> Vector n c -> Vector n d
zipWith3 = (a -> b -> c -> d)
-> Vector Vector n a
-> Vector Vector n b
-> Vector Vector n c
-> Vector Vector n d
forall (v :: Type -> Type) a b c d (n :: Nat).
(Vector v a, Vector v b, Vector v c, Vector v d) =>
(a -> b -> c -> d)
-> Vector v n a -> Vector v n b -> Vector v n c -> Vector v n d
V.zipWith3
{-# inline zipWith3 #-}
zipWith4 :: (Unbox a,Unbox b,Unbox c,Unbox d,Unbox e)
=> (a -> b -> c -> d -> e)
-> Vector n a
-> Vector n b
-> Vector n c
-> Vector n d
-> Vector n e
zipWith4 :: forall a b c d e (n :: Nat).
(Unbox a, Unbox b, Unbox c, Unbox d, Unbox e) =>
(a -> b -> c -> d -> e)
-> Vector n a
-> Vector n b
-> Vector n c
-> Vector n d
-> Vector n e
zipWith4 = (a -> b -> c -> d -> e)
-> Vector Vector n a
-> Vector Vector n b
-> Vector Vector n c
-> Vector Vector n d
-> Vector Vector n e
forall (v :: Type -> Type) a b c d e (n :: Nat).
(Vector v a, Vector v b, Vector v c, Vector v d, Vector v e) =>
(a -> b -> c -> d -> e)
-> Vector v n a
-> Vector v n b
-> Vector v n c
-> Vector v n d
-> Vector v n e
V.zipWith4
{-# inline zipWith4 #-}
zipWith5 :: (Unbox a,Unbox b,Unbox c,Unbox d,Unbox e,Unbox f)
=> (a -> b -> c -> d -> e -> f)
-> Vector n a
-> Vector n b
-> Vector n c
-> Vector n d
-> Vector n e
-> Vector n f
zipWith5 :: forall a b c d e f (n :: Nat).
(Unbox a, Unbox b, Unbox c, Unbox d, Unbox e, Unbox f) =>
(a -> b -> c -> d -> e -> f)
-> Vector n a
-> Vector n b
-> Vector n c
-> Vector n d
-> Vector n e
-> Vector n f
zipWith5 = (a -> b -> c -> d -> e -> f)
-> Vector Vector n a
-> Vector Vector n b
-> Vector Vector n c
-> Vector Vector n d
-> Vector Vector n e
-> Vector Vector n f
forall (v :: Type -> Type) a b c d e f (n :: Nat).
(Vector v a, Vector v b, Vector v c, Vector v d, Vector v e,
Vector v f) =>
(a -> b -> c -> d -> e -> f)
-> Vector v n a
-> Vector v n b
-> Vector v n c
-> Vector v n d
-> Vector v n e
-> Vector v n f
V.zipWith5
{-# inline zipWith5 #-}
zipWith6 :: (Unbox a,Unbox b,Unbox c,Unbox d,Unbox e,Unbox f,Unbox g)
=> (a -> b -> c -> d -> e -> f -> g)
-> Vector n a
-> Vector n b
-> Vector n c
-> Vector n d
-> Vector n e
-> Vector n f
-> Vector n g
zipWith6 :: forall a b c d e f g (n :: Nat).
(Unbox a, Unbox b, Unbox c, Unbox d, Unbox e, Unbox f, Unbox g) =>
(a -> b -> c -> d -> e -> f -> g)
-> Vector n a
-> Vector n b
-> Vector n c
-> Vector n d
-> Vector n e
-> Vector n f
-> Vector n g
zipWith6 = (a -> b -> c -> d -> e -> f -> g)
-> Vector Vector n a
-> Vector Vector n b
-> Vector Vector n c
-> Vector Vector n d
-> Vector Vector n e
-> Vector Vector n f
-> Vector Vector n g
forall (v :: Type -> Type) a b c d e f g (n :: Nat).
(Vector v a, Vector v b, Vector v c, Vector v d, Vector v e,
Vector v f, Vector v g) =>
(a -> b -> c -> d -> e -> f -> g)
-> Vector v n a
-> Vector v n b
-> Vector v n c
-> Vector v n d
-> Vector v n e
-> Vector v n f
-> Vector v n g
V.zipWith6
{-# inline zipWith6 #-}
izipWith :: (Unbox a,Unbox b,Unbox c)
=> (Finite n -> a -> b -> c)
-> Vector n a
-> Vector n b
-> Vector n c
izipWith :: forall a b c (n :: Nat).
(Unbox a, Unbox b, Unbox c) =>
(Finite n -> a -> b -> c) -> Vector n a -> Vector n b -> Vector n c
izipWith = (Finite n -> a -> b -> c)
-> Vector Vector n a -> Vector Vector n b -> Vector Vector n c
forall (v :: Type -> Type) a b c (n :: Nat).
(Vector v a, Vector v b, Vector v c) =>
(Finite n -> a -> b -> c)
-> Vector v n a -> Vector v n b -> Vector v n c
V.izipWith
{-# inline izipWith #-}
izipWith3 :: (Unbox a,Unbox b,Unbox c,Unbox d)
=> (Finite n -> a -> b -> c -> d)
-> Vector n a
-> Vector n b
-> Vector n c
-> Vector n d
izipWith3 :: forall a b c d (n :: Nat).
(Unbox a, Unbox b, Unbox c, Unbox d) =>
(Finite n -> a -> b -> c -> d)
-> Vector n a -> Vector n b -> Vector n c -> Vector n d
izipWith3 = (Finite n -> a -> b -> c -> d)
-> Vector Vector n a
-> Vector Vector n b
-> Vector Vector n c
-> Vector Vector n d
forall (v :: Type -> Type) a b c d (n :: Nat).
(Vector v a, Vector v b, Vector v c, Vector v d) =>
(Finite n -> a -> b -> c -> d)
-> Vector v n a -> Vector v n b -> Vector v n c -> Vector v n d
V.izipWith3
{-# inline izipWith3 #-}
izipWith4 :: (Unbox a,Unbox b,Unbox c,Unbox d,Unbox e)
=> (Finite n -> a -> b -> c -> d -> e)
-> Vector n a
-> Vector n b
-> Vector n c
-> Vector n d
-> Vector n e
izipWith4 :: forall a b c d e (n :: Nat).
(Unbox a, Unbox b, Unbox c, Unbox d, Unbox e) =>
(Finite n -> a -> b -> c -> d -> e)
-> Vector n a
-> Vector n b
-> Vector n c
-> Vector n d
-> Vector n e
izipWith4 = (Finite n -> a -> b -> c -> d -> e)
-> Vector Vector n a
-> Vector Vector n b
-> Vector Vector n c
-> Vector Vector n d
-> Vector Vector n e
forall (v :: Type -> Type) a b c d e (n :: Nat).
(Vector v a, Vector v b, Vector v c, Vector v d, Vector v e) =>
(Finite n -> a -> b -> c -> d -> e)
-> Vector v n a
-> Vector v n b
-> Vector v n c
-> Vector v n d
-> Vector v n e
V.izipWith4
{-# inline izipWith4 #-}
izipWith5 :: (Unbox a,Unbox b,Unbox c,Unbox d,Unbox e,Unbox f)
=> (Finite n -> a -> b -> c -> d -> e -> f)
-> Vector n a
-> Vector n b
-> Vector n c
-> Vector n d
-> Vector n e
-> Vector n f
izipWith5 :: forall a b c d e f (n :: Nat).
(Unbox a, Unbox b, Unbox c, Unbox d, Unbox e, Unbox f) =>
(Finite n -> a -> b -> c -> d -> e -> f)
-> Vector n a
-> Vector n b
-> Vector n c
-> Vector n d
-> Vector n e
-> Vector n f
izipWith5 = (Finite n -> a -> b -> c -> d -> e -> f)
-> Vector Vector n a
-> Vector Vector n b
-> Vector Vector n c
-> Vector Vector n d
-> Vector Vector n e
-> Vector Vector n f
forall (v :: Type -> Type) a b c d e f (n :: Nat).
(Vector v a, Vector v b, Vector v c, Vector v d, Vector v e,
Vector v f) =>
(Finite n -> a -> b -> c -> d -> e -> f)
-> Vector v n a
-> Vector v n b
-> Vector v n c
-> Vector v n d
-> Vector v n e
-> Vector v n f
V.izipWith5
{-# inline izipWith5 #-}
izipWith6 :: (Unbox a,Unbox b,Unbox c,Unbox d,Unbox e,Unbox f,Unbox g)
=> (Finite n -> a -> b -> c -> d -> e -> f -> g)
-> Vector n a
-> Vector n b
-> Vector n c
-> Vector n d
-> Vector n e
-> Vector n f
-> Vector n g
izipWith6 :: forall a b c d e f g (n :: Nat).
(Unbox a, Unbox b, Unbox c, Unbox d, Unbox e, Unbox f, Unbox g) =>
(Finite n -> a -> b -> c -> d -> e -> f -> g)
-> Vector n a
-> Vector n b
-> Vector n c
-> Vector n d
-> Vector n e
-> Vector n f
-> Vector n g
izipWith6 = (Finite n -> a -> b -> c -> d -> e -> f -> g)
-> Vector Vector n a
-> Vector Vector n b
-> Vector Vector n c
-> Vector Vector n d
-> Vector Vector n e
-> Vector Vector n f
-> Vector Vector n g
forall (v :: Type -> Type) a b c d e f g (n :: Nat).
(Vector v a, Vector v b, Vector v c, Vector v d, Vector v e,
Vector v f, Vector v g) =>
(Finite n -> a -> b -> c -> d -> e -> f -> g)
-> Vector v n a
-> Vector v n b
-> Vector v n c
-> Vector v n d
-> Vector v n e
-> Vector v n f
-> Vector v n g
V.izipWith6
{-# inline izipWith6 #-}
zip :: (Unbox a, Unbox b)
=> Vector n a -> Vector n b -> Vector n (a, b)
zip :: forall a b (n :: Nat).
(Unbox a, Unbox b) =>
Vector n a -> Vector n b -> Vector n (a, b)
zip = Vector Vector n a -> Vector Vector n b -> Vector Vector n (a, b)
forall (v :: Type -> Type) a b (n :: Nat).
(Vector v a, Vector v b, Vector v (a, b)) =>
Vector v n a -> Vector v n b -> Vector v n (a, b)
V.zip
{-# inline zip #-}
zip3 :: (Unbox a, Unbox b, Unbox c)
=> Vector n a -> Vector n b -> Vector n c -> Vector n (a, b, c)
zip3 :: forall a b c (n :: Nat).
(Unbox a, Unbox b, Unbox c) =>
Vector n a -> Vector n b -> Vector n c -> Vector n (a, b, c)
zip3 = Vector Vector n a
-> Vector Vector n b
-> Vector Vector n c
-> Vector Vector n (a, b, c)
forall (v :: Type -> Type) a b c (n :: Nat).
(Vector v a, Vector v b, Vector v c, Vector v (a, b, c)) =>
Vector v n a
-> Vector v n b -> Vector v n c -> Vector v n (a, b, c)
V.zip3
{-# inline zip3 #-}
zip4 :: (Unbox a,Unbox b,Unbox c,Unbox d)
=> Vector n a
-> Vector n b
-> Vector n c
-> Vector n d
-> Vector n (a,b,c,d)
zip4 :: forall a b c d (n :: Nat).
(Unbox a, Unbox b, Unbox c, Unbox d) =>
Vector n a
-> Vector n b -> Vector n c -> Vector n d -> Vector n (a, b, c, d)
zip4 = Vector Vector n a
-> Vector Vector n b
-> Vector Vector n c
-> Vector Vector n d
-> Vector Vector n (a, b, c, d)
forall (v :: Type -> Type) a b c d (n :: Nat).
(Vector v a, Vector v b, Vector v c, Vector v d,
Vector v (a, b, c, d)) =>
Vector v n a
-> Vector v n b
-> Vector v n c
-> Vector v n d
-> Vector v n (a, b, c, d)
V.zip4
{-# inline zip4 #-}
zip5 :: (Unbox a,Unbox b,Unbox c,Unbox d,Unbox e)
=> Vector n a
-> Vector n b
-> Vector n c
-> Vector n d
-> Vector n e
-> Vector n (a,b,c,d,e)
zip5 :: forall a b c d e (n :: Nat).
(Unbox a, Unbox b, Unbox c, Unbox d, Unbox e) =>
Vector n a
-> Vector n b
-> Vector n c
-> Vector n d
-> Vector n e
-> Vector n (a, b, c, d, e)
zip5 = Vector Vector n a
-> Vector Vector n b
-> Vector Vector n c
-> Vector Vector n d
-> Vector Vector n e
-> Vector Vector n (a, b, c, d, e)
forall (v :: Type -> Type) a b c d e (n :: Nat).
(Vector v a, Vector v b, Vector v c, Vector v d, Vector v e,
Vector v (a, b, c, d, e)) =>
Vector v n a
-> Vector v n b
-> Vector v n c
-> Vector v n d
-> Vector v n e
-> Vector v n (a, b, c, d, e)
V.zip5
{-# inline zip5 #-}
zip6 :: (Unbox a,Unbox b,Unbox c,Unbox d,Unbox e,Unbox f)
=> Vector n a
-> Vector n b
-> Vector n c
-> Vector n d
-> Vector n e
-> Vector n f
-> Vector n (a,b,c,d,e,f)
zip6 :: forall a b c d e f (n :: Nat).
(Unbox a, Unbox b, Unbox c, Unbox d, Unbox e, Unbox f) =>
Vector n a
-> Vector n b
-> Vector n c
-> Vector n d
-> Vector n e
-> Vector n f
-> Vector n (a, b, c, d, e, f)
zip6 = Vector Vector n a
-> Vector Vector n b
-> Vector Vector n c
-> Vector Vector n d
-> Vector Vector n e
-> Vector Vector n f
-> Vector Vector n (a, b, c, d, e, f)
forall (v :: Type -> Type) a b c d e f (n :: Nat).
(Vector v a, Vector v b, Vector v c, Vector v d, Vector v e,
Vector v f, Vector v (a, b, c, d, e, f)) =>
Vector v n a
-> Vector v n b
-> Vector v n c
-> Vector v n d
-> Vector v n e
-> Vector v n f
-> Vector v n (a, b, c, d, e, f)
V.zip6
{-# inline zip6 #-}
zipWithM :: (Monad m, Unbox a, Unbox b, Unbox c)
=> (a -> b -> m c) -> Vector n a -> Vector n b -> m (Vector n c)
zipWithM :: forall (m :: Type -> Type) a b c (n :: Nat).
(Monad m, Unbox a, Unbox b, Unbox c) =>
(a -> b -> m c) -> Vector n a -> Vector n b -> m (Vector n c)
zipWithM = (a -> b -> m c)
-> Vector Vector n a -> Vector Vector n b -> m (Vector Vector n c)
forall (m :: Type -> Type) (v :: Type -> Type) a b c (n :: Nat).
(Monad m, Vector v a, Vector v b, Vector v c) =>
(a -> b -> m c) -> Vector v n a -> Vector v n b -> m (Vector v n c)
V.zipWithM
{-# inline zipWithM #-}
izipWithM :: (Monad m, Unbox a, Unbox b, Unbox c)
=> (Finite n -> a -> b -> m c) -> Vector n a -> Vector n b -> m (Vector n c)
izipWithM :: forall (m :: Type -> Type) a b c (n :: Nat).
(Monad m, Unbox a, Unbox b, Unbox c) =>
(Finite n -> a -> b -> m c)
-> Vector n a -> Vector n b -> m (Vector n c)
izipWithM = (Finite n -> a -> b -> m c)
-> Vector Vector n a -> Vector Vector n b -> m (Vector Vector n c)
forall (m :: Type -> Type) (v :: Type -> Type) a b c (n :: Nat).
(Monad m, Vector v a, Vector v b, Vector v c) =>
(Finite n -> a -> b -> m c)
-> Vector v n a -> Vector v n b -> m (Vector v n c)
V.izipWithM
{-# inline izipWithM #-}
zipWithM_ :: (Monad m, Unbox a, Unbox b)
=> (a -> b -> m c) -> Vector n a -> Vector n b -> m ()
zipWithM_ :: forall (m :: Type -> Type) a b c (n :: Nat).
(Monad m, Unbox a, Unbox b) =>
(a -> b -> m c) -> Vector n a -> Vector n b -> m ()
zipWithM_ = (a -> b -> m c) -> Vector Vector n a -> Vector Vector n b -> m ()
forall (m :: Type -> Type) (v :: Type -> Type) a b c (n :: Nat).
(Monad m, Vector v a, Vector v b) =>
(a -> b -> m c) -> Vector v n a -> Vector v n b -> m ()
V.zipWithM_
{-# inline zipWithM_ #-}
izipWithM_ :: (Monad m, Unbox a, Unbox b)
=> (Finite n -> a -> b -> m c) -> Vector n a -> Vector n b -> m ()
izipWithM_ :: forall (m :: Type -> Type) a b (n :: Nat) c.
(Monad m, Unbox a, Unbox b) =>
(Finite n -> a -> b -> m c) -> Vector n a -> Vector n b -> m ()
izipWithM_ = (Finite n -> a -> b -> m c)
-> Vector Vector n a -> Vector Vector n b -> m ()
forall (m :: Type -> Type) (v :: Type -> Type) a b (n :: Nat) c.
(Monad m, Vector v a, Vector v b) =>
(Finite n -> a -> b -> m c) -> Vector v n a -> Vector v n b -> m ()
V.izipWithM_
{-# inline izipWithM_ #-}
unzip :: (Unbox a, Unbox b)
=> Vector n (a, b) -> (Vector n a, Vector n b)
unzip :: forall a b (n :: Nat).
(Unbox a, Unbox b) =>
Vector n (a, b) -> (Vector n a, Vector n b)
unzip = Vector Vector n (a, b) -> (Vector Vector n a, Vector Vector n b)
forall (v :: Type -> Type) a b (n :: Nat).
(Vector v a, Vector v b, Vector v (a, b)) =>
Vector v n (a, b) -> (Vector v n a, Vector v n b)
V.unzip
{-# inline unzip #-}
unzip3 :: (Unbox a, Unbox b, Unbox c)
=> Vector n (a, b, c) -> (Vector n a, Vector n b, Vector n c)
unzip3 :: forall a b c (n :: Nat).
(Unbox a, Unbox b, Unbox c) =>
Vector n (a, b, c) -> (Vector n a, Vector n b, Vector n c)
unzip3 = Vector Vector n (a, b, c)
-> (Vector Vector n a, Vector Vector n b, Vector Vector n c)
forall (v :: Type -> Type) a b c (n :: Nat).
(Vector v a, Vector v b, Vector v c, Vector v (a, b, c)) =>
Vector v n (a, b, c) -> (Vector v n a, Vector v n b, Vector v n c)
V.unzip3
{-# inline unzip3 #-}
unzip4 :: (Unbox a, Unbox b, Unbox c, Unbox d)
=> Vector n (a, b, c, d) -> (Vector n a, Vector n b, Vector n c, Vector n d)
unzip4 :: forall a b c d (n :: Nat).
(Unbox a, Unbox b, Unbox c, Unbox d) =>
Vector n (a, b, c, d)
-> (Vector n a, Vector n b, Vector n c, Vector n d)
unzip4 = Vector Vector n (a, b, c, d)
-> (Vector Vector n a, Vector Vector n b, Vector Vector n c,
Vector Vector n d)
forall (v :: Type -> Type) a b c d (n :: Nat).
(Vector v a, Vector v b, Vector v c, Vector v d,
Vector v (a, b, c, d)) =>
Vector v n (a, b, c, d)
-> (Vector v n a, Vector v n b, Vector v n c, Vector v n d)
V.unzip4
{-# inline unzip4 #-}
unzip5 :: (Unbox a, Unbox b, Unbox c, Unbox d, Unbox e)
=> Vector n (a, b, c, d, e) -> (Vector n a, Vector n b, Vector n c, Vector n d, Vector n e)
unzip5 :: forall a b c d e (n :: Nat).
(Unbox a, Unbox b, Unbox c, Unbox d, Unbox e) =>
Vector n (a, b, c, d, e)
-> (Vector n a, Vector n b, Vector n c, Vector n d, Vector n e)
unzip5 = Vector Vector n (a, b, c, d, e)
-> (Vector Vector n a, Vector Vector n b, Vector Vector n c,
Vector Vector n d, Vector Vector n e)
forall (v :: Type -> Type) a b c d e (n :: Nat).
(Vector v a, Vector v b, Vector v c, Vector v d, Vector v e,
Vector v (a, b, c, d, e)) =>
Vector v n (a, b, c, d, e)
-> (Vector v n a, Vector v n b, Vector v n c, Vector v n d,
Vector v n e)
V.unzip5
{-# inline unzip5 #-}
unzip6 :: (Unbox a, Unbox b, Unbox c, Unbox d, Unbox e, Unbox f)
=> Vector n (a, b, c, d, e, f) -> (Vector n a, Vector n b, Vector n c, Vector n d, Vector n e, Vector n f)
unzip6 :: forall a b c d e f (n :: Nat).
(Unbox a, Unbox b, Unbox c, Unbox d, Unbox e, Unbox f) =>
Vector n (a, b, c, d, e, f)
-> (Vector n a, Vector n b, Vector n c, Vector n d, Vector n e,
Vector n f)
unzip6 = Vector Vector n (a, b, c, d, e, f)
-> (Vector Vector n a, Vector Vector n b, Vector Vector n c,
Vector Vector n d, Vector Vector n e, Vector Vector n f)
forall (v :: Type -> Type) a b c d e f (n :: Nat).
(Vector v a, Vector v b, Vector v c, Vector v d, Vector v e,
Vector v f, Vector v (a, b, c, d, e, f)) =>
Vector v n (a, b, c, d, e, f)
-> (Vector v n a, Vector v n b, Vector v n c, Vector v n d,
Vector v n e, Vector v n f)
V.unzip6
{-# inline unzip6 #-}
infix 4 `elem`
elem :: (Unbox a, Eq a) => a -> Vector n a -> Bool
elem :: forall a (n :: Nat). (Unbox a, Eq a) => a -> Vector n a -> Bool
elem = a -> Vector Vector n a -> Bool
forall (v :: Type -> Type) a (n :: Nat).
(Vector v a, Eq a) =>
a -> Vector v n a -> Bool
V.elem
{-# inline elem #-}
infix 4 `notElem`
notElem :: (Unbox a, Eq a) => a -> Vector n a -> Bool
notElem :: forall a (n :: Nat). (Unbox a, Eq a) => a -> Vector n a -> Bool
notElem = a -> Vector Vector n a -> Bool
forall (v :: Type -> Type) a (n :: Nat).
(Vector v a, Eq a) =>
a -> Vector v n a -> Bool
V.notElem
{-# inline notElem #-}
find :: Unbox a => (a -> Bool) -> Vector n a -> Maybe a
find :: forall a (n :: Nat).
Unbox a =>
(a -> Bool) -> Vector n a -> Maybe a
find = (a -> Bool) -> Vector Vector n a -> Maybe a
forall (v :: Type -> Type) a (n :: Nat).
Vector v a =>
(a -> Bool) -> Vector v n a -> Maybe a
V.find
{-# inline find #-}
findIndex :: Unbox a => (a -> Bool) -> Vector n a -> Maybe (Finite n)
findIndex :: forall a (n :: Nat).
Unbox a =>
(a -> Bool) -> Vector n a -> Maybe (Finite n)
findIndex = (a -> Bool) -> Vector Vector n a -> Maybe (Finite n)
forall (v :: Type -> Type) a (n :: Nat).
Vector v a =>
(a -> Bool) -> Vector v n a -> Maybe (Finite n)
V.findIndex
{-# inline findIndex #-}
elemIndex :: (Unbox a, Eq a) => a -> Vector n a -> Maybe (Finite n)
elemIndex :: forall a (n :: Nat).
(Unbox a, Eq a) =>
a -> Vector n a -> Maybe (Finite n)
elemIndex = a -> Vector Vector n a -> Maybe (Finite n)
forall (v :: Type -> Type) a (n :: Nat).
(Vector v a, Eq a) =>
a -> Vector v n a -> Maybe (Finite n)
V.elemIndex
{-# inline elemIndex #-}
foldl :: Unbox b => (a -> b -> a) -> a -> Vector n b -> a
foldl :: forall b a (n :: Nat).
Unbox b =>
(a -> b -> a) -> a -> Vector n b -> a
foldl = (a -> b -> a) -> a -> Vector Vector n b -> a
forall (v :: Type -> Type) b a (n :: Nat).
Vector v b =>
(a -> b -> a) -> a -> Vector v n b -> a
V.foldl
{-# inline foldl #-}
foldl1 :: Unbox a => (a -> a -> a) -> Vector (1+n) a -> a
foldl1 :: forall a (n :: Nat).
Unbox a =>
(a -> a -> a) -> Vector (1 + n) a -> a
foldl1 = (a -> a -> a) -> Vector Vector (1 + n) a -> a
forall (v :: Type -> Type) a (n :: Nat).
Vector v a =>
(a -> a -> a) -> Vector v (1 + n) a -> a
V.foldl1
{-# inline foldl1 #-}
foldl' :: Unbox b => (a -> b -> a) -> a -> Vector n b -> a
foldl' :: forall b a (n :: Nat).
Unbox b =>
(a -> b -> a) -> a -> Vector n b -> a
foldl' = (a -> b -> a) -> a -> Vector Vector n b -> a
forall (v :: Type -> Type) b a (n :: Nat).
Vector v b =>
(a -> b -> a) -> a -> Vector v n b -> a
V.foldl'
{-# inline foldl' #-}
foldl1' :: Unbox a => (a -> a -> a) -> Vector (1+n) a -> a
foldl1' :: forall a (n :: Nat).
Unbox a =>
(a -> a -> a) -> Vector (1 + n) a -> a
foldl1' = (a -> a -> a) -> Vector Vector (1 + n) a -> a
forall (v :: Type -> Type) a (n :: Nat).
Vector v a =>
(a -> a -> a) -> Vector v (1 + n) a -> a
V.foldl1'
{-# inline foldl1' #-}
foldr :: Unbox a => (a -> b -> b) -> b -> Vector n a -> b
foldr :: forall a b (n :: Nat).
Unbox a =>
(a -> b -> b) -> b -> Vector n a -> b
foldr = (a -> b -> b) -> b -> Vector Vector n a -> b
forall (v :: Type -> Type) a b (n :: Nat).
Vector v a =>
(a -> b -> b) -> b -> Vector v n a -> b
V.foldr
{-# inline foldr #-}
foldr1 :: Unbox a => (a -> a -> a) -> Vector (n+1) a -> a
foldr1 :: forall a (n :: Nat).
Unbox a =>
(a -> a -> a) -> Vector (n + 1) a -> a
foldr1 = (a -> a -> a) -> Vector Vector (n + 1) a -> a
forall (v :: Type -> Type) a (n :: Nat).
Vector v a =>
(a -> a -> a) -> Vector v (n + 1) a -> a
V.foldr1
{-# inline foldr1 #-}
foldr' :: Unbox a => (a -> b -> b) -> b -> Vector n a -> b
foldr' :: forall a b (n :: Nat).
Unbox a =>
(a -> b -> b) -> b -> Vector n a -> b
foldr' = (a -> b -> b) -> b -> Vector Vector n a -> b
forall (v :: Type -> Type) a b (n :: Nat).
Vector v a =>
(a -> b -> b) -> b -> Vector v n a -> b
V.foldr'
{-# inline foldr' #-}
foldr1' :: Unbox a => (a -> a -> a) -> Vector (n+1) a -> a
foldr1' :: forall a (n :: Nat).
Unbox a =>
(a -> a -> a) -> Vector (n + 1) a -> a
foldr1' = (a -> a -> a) -> Vector Vector (n + 1) a -> a
forall (v :: Type -> Type) a (n :: Nat).
Vector v a =>
(a -> a -> a) -> Vector v (n + 1) a -> a
V.foldr1'
{-# inline foldr1' #-}
ifoldl :: Unbox b => (a -> Finite n -> b -> a) -> a -> Vector n b -> a
ifoldl :: forall b a (n :: Nat).
Unbox b =>
(a -> Finite n -> b -> a) -> a -> Vector n b -> a
ifoldl = (a -> Finite n -> b -> a) -> a -> Vector Vector n b -> a
forall (v :: Type -> Type) b a (n :: Nat).
Vector v b =>
(a -> Finite n -> b -> a) -> a -> Vector v n b -> a
V.ifoldl
{-# inline ifoldl #-}
ifoldl' :: Unbox b => (a -> Finite n -> b -> a) -> a -> Vector n b -> a
ifoldl' :: forall b a (n :: Nat).
Unbox b =>
(a -> Finite n -> b -> a) -> a -> Vector n b -> a
ifoldl' = (a -> Finite n -> b -> a) -> a -> Vector Vector n b -> a
forall (v :: Type -> Type) b a (n :: Nat).
Vector v b =>
(a -> Finite n -> b -> a) -> a -> Vector v n b -> a
V.ifoldl'
{-# inline ifoldl' #-}
ifoldr :: Unbox a => (Finite n -> a -> b -> b) -> b -> Vector n a -> b
ifoldr :: forall a (n :: Nat) b.
Unbox a =>
(Finite n -> a -> b -> b) -> b -> Vector n a -> b
ifoldr = (Finite n -> a -> b -> b) -> b -> Vector Vector n a -> b
forall (v :: Type -> Type) a (n :: Nat) b.
Vector v a =>
(Finite n -> a -> b -> b) -> b -> Vector v n a -> b
V.ifoldr
{-# inline ifoldr #-}
ifoldr' :: Unbox a => (Finite n -> a -> b -> b) -> b -> Vector n a -> b
ifoldr' :: forall a (n :: Nat) b.
Unbox a =>
(Finite n -> a -> b -> b) -> b -> Vector n a -> b
ifoldr' = (Finite n -> a -> b -> b) -> b -> Vector Vector n a -> b
forall (v :: Type -> Type) a (n :: Nat) b.
Vector v a =>
(Finite n -> a -> b -> b) -> b -> Vector v n a -> b
V.ifoldr'
{-# inline ifoldr' #-}
all :: Unbox a => (a -> Bool) -> Vector n a -> Bool
all :: forall a (n :: Nat). Unbox a => (a -> Bool) -> Vector n a -> Bool
all = (a -> Bool) -> Vector Vector n a -> Bool
forall (v :: Type -> Type) a (n :: Nat).
Vector v a =>
(a -> Bool) -> Vector v n a -> Bool
V.all
{-# inline all #-}
any :: Unbox a => (a -> Bool) -> Vector n a -> Bool
any :: forall a (n :: Nat). Unbox a => (a -> Bool) -> Vector n a -> Bool
any = (a -> Bool) -> Vector Vector n a -> Bool
forall (v :: Type -> Type) a (n :: Nat).
Vector v a =>
(a -> Bool) -> Vector v n a -> Bool
V.any
{-# inline any #-}
and :: Vector n Bool -> Bool
and :: forall (n :: Nat). Vector n Bool -> Bool
and = Vector Vector n Bool -> Bool
forall (v :: Type -> Type) (n :: Nat).
Vector v Bool =>
Vector v n Bool -> Bool
V.and
{-# inline and #-}
or :: Vector n Bool -> Bool
or :: forall (n :: Nat). Vector n Bool -> Bool
or = Vector Vector n Bool -> Bool
forall (v :: Type -> Type) (n :: Nat).
Vector v Bool =>
Vector v n Bool -> Bool
V.or
{-# inline or #-}
sum :: (Unbox a, Num a) => Vector n a -> a
sum :: forall a (n :: Nat). (Unbox a, Num a) => Vector n a -> a
sum = Vector Vector n a -> a
forall (v :: Type -> Type) a (n :: Nat).
(Vector v a, Num a) =>
Vector v n a -> a
V.sum
{-# inline sum #-}
product :: (Unbox a, Num a) => Vector n a -> a
product :: forall a (n :: Nat). (Unbox a, Num a) => Vector n a -> a
product = Vector Vector n a -> a
forall (v :: Type -> Type) a (n :: Nat).
(Vector v a, Num a) =>
Vector v n a -> a
V.product
{-# inline product #-}
maximum :: (Unbox a, Ord a) => Vector (n+1) a -> a
maximum :: forall a (n :: Nat). (Unbox a, Ord a) => Vector (n + 1) a -> a
maximum = Vector Vector (n + 1) a -> a
forall (v :: Type -> Type) a (n :: Nat).
(Vector v a, Ord a) =>
Vector v (n + 1) a -> a
V.maximum
{-# inline maximum #-}
maximumBy :: Unbox a
=> (a -> a -> Ordering) -> Vector (n+1) a -> a
maximumBy :: forall a (n :: Nat).
Unbox a =>
(a -> a -> Ordering) -> Vector (n + 1) a -> a
maximumBy = (a -> a -> Ordering) -> Vector Vector (n + 1) a -> a
forall (v :: Type -> Type) a (n :: Nat).
Vector v a =>
(a -> a -> Ordering) -> Vector v (n + 1) a -> a
V.maximumBy
{-# inline maximumBy #-}
minimum :: (Unbox a, Ord a) => Vector (n+1) a -> a
minimum :: forall a (n :: Nat). (Unbox a, Ord a) => Vector (n + 1) a -> a
minimum = Vector Vector (n + 1) a -> a
forall (v :: Type -> Type) a (n :: Nat).
(Vector v a, Ord a) =>
Vector v (n + 1) a -> a
V.minimum
{-# inline minimum #-}
minimumBy :: Unbox a
=> (a -> a -> Ordering) -> Vector (n+1) a -> a
minimumBy :: forall a (n :: Nat).
Unbox a =>
(a -> a -> Ordering) -> Vector (n + 1) a -> a
minimumBy = (a -> a -> Ordering) -> Vector Vector (n + 1) a -> a
forall (v :: Type -> Type) a (n :: Nat).
Vector v a =>
(a -> a -> Ordering) -> Vector v (n + 1) a -> a
V.minimumBy
{-# inline minimumBy #-}
maxIndex :: (Unbox a, Ord a) => Vector (n+1) a -> Finite (n + 1)
maxIndex :: forall a (n :: Nat).
(Unbox a, Ord a) =>
Vector (n + 1) a -> Finite (n + 1)
maxIndex = Vector Vector (n + 1) a -> Finite (n + 1)
forall (v :: Type -> Type) a (n :: Nat).
(Vector v a, Ord a) =>
Vector v (n + 1) a -> Finite (n + 1)
V.maxIndex
{-# inline maxIndex #-}
maxIndexBy :: Unbox a
=> (a -> a -> Ordering) -> Vector (n+1) a -> Finite (n + 1)
maxIndexBy :: forall a (n :: Nat).
Unbox a =>
(a -> a -> Ordering) -> Vector (n + 1) a -> Finite (n + 1)
maxIndexBy = (a -> a -> Ordering) -> Vector Vector (n + 1) a -> Finite (n + 1)
forall (v :: Type -> Type) a (n :: Nat).
Vector v a =>
(a -> a -> Ordering) -> Vector v (n + 1) a -> Finite (n + 1)
V.maxIndexBy
{-# inline maxIndexBy #-}
minIndex :: (Unbox a, Ord a) => Vector (n+1) a -> Finite (n + 1)
minIndex :: forall a (n :: Nat).
(Unbox a, Ord a) =>
Vector (n + 1) a -> Finite (n + 1)
minIndex = Vector Vector (n + 1) a -> Finite (n + 1)
forall (v :: Type -> Type) a (n :: Nat).
(Vector v a, Ord a) =>
Vector v (n + 1) a -> Finite (n + 1)
V.minIndex
{-# inline minIndex #-}
minIndexBy :: Unbox a
=> (a -> a -> Ordering) -> Vector (n+1) a -> Finite (n + 1)
minIndexBy :: forall a (n :: Nat).
Unbox a =>
(a -> a -> Ordering) -> Vector (n + 1) a -> Finite (n + 1)
minIndexBy = (a -> a -> Ordering) -> Vector Vector (n + 1) a -> Finite (n + 1)
forall (v :: Type -> Type) a (n :: Nat).
Vector v a =>
(a -> a -> Ordering) -> Vector v (n + 1) a -> Finite (n + 1)
V.minIndexBy
{-# inline minIndexBy #-}
foldM :: (Monad m, Unbox b) => (a -> b -> m a) -> a -> Vector n b -> m a
foldM :: forall (m :: Type -> Type) b a (n :: Nat).
(Monad m, Unbox b) =>
(a -> b -> m a) -> a -> Vector n b -> m a
foldM = (a -> b -> m a) -> a -> Vector Vector n b -> m a
forall (m :: Type -> Type) (v :: Type -> Type) b a (n :: Nat).
(Monad m, Vector v b) =>
(a -> b -> m a) -> a -> Vector v n b -> m a
V.foldM
{-# inline foldM #-}
ifoldM :: (Monad m, Unbox b) => (a -> Finite n -> b -> m a) -> a -> Vector n b -> m a
ifoldM :: forall (m :: Type -> Type) b a (n :: Nat).
(Monad m, Unbox b) =>
(a -> Finite n -> b -> m a) -> a -> Vector n b -> m a
ifoldM = (a -> Finite n -> b -> m a) -> a -> Vector Vector n b -> m a
forall (m :: Type -> Type) (v :: Type -> Type) b a (n :: Nat).
(Monad m, Vector v b) =>
(a -> Finite n -> b -> m a) -> a -> Vector v n b -> m a
V.ifoldM
{-# inline ifoldM #-}
fold1M :: (Monad m, Unbox a)
=> (a -> a -> m a) -> Vector (1+n) a -> m a
fold1M :: forall (m :: Type -> Type) a (n :: Nat).
(Monad m, Unbox a) =>
(a -> a -> m a) -> Vector (1 + n) a -> m a
fold1M = (a -> a -> m a) -> Vector Vector (1 + n) a -> m a
forall (m :: Type -> Type) (v :: Type -> Type) a (n :: Nat).
(Monad m, Vector v a) =>
(a -> a -> m a) -> Vector v (1 + n) a -> m a
V.fold1M
{-# inline fold1M #-}
foldM' :: (Monad m, Unbox b) => (a -> b -> m a) -> a -> Vector n b -> m a
foldM' :: forall (m :: Type -> Type) b a (n :: Nat).
(Monad m, Unbox b) =>
(a -> b -> m a) -> a -> Vector n b -> m a
foldM' = (a -> b -> m a) -> a -> Vector Vector n b -> m a
forall (m :: Type -> Type) (v :: Type -> Type) b a (n :: Nat).
(Monad m, Vector v b) =>
(a -> b -> m a) -> a -> Vector v n b -> m a
V.foldM'
{-# inline foldM' #-}
ifoldM' :: (Monad m, Unbox b)
=> (a -> Finite n -> b -> m a) -> a -> Vector n b -> m a
ifoldM' :: forall (m :: Type -> Type) b a (n :: Nat).
(Monad m, Unbox b) =>
(a -> Finite n -> b -> m a) -> a -> Vector n b -> m a
ifoldM' = (a -> Finite n -> b -> m a) -> a -> Vector Vector n b -> m a
forall (m :: Type -> Type) (v :: Type -> Type) b a (n :: Nat).
(Monad m, Vector v b) =>
(a -> Finite n -> b -> m a) -> a -> Vector v n b -> m a
V.ifoldM'
{-# inline ifoldM' #-}
fold1M' :: (Monad m, Unbox a)
=> (a -> a -> m a) -> Vector (n+1) a -> m a
fold1M' :: forall (m :: Type -> Type) a (n :: Nat).
(Monad m, Unbox a) =>
(a -> a -> m a) -> Vector (n + 1) a -> m a
fold1M' = (a -> a -> m a) -> Vector Vector (n + 1) a -> m a
forall (m :: Type -> Type) (v :: Type -> Type) a (n :: Nat).
(Monad m, Vector v a) =>
(a -> a -> m a) -> Vector v (n + 1) a -> m a
V.fold1M'
{-# inline fold1M' #-}
foldM_ :: (Monad m, Unbox b)
=> (a -> b -> m a) -> a -> Vector n b -> m ()
foldM_ :: forall (m :: Type -> Type) b a (n :: Nat).
(Monad m, Unbox b) =>
(a -> b -> m a) -> a -> Vector n b -> m ()
foldM_ = (a -> b -> m a) -> a -> Vector Vector n b -> m ()
forall (m :: Type -> Type) (v :: Type -> Type) b a (n :: Nat).
(Monad m, Vector v b) =>
(a -> b -> m a) -> a -> Vector v n b -> m ()
V.foldM_
{-# inline foldM_ #-}
ifoldM_ :: (Monad m, Unbox b)
=> (a -> Finite n -> b -> m a) -> a -> Vector n b -> m ()
ifoldM_ :: forall (m :: Type -> Type) b a (n :: Nat).
(Monad m, Unbox b) =>
(a -> Finite n -> b -> m a) -> a -> Vector n b -> m ()
ifoldM_ = (a -> Finite n -> b -> m a) -> a -> Vector Vector n b -> m ()
forall (m :: Type -> Type) (v :: Type -> Type) b a (n :: Nat).
(Monad m, Vector v b) =>
(a -> Finite n -> b -> m a) -> a -> Vector v n b -> m ()
V.ifoldM_
{-# inline ifoldM_ #-}
fold1M_ :: (Monad m, Unbox a)
=> (a -> a -> m a) -> Vector (n+1) a -> m ()
fold1M_ :: forall (m :: Type -> Type) a (n :: Nat).
(Monad m, Unbox a) =>
(a -> a -> m a) -> Vector (n + 1) a -> m ()
fold1M_ = (a -> a -> m a) -> Vector Vector (n + 1) a -> m ()
forall (m :: Type -> Type) (v :: Type -> Type) a (n :: Nat).
(Monad m, Vector v a) =>
(a -> a -> m a) -> Vector v (n + 1) a -> m ()
V.fold1M_
{-# inline fold1M_ #-}
foldM'_ :: (Monad m, Unbox b)
=> (a -> b -> m a) -> a -> Vector n b -> m ()
foldM'_ :: forall (m :: Type -> Type) b a (n :: Nat).
(Monad m, Unbox b) =>
(a -> b -> m a) -> a -> Vector n b -> m ()
foldM'_ = (a -> b -> m a) -> a -> Vector Vector n b -> m ()
forall (m :: Type -> Type) (v :: Type -> Type) b a (n :: Nat).
(Monad m, Vector v b) =>
(a -> b -> m a) -> a -> Vector v n b -> m ()
V.foldM'_
{-# inline foldM'_ #-}
ifoldM'_ :: (Monad m, Unbox b)
=> (a -> Finite n -> b -> m a) -> a -> Vector n b -> m ()
ifoldM'_ :: forall (m :: Type -> Type) b a (n :: Nat).
(Monad m, Unbox b) =>
(a -> Finite n -> b -> m a) -> a -> Vector n b -> m ()
ifoldM'_ = (a -> Finite n -> b -> m a) -> a -> Vector Vector n b -> m ()
forall (m :: Type -> Type) (v :: Type -> Type) b a (n :: Nat).
(Monad m, Vector v b) =>
(a -> Finite n -> b -> m a) -> a -> Vector v n b -> m ()
V.ifoldM'_
{-# inline ifoldM'_ #-}
fold1M'_ :: (Monad m, Unbox a)
=> (a -> a -> m a) -> Vector (n+1) a -> m ()
fold1M'_ :: forall (m :: Type -> Type) a (n :: Nat).
(Monad m, Unbox a) =>
(a -> a -> m a) -> Vector (n + 1) a -> m ()
fold1M'_ = (a -> a -> m a) -> Vector Vector (n + 1) a -> m ()
forall (m :: Type -> Type) (v :: Type -> Type) a (n :: Nat).
(Monad m, Vector v a) =>
(a -> a -> m a) -> Vector v (n + 1) a -> m ()
V.fold1M'_
{-# inline fold1M'_ #-}
sequence :: (Monad m, Unbox a, Unbox (m a))
=> Vector n (m a) -> m (Vector n a)
sequence :: forall (m :: Type -> Type) a (n :: Nat).
(Monad m, Unbox a, Unbox (m a)) =>
Vector n (m a) -> m (Vector n a)
sequence = Vector Vector n (m a) -> m (Vector Vector n a)
forall (m :: Type -> Type) (v :: Type -> Type) a (n :: Nat).
(Monad m, Vector v a, Vector v (m a)) =>
Vector v n (m a) -> m (Vector v n a)
V.sequence
{-# inline sequence #-}
sequence_ :: (Monad m, Unbox (m a)) => Vector n (m a) -> m ()
sequence_ :: forall (m :: Type -> Type) a (n :: Nat).
(Monad m, Unbox (m a)) =>
Vector n (m a) -> m ()
sequence_ = Vector Vector n (m a) -> m ()
forall (m :: Type -> Type) (v :: Type -> Type) a (n :: Nat).
(Monad m, Vector v (m a)) =>
Vector v n (m a) -> m ()
V.sequence_
{-# inline sequence_ #-}
prescanl :: (Unbox a, Unbox b) => (a -> b -> a) -> a -> Vector n b -> Vector n a
prescanl :: forall a b (n :: Nat).
(Unbox a, Unbox b) =>
(a -> b -> a) -> a -> Vector n b -> Vector n a
prescanl = (a -> b -> a) -> a -> Vector Vector n b -> Vector Vector n a
forall (v :: Type -> Type) a b (n :: Nat).
(Vector v a, Vector v b) =>
(a -> b -> a) -> a -> Vector v n b -> Vector v n a
V.prescanl
{-# inline prescanl #-}
prescanl' :: (Unbox a, Unbox b) => (a -> b -> a) -> a -> Vector n b -> Vector n a
prescanl' :: forall a b (n :: Nat).
(Unbox a, Unbox b) =>
(a -> b -> a) -> a -> Vector n b -> Vector n a
prescanl' = (a -> b -> a) -> a -> Vector Vector n b -> Vector Vector n a
forall (v :: Type -> Type) a b (n :: Nat).
(Vector v a, Vector v b) =>
(a -> b -> a) -> a -> Vector v n b -> Vector v n a
V.prescanl'
{-# inline prescanl' #-}
postscanl :: (Unbox a, Unbox b) => (a -> b -> a) -> a -> Vector n b -> Vector n a
postscanl :: forall a b (n :: Nat).
(Unbox a, Unbox b) =>
(a -> b -> a) -> a -> Vector n b -> Vector n a
postscanl = (a -> b -> a) -> a -> Vector Vector n b -> Vector Vector n a
forall (v :: Type -> Type) a b (n :: Nat).
(Vector v a, Vector v b) =>
(a -> b -> a) -> a -> Vector v n b -> Vector v n a
V.postscanl
{-# inline postscanl #-}
postscanl' :: (Unbox a, Unbox b) => (a -> b -> a) -> a -> Vector n b -> Vector n a
postscanl' :: forall a b (n :: Nat).
(Unbox a, Unbox b) =>
(a -> b -> a) -> a -> Vector n b -> Vector n a
postscanl' = (a -> b -> a) -> a -> Vector Vector n b -> Vector Vector n a
forall (v :: Type -> Type) a b (n :: Nat).
(Vector v a, Vector v b) =>
(a -> b -> a) -> a -> Vector v n b -> Vector v n a
V.postscanl'
{-# inline postscanl' #-}
scanl :: (Unbox a, Unbox b) => (a -> b -> a) -> a -> Vector n b -> Vector (1+n) a
scanl :: forall a b (n :: Nat).
(Unbox a, Unbox b) =>
(a -> b -> a) -> a -> Vector n b -> Vector (1 + n) a
scanl = (a -> b -> a) -> a -> Vector Vector n b -> Vector Vector (1 + n) a
forall (v :: Type -> Type) a b (n :: Nat).
(Vector v a, Vector v b) =>
(a -> b -> a) -> a -> Vector v n b -> Vector v (1 + n) a
V.scanl
{-# inline scanl #-}
scanl' :: (Unbox a, Unbox b) => (a -> b -> a) -> a -> Vector n b -> Vector (1+n) a
scanl' :: forall a b (n :: Nat).
(Unbox a, Unbox b) =>
(a -> b -> a) -> a -> Vector n b -> Vector (1 + n) a
scanl' = (a -> b -> a) -> a -> Vector Vector n b -> Vector Vector (1 + n) a
forall (v :: Type -> Type) a b (n :: Nat).
(Vector v a, Vector v b) =>
(a -> b -> a) -> a -> Vector v n b -> Vector v (1 + n) a
V.scanl'
{-# inline scanl' #-}
scanl1 :: Unbox a => (a -> a -> a) -> Vector (1+n) a -> Vector (2+n) a
scanl1 :: forall a (n :: Nat).
Unbox a =>
(a -> a -> a) -> Vector (1 + n) a -> Vector (2 + n) a
scanl1 = (a -> a -> a) -> Vector Vector (1 + n) a -> Vector Vector (2 + n) a
forall (v :: Type -> Type) a (n :: Nat).
Vector v a =>
(a -> a -> a) -> Vector v (1 + n) a -> Vector v (2 + n) a
V.scanl1
{-# inline scanl1 #-}
scanl1' :: Unbox a => (a -> a -> a) -> Vector (1+n) a -> Vector (2+n) a
scanl1' :: forall a (n :: Nat).
Unbox a =>
(a -> a -> a) -> Vector (1 + n) a -> Vector (2 + n) a
scanl1' = (a -> a -> a) -> Vector Vector (1 + n) a -> Vector Vector (2 + n) a
forall (v :: Type -> Type) a (n :: Nat).
Vector v a =>
(a -> a -> a) -> Vector v (1 + n) a -> Vector v (2 + n) a
V.scanl1'
{-# inline scanl1' #-}
prescanr :: (Unbox a, Unbox b) => (a -> b -> b) -> b -> Vector n a -> Vector n b
prescanr :: forall a b (n :: Nat).
(Unbox a, Unbox b) =>
(a -> b -> b) -> b -> Vector n a -> Vector n b
prescanr = (a -> b -> b) -> b -> Vector Vector n a -> Vector Vector n b
forall (v :: Type -> Type) a b (n :: Nat).
(Vector v a, Vector v b) =>
(a -> b -> b) -> b -> Vector v n a -> Vector v n b
V.prescanr
{-# inline prescanr #-}
prescanr' :: (Unbox a, Unbox b) => (a -> b -> b) -> b -> Vector n a -> Vector n b
prescanr' :: forall a b (n :: Nat).
(Unbox a, Unbox b) =>
(a -> b -> b) -> b -> Vector n a -> Vector n b
prescanr' = (a -> b -> b) -> b -> Vector Vector n a -> Vector Vector n b
forall (v :: Type -> Type) a b (n :: Nat).
(Vector v a, Vector v b) =>
(a -> b -> b) -> b -> Vector v n a -> Vector v n b
V.prescanr'
{-# inline prescanr' #-}
postscanr :: (Unbox a, Unbox b) => (a -> b -> b) -> b -> Vector n a -> Vector n b
postscanr :: forall a b (n :: Nat).
(Unbox a, Unbox b) =>
(a -> b -> b) -> b -> Vector n a -> Vector n b
postscanr = (a -> b -> b) -> b -> Vector Vector n a -> Vector Vector n b
forall (v :: Type -> Type) a b (n :: Nat).
(Vector v a, Vector v b) =>
(a -> b -> b) -> b -> Vector v n a -> Vector v n b
V.postscanr
{-# inline postscanr #-}
postscanr' :: (Unbox a, Unbox b) => (a -> b -> b) -> b -> Vector n a -> Vector n b
postscanr' :: forall a b (n :: Nat).
(Unbox a, Unbox b) =>
(a -> b -> b) -> b -> Vector n a -> Vector n b
postscanr' = (a -> b -> b) -> b -> Vector Vector n a -> Vector Vector n b
forall (v :: Type -> Type) a b (n :: Nat).
(Vector v a, Vector v b) =>
(a -> b -> b) -> b -> Vector v n a -> Vector v n b
V.postscanr'
{-# inline postscanr' #-}
scanr :: (Unbox a, Unbox b) => (a -> b -> b) -> b -> Vector n a -> Vector (n+1) b
scanr :: forall a b (n :: Nat).
(Unbox a, Unbox b) =>
(a -> b -> b) -> b -> Vector n a -> Vector (n + 1) b
scanr = (a -> b -> b) -> b -> Vector Vector n a -> Vector Vector (n + 1) b
forall (v :: Type -> Type) a b (n :: Nat).
(Vector v a, Vector v b) =>
(a -> b -> b) -> b -> Vector v n a -> Vector v (n + 1) b
V.scanr
{-# inline scanr #-}
scanr' :: (Unbox a, Unbox b) => (a -> b -> b) -> b -> Vector n a -> Vector (n+1) b
scanr' :: forall a b (n :: Nat).
(Unbox a, Unbox b) =>
(a -> b -> b) -> b -> Vector n a -> Vector (n + 1) b
scanr' = (a -> b -> b) -> b -> Vector Vector n a -> Vector Vector (n + 1) b
forall (v :: Type -> Type) a b (n :: Nat).
(Vector v a, Vector v b) =>
(a -> b -> b) -> b -> Vector v n a -> Vector v (n + 1) b
V.scanr'
{-# inline scanr' #-}
scanr1 :: Unbox a => (a -> a -> a) -> Vector (n+1) a -> Vector (n+2) a
scanr1 :: forall a (n :: Nat).
Unbox a =>
(a -> a -> a) -> Vector (n + 1) a -> Vector (n + 2) a
scanr1 = (a -> a -> a) -> Vector Vector (n + 1) a -> Vector Vector (n + 2) a
forall (v :: Type -> Type) a (n :: Nat).
Vector v a =>
(a -> a -> a) -> Vector v (n + 1) a -> Vector v (n + 2) a
V.scanr1
{-# inline scanr1 #-}
scanr1' :: Unbox a => (a -> a -> a) -> Vector (n+1) a -> Vector (n+2) a
scanr1' :: forall a (n :: Nat).
Unbox a =>
(a -> a -> a) -> Vector (n + 1) a -> Vector (n + 2) a
scanr1' = (a -> a -> a) -> Vector Vector (n + 1) a -> Vector Vector (n + 2) a
forall (v :: Type -> Type) a (n :: Nat).
Vector v a =>
(a -> a -> a) -> Vector v (n + 1) a -> Vector v (n + 2) a
V.scanr1'
{-# inline scanr1' #-}
toList :: Unbox a => Vector n a -> [a]
toList :: forall a (n :: Nat). Unbox a => Vector n a -> [a]
toList = Vector Vector n a -> [a]
forall (v :: Type -> Type) a (n :: Nat).
Vector v a =>
Vector v n a -> [a]
V.toList
{-# inline toList #-}
fromList :: (Unbox a, KnownNat n) => [a] -> Maybe (Vector n a)
fromList :: forall a (n :: Nat).
(Unbox a, KnownNat n) =>
[a] -> Maybe (Vector n a)
fromList = [a] -> Maybe (Vector Vector n a)
forall (v :: Type -> Type) a (n :: Nat).
(Vector v a, KnownNat n) =>
[a] -> Maybe (Vector v n a)
V.fromList
{-# inline fromList #-}
fromListN :: forall n a. (Unbox a, KnownNat n)
=> [a] -> Maybe (Vector n a)
fromListN :: forall (n :: Nat) a.
(Unbox a, KnownNat n) =>
[a] -> Maybe (Vector n a)
fromListN = [a] -> Maybe (Vector Vector n a)
forall (v :: Type -> Type) (n :: Nat) a.
(Vector v a, KnownNat n) =>
[a] -> Maybe (Vector v n a)
V.fromListN
{-# inline fromListN #-}
fromListN' :: forall n a p. (Unbox a, KnownNat n)
=> p n -> [a] -> Maybe (Vector n a)
fromListN' :: forall (n :: Nat) a (p :: Nat -> Type).
(Unbox a, KnownNat n) =>
p n -> [a] -> Maybe (Vector n a)
fromListN' = p n -> [a] -> Maybe (Vector Vector n a)
forall (v :: Type -> Type) (n :: Nat) a (p :: Nat -> Type).
(Vector v a, KnownNat n) =>
p n -> [a] -> Maybe (Vector v n a)
V.fromListN'
{-# inline fromListN' #-}
withSizedList :: forall a r. Unbox a
=> [a] -> (forall n. KnownNat n => Vector n a -> r) -> r
withSizedList :: forall a r.
Unbox a =>
[a] -> (forall (n :: Nat). KnownNat n => Vector n a -> r) -> r
withSizedList [a]
xs = Vector a -> (forall (n :: Nat). KnownNat n => Vector n a -> r) -> r
forall a r.
Unbox a =>
Vector a -> (forall (n :: Nat). KnownNat n => Vector n a -> r) -> r
withSized ([a] -> Vector a
forall a. Unbox a => [a] -> Vector a
VU.fromList [a]
xs)
{-# inline withSizedList #-}
freeze :: (PrimMonad m, Unbox a)
=> VUM.MVector n (PrimState m) a
-> m (Vector n a)
freeze :: forall (m :: Type -> Type) a (n :: Nat).
(PrimMonad m, Unbox a) =>
MVector n (PrimState m) a -> m (Vector n a)
freeze = MVector (Mutable Vector) n (PrimState m) a -> m (Vector Vector n a)
MVector MVector n (PrimState m) a -> m (Vector Vector n a)
forall (m :: Type -> Type) (v :: Type -> Type) a (n :: Nat).
(PrimMonad m, Vector v a) =>
MVector (Mutable v) n (PrimState m) a -> m (Vector v n a)
V.freeze
unsafeFreeze :: (PrimMonad m, Unbox a)
=> VUM.MVector n (PrimState m) a
-> m (Vector n a)
unsafeFreeze :: forall (m :: Type -> Type) a (n :: Nat).
(PrimMonad m, Unbox a) =>
MVector n (PrimState m) a -> m (Vector n a)
unsafeFreeze = MVector (Mutable Vector) n (PrimState m) a -> m (Vector Vector n a)
MVector MVector n (PrimState m) a -> m (Vector Vector n a)
forall (m :: Type -> Type) (v :: Type -> Type) a (n :: Nat).
(PrimMonad m, Vector v a) =>
MVector (Mutable v) n (PrimState m) a -> m (Vector v n a)
V.unsafeFreeze
thaw :: (PrimMonad m, Unbox a)
=> Vector n a
-> m (VUM.MVector n (PrimState m) a)
thaw :: forall (m :: Type -> Type) a (n :: Nat).
(PrimMonad m, Unbox a) =>
Vector n a -> m (MVector n (PrimState m) a)
thaw = Vector Vector n a -> m (MVector (Mutable Vector) n (PrimState m) a)
Vector Vector n a -> m (MVector MVector n (PrimState m) a)
forall (m :: Type -> Type) (v :: Type -> Type) a (n :: Nat).
(PrimMonad m, Vector v a) =>
Vector v n a -> m (MVector (Mutable v) n (PrimState m) a)
V.thaw
unsafeThaw :: (PrimMonad m, Unbox a)
=> Vector n a
-> m (VUM.MVector n (PrimState m) a)
unsafeThaw :: forall (m :: Type -> Type) a (n :: Nat).
(PrimMonad m, Unbox a) =>
Vector n a -> m (MVector n (PrimState m) a)
unsafeThaw = Vector Vector n a -> m (MVector (Mutable Vector) n (PrimState m) a)
Vector Vector n a -> m (MVector MVector n (PrimState m) a)
forall (m :: Type -> Type) (v :: Type -> Type) a (n :: Nat).
(PrimMonad m, Vector v a) =>
Vector v n a -> m (MVector (Mutable v) n (PrimState m) a)
V.unsafeThaw
copy :: (PrimMonad m, Unbox a)
=> VUM.MVector n (PrimState m) a
-> Vector n a
-> m ()
copy :: forall (m :: Type -> Type) a (n :: Nat).
(PrimMonad m, Unbox a) =>
MVector n (PrimState m) a -> Vector n a -> m ()
copy = MVector (Mutable Vector) n (PrimState m) a
-> Vector Vector n a -> m ()
MVector MVector n (PrimState m) a -> Vector Vector n a -> m ()
forall (m :: Type -> Type) (v :: Type -> Type) a (n :: Nat).
(PrimMonad m, Vector v a) =>
MVector (Mutable v) n (PrimState m) a -> Vector v n a -> m ()
V.copy
toSized :: forall n a. (Unbox a, KnownNat n)
=> VU.Vector a -> Maybe (Vector n a)
toSized :: forall (n :: Nat) a.
(Unbox a, KnownNat n) =>
Vector a -> Maybe (Vector n a)
toSized = Vector a -> Maybe (Vector Vector n a)
forall (v :: Type -> Type) (n :: Nat) a.
(Vector v a, KnownNat n) =>
v a -> Maybe (Vector v n a)
V.toSized
{-# inline toSized #-}
withSized :: forall a r. Unbox a
=> VU.Vector a -> (forall n. KnownNat n => Vector n a -> r) -> r
withSized :: forall a r.
Unbox a =>
Vector a -> (forall (n :: Nat). KnownNat n => Vector n a -> r) -> r
withSized = Vector a
-> (forall (n :: Nat). KnownNat n => Vector Vector n a -> r) -> r
forall (v :: Type -> Type) a r.
Vector v a =>
v a -> (forall (n :: Nat). KnownNat n => Vector v n a -> r) -> r
V.withSized
{-# inline withSized #-}
fromSized :: Vector n a -> VU.Vector a
fromSized :: forall (n :: Nat) a. Vector n a -> Vector a
fromSized = Vector Vector n a -> Vector a
forall (v :: Type -> Type) (n :: Nat) a. Vector v n a -> v a
V.fromSized
{-# inline fromSized #-}
withVectorUnsafe :: forall a b (n :: Nat). ()
=> (VU.Vector a -> VU.Vector b) -> Vector n a -> Vector n b
withVectorUnsafe :: forall a b (n :: Nat).
(Vector a -> Vector b) -> Vector n a -> Vector n b
withVectorUnsafe = (Vector a -> Vector b) -> Vector Vector n a -> Vector Vector n b
forall (v :: Type -> Type) a (w :: Type -> Type) b (n :: Nat).
(v a -> w b) -> Vector v n a -> Vector w n b
V.withVectorUnsafe
{-# inline withVectorUnsafe #-}
zipVectorsUnsafe :: (VU.Vector a -> VU.Vector b -> VU.Vector c) -> Vector n a -> Vector n b -> Vector n c
zipVectorsUnsafe :: forall a b c (n :: Nat).
(Vector a -> Vector b -> Vector c)
-> Vector n a -> Vector n b -> Vector n c
zipVectorsUnsafe = (Vector a -> Vector b -> Vector c)
-> Vector Vector n a -> Vector Vector n b -> Vector Vector n c
forall (u :: Type -> Type) a (v :: Type -> Type) b
(w :: Type -> Type) c (n :: Nat).
(u a -> v b -> w c) -> Vector u n a -> Vector v n b -> Vector w n c
V.zipVectorsUnsafe
{-# inline zipVectorsUnsafe #-}
pattern SomeSized :: Unbox a => KnownNat n => Vector n a -> VU.Vector a
pattern $mSomeSized :: forall {r} {a}.
Unbox a =>
Vector a
-> (forall {n :: Nat}. KnownNat n => Vector n a -> r)
-> ((# #) -> r)
-> r
$bSomeSized :: forall a (n :: Nat).
(Unbox a, KnownNat n) =>
Vector n a -> Vector a
SomeSized v = V.SomeSized v
{-# complete SomeSized #-}