{-# LANGUAGE GeneralizedNewtypeDeriving #-}
{-# LANGUAGE KindSignatures #-}
{-# LANGUAGE GADTs #-}
{-# LANGUAGE MultiParamTypeClasses #-}
{-# LANGUAGE UndecidableInstances #-}
{-# LANGUAGE FlexibleInstances #-}
{-# LANGUAGE TypeFamilies #-}
{-# LANGUAGE Rank2Types #-}
module Data.Vector.Hybrid
( Vector, MVector
, length, null
, (!), (!?), head, last
, unsafeIndex, unsafeHead, unsafeLast
, indexM, headM, lastM
, unsafeIndexM, unsafeHeadM, unsafeLastM
, slice, init, tail, take, drop, splitAt
, unsafeSlice, unsafeInit, unsafeTail, unsafeTake, unsafeDrop
, empty, singleton, replicate, generate, iterateN
, replicateM, generateM, create
, unfoldr, unfoldrN
, constructN, constructrN
, cons, snoc, (++), concat
, force
, (//)
, unsafeUpd
, accum, unsafeAccum
, reverse
, modify
, map, imap, concatMap
, mapM, mapM_, forM, forM_
, zipWith, zipWith3, zipWith4, zipWith5, zipWith6
, izipWith, izipWith3, izipWith4, izipWith5, izipWith6
, zipWithM, zipWithM_
, filter, ifilter, filterM
, takeWhile, dropWhile
, partition, unstablePartition, span, break
, elem, notElem, find, findIndex
, elemIndex
, foldl, foldl1, foldl', foldl1', foldr, foldr1, foldr', foldr1'
, ifoldl, ifoldl', ifoldr, ifoldr'
, all, any
, maximum, maximumBy, minimum, minimumBy
, minIndex, minIndexBy, maxIndex, maxIndexBy
, foldM, foldM', fold1M, fold1M'
, foldM_, foldM'_, fold1M_, fold1M'_
, prescanl, prescanl'
, postscanl, postscanl'
, scanl, scanl', scanl1, scanl1'
, prescanr, prescanr'
, postscanr, postscanr'
, scanr, scanr', scanr1, scanr1'
, projectFst
, projectSnd
, unsafeZip
, toList, fromList, fromListN
, G.convert
, freeze, thaw, copy, unsafeFreeze, unsafeThaw, unsafeCopy
) where
import Control.Monad.Primitive
import Control.Monad.ST
import Data.Vector.Hybrid.Internal
import qualified Data.Vector.Generic as G
import Prelude (Int, Bool, Maybe, Monad, Ordering, Ord, Eq)
length :: G.Vector u a => Vector u v (a, b) -> Int
length :: forall (u :: * -> *) a (v :: * -> *) b.
Vector u a =>
Vector u v (a, b) -> Int
length (V u a
ks v b
_) = forall (v :: * -> *) a. Vector v a => v a -> Int
G.length u a
ks
{-# INLINE length #-}
null :: G.Vector u a => Vector u v (a, b) -> Bool
null :: forall (u :: * -> *) a (v :: * -> *) b.
Vector u a =>
Vector u v (a, b) -> Bool
null (V u a
ks v b
_) = forall (v :: * -> *) a. Vector v a => v a -> Bool
G.null u a
ks
{-# INLINE null #-}
(!) :: (G.Vector u a, G.Vector v b) => Vector u v (a, b) -> Int -> (a, b)
! :: forall (u :: * -> *) a (v :: * -> *) b.
(Vector u a, Vector v b) =>
Vector u v (a, b) -> Int -> (a, b)
(!) = forall (v :: * -> *) a.
(HasCallStack, Vector v a) =>
v a -> Int -> a
(G.!)
{-# INLINE (!) #-}
(!?) :: (G.Vector u a, G.Vector v b) => Vector u v (a, b) -> Int -> Maybe (a, b)
!? :: forall (u :: * -> *) a (v :: * -> *) b.
(Vector u a, Vector v b) =>
Vector u v (a, b) -> Int -> Maybe (a, b)
(!?) = forall (v :: * -> *) a. Vector v a => v a -> Int -> Maybe a
(G.!?)
{-# INLINE (!?) #-}
head :: (G.Vector u a, G.Vector v b) => Vector u v (a, b) -> (a, b)
head :: forall (u :: * -> *) a (v :: * -> *) b.
(Vector u a, Vector v b) =>
Vector u v (a, b) -> (a, b)
head = forall (v :: * -> *) a. Vector v a => v a -> a
G.head
{-# INLINE head #-}
last :: (G.Vector u a, G.Vector v b) => Vector u v (a, b) -> (a, b)
last :: forall (u :: * -> *) a (v :: * -> *) b.
(Vector u a, Vector v b) =>
Vector u v (a, b) -> (a, b)
last = forall (v :: * -> *) a. Vector v a => v a -> a
G.last
{-# INLINE last #-}
unsafeIndex :: (G.Vector u a, G.Vector v b) => Vector u v (a, b) -> Int -> (a, b)
{-# INLINE unsafeIndex #-}
unsafeIndex :: forall (u :: * -> *) a (v :: * -> *) b.
(Vector u a, Vector v b) =>
Vector u v (a, b) -> Int -> (a, b)
unsafeIndex = forall (v :: * -> *) a. Vector v a => v a -> Int -> a
G.unsafeIndex
unsafeHead :: (G.Vector u a, G.Vector v b) => Vector u v (a, b) -> (a, b)
{-# INLINE unsafeHead #-}
unsafeHead :: forall (u :: * -> *) a (v :: * -> *) b.
(Vector u a, Vector v b) =>
Vector u v (a, b) -> (a, b)
unsafeHead = forall (v :: * -> *) a. Vector v a => v a -> a
G.unsafeHead
unsafeLast :: (G.Vector u a, G.Vector v b) => Vector u v (a, b) -> (a, b)
{-# INLINE unsafeLast #-}
unsafeLast :: forall (u :: * -> *) a (v :: * -> *) b.
(Vector u a, Vector v b) =>
Vector u v (a, b) -> (a, b)
unsafeLast = forall (v :: * -> *) a. Vector v a => v a -> a
G.unsafeLast
indexM :: (G.Vector u a, G.Vector v b, Monad m) => Vector u v (a, b) -> Int -> m (a, b)
indexM :: forall (u :: * -> *) a (v :: * -> *) b (m :: * -> *).
(Vector u a, Vector v b, Monad m) =>
Vector u v (a, b) -> Int -> m (a, b)
indexM = forall (v :: * -> *) a (m :: * -> *).
(HasCallStack, Vector v a, Monad m) =>
v a -> Int -> m a
G.indexM
{-# INLINE indexM #-}
headM :: (G.Vector u a, G.Vector v b, Monad m) => Vector u v (a, b) -> m (a, b)
headM :: forall (u :: * -> *) a (v :: * -> *) b (m :: * -> *).
(Vector u a, Vector v b, Monad m) =>
Vector u v (a, b) -> m (a, b)
headM = forall (v :: * -> *) a (m :: * -> *).
(Vector v a, Monad m) =>
v a -> m a
G.headM
{-# INLINE headM #-}
lastM :: (G.Vector u a, G.Vector v b, Monad m) => Vector u v (a, b) -> m (a, b)
lastM :: forall (u :: * -> *) a (v :: * -> *) b (m :: * -> *).
(Vector u a, Vector v b, Monad m) =>
Vector u v (a, b) -> m (a, b)
lastM = forall (v :: * -> *) a (m :: * -> *).
(Vector v a, Monad m) =>
v a -> m a
G.lastM
{-# INLINE lastM #-}
unsafeIndexM :: (G.Vector u a, G.Vector v b, Monad m) => Vector u v (a, b) -> Int -> m (a, b)
unsafeIndexM :: forall (u :: * -> *) a (v :: * -> *) b (m :: * -> *).
(Vector u a, Vector v b, Monad m) =>
Vector u v (a, b) -> Int -> m (a, b)
unsafeIndexM = forall (v :: * -> *) a (m :: * -> *).
(Vector v a, Monad m) =>
v a -> Int -> m a
G.unsafeIndexM
{-# INLINE unsafeIndexM #-}
unsafeHeadM :: (G.Vector u a, G.Vector v b, Monad m) => Vector u v (a, b) -> m (a, b)
unsafeHeadM :: forall (u :: * -> *) a (v :: * -> *) b (m :: * -> *).
(Vector u a, Vector v b, Monad m) =>
Vector u v (a, b) -> m (a, b)
unsafeHeadM = forall (v :: * -> *) a (m :: * -> *).
(Vector v a, Monad m) =>
v a -> m a
G.unsafeHeadM
{-# INLINE unsafeHeadM #-}
unsafeLastM :: (G.Vector u a, G.Vector v b, Monad m) => Vector u v (a, b) -> m (a, b)
unsafeLastM :: forall (u :: * -> *) a (v :: * -> *) b (m :: * -> *).
(Vector u a, Vector v b, Monad m) =>
Vector u v (a, b) -> m (a, b)
unsafeLastM = forall (v :: * -> *) a (m :: * -> *).
(Vector v a, Monad m) =>
v a -> m a
G.unsafeLastM
{-# INLINE unsafeLastM #-}
slice :: (G.Vector u a, G.Vector v b)
=> Int
-> Int
-> Vector u v (a, b)
-> Vector u v (a, b)
slice :: forall (u :: * -> *) a (v :: * -> *) b.
(Vector u a, Vector v b) =>
Int -> Int -> Vector u v (a, b) -> Vector u v (a, b)
slice = forall (v :: * -> *) a.
(HasCallStack, Vector v a) =>
Int -> Int -> v a -> v a
G.slice
{-# INLINE slice #-}
init :: (G.Vector u a, G.Vector v b) => Vector u v (a, b) -> Vector u v (a, b)
init :: forall (u :: * -> *) a (v :: * -> *) b.
(Vector u a, Vector v b) =>
Vector u v (a, b) -> Vector u v (a, b)
init = forall (v :: * -> *) a. Vector v a => v a -> v a
G.init
{-# INLINE init #-}
tail :: (G.Vector u a, G.Vector v b) => Vector u v (a, b) -> Vector u v (a, b)
tail :: forall (u :: * -> *) a (v :: * -> *) b.
(Vector u a, Vector v b) =>
Vector u v (a, b) -> Vector u v (a, b)
tail = forall (v :: * -> *) a. Vector v a => v a -> v a
G.tail
{-# INLINE tail #-}
take :: (G.Vector u a, G.Vector v b) => Int -> Vector u v (a, b) -> Vector u v (a, b)
take :: forall (u :: * -> *) a (v :: * -> *) b.
(Vector u a, Vector v b) =>
Int -> Vector u v (a, b) -> Vector u v (a, b)
take = forall (v :: * -> *) a. Vector v a => Int -> v a -> v a
G.take
{-# INLINE take #-}
drop :: (G.Vector u a, G.Vector v b) => Int -> Vector u v (a, b) -> Vector u v (a, b)
drop :: forall (u :: * -> *) a (v :: * -> *) b.
(Vector u a, Vector v b) =>
Int -> Vector u v (a, b) -> Vector u v (a, b)
drop = forall (v :: * -> *) a. Vector v a => Int -> v a -> v a
G.drop
{-# INLINE drop #-}
splitAt :: (G.Vector u a, G.Vector v b) => Int -> Vector u v (a, b) -> (Vector u v (a, b), Vector u v (a, b))
splitAt :: forall (u :: * -> *) a (v :: * -> *) b.
(Vector u a, Vector v b) =>
Int -> Vector u v (a, b) -> (Vector u v (a, b), Vector u v (a, b))
splitAt = forall (v :: * -> *) a. Vector v a => Int -> v a -> (v a, v a)
G.splitAt
{-# INLINE splitAt #-}
unsafeSlice :: (G.Vector u a, G.Vector v b) => Int
-> Int
-> Vector u v (a, b)
-> Vector u v (a, b)
unsafeSlice :: forall (u :: * -> *) a (v :: * -> *) b.
(Vector u a, Vector v b) =>
Int -> Int -> Vector u v (a, b) -> Vector u v (a, b)
unsafeSlice = forall (v :: * -> *) a. Vector v a => Int -> Int -> v a -> v a
G.unsafeSlice
{-# INLINE unsafeSlice #-}
unsafeInit :: (G.Vector u a, G.Vector v b) => Vector u v (a, b) -> Vector u v (a, b)
unsafeInit :: forall (u :: * -> *) a (v :: * -> *) b.
(Vector u a, Vector v b) =>
Vector u v (a, b) -> Vector u v (a, b)
unsafeInit = forall (v :: * -> *) a. Vector v a => v a -> v a
G.unsafeInit
{-# INLINE unsafeInit #-}
unsafeTail :: (G.Vector u a, G.Vector v b) => Vector u v (a, b) -> Vector u v (a, b)
unsafeTail :: forall (u :: * -> *) a (v :: * -> *) b.
(Vector u a, Vector v b) =>
Vector u v (a, b) -> Vector u v (a, b)
unsafeTail = forall (v :: * -> *) a. Vector v a => v a -> v a
G.unsafeTail
{-# INLINE unsafeTail #-}
unsafeTake :: (G.Vector u a, G.Vector v b) => Int -> Vector u v (a, b) -> Vector u v (a, b)
unsafeTake :: forall (u :: * -> *) a (v :: * -> *) b.
(Vector u a, Vector v b) =>
Int -> Vector u v (a, b) -> Vector u v (a, b)
unsafeTake = forall (v :: * -> *) a. Vector v a => Int -> v a -> v a
G.unsafeTake
{-# INLINE unsafeTake #-}
unsafeDrop :: (G.Vector u a, G.Vector v b) => Int -> Vector u v (a, b) -> Vector u v (a, b)
unsafeDrop :: forall (u :: * -> *) a (v :: * -> *) b.
(Vector u a, Vector v b) =>
Int -> Vector u v (a, b) -> Vector u v (a, b)
unsafeDrop = forall (v :: * -> *) a. Vector v a => Int -> v a -> v a
G.unsafeDrop
{-# INLINE unsafeDrop #-}
empty :: (G.Vector u a, G.Vector v b) => Vector u v (a, b)
empty :: forall (u :: * -> *) a (v :: * -> *) b.
(Vector u a, Vector v b) =>
Vector u v (a, b)
empty = forall (v :: * -> *) a. Vector v a => v a
G.empty
{-# INLINE empty #-}
singleton :: (G.Vector u a, G.Vector v b) => (a, b) -> Vector u v (a, b)
singleton :: forall (u :: * -> *) a (v :: * -> *) b.
(Vector u a, Vector v b) =>
(a, b) -> Vector u v (a, b)
singleton = forall (v :: * -> *) a. Vector v a => a -> v a
G.singleton
{-# INLINE singleton #-}
replicate :: (G.Vector u a, G.Vector v b) => Int -> (a, b) -> Vector u v (a, b)
replicate :: forall (u :: * -> *) a (v :: * -> *) b.
(Vector u a, Vector v b) =>
Int -> (a, b) -> Vector u v (a, b)
replicate = forall (v :: * -> *) a. Vector v a => Int -> a -> v a
G.replicate
{-# INLINE replicate #-}
generate :: (G.Vector u a, G.Vector v b) => Int -> (Int -> (a, b)) -> Vector u v (a, b)
generate :: forall (u :: * -> *) a (v :: * -> *) b.
(Vector u a, Vector v b) =>
Int -> (Int -> (a, b)) -> Vector u v (a, b)
generate = forall (v :: * -> *) a. Vector v a => Int -> (Int -> a) -> v a
G.generate
{-# INLINE generate #-}
iterateN :: (G.Vector u a, G.Vector v b) => Int -> ((a, b) -> (a, b)) -> (a, b) -> Vector u v (a, b)
iterateN :: forall (u :: * -> *) a (v :: * -> *) b.
(Vector u a, Vector v b) =>
Int -> ((a, b) -> (a, b)) -> (a, b) -> Vector u v (a, b)
iterateN = forall (v :: * -> *) a. Vector v a => Int -> (a -> a) -> a -> v a
G.iterateN
{-# INLINE iterateN #-}
unfoldr :: (G.Vector u a, G.Vector v b) => (c -> Maybe ((a, b), c)) -> c -> Vector u v (a, b)
unfoldr :: forall (u :: * -> *) a (v :: * -> *) b c.
(Vector u a, Vector v b) =>
(c -> Maybe ((a, b), c)) -> c -> Vector u v (a, b)
unfoldr = forall (v :: * -> *) a b.
Vector v a =>
(b -> Maybe (a, b)) -> b -> v a
G.unfoldr
{-# INLINE unfoldr #-}
unfoldrN :: (G.Vector u a, G.Vector v b) => Int -> (c -> Maybe ((a, b), c)) -> c -> Vector u v (a, b)
unfoldrN :: forall (u :: * -> *) a (v :: * -> *) b c.
(Vector u a, Vector v b) =>
Int -> (c -> Maybe ((a, b), c)) -> c -> Vector u v (a, b)
unfoldrN = forall (v :: * -> *) a b.
Vector v a =>
Int -> (b -> Maybe (a, b)) -> b -> v a
G.unfoldrN
{-# INLINE unfoldrN #-}
constructN :: (G.Vector u a, G.Vector v b) => Int -> (Vector u v (a, b) -> (a, b)) -> Vector u v (a, b)
constructN :: forall (u :: * -> *) a (v :: * -> *) b.
(Vector u a, Vector v b) =>
Int -> (Vector u v (a, b) -> (a, b)) -> Vector u v (a, b)
constructN = forall (v :: * -> *) a. Vector v a => Int -> (v a -> a) -> v a
G.constructN
{-# INLINE constructN #-}
constructrN :: (G.Vector u a, G.Vector v b) => Int -> (Vector u v (a, b) -> (a, b)) -> Vector u v (a, b)
constructrN :: forall (u :: * -> *) a (v :: * -> *) b.
(Vector u a, Vector v b) =>
Int -> (Vector u v (a, b) -> (a, b)) -> Vector u v (a, b)
constructrN = forall (v :: * -> *) a. Vector v a => Int -> (v a -> a) -> v a
G.constructrN
{-# INLINE constructrN #-}
cons :: (G.Vector u a, G.Vector v b) => (a, b) -> Vector u v (a, b) -> Vector u v (a, b)
{-# INLINE cons #-}
cons :: forall (u :: * -> *) a (v :: * -> *) b.
(Vector u a, Vector v b) =>
(a, b) -> Vector u v (a, b) -> Vector u v (a, b)
cons = forall (v :: * -> *) a. Vector v a => a -> v a -> v a
G.cons
snoc :: (G.Vector u a, G.Vector v b) => Vector u v (a, b) -> (a, b) -> Vector u v (a, b)
{-# INLINE snoc #-}
snoc :: forall (u :: * -> *) a (v :: * -> *) b.
(Vector u a, Vector v b) =>
Vector u v (a, b) -> (a, b) -> Vector u v (a, b)
snoc = forall (v :: * -> *) a. Vector v a => v a -> a -> v a
G.snoc
infixr 5 ++
(++) :: (G.Vector u a, G.Vector v b) => Vector u v (a, b) -> Vector u v (a, b) -> Vector u v (a, b)
{-# INLINE (++) #-}
++ :: forall (u :: * -> *) a (v :: * -> *) b.
(Vector u a, Vector v b) =>
Vector u v (a, b) -> Vector u v (a, b) -> Vector u v (a, b)
(++) = forall (v :: * -> *) a. Vector v a => v a -> v a -> v a
(G.++)
concat :: (G.Vector u a, G.Vector v b) => [Vector u v (a, b)] -> Vector u v (a, b)
{-# INLINE concat #-}
concat :: forall (u :: * -> *) a (v :: * -> *) b.
(Vector u a, Vector v b) =>
[Vector u v (a, b)] -> Vector u v (a, b)
concat = forall (v :: * -> *) a. Vector v a => [v a] -> v a
G.concat
replicateM :: (Monad m, G.Vector u a, G.Vector v b) => Int -> m (a, b) -> m (Vector u v (a, b))
replicateM :: forall (m :: * -> *) (u :: * -> *) a (v :: * -> *) b.
(Monad m, Vector u a, Vector v b) =>
Int -> m (a, b) -> m (Vector u v (a, b))
replicateM = forall (m :: * -> *) (v :: * -> *) a.
(Monad m, Vector v a) =>
Int -> m a -> m (v a)
G.replicateM
{-# INLINE replicateM #-}
generateM :: (Monad m, G.Vector u a, G.Vector v b) => Int -> (Int -> m (a, b)) -> m (Vector u v (a, b))
generateM :: forall (m :: * -> *) (u :: * -> *) a (v :: * -> *) b.
(Monad m, Vector u a, Vector v b) =>
Int -> (Int -> m (a, b)) -> m (Vector u v (a, b))
generateM = forall (m :: * -> *) (v :: * -> *) a.
(Monad m, Vector v a) =>
Int -> (Int -> m a) -> m (v a)
G.generateM
{-# INLINE generateM #-}
create :: (G.Vector u a, G.Vector v b) => (forall s. ST s (G.Mutable (Vector u v) s (a, b))) -> Vector u v (a, b)
create :: forall (u :: * -> *) a (v :: * -> *) b.
(Vector u a, Vector v b) =>
(forall s. ST s (Mutable (Vector u v) s (a, b)))
-> Vector u v (a, b)
create forall s. ST s (Mutable (Vector u v) s (a, b))
p = forall (v :: * -> *) a.
Vector v a =>
(forall s. ST s (Mutable v s a)) -> v a
G.create forall s. ST s (Mutable (Vector u v) s (a, b))
p
{-# INLINE create #-}
force :: (G.Vector u a, G.Vector v b) => Vector u v (a, b) -> Vector u v (a, b)
force :: forall (u :: * -> *) a (v :: * -> *) b.
(Vector u a, Vector v b) =>
Vector u v (a, b) -> Vector u v (a, b)
force = forall (v :: * -> *) a. Vector v a => v a -> v a
G.force
{-# INLINE force #-}
(//) :: (G.Vector u a, G.Vector v b) => Vector u v (a, b)
-> [(Int, (a, b))]
-> Vector u v (a, b)
// :: forall (u :: * -> *) a (v :: * -> *) b.
(Vector u a, Vector v b) =>
Vector u v (a, b) -> [(Int, (a, b))] -> Vector u v (a, b)
(//) = forall (v :: * -> *) a. Vector v a => v a -> [(Int, a)] -> v a
(G.//)
{-# INLINE (//) #-}
unsafeUpd :: (G.Vector u a, G.Vector v b) => Vector u v (a, b) -> [(Int, (a, b))] -> Vector u v (a, b)
unsafeUpd :: forall (u :: * -> *) a (v :: * -> *) b.
(Vector u a, Vector v b) =>
Vector u v (a, b) -> [(Int, (a, b))] -> Vector u v (a, b)
unsafeUpd = forall (v :: * -> *) a. Vector v a => v a -> [(Int, a)] -> v a
G.unsafeUpd
{-# INLINE unsafeUpd #-}
accum :: (G.Vector u a, G.Vector v b)
=> ((a, b) -> c -> (a, b))
-> Vector u v (a, b)
-> [(Int,c)]
-> Vector u v (a, b)
accum :: forall (u :: * -> *) a (v :: * -> *) b c.
(Vector u a, Vector v b) =>
((a, b) -> c -> (a, b))
-> Vector u v (a, b) -> [(Int, c)] -> Vector u v (a, b)
accum = forall (v :: * -> *) a b.
Vector v a =>
(a -> b -> a) -> v a -> [(Int, b)] -> v a
G.accum
{-# INLINE accum #-}
unsafeAccum :: (G.Vector u a, G.Vector v b) => ((a, b) -> c -> (a, b)) -> Vector u v (a, b) -> [(Int,c)] -> Vector u v (a, b)
unsafeAccum :: forall (u :: * -> *) a (v :: * -> *) b c.
(Vector u a, Vector v b) =>
((a, b) -> c -> (a, b))
-> Vector u v (a, b) -> [(Int, c)] -> Vector u v (a, b)
unsafeAccum = forall (v :: * -> *) a b.
Vector v a =>
(a -> b -> a) -> v a -> [(Int, b)] -> v a
G.unsafeAccum
{-# INLINE unsafeAccum #-}
reverse :: (G.Vector u a, G.Vector v b) => Vector u v (a, b) -> Vector u v (a, b)
{-# INLINE reverse #-}
reverse :: forall (u :: * -> *) a (v :: * -> *) b.
(Vector u a, Vector v b) =>
Vector u v (a, b) -> Vector u v (a, b)
reverse = forall (v :: * -> *) a. Vector v a => v a -> v a
G.reverse
modify :: (G.Vector u a, G.Vector v b)
=> (forall s. G.Mutable (Vector u v) s (a, b) -> ST s ())
-> Vector u v (a, b) -> Vector u v (a, b)
{-# INLINE modify #-}
modify :: forall (u :: * -> *) a (v :: * -> *) b.
(Vector u a, Vector v b) =>
(forall s. Mutable (Vector u v) s (a, b) -> ST s ())
-> Vector u v (a, b) -> Vector u v (a, b)
modify forall s. Mutable (Vector u v) s (a, b) -> ST s ()
p = forall (v :: * -> *) a.
Vector v a =>
(forall s. Mutable v s a -> ST s ()) -> v a -> v a
G.modify forall s. Mutable (Vector u v) s (a, b) -> ST s ()
p
map :: (G.Vector u a, G.Vector v b, G.Vector u c, G.Vector v d)
=> ((a, b) -> (c, d)) -> Vector u v (a, b) -> Vector u v (c, d)
map :: forall (u :: * -> *) a (v :: * -> *) b c d.
(Vector u a, Vector v b, Vector u c, Vector v d) =>
((a, b) -> (c, d)) -> Vector u v (a, b) -> Vector u v (c, d)
map = forall (v :: * -> *) a b.
(Vector v a, Vector v b) =>
(a -> b) -> v a -> v b
G.map
{-# INLINE map #-}
imap :: (G.Vector u a, G.Vector v b, G.Vector u c, G.Vector v d)
=> (Int -> (a, b) -> (c, d))
-> Vector u v (a, b) -> Vector u v (c, d)
imap :: forall (u :: * -> *) a (v :: * -> *) b c d.
(Vector u a, Vector v b, Vector u c, Vector v d) =>
(Int -> (a, b) -> (c, d)) -> Vector u v (a, b) -> Vector u v (c, d)
imap = forall (v :: * -> *) a b.
(Vector v a, Vector v b) =>
(Int -> a -> b) -> v a -> v b
G.imap
{-# INLINE imap #-}
concatMap :: (G.Vector u a, G.Vector v b, G.Vector u c, G.Vector v d)
=> ((a, b) -> Vector u v (c, d)) -> Vector u v (a, b) -> Vector u v (c, d)
concatMap :: forall (u :: * -> *) a (v :: * -> *) b c d.
(Vector u a, Vector v b, Vector u c, Vector v d) =>
((a, b) -> Vector u v (c, d))
-> Vector u v (a, b) -> Vector u v (c, d)
concatMap = forall (v :: * -> *) a b.
(Vector v a, Vector v b) =>
(a -> v b) -> v a -> v b
G.concatMap
{-# INLINE concatMap #-}
mapM :: (Monad m, G.Vector u a, G.Vector v b, G.Vector u c, G.Vector v d) => ((a, b) -> m (c, d)) -> Vector u v (a, b) -> m (Vector u v (c, d))
mapM :: forall (m :: * -> *) (u :: * -> *) a (v :: * -> *) b c d.
(Monad m, Vector u a, Vector v b, Vector u c, Vector v d) =>
((a, b) -> m (c, d)) -> Vector u v (a, b) -> m (Vector u v (c, d))
mapM = forall (m :: * -> *) (v :: * -> *) a b.
(Monad m, Vector v a, Vector v b) =>
(a -> m b) -> v a -> m (v b)
G.mapM
{-# INLINE mapM #-}
mapM_ :: (Monad m, G.Vector u a, G.Vector v b, G.Vector u c, G.Vector v d) => ((a, b) -> m (c, d)) -> Vector u v (a, b) -> m ()
mapM_ :: forall (m :: * -> *) (u :: * -> *) a (v :: * -> *) b c d.
(Monad m, Vector u a, Vector v b, Vector u c, Vector v d) =>
((a, b) -> m (c, d)) -> Vector u v (a, b) -> m ()
mapM_ = forall (m :: * -> *) (v :: * -> *) a b.
(Monad m, Vector v a) =>
(a -> m b) -> v a -> m ()
G.mapM_
{-# INLINE mapM_ #-}
forM :: (Monad m, G.Vector u a, G.Vector v b, G.Vector u c, G.Vector v d) => Vector u v (a, b) -> ((a, b) -> m (c, d)) -> m (Vector u v (c, d))
forM :: forall (m :: * -> *) (u :: * -> *) a (v :: * -> *) b c d.
(Monad m, Vector u a, Vector v b, Vector u c, Vector v d) =>
Vector u v (a, b) -> ((a, b) -> m (c, d)) -> m (Vector u v (c, d))
forM = forall (m :: * -> *) (v :: * -> *) a b.
(Monad m, Vector v a, Vector v b) =>
v a -> (a -> m b) -> m (v b)
G.forM
{-# INLINE forM #-}
forM_ :: (Monad m, G.Vector u a, G.Vector v b, G.Vector u c, G.Vector v d) => Vector u v (a, b) -> ((a, b) -> m (c, d)) -> m ()
forM_ :: forall (m :: * -> *) (u :: * -> *) a (v :: * -> *) b c d.
(Monad m, Vector u a, Vector v b, Vector u c, Vector v d) =>
Vector u v (a, b) -> ((a, b) -> m (c, d)) -> m ()
forM_ = forall (m :: * -> *) (v :: * -> *) a b.
(Monad m, Vector v a) =>
v a -> (a -> m b) -> m ()
G.forM_
{-# INLINE forM_ #-}
zipWith :: ( G.Vector u a, G.Vector v a'
, G.Vector u b, G.Vector v b'
, G.Vector u c, G.Vector v c'
) => ((a,a') -> (b,b') -> (c,c'))
-> Vector u v (a,a') -> Vector u v (b,b') -> Vector u v (c,c')
zipWith :: forall (u :: * -> *) a (v :: * -> *) a' b b' c c'.
(Vector u a, Vector v a', Vector u b, Vector v b', Vector u c,
Vector v c') =>
((a, a') -> (b, b') -> (c, c'))
-> Vector u v (a, a') -> Vector u v (b, b') -> Vector u v (c, c')
zipWith = forall (v :: * -> *) a b c.
(Vector v a, Vector v b, Vector v c) =>
(a -> b -> c) -> v a -> v b -> v c
G.zipWith
{-# INLINE zipWith #-}
zipWith3 :: ( G.Vector u a, G.Vector v a'
, G.Vector u b, G.Vector v b'
, G.Vector u c, G.Vector v c'
, G.Vector u d, G.Vector v d'
) => ((a,a') -> (b,b') -> (c,c') -> (d, d'))
-> Vector u v (a,a') -> Vector u v (b,b') -> Vector u v (c,c') -> Vector u v (d,d')
zipWith3 :: forall (u :: * -> *) a (v :: * -> *) a' b b' c c' d d'.
(Vector u a, Vector v a', Vector u b, Vector v b', Vector u c,
Vector v c', Vector u d, Vector v d') =>
((a, a') -> (b, b') -> (c, c') -> (d, d'))
-> Vector u v (a, a')
-> Vector u v (b, b')
-> Vector u v (c, c')
-> Vector u v (d, d')
zipWith3 = forall (v :: * -> *) a b c d.
(Vector v a, Vector v b, Vector v c, Vector v d) =>
(a -> b -> c -> d) -> v a -> v b -> v c -> v d
G.zipWith3
{-# INLINE zipWith3 #-}
zipWith4 :: ( G.Vector u a, G.Vector v a'
, G.Vector u b, G.Vector v b'
, G.Vector u c, G.Vector v c'
, G.Vector u d, G.Vector v d'
, G.Vector u e, G.Vector v e'
) => ((a,a') -> (b,b') -> (c,c') -> (d, d') -> (e,e'))
-> Vector u v (a,a') -> Vector u v (b,b') -> Vector u v (c,c') -> Vector u v (d,d') -> Vector u v (e,e')
zipWith4 :: forall (u :: * -> *) a (v :: * -> *) a' b b' c c' d d' e e'.
(Vector u a, Vector v a', Vector u b, Vector v b', Vector u c,
Vector v c', Vector u d, Vector v d', Vector u e, Vector v e') =>
((a, a') -> (b, b') -> (c, c') -> (d, d') -> (e, e'))
-> Vector u v (a, a')
-> Vector u v (b, b')
-> Vector u v (c, c')
-> Vector u v (d, d')
-> Vector u v (e, e')
zipWith4 = forall (v :: * -> *) a b c d e.
(Vector v a, Vector v b, Vector v c, Vector v d, Vector v e) =>
(a -> b -> c -> d -> e) -> v a -> v b -> v c -> v d -> v e
G.zipWith4
{-# INLINE zipWith4 #-}
zipWith5 :: ( G.Vector u a, G.Vector v a'
, G.Vector u b, G.Vector v b'
, G.Vector u c, G.Vector v c'
, G.Vector u d, G.Vector v d'
, G.Vector u e, G.Vector v e'
, G.Vector u f, G.Vector v f'
) => ((a,a') -> (b,b') -> (c,c') -> (d, d') -> (e,e') -> (f,f'))
-> Vector u v (a,a') -> Vector u v (b,b') -> Vector u v (c,c') -> Vector u v (d,d') -> Vector u v (e,e') -> Vector u v (f,f')
zipWith5 :: forall (u :: * -> *) a (v :: * -> *) a' b b' c c' d d' e e' f f'.
(Vector u a, Vector v a', Vector u b, Vector v b', Vector u c,
Vector v c', Vector u d, Vector v d', Vector u e, Vector v e',
Vector u f, Vector v f') =>
((a, a') -> (b, b') -> (c, c') -> (d, d') -> (e, e') -> (f, f'))
-> Vector u v (a, a')
-> Vector u v (b, b')
-> Vector u v (c, c')
-> Vector u v (d, d')
-> Vector u v (e, e')
-> Vector u v (f, f')
zipWith5 = forall (v :: * -> *) a b c d e f.
(Vector v a, Vector v b, Vector v c, Vector v d, Vector v e,
Vector v f) =>
(a -> b -> c -> d -> e -> f)
-> v a -> v b -> v c -> v d -> v e -> v f
G.zipWith5
{-# INLINE zipWith5 #-}
zipWith6 :: ( G.Vector u a, G.Vector v a'
, G.Vector u b, G.Vector v b'
, G.Vector u c, G.Vector v c'
, G.Vector u d, G.Vector v d'
, G.Vector u e, G.Vector v e'
, G.Vector u f, G.Vector v f'
, G.Vector u g, G.Vector v g'
) => ((a,a') -> (b,b') -> (c,c') -> (d, d') -> (e,e') -> (f,f') -> (g,g'))
-> Vector u v (a,a') -> Vector u v (b,b') -> Vector u v (c,c') -> Vector u v (d,d') -> Vector u v (e,e') -> Vector u v (f,f') -> Vector u v (g,g')
zipWith6 :: forall (u :: * -> *) a (v :: * -> *) a' b b' c c' d d' e e' f f' g
g'.
(Vector u a, Vector v a', Vector u b, Vector v b', Vector u c,
Vector v c', Vector u d, Vector v d', Vector u e, Vector v e',
Vector u f, Vector v f', Vector u g, Vector v g') =>
((a, a')
-> (b, b') -> (c, c') -> (d, d') -> (e, e') -> (f, f') -> (g, g'))
-> Vector u v (a, a')
-> Vector u v (b, b')
-> Vector u v (c, c')
-> Vector u v (d, d')
-> Vector u v (e, e')
-> Vector u v (f, f')
-> Vector u v (g, g')
zipWith6 = forall (v :: * -> *) a b c d e f g.
(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)
-> v a -> v b -> v c -> v d -> v e -> v f -> v g
G.zipWith6
{-# INLINE zipWith6 #-}
izipWith :: ( G.Vector u a, G.Vector v a'
, G.Vector u b, G.Vector v b'
, G.Vector u c, G.Vector v c'
) => (Int -> (a,a') -> (b,b') -> (c,c'))
-> Vector u v (a,a') -> Vector u v (b,b') -> Vector u v (c,c')
izipWith :: forall (u :: * -> *) a (v :: * -> *) a' b b' c c'.
(Vector u a, Vector v a', Vector u b, Vector v b', Vector u c,
Vector v c') =>
(Int -> (a, a') -> (b, b') -> (c, c'))
-> Vector u v (a, a') -> Vector u v (b, b') -> Vector u v (c, c')
izipWith = forall (v :: * -> *) a b c.
(Vector v a, Vector v b, Vector v c) =>
(Int -> a -> b -> c) -> v a -> v b -> v c
G.izipWith
{-# INLINE izipWith #-}
izipWith3 :: ( G.Vector u a, G.Vector v a'
, G.Vector u b, G.Vector v b'
, G.Vector u c, G.Vector v c'
, G.Vector u d, G.Vector v d'
) => (Int -> (a,a') -> (b,b') -> (c,c') -> (d, d'))
-> Vector u v (a,a') -> Vector u v (b,b') -> Vector u v (c,c') -> Vector u v (d,d')
izipWith3 :: forall (u :: * -> *) a (v :: * -> *) a' b b' c c' d d'.
(Vector u a, Vector v a', Vector u b, Vector v b', Vector u c,
Vector v c', Vector u d, Vector v d') =>
(Int -> (a, a') -> (b, b') -> (c, c') -> (d, d'))
-> Vector u v (a, a')
-> Vector u v (b, b')
-> Vector u v (c, c')
-> Vector u v (d, d')
izipWith3 = forall (v :: * -> *) a b c d.
(Vector v a, Vector v b, Vector v c, Vector v d) =>
(Int -> a -> b -> c -> d) -> v a -> v b -> v c -> v d
G.izipWith3
{-# INLINE izipWith3 #-}
izipWith4 :: ( G.Vector u a, G.Vector v a'
, G.Vector u b, G.Vector v b'
, G.Vector u c, G.Vector v c'
, G.Vector u d, G.Vector v d'
, G.Vector u e, G.Vector v e'
) => (Int -> (a,a') -> (b,b') -> (c,c') -> (d, d') -> (e,e'))
-> Vector u v (a,a') -> Vector u v (b,b') -> Vector u v (c,c') -> Vector u v (d,d') -> Vector u v (e,e')
izipWith4 :: forall (u :: * -> *) a (v :: * -> *) a' b b' c c' d d' e e'.
(Vector u a, Vector v a', Vector u b, Vector v b', Vector u c,
Vector v c', Vector u d, Vector v d', Vector u e, Vector v e') =>
(Int -> (a, a') -> (b, b') -> (c, c') -> (d, d') -> (e, e'))
-> Vector u v (a, a')
-> Vector u v (b, b')
-> Vector u v (c, c')
-> Vector u v (d, d')
-> Vector u v (e, e')
izipWith4 = forall (v :: * -> *) a b c d e.
(Vector v a, Vector v b, Vector v c, Vector v d, Vector v e) =>
(Int -> a -> b -> c -> d -> e) -> v a -> v b -> v c -> v d -> v e
G.izipWith4
{-# INLINE izipWith4 #-}
izipWith5 :: ( G.Vector u a, G.Vector v a'
, G.Vector u b, G.Vector v b'
, G.Vector u c, G.Vector v c'
, G.Vector u d, G.Vector v d'
, G.Vector u e, G.Vector v e'
, G.Vector u f, G.Vector v f'
) => (Int -> (a,a') -> (b,b') -> (c,c') -> (d, d') -> (e,e') -> (f,f'))
-> Vector u v (a,a') -> Vector u v (b,b') -> Vector u v (c,c') -> Vector u v (d,d') -> Vector u v (e,e') -> Vector u v (f,f')
izipWith5 :: forall (u :: * -> *) a (v :: * -> *) a' b b' c c' d d' e e' f f'.
(Vector u a, Vector v a', Vector u b, Vector v b', Vector u c,
Vector v c', Vector u d, Vector v d', Vector u e, Vector v e',
Vector u f, Vector v f') =>
(Int
-> (a, a') -> (b, b') -> (c, c') -> (d, d') -> (e, e') -> (f, f'))
-> Vector u v (a, a')
-> Vector u v (b, b')
-> Vector u v (c, c')
-> Vector u v (d, d')
-> Vector u v (e, e')
-> Vector u v (f, f')
izipWith5 = forall (v :: * -> *) a b c d e f.
(Vector v a, Vector v b, Vector v c, Vector v d, Vector v e,
Vector v f) =>
(Int -> a -> b -> c -> d -> e -> f)
-> v a -> v b -> v c -> v d -> v e -> v f
G.izipWith5
{-# INLINE izipWith5 #-}
izipWith6 :: ( G.Vector u a, G.Vector v a'
, G.Vector u b, G.Vector v b'
, G.Vector u c, G.Vector v c'
, G.Vector u d, G.Vector v d'
, G.Vector u e, G.Vector v e'
, G.Vector u f, G.Vector v f'
, G.Vector u g, G.Vector v g'
) => (Int -> (a,a') -> (b,b') -> (c,c') -> (d, d') -> (e,e') -> (f,f') -> (g,g'))
-> Vector u v (a,a') -> Vector u v (b,b') -> Vector u v (c,c') -> Vector u v (d,d') -> Vector u v (e,e') -> Vector u v (f,f') -> Vector u v (g,g')
izipWith6 :: forall (u :: * -> *) a (v :: * -> *) a' b b' c c' d d' e e' f f' g
g'.
(Vector u a, Vector v a', Vector u b, Vector v b', Vector u c,
Vector v c', Vector u d, Vector v d', Vector u e, Vector v e',
Vector u f, Vector v f', Vector u g, Vector v g') =>
(Int
-> (a, a')
-> (b, b')
-> (c, c')
-> (d, d')
-> (e, e')
-> (f, f')
-> (g, g'))
-> Vector u v (a, a')
-> Vector u v (b, b')
-> Vector u v (c, c')
-> Vector u v (d, d')
-> Vector u v (e, e')
-> Vector u v (f, f')
-> Vector u v (g, g')
izipWith6 = forall (v :: * -> *) a b c d e f g.
(Vector v a, Vector v b, Vector v c, Vector v d, Vector v e,
Vector v f, Vector v g) =>
(Int -> a -> b -> c -> d -> e -> f -> g)
-> v a -> v b -> v c -> v d -> v e -> v f -> v g
G.izipWith6
{-# INLINE izipWith6 #-}
zipWithM :: (Monad m, G.Vector u a, G.Vector v b, G.Vector u c, G.Vector v d, G.Vector u e, G.Vector v f)
=> ((a, b) -> (c, d) -> m (e,f)) -> Vector u v (a, b) -> Vector u v (c, d) -> m (Vector u v (e,f))
zipWithM :: forall (m :: * -> *) (u :: * -> *) a (v :: * -> *) b c d e f.
(Monad m, Vector u a, Vector v b, Vector u c, Vector v d,
Vector u e, Vector v f) =>
((a, b) -> (c, d) -> m (e, f))
-> Vector u v (a, b) -> Vector u v (c, d) -> m (Vector u v (e, f))
zipWithM = forall (m :: * -> *) (v :: * -> *) a b c.
(Monad m, Vector v a, Vector v b, Vector v c) =>
(a -> b -> m c) -> v a -> v b -> m (v c)
G.zipWithM
{-# INLINE zipWithM #-}
zipWithM_ :: (Monad m, G.Vector u a, G.Vector v b, G.Vector u c, G.Vector v d)
=> ((a, b) -> (c, d) -> m e) -> Vector u v (a, b) -> Vector u v (c, d) -> m ()
zipWithM_ :: forall (m :: * -> *) (u :: * -> *) a (v :: * -> *) b c d e.
(Monad m, Vector u a, Vector v b, Vector u c, Vector v d) =>
((a, b) -> (c, d) -> m e)
-> Vector u v (a, b) -> Vector u v (c, d) -> m ()
zipWithM_ = forall (m :: * -> *) (v :: * -> *) a b c.
(Monad m, Vector v a, Vector v b) =>
(a -> b -> m c) -> v a -> v b -> m ()
G.zipWithM_
{-# INLINE zipWithM_ #-}
filter :: (G.Vector u a, G.Vector v b) => ((a, b) -> Bool) -> Vector u v (a, b) -> Vector u v (a, b)
filter :: forall (u :: * -> *) a (v :: * -> *) b.
(Vector u a, Vector v b) =>
((a, b) -> Bool) -> Vector u v (a, b) -> Vector u v (a, b)
filter = forall (v :: * -> *) a. Vector v a => (a -> Bool) -> v a -> v a
G.filter
{-# INLINE filter #-}
ifilter :: (G.Vector u a, G.Vector v b) => (Int -> (a, b) -> Bool) -> Vector u v (a, b) -> Vector u v (a, b)
ifilter :: forall (u :: * -> *) a (v :: * -> *) b.
(Vector u a, Vector v b) =>
(Int -> (a, b) -> Bool) -> Vector u v (a, b) -> Vector u v (a, b)
ifilter = forall (v :: * -> *) a.
Vector v a =>
(Int -> a -> Bool) -> v a -> v a
G.ifilter
{-# INLINE ifilter #-}
filterM :: (Monad m, G.Vector u a, G.Vector v b) => ((a, b) -> m Bool) -> Vector u v (a, b) -> m (Vector u v (a, b))
filterM :: forall (m :: * -> *) (u :: * -> *) a (v :: * -> *) b.
(Monad m, Vector u a, Vector v b) =>
((a, b) -> m Bool) -> Vector u v (a, b) -> m (Vector u v (a, b))
filterM = forall (m :: * -> *) (v :: * -> *) a.
(Monad m, Vector v a) =>
(a -> m Bool) -> v a -> m (v a)
G.filterM
{-# INLINE filterM #-}
takeWhile :: (G.Vector u a, G.Vector v b) => ((a, b) -> Bool) -> Vector u v (a, b) -> Vector u v (a, b)
takeWhile :: forall (u :: * -> *) a (v :: * -> *) b.
(Vector u a, Vector v b) =>
((a, b) -> Bool) -> Vector u v (a, b) -> Vector u v (a, b)
takeWhile = forall (v :: * -> *) a. Vector v a => (a -> Bool) -> v a -> v a
G.takeWhile
{-# INLINE takeWhile #-}
dropWhile :: (G.Vector u a, G.Vector v b) => ((a, b) -> Bool) -> Vector u v (a, b) -> Vector u v (a, b)
dropWhile :: forall (u :: * -> *) a (v :: * -> *) b.
(Vector u a, Vector v b) =>
((a, b) -> Bool) -> Vector u v (a, b) -> Vector u v (a, b)
dropWhile = forall (v :: * -> *) a. Vector v a => (a -> Bool) -> v a -> v a
G.dropWhile
{-# INLINE dropWhile #-}
partition :: (G.Vector u a, G.Vector v b) => ((a, b) -> Bool) -> Vector u v (a, b) -> (Vector u v (a, b), Vector u v (a, b))
{-# INLINE partition #-}
partition :: forall (u :: * -> *) a (v :: * -> *) b.
(Vector u a, Vector v b) =>
((a, b) -> Bool)
-> Vector u v (a, b) -> (Vector u v (a, b), Vector u v (a, b))
partition = forall (v :: * -> *) a.
Vector v a =>
(a -> Bool) -> v a -> (v a, v a)
G.partition
unstablePartition :: (G.Vector u a, G.Vector v b) => ((a, b) -> Bool) -> Vector u v (a, b) -> (Vector u v (a, b), Vector u v (a, b))
{-# INLINE unstablePartition #-}
unstablePartition :: forall (u :: * -> *) a (v :: * -> *) b.
(Vector u a, Vector v b) =>
((a, b) -> Bool)
-> Vector u v (a, b) -> (Vector u v (a, b), Vector u v (a, b))
unstablePartition = forall (v :: * -> *) a.
Vector v a =>
(a -> Bool) -> v a -> (v a, v a)
G.unstablePartition
span :: (G.Vector u a, G.Vector v b) => ((a, b) -> Bool) -> Vector u v (a, b) -> (Vector u v (a, b), Vector u v (a, b))
{-# INLINE span #-}
span :: forall (u :: * -> *) a (v :: * -> *) b.
(Vector u a, Vector v b) =>
((a, b) -> Bool)
-> Vector u v (a, b) -> (Vector u v (a, b), Vector u v (a, b))
span = forall (v :: * -> *) a.
Vector v a =>
(a -> Bool) -> v a -> (v a, v a)
G.span
break :: (G.Vector u a, G.Vector v b) => ((a, b) -> Bool) -> Vector u v (a, b) -> (Vector u v (a, b), Vector u v (a, b))
{-# INLINE break #-}
break :: forall (u :: * -> *) a (v :: * -> *) b.
(Vector u a, Vector v b) =>
((a, b) -> Bool)
-> Vector u v (a, b) -> (Vector u v (a, b), Vector u v (a, b))
break = forall (v :: * -> *) a.
Vector v a =>
(a -> Bool) -> v a -> (v a, v a)
G.break
infix 4 `elem`
elem :: (G.Vector u a, G.Vector v b, Eq a, Eq b) => (a, b) -> Vector u v (a, b) -> Bool
elem :: forall (u :: * -> *) a (v :: * -> *) b.
(Vector u a, Vector v b, Eq a, Eq b) =>
(a, b) -> Vector u v (a, b) -> Bool
elem = forall (v :: * -> *) a. (Vector v a, Eq a) => a -> v a -> Bool
G.elem
{-# INLINE elem #-}
infix 4 `notElem`
notElem :: (G.Vector u a, G.Vector v b, Eq a, Eq b) => (a, b) -> Vector u v (a, b) -> Bool
notElem :: forall (u :: * -> *) a (v :: * -> *) b.
(Vector u a, Vector v b, Eq a, Eq b) =>
(a, b) -> Vector u v (a, b) -> Bool
notElem = forall (v :: * -> *) a. (Vector v a, Eq a) => a -> v a -> Bool
G.notElem
{-# INLINE notElem #-}
find :: (G.Vector u a, G.Vector v b) => ((a, b) -> Bool) -> Vector u v (a, b) -> Maybe (a, b)
find :: forall (u :: * -> *) a (v :: * -> *) b.
(Vector u a, Vector v b) =>
((a, b) -> Bool) -> Vector u v (a, b) -> Maybe (a, b)
find = forall (v :: * -> *) a. Vector v a => (a -> Bool) -> v a -> Maybe a
G.find
{-# INLINE find #-}
findIndex :: (G.Vector u a, G.Vector v b) => ((a, b) -> Bool) -> Vector u v (a, b) -> Maybe Int
findIndex :: forall (u :: * -> *) a (v :: * -> *) b.
(Vector u a, Vector v b) =>
((a, b) -> Bool) -> Vector u v (a, b) -> Maybe Int
findIndex = forall (v :: * -> *) a.
Vector v a =>
(a -> Bool) -> v a -> Maybe Int
G.findIndex
{-# INLINE findIndex #-}
elemIndex :: (G.Vector u a, G.Vector v b, Eq a, Eq b) => (a, b) -> Vector u v (a, b) -> Maybe Int
elemIndex :: forall (u :: * -> *) a (v :: * -> *) b.
(Vector u a, Vector v b, Eq a, Eq b) =>
(a, b) -> Vector u v (a, b) -> Maybe Int
elemIndex = forall (v :: * -> *) a. (Vector v a, Eq a) => a -> v a -> Maybe Int
G.elemIndex
{-# INLINE elemIndex #-}
foldl :: (G.Vector u a, G.Vector v b) => (r -> (a, b) -> r) -> r -> Vector u v (a, b) -> r
foldl :: forall (u :: * -> *) a (v :: * -> *) b r.
(Vector u a, Vector v b) =>
(r -> (a, b) -> r) -> r -> Vector u v (a, b) -> r
foldl = forall (v :: * -> *) b a.
Vector v b =>
(a -> b -> a) -> a -> v b -> a
G.foldl
{-# INLINE foldl #-}
foldl1 :: (G.Vector u a, G.Vector v b) => ((a, b) -> (a, b) -> (a, b)) -> Vector u v (a, b) -> (a, b)
foldl1 :: forall (u :: * -> *) a (v :: * -> *) b.
(Vector u a, Vector v b) =>
((a, b) -> (a, b) -> (a, b)) -> Vector u v (a, b) -> (a, b)
foldl1 = forall (v :: * -> *) a. Vector v a => (a -> a -> a) -> v a -> a
G.foldl1
{-# INLINE foldl1 #-}
foldl' :: (G.Vector u a, G.Vector v b) => (r -> (a, b) -> r) -> r -> Vector u v (a, b) -> r
foldl' :: forall (u :: * -> *) a (v :: * -> *) b r.
(Vector u a, Vector v b) =>
(r -> (a, b) -> r) -> r -> Vector u v (a, b) -> r
foldl' = forall (v :: * -> *) b a.
Vector v b =>
(a -> b -> a) -> a -> v b -> a
G.foldl'
{-# INLINE foldl' #-}
foldl1' :: (G.Vector u a, G.Vector v b) => ((a, b) -> (a, b) -> (a, b)) -> Vector u v (a, b) -> (a, b)
foldl1' :: forall (u :: * -> *) a (v :: * -> *) b.
(Vector u a, Vector v b) =>
((a, b) -> (a, b) -> (a, b)) -> Vector u v (a, b) -> (a, b)
foldl1' = forall (v :: * -> *) a. Vector v a => (a -> a -> a) -> v a -> a
G.foldl1'
{-# INLINE foldl1' #-}
foldr :: (G.Vector u a, G.Vector v b) => ((a, b) -> r -> r) -> r -> Vector u v (a, b) -> r
foldr :: forall (u :: * -> *) a (v :: * -> *) b r.
(Vector u a, Vector v b) =>
((a, b) -> r -> r) -> r -> Vector u v (a, b) -> r
foldr = forall (v :: * -> *) a b.
Vector v a =>
(a -> b -> b) -> b -> v a -> b
G.foldr
{-# INLINE foldr #-}
foldr1 :: (G.Vector u a, G.Vector v b) => ((a, b) -> (a, b) -> (a, b)) -> Vector u v (a, b) -> (a, b)
foldr1 :: forall (u :: * -> *) a (v :: * -> *) b.
(Vector u a, Vector v b) =>
((a, b) -> (a, b) -> (a, b)) -> Vector u v (a, b) -> (a, b)
foldr1 = forall (v :: * -> *) a. Vector v a => (a -> a -> a) -> v a -> a
G.foldr1
{-# INLINE foldr1 #-}
foldr' :: (G.Vector u a, G.Vector v b) => ((a, b) -> r -> r) -> r -> Vector u v (a, b) -> r
foldr' :: forall (u :: * -> *) a (v :: * -> *) b r.
(Vector u a, Vector v b) =>
((a, b) -> r -> r) -> r -> Vector u v (a, b) -> r
foldr' = forall (v :: * -> *) a b.
Vector v a =>
(a -> b -> b) -> b -> v a -> b
G.foldr'
{-# INLINE foldr' #-}
foldr1' :: (G.Vector u a, G.Vector v b) => ((a, b) -> (a, b) -> (a, b)) -> Vector u v (a, b) -> (a, b)
foldr1' :: forall (u :: * -> *) a (v :: * -> *) b.
(Vector u a, Vector v b) =>
((a, b) -> (a, b) -> (a, b)) -> Vector u v (a, b) -> (a, b)
foldr1' = forall (v :: * -> *) a. Vector v a => (a -> a -> a) -> v a -> a
G.foldr1'
{-# INLINE foldr1' #-}
ifoldl :: (G.Vector u a, G.Vector v b) => (r -> Int -> (a, b) -> r) -> r -> Vector u v (a, b) -> r
ifoldl :: forall (u :: * -> *) a (v :: * -> *) b r.
(Vector u a, Vector v b) =>
(r -> Int -> (a, b) -> r) -> r -> Vector u v (a, b) -> r
ifoldl = forall (v :: * -> *) b a.
Vector v b =>
(a -> Int -> b -> a) -> a -> v b -> a
G.ifoldl
{-# INLINE ifoldl #-}
ifoldl' :: (G.Vector u a, G.Vector v b) => (r -> Int -> (a, b) -> r) -> r -> Vector u v (a, b) -> r
ifoldl' :: forall (u :: * -> *) a (v :: * -> *) b r.
(Vector u a, Vector v b) =>
(r -> Int -> (a, b) -> r) -> r -> Vector u v (a, b) -> r
ifoldl' = forall (v :: * -> *) b a.
Vector v b =>
(a -> Int -> b -> a) -> a -> v b -> a
G.ifoldl'
{-# INLINE ifoldl' #-}
ifoldr :: (G.Vector u a, G.Vector v b) => (Int -> (a, b) -> r -> r) -> r -> Vector u v (a, b) -> r
ifoldr :: forall (u :: * -> *) a (v :: * -> *) b r.
(Vector u a, Vector v b) =>
(Int -> (a, b) -> r -> r) -> r -> Vector u v (a, b) -> r
ifoldr = forall (v :: * -> *) a b.
Vector v a =>
(Int -> a -> b -> b) -> b -> v a -> b
G.ifoldr
{-# INLINE ifoldr #-}
ifoldr' :: (G.Vector u a, G.Vector v b) => (Int -> (a, b) -> r -> r) -> r -> Vector u v (a, b) -> r
ifoldr' :: forall (u :: * -> *) a (v :: * -> *) b r.
(Vector u a, Vector v b) =>
(Int -> (a, b) -> r -> r) -> r -> Vector u v (a, b) -> r
ifoldr' = forall (v :: * -> *) a b.
Vector v a =>
(Int -> a -> b -> b) -> b -> v a -> b
G.ifoldr'
{-# INLINE ifoldr' #-}
all :: (G.Vector u a, G.Vector v b) => ((a, b) -> Bool) -> Vector u v (a, b) -> Bool
{-# INLINE all #-}
all :: forall (u :: * -> *) a (v :: * -> *) b.
(Vector u a, Vector v b) =>
((a, b) -> Bool) -> Vector u v (a, b) -> Bool
all = forall (v :: * -> *) a. Vector v a => (a -> Bool) -> v a -> Bool
G.all
any :: (G.Vector u a, G.Vector v b) => ((a, b) -> Bool) -> Vector u v (a, b) -> Bool
{-# INLINE any #-}
any :: forall (u :: * -> *) a (v :: * -> *) b.
(Vector u a, Vector v b) =>
((a, b) -> Bool) -> Vector u v (a, b) -> Bool
any = forall (v :: * -> *) a. Vector v a => (a -> Bool) -> v a -> Bool
G.any
maximum :: (G.Vector u a, G.Vector v b, Ord a, Ord b) => Vector u v (a, b) -> (a, b)
{-# INLINE maximum #-}
maximum :: forall (u :: * -> *) a (v :: * -> *) b.
(Vector u a, Vector v b, Ord a, Ord b) =>
Vector u v (a, b) -> (a, b)
maximum = forall (v :: * -> *) a. (Vector v a, Ord a) => v a -> a
G.maximum
maximumBy :: (G.Vector u a, G.Vector v b) => ((a, b) -> (a, b) -> Ordering) -> Vector u v (a, b) -> (a, b)
{-# INLINE maximumBy #-}
maximumBy :: forall (u :: * -> *) a (v :: * -> *) b.
(Vector u a, Vector v b) =>
((a, b) -> (a, b) -> Ordering) -> Vector u v (a, b) -> (a, b)
maximumBy = forall (v :: * -> *) a.
Vector v a =>
(a -> a -> Ordering) -> v a -> a
G.maximumBy
minimum :: (G.Vector u a, G.Vector v b, Ord a, Ord b) => Vector u v (a, b) -> (a, b)
{-# INLINE minimum #-}
minimum :: forall (u :: * -> *) a (v :: * -> *) b.
(Vector u a, Vector v b, Ord a, Ord b) =>
Vector u v (a, b) -> (a, b)
minimum = forall (v :: * -> *) a. (Vector v a, Ord a) => v a -> a
G.minimum
minimumBy :: (G.Vector u a, G.Vector v b) => ((a, b) -> (a, b) -> Ordering) -> Vector u v (a, b) -> (a, b)
{-# INLINE minimumBy #-}
minimumBy :: forall (u :: * -> *) a (v :: * -> *) b.
(Vector u a, Vector v b) =>
((a, b) -> (a, b) -> Ordering) -> Vector u v (a, b) -> (a, b)
minimumBy = forall (v :: * -> *) a.
Vector v a =>
(a -> a -> Ordering) -> v a -> a
G.minimumBy
maxIndex :: (G.Vector u a, G.Vector v b, Ord a, Ord b) => Vector u v (a, b) -> Int
{-# INLINE maxIndex #-}
maxIndex :: forall (u :: * -> *) a (v :: * -> *) b.
(Vector u a, Vector v b, Ord a, Ord b) =>
Vector u v (a, b) -> Int
maxIndex = forall (v :: * -> *) a. (Vector v a, Ord a) => v a -> Int
G.maxIndex
maxIndexBy :: (G.Vector u a, G.Vector v b) => ((a, b) -> (a, b) -> Ordering) -> Vector u v (a, b) -> Int
{-# INLINE maxIndexBy #-}
maxIndexBy :: forall (u :: * -> *) a (v :: * -> *) b.
(Vector u a, Vector v b) =>
((a, b) -> (a, b) -> Ordering) -> Vector u v (a, b) -> Int
maxIndexBy = forall (v :: * -> *) a.
Vector v a =>
(a -> a -> Ordering) -> v a -> Int
G.maxIndexBy
minIndex :: (G.Vector u a, G.Vector v b, Ord a, Ord b) => Vector u v (a, b) -> Int
{-# INLINE minIndex #-}
minIndex :: forall (u :: * -> *) a (v :: * -> *) b.
(Vector u a, Vector v b, Ord a, Ord b) =>
Vector u v (a, b) -> Int
minIndex = forall (v :: * -> *) a. (Vector v a, Ord a) => v a -> Int
G.minIndex
minIndexBy :: (G.Vector u a, G.Vector v b) => ((a, b) -> (a, b) -> Ordering) -> Vector u v (a, b) -> Int
{-# INLINE minIndexBy #-}
minIndexBy :: forall (u :: * -> *) a (v :: * -> *) b.
(Vector u a, Vector v b) =>
((a, b) -> (a, b) -> Ordering) -> Vector u v (a, b) -> Int
minIndexBy = forall (v :: * -> *) a.
Vector v a =>
(a -> a -> Ordering) -> v a -> Int
G.minIndexBy
foldM :: (Monad m, G.Vector u a, G.Vector v b) => (r -> (a, b) -> m r) -> r -> Vector u v (a, b) -> m r
foldM :: forall (m :: * -> *) (u :: * -> *) a (v :: * -> *) b r.
(Monad m, Vector u a, Vector v b) =>
(r -> (a, b) -> m r) -> r -> Vector u v (a, b) -> m r
foldM = forall (m :: * -> *) (v :: * -> *) b a.
(Monad m, Vector v b) =>
(a -> b -> m a) -> a -> v b -> m a
G.foldM
{-# INLINE foldM #-}
fold1M :: (Monad m, G.Vector u a, G.Vector v b) => ((a, b) -> (a, b) -> m (a, b)) -> Vector u v (a, b) -> m (a, b)
{-# INLINE fold1M #-}
fold1M :: forall (m :: * -> *) (u :: * -> *) a (v :: * -> *) b.
(Monad m, Vector u a, Vector v b) =>
((a, b) -> (a, b) -> m (a, b)) -> Vector u v (a, b) -> m (a, b)
fold1M = forall (m :: * -> *) (v :: * -> *) a.
(Monad m, Vector v a) =>
(a -> a -> m a) -> v a -> m a
G.fold1M
foldM' :: (Monad m, G.Vector u a, G.Vector v b) => (r -> (a, b) -> m r) -> r -> Vector u v (a, b) -> m r
{-# INLINE foldM' #-}
foldM' :: forall (m :: * -> *) (u :: * -> *) a (v :: * -> *) b r.
(Monad m, Vector u a, Vector v b) =>
(r -> (a, b) -> m r) -> r -> Vector u v (a, b) -> m r
foldM' = forall (m :: * -> *) (v :: * -> *) b a.
(Monad m, Vector v b) =>
(a -> b -> m a) -> a -> v b -> m a
G.foldM'
fold1M' :: (Monad m, G.Vector u a, G.Vector v b) => ((a, b) -> (a, b) -> m (a, b)) -> Vector u v (a, b) -> m (a, b)
{-# INLINE fold1M' #-}
fold1M' :: forall (m :: * -> *) (u :: * -> *) a (v :: * -> *) b.
(Monad m, Vector u a, Vector v b) =>
((a, b) -> (a, b) -> m (a, b)) -> Vector u v (a, b) -> m (a, b)
fold1M' = forall (m :: * -> *) (v :: * -> *) a.
(Monad m, Vector v a) =>
(a -> a -> m a) -> v a -> m a
G.fold1M'
foldM_ :: (Monad m, G.Vector u a, G.Vector v b) => (r -> (a, b) -> m r) -> r -> Vector u v (a, b) -> m ()
{-# INLINE foldM_ #-}
foldM_ :: forall (m :: * -> *) (u :: * -> *) a (v :: * -> *) b r.
(Monad m, Vector u a, Vector v b) =>
(r -> (a, b) -> m r) -> r -> Vector u v (a, b) -> m ()
foldM_ = forall (m :: * -> *) (v :: * -> *) b a.
(Monad m, Vector v b) =>
(a -> b -> m a) -> a -> v b -> m ()
G.foldM_
fold1M_ :: (Monad m, G.Vector u a, G.Vector v b) => ((a, b) -> (a, b) -> m (a, b)) -> Vector u v (a, b) -> m ()
{-# INLINE fold1M_ #-}
fold1M_ :: forall (m :: * -> *) (u :: * -> *) a (v :: * -> *) b.
(Monad m, Vector u a, Vector v b) =>
((a, b) -> (a, b) -> m (a, b)) -> Vector u v (a, b) -> m ()
fold1M_ = forall (m :: * -> *) (v :: * -> *) a.
(Monad m, Vector v a) =>
(a -> a -> m a) -> v a -> m ()
G.fold1M_
foldM'_ :: (Monad m, G.Vector u a, G.Vector v b) => (r -> (a, b) -> m r) -> r -> Vector u v (a, b) -> m ()
{-# INLINE foldM'_ #-}
foldM'_ :: forall (m :: * -> *) (u :: * -> *) a (v :: * -> *) b r.
(Monad m, Vector u a, Vector v b) =>
(r -> (a, b) -> m r) -> r -> Vector u v (a, b) -> m ()
foldM'_ = forall (m :: * -> *) (v :: * -> *) b a.
(Monad m, Vector v b) =>
(a -> b -> m a) -> a -> v b -> m ()
G.foldM'_
fold1M'_ :: (Monad m, G.Vector u a, G.Vector v b) => ((a, b) -> (a, b) -> m (a, b)) -> Vector u v (a, b) -> m ()
{-# INLINE fold1M'_ #-}
fold1M'_ :: forall (m :: * -> *) (u :: * -> *) a (v :: * -> *) b.
(Monad m, Vector u a, Vector v b) =>
((a, b) -> (a, b) -> m (a, b)) -> Vector u v (a, b) -> m ()
fold1M'_ = forall (m :: * -> *) (v :: * -> *) a.
(Monad m, Vector v a) =>
(a -> a -> m a) -> v a -> m ()
G.fold1M'_
prescanl :: (G.Vector u a, G.Vector v b, G.Vector u c, G.Vector v d) => ((a, b) -> (c, d) -> (a, b)) -> (a, b) -> Vector u v (c, d) -> Vector u v (a, b)
prescanl :: forall (u :: * -> *) a (v :: * -> *) b c d.
(Vector u a, Vector v b, Vector u c, Vector v d) =>
((a, b) -> (c, d) -> (a, b))
-> (a, b) -> Vector u v (c, d) -> Vector u v (a, b)
prescanl = forall (v :: * -> *) a b.
(Vector v a, Vector v b) =>
(a -> b -> a) -> a -> v b -> v a
G.prescanl
{-# INLINE prescanl #-}
prescanl' :: (G.Vector u a, G.Vector v b, G.Vector u c, G.Vector v d) => ((a, b) -> (c, d) -> (a, b)) -> (a, b) -> Vector u v (c, d) -> Vector u v (a, b)
prescanl' :: forall (u :: * -> *) a (v :: * -> *) b c d.
(Vector u a, Vector v b, Vector u c, Vector v d) =>
((a, b) -> (c, d) -> (a, b))
-> (a, b) -> Vector u v (c, d) -> Vector u v (a, b)
prescanl' = forall (v :: * -> *) a b.
(Vector v a, Vector v b) =>
(a -> b -> a) -> a -> v b -> v a
G.prescanl'
{-# INLINE prescanl' #-}
postscanl :: (G.Vector u a, G.Vector v b, G.Vector u c, G.Vector v d) => ((a, b) -> (c, d) -> (a, b)) -> (a, b) -> Vector u v (c, d) -> Vector u v (a, b)
postscanl :: forall (u :: * -> *) a (v :: * -> *) b c d.
(Vector u a, Vector v b, Vector u c, Vector v d) =>
((a, b) -> (c, d) -> (a, b))
-> (a, b) -> Vector u v (c, d) -> Vector u v (a, b)
postscanl = forall (v :: * -> *) a b.
(Vector v a, Vector v b) =>
(a -> b -> a) -> a -> v b -> v a
G.postscanl
{-# INLINE postscanl #-}
postscanl' :: (G.Vector u a, G.Vector v b, G.Vector u c, G.Vector v d) => ((a, b) -> (c, d) -> (a, b)) -> (a, b) -> Vector u v (c, d) -> Vector u v (a, b)
postscanl' :: forall (u :: * -> *) a (v :: * -> *) b c d.
(Vector u a, Vector v b, Vector u c, Vector v d) =>
((a, b) -> (c, d) -> (a, b))
-> (a, b) -> Vector u v (c, d) -> Vector u v (a, b)
postscanl' = forall (v :: * -> *) a b.
(Vector v a, Vector v b) =>
(a -> b -> a) -> a -> v b -> v a
G.postscanl'
{-# INLINE postscanl' #-}
scanl :: (G.Vector u a, G.Vector v b, G.Vector u c, G.Vector v d) => ((a, b) -> (c, d) -> (a, b)) -> (a, b) -> Vector u v (c, d) -> Vector u v (a, b)
scanl :: forall (u :: * -> *) a (v :: * -> *) b c d.
(Vector u a, Vector v b, Vector u c, Vector v d) =>
((a, b) -> (c, d) -> (a, b))
-> (a, b) -> Vector u v (c, d) -> Vector u v (a, b)
scanl = forall (v :: * -> *) a b.
(Vector v a, Vector v b) =>
(a -> b -> a) -> a -> v b -> v a
G.scanl
{-# INLINE scanl #-}
scanl' :: (G.Vector u a, G.Vector v b, G.Vector u c, G.Vector v d) => ((a, b) -> (c, d) -> (a, b)) -> (a, b) -> Vector u v (c, d) -> Vector u v (a, b)
scanl' :: forall (u :: * -> *) a (v :: * -> *) b c d.
(Vector u a, Vector v b, Vector u c, Vector v d) =>
((a, b) -> (c, d) -> (a, b))
-> (a, b) -> Vector u v (c, d) -> Vector u v (a, b)
scanl' = forall (v :: * -> *) a b.
(Vector v a, Vector v b) =>
(a -> b -> a) -> a -> v b -> v a
G.scanl'
{-# INLINE scanl' #-}
scanl1 :: (G.Vector u a, G.Vector v b) => ((a, b) -> (a, b) -> (a, b)) -> Vector u v (a, b) -> Vector u v (a, b)
scanl1 :: forall (u :: * -> *) a (v :: * -> *) b.
(Vector u a, Vector v b) =>
((a, b) -> (a, b) -> (a, b))
-> Vector u v (a, b) -> Vector u v (a, b)
scanl1 = forall (v :: * -> *) a. Vector v a => (a -> a -> a) -> v a -> v a
G.scanl1
{-# INLINE scanl1 #-}
scanl1' :: (G.Vector u a, G.Vector v b) => ((a, b) -> (a, b) -> (a, b)) -> Vector u v (a, b) -> Vector u v (a, b)
scanl1' :: forall (u :: * -> *) a (v :: * -> *) b.
(Vector u a, Vector v b) =>
((a, b) -> (a, b) -> (a, b))
-> Vector u v (a, b) -> Vector u v (a, b)
scanl1' = forall (v :: * -> *) a. Vector v a => (a -> a -> a) -> v a -> v a
G.scanl1'
{-# INLINE scanl1' #-}
prescanr :: (G.Vector u a, G.Vector v b, G.Vector u c, G.Vector v d) => ((a, b) -> (c, d) -> (c, d)) -> (c, d) -> Vector u v (a, b) -> Vector u v (c, d)
{-# INLINE prescanr #-}
prescanr :: forall (u :: * -> *) a (v :: * -> *) b c d.
(Vector u a, Vector v b, Vector u c, Vector v d) =>
((a, b) -> (c, d) -> (c, d))
-> (c, d) -> Vector u v (a, b) -> Vector u v (c, d)
prescanr = forall (v :: * -> *) a b.
(Vector v a, Vector v b) =>
(a -> b -> b) -> b -> v a -> v b
G.prescanr
prescanr' :: (G.Vector u a, G.Vector v b, G.Vector u c, G.Vector v d) => ((a, b) -> (c, d) -> (c, d)) -> (c, d) -> Vector u v (a, b) -> Vector u v (c, d)
prescanr' :: forall (u :: * -> *) a (v :: * -> *) b c d.
(Vector u a, Vector v b, Vector u c, Vector v d) =>
((a, b) -> (c, d) -> (c, d))
-> (c, d) -> Vector u v (a, b) -> Vector u v (c, d)
prescanr' = forall (v :: * -> *) a b.
(Vector v a, Vector v b) =>
(a -> b -> b) -> b -> v a -> v b
G.prescanr'
{-# INLINE prescanr' #-}
postscanr :: (G.Vector u a, G.Vector v b, G.Vector u c, G.Vector v d) => ((a, b) -> (c, d) -> (c, d)) -> (c, d) -> Vector u v (a, b) -> Vector u v (c, d)
postscanr :: forall (u :: * -> *) a (v :: * -> *) b c d.
(Vector u a, Vector v b, Vector u c, Vector v d) =>
((a, b) -> (c, d) -> (c, d))
-> (c, d) -> Vector u v (a, b) -> Vector u v (c, d)
postscanr = forall (v :: * -> *) a b.
(Vector v a, Vector v b) =>
(a -> b -> b) -> b -> v a -> v b
G.postscanr
{-# INLINE postscanr #-}
postscanr' :: (G.Vector u a, G.Vector v b, G.Vector u c, G.Vector v d) => ((a, b) -> (c, d) -> (c, d)) -> (c, d) -> Vector u v (a, b) -> Vector u v (c, d)
postscanr' :: forall (u :: * -> *) a (v :: * -> *) b c d.
(Vector u a, Vector v b, Vector u c, Vector v d) =>
((a, b) -> (c, d) -> (c, d))
-> (c, d) -> Vector u v (a, b) -> Vector u v (c, d)
postscanr' = forall (v :: * -> *) a b.
(Vector v a, Vector v b) =>
(a -> b -> b) -> b -> v a -> v b
G.postscanr'
{-# INLINE postscanr' #-}
scanr :: (G.Vector u a, G.Vector v b, G.Vector u c, G.Vector v d) => ((a, b) -> (c, d) -> (c, d)) -> (c, d) -> Vector u v (a, b) -> Vector u v (c, d)
scanr :: forall (u :: * -> *) a (v :: * -> *) b c d.
(Vector u a, Vector v b, Vector u c, Vector v d) =>
((a, b) -> (c, d) -> (c, d))
-> (c, d) -> Vector u v (a, b) -> Vector u v (c, d)
scanr = forall (v :: * -> *) a b.
(Vector v a, Vector v b) =>
(a -> b -> b) -> b -> v a -> v b
G.scanr
{-# INLINE scanr #-}
scanr' :: (G.Vector u a, G.Vector v b, G.Vector u c, G.Vector v d) => ((a, b) -> (c, d) -> (c, d)) -> (c, d) -> Vector u v (a, b) -> Vector u v (c, d)
scanr' :: forall (u :: * -> *) a (v :: * -> *) b c d.
(Vector u a, Vector v b, Vector u c, Vector v d) =>
((a, b) -> (c, d) -> (c, d))
-> (c, d) -> Vector u v (a, b) -> Vector u v (c, d)
scanr' = forall (v :: * -> *) a b.
(Vector v a, Vector v b) =>
(a -> b -> b) -> b -> v a -> v b
G.scanr'
{-# INLINE scanr' #-}
scanr1 :: (G.Vector u a, G.Vector v b) => ((a, b) -> (a, b) -> (a, b)) -> Vector u v (a, b) -> Vector u v (a, b)
{-# INLINE scanr1 #-}
scanr1 :: forall (u :: * -> *) a (v :: * -> *) b.
(Vector u a, Vector v b) =>
((a, b) -> (a, b) -> (a, b))
-> Vector u v (a, b) -> Vector u v (a, b)
scanr1 = forall (v :: * -> *) a. Vector v a => (a -> a -> a) -> v a -> v a
G.scanr1
scanr1' :: (G.Vector u a, G.Vector v b) => ((a, b) -> (a, b) -> (a, b)) -> Vector u v (a, b) -> Vector u v (a, b)
{-# INLINE scanr1' #-}
scanr1' :: forall (u :: * -> *) a (v :: * -> *) b.
(Vector u a, Vector v b) =>
((a, b) -> (a, b) -> (a, b))
-> Vector u v (a, b) -> Vector u v (a, b)
scanr1' = forall (v :: * -> *) a. Vector v a => (a -> a -> a) -> v a -> v a
G.scanr1'
projectFst :: Vector u v (a, b) -> u a
projectFst :: forall (u :: * -> *) (v :: * -> *) a b. Vector u v (a, b) -> u a
projectFst (V u a
as v b
_) = u a
as
{-# INLINE projectFst #-}
projectSnd :: Vector u v (a, b) -> v b
projectSnd :: forall (u :: * -> *) (v :: * -> *) a b. Vector u v (a, b) -> v b
projectSnd (V u a
_ v b
bs) = v b
bs
{-# INLINE projectSnd #-}
unsafeZip :: u a -> v b -> Vector u v (a, b)
unsafeZip :: forall (u :: * -> *) a (v :: * -> *) b.
u a -> v b -> Vector u v (a, b)
unsafeZip = forall (u :: * -> *) a (v :: * -> *) b.
u a -> v b -> Vector u v (a, b)
V
{-# INLINE unsafeZip #-}
toList :: (G.Vector u a, G.Vector v b) => Vector u v (a, b) -> [(a, b)]
toList :: forall (u :: * -> *) a (v :: * -> *) b.
(Vector u a, Vector v b) =>
Vector u v (a, b) -> [(a, b)]
toList = forall (v :: * -> *) a. Vector v a => v a -> [a]
G.toList
{-# INLINE toList #-}
fromList :: (G.Vector u a, G.Vector v b) => [(a, b)] -> Vector u v (a, b)
fromList :: forall (u :: * -> *) a (v :: * -> *) b.
(Vector u a, Vector v b) =>
[(a, b)] -> Vector u v (a, b)
fromList = forall (v :: * -> *) a. Vector v a => [a] -> v a
G.fromList
{-# INLINE fromList #-}
fromListN :: (G.Vector u a, G.Vector v b) => Int -> [(a, b)] -> Vector u v (a, b)
fromListN :: forall (u :: * -> *) a (v :: * -> *) b.
(Vector u a, Vector v b) =>
Int -> [(a, b)] -> Vector u v (a, b)
fromListN = forall (v :: * -> *) a. Vector v a => Int -> [a] -> v a
G.fromListN
{-# INLINE fromListN #-}
unsafeFreeze :: (G.Vector u a, G.Vector v b, PrimMonad m) => G.Mutable (Vector u v) (PrimState m) (a, b) -> m (Vector u v (a, b))
unsafeFreeze :: forall (u :: * -> *) a (v :: * -> *) b (m :: * -> *).
(Vector u a, Vector v b, PrimMonad m) =>
Mutable (Vector u v) (PrimState m) (a, b) -> m (Vector u v (a, b))
unsafeFreeze = forall (m :: * -> *) (v :: * -> *) a.
(PrimMonad m, Vector v a) =>
Mutable v (PrimState m) a -> m (v a)
G.unsafeFreeze
{-# INLINE unsafeFreeze #-}
unsafeThaw :: (G.Vector u a, G.Vector v b, PrimMonad m) => Vector u v (a, b) -> m (G.Mutable (Vector u v) (PrimState m) (a, b))
unsafeThaw :: forall (u :: * -> *) a (v :: * -> *) b (m :: * -> *).
(Vector u a, Vector v b, PrimMonad m) =>
Vector u v (a, b) -> m (Mutable (Vector u v) (PrimState m) (a, b))
unsafeThaw = forall (m :: * -> *) (v :: * -> *) a.
(PrimMonad m, Vector v a) =>
v a -> m (Mutable v (PrimState m) a)
G.unsafeThaw
{-# INLINE unsafeThaw #-}
thaw :: (G.Vector u a, G.Vector v b, PrimMonad m) => Vector u v (a, b) -> m (G.Mutable (Vector u v) (PrimState m) (a, b))
thaw :: forall (u :: * -> *) a (v :: * -> *) b (m :: * -> *).
(Vector u a, Vector v b, PrimMonad m) =>
Vector u v (a, b) -> m (Mutable (Vector u v) (PrimState m) (a, b))
thaw = forall (m :: * -> *) (v :: * -> *) a.
(PrimMonad m, Vector v a) =>
v a -> m (Mutable v (PrimState m) a)
G.thaw
{-# INLINE thaw #-}
freeze :: (G.Vector u a, G.Vector v b, PrimMonad m) => G.Mutable (Vector u v) (PrimState m) (a, b) -> m (Vector u v (a, b))
freeze :: forall (u :: * -> *) a (v :: * -> *) b (m :: * -> *).
(Vector u a, Vector v b, PrimMonad m) =>
Mutable (Vector u v) (PrimState m) (a, b) -> m (Vector u v (a, b))
freeze = forall (m :: * -> *) (v :: * -> *) a.
(PrimMonad m, Vector v a) =>
Mutable v (PrimState m) a -> m (v a)
G.freeze
{-# INLINE freeze #-}
unsafeCopy
:: (G.Vector u a, G.Vector v b, PrimMonad m) => G.Mutable (Vector u v) (PrimState m) (a, b) -> Vector u v (a, b) -> m ()
unsafeCopy :: forall (u :: * -> *) a (v :: * -> *) b (m :: * -> *).
(Vector u a, Vector v b, PrimMonad m) =>
Mutable (Vector u v) (PrimState m) (a, b)
-> Vector u v (a, b) -> m ()
unsafeCopy = forall (m :: * -> *) (v :: * -> *) a.
(PrimMonad m, Vector v a) =>
Mutable v (PrimState m) a -> v a -> m ()
G.unsafeCopy
{-# INLINE unsafeCopy #-}
copy :: (G.Vector u a, G.Vector v b, PrimMonad m) => G.Mutable (Vector u v) (PrimState m) (a, b) -> Vector u v (a, b) -> m ()
copy :: forall (u :: * -> *) a (v :: * -> *) b (m :: * -> *).
(Vector u a, Vector v b, PrimMonad m) =>
Mutable (Vector u v) (PrimState m) (a, b)
-> Vector u v (a, b) -> m ()
copy = forall (m :: * -> *) (v :: * -> *) a.
(HasCallStack, PrimMonad m, Vector v a) =>
Mutable v (PrimState m) a -> v a -> m ()
G.copy
{-# INLINE copy #-}