{-# LANGUAGE BangPatterns, GeneralizedNewtypeDeriving, MultiParamTypeClasses,
             TypeFamilies #-}
{-# LANGUAGE CPP #-}
#if __GLASGOW_HASKELL__ >= 908
{-# OPTIONS_GHC -Wno-x-partial #-}
#endif

module Data.SearchEngine.TermBag (
    TermId(TermId), TermCount,
    TermBag,
    size,
    fromList,
    toList,
    elems,
    termCount,
    denseTable,
    invariant
  ) where

import qualified Data.Vector.Unboxed         as Vec
import qualified Data.Vector.Unboxed.Mutable as MVec
import qualified Data.Vector.Generic         as GVec
import qualified Data.Vector.Generic.Mutable as GMVec
import Control.Monad.ST
import Control.Monad (liftM)
import qualified Data.Map as Map
import Data.Word (Word32, Word8)
import Data.Bits
import qualified Data.List as List
import Data.Function (on)

newtype TermId = TermId { TermId -> TermIdAndCount
unTermId :: Word32 }
  deriving (TermId -> TermId -> Bool
(TermId -> TermId -> Bool)
-> (TermId -> TermId -> Bool) -> Eq TermId
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
$c== :: TermId -> TermId -> Bool
== :: TermId -> TermId -> Bool
$c/= :: TermId -> TermId -> Bool
/= :: TermId -> TermId -> Bool
Eq, Eq TermId
Eq TermId =>
(TermId -> TermId -> Ordering)
-> (TermId -> TermId -> Bool)
-> (TermId -> TermId -> Bool)
-> (TermId -> TermId -> Bool)
-> (TermId -> TermId -> Bool)
-> (TermId -> TermId -> TermId)
-> (TermId -> TermId -> TermId)
-> Ord TermId
TermId -> TermId -> Bool
TermId -> TermId -> Ordering
TermId -> TermId -> TermId
forall a.
Eq a =>
(a -> a -> Ordering)
-> (a -> a -> Bool)
-> (a -> a -> Bool)
-> (a -> a -> Bool)
-> (a -> a -> Bool)
-> (a -> a -> a)
-> (a -> a -> a)
-> Ord a
$ccompare :: TermId -> TermId -> Ordering
compare :: TermId -> TermId -> Ordering
$c< :: TermId -> TermId -> Bool
< :: TermId -> TermId -> Bool
$c<= :: TermId -> TermId -> Bool
<= :: TermId -> TermId -> Bool
$c> :: TermId -> TermId -> Bool
> :: TermId -> TermId -> Bool
$c>= :: TermId -> TermId -> Bool
>= :: TermId -> TermId -> Bool
$cmax :: TermId -> TermId -> TermId
max :: TermId -> TermId -> TermId
$cmin :: TermId -> TermId -> TermId
min :: TermId -> TermId -> TermId
Ord, Int -> TermId -> ShowS
[TermId] -> ShowS
TermId -> String
(Int -> TermId -> ShowS)
-> (TermId -> String) -> ([TermId] -> ShowS) -> Show TermId
forall a.
(Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
$cshowsPrec :: Int -> TermId -> ShowS
showsPrec :: Int -> TermId -> ShowS
$cshow :: TermId -> String
show :: TermId -> String
$cshowList :: [TermId] -> ShowS
showList :: [TermId] -> ShowS
Show, Int -> TermId
TermId -> Int
TermId -> [TermId]
TermId -> TermId
TermId -> TermId -> [TermId]
TermId -> TermId -> TermId -> [TermId]
(TermId -> TermId)
-> (TermId -> TermId)
-> (Int -> TermId)
-> (TermId -> Int)
-> (TermId -> [TermId])
-> (TermId -> TermId -> [TermId])
-> (TermId -> TermId -> [TermId])
-> (TermId -> TermId -> TermId -> [TermId])
-> Enum TermId
forall a.
(a -> a)
-> (a -> a)
-> (Int -> a)
-> (a -> Int)
-> (a -> [a])
-> (a -> a -> [a])
-> (a -> a -> [a])
-> (a -> a -> a -> [a])
-> Enum a
$csucc :: TermId -> TermId
succ :: TermId -> TermId
$cpred :: TermId -> TermId
pred :: TermId -> TermId
$ctoEnum :: Int -> TermId
toEnum :: Int -> TermId
$cfromEnum :: TermId -> Int
fromEnum :: TermId -> Int
$cenumFrom :: TermId -> [TermId]
enumFrom :: TermId -> [TermId]
$cenumFromThen :: TermId -> TermId -> [TermId]
enumFromThen :: TermId -> TermId -> [TermId]
$cenumFromTo :: TermId -> TermId -> [TermId]
enumFromTo :: TermId -> TermId -> [TermId]
$cenumFromThenTo :: TermId -> TermId -> TermId -> [TermId]
enumFromThenTo :: TermId -> TermId -> TermId -> [TermId]
Enum)

instance Bounded TermId where
  minBound :: TermId
minBound = TermIdAndCount -> TermId
TermId TermIdAndCount
0
  maxBound :: TermId
maxBound = TermIdAndCount -> TermId
TermId TermIdAndCount
0x00FFFFFF

data TermBag = TermBag !Int !(Vec.Vector TermIdAndCount)
  deriving Int -> TermBag -> ShowS
[TermBag] -> ShowS
TermBag -> String
(Int -> TermBag -> ShowS)
-> (TermBag -> String) -> ([TermBag] -> ShowS) -> Show TermBag
forall a.
(Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
$cshowsPrec :: Int -> TermBag -> ShowS
showsPrec :: Int -> TermBag -> ShowS
$cshow :: TermBag -> String
show :: TermBag -> String
$cshowList :: [TermBag] -> ShowS
showList :: [TermBag] -> ShowS
Show

-- We sneakily stuff both the TermId and the bag count into one 32bit word
type TermIdAndCount = Word32
type TermCount      = Word8

-- Bottom 24 bits is the TermId, top 8 bits is the bag count
termIdAndCount :: TermId -> Int -> TermIdAndCount
termIdAndCount :: TermId -> Int -> TermIdAndCount
termIdAndCount (TermId TermIdAndCount
termid) Int
freq =
      (TermIdAndCount -> TermIdAndCount -> TermIdAndCount
forall a. Ord a => a -> a -> a
min (Int -> TermIdAndCount
forall a b. (Integral a, Num b) => a -> b
fromIntegral Int
freq) TermIdAndCount
255 TermIdAndCount -> Int -> TermIdAndCount
forall a. Bits a => a -> Int -> a
`shiftL` Int
24)
  TermIdAndCount -> TermIdAndCount -> TermIdAndCount
forall a. Bits a => a -> a -> a
.|. (TermIdAndCount
termid TermIdAndCount -> TermIdAndCount -> TermIdAndCount
forall a. Bits a => a -> a -> a
.&. TermIdAndCount
0x00FFFFFF)

getTermId :: TermIdAndCount -> TermId
getTermId :: TermIdAndCount -> TermId
getTermId TermIdAndCount
word = TermIdAndCount -> TermId
TermId (TermIdAndCount
word TermIdAndCount -> TermIdAndCount -> TermIdAndCount
forall a. Bits a => a -> a -> a
.&. TermIdAndCount
0x00FFFFFF)

getTermCount :: TermIdAndCount -> TermCount
getTermCount :: TermIdAndCount -> TermCount
getTermCount TermIdAndCount
word = TermIdAndCount -> TermCount
forall a b. (Integral a, Num b) => a -> b
fromIntegral (TermIdAndCount
word TermIdAndCount -> Int -> TermIdAndCount
forall a. Bits a => a -> Int -> a
`shiftR` Int
24)

invariant :: TermBag -> Bool
invariant :: TermBag -> Bool
invariant (TermBag Int
_ Vector TermIdAndCount
vec) =
    [TermIdAndCount] -> Bool
strictlyAscending (Vector TermIdAndCount -> [TermIdAndCount]
forall a. Unbox a => Vector a -> [a]
Vec.toList Vector TermIdAndCount
vec)
  where
    strictlyAscending :: [TermIdAndCount] -> Bool
strictlyAscending (TermIdAndCount
a:xs :: [TermIdAndCount]
xs@(TermIdAndCount
b:[TermIdAndCount]
_)) = TermIdAndCount -> TermId
getTermId TermIdAndCount
a TermId -> TermId -> Bool
forall a. Ord a => a -> a -> Bool
< TermIdAndCount -> TermId
getTermId TermIdAndCount
b
                                  Bool -> Bool -> Bool
&& [TermIdAndCount] -> Bool
strictlyAscending [TermIdAndCount]
xs
    strictlyAscending [TermIdAndCount]
_  = Bool
True

size :: TermBag -> Int
size :: TermBag -> Int
size (TermBag Int
sz Vector TermIdAndCount
_) = Int
sz

elems :: TermBag -> [TermId]
elems :: TermBag -> [TermId]
elems (TermBag Int
_ Vector TermIdAndCount
vec) = (TermIdAndCount -> TermId) -> [TermIdAndCount] -> [TermId]
forall a b. (a -> b) -> [a] -> [b]
map TermIdAndCount -> TermId
getTermId (Vector TermIdAndCount -> [TermIdAndCount]
forall a. Unbox a => Vector a -> [a]
Vec.toList Vector TermIdAndCount
vec)

toList :: TermBag -> [(TermId, TermCount)]
toList :: TermBag -> [(TermId, TermCount)]
toList (TermBag Int
_ Vector TermIdAndCount
vec) = [ (TermIdAndCount -> TermId
getTermId TermIdAndCount
x, TermIdAndCount -> TermCount
getTermCount TermIdAndCount
x)
                         | TermIdAndCount
x <- Vector TermIdAndCount -> [TermIdAndCount]
forall a. Unbox a => Vector a -> [a]
Vec.toList Vector TermIdAndCount
vec ]

termCount :: TermBag -> TermId -> TermCount
termCount :: TermBag -> TermId -> TermCount
termCount (TermBag Int
_ Vector TermIdAndCount
vec) =
    Int -> Int -> TermId -> TermCount
binarySearch Int
0 (Vector TermIdAndCount -> Int
forall a. Unbox a => Vector a -> Int
Vec.length Vector TermIdAndCount
vec Int -> Int -> Int
forall a. Num a => a -> a -> a
- Int
1)
  where
    binarySearch :: Int -> Int -> TermId -> TermCount
    binarySearch :: Int -> Int -> TermId -> TermCount
binarySearch !Int
a !Int
b !TermId
key
      | Int
a Int -> Int -> Bool
forall a. Ord a => a -> a -> Bool
> Int
b     = TermCount
0
      | Bool
otherwise =
        let mid :: Int
mid         = (Int
a Int -> Int -> Int
forall a. Num a => a -> a -> a
+ Int
b) Int -> Int -> Int
forall a. Integral a => a -> a -> a
`div` Int
2
            tidAndCount :: TermIdAndCount
tidAndCount = Vector TermIdAndCount
vec Vector TermIdAndCount -> Int -> TermIdAndCount
forall a. Unbox a => Vector a -> Int -> a
Vec.! Int
mid
         in case TermId -> TermId -> Ordering
forall a. Ord a => a -> a -> Ordering
compare TermId
key (TermIdAndCount -> TermId
getTermId TermIdAndCount
tidAndCount) of
              Ordering
LT -> Int -> Int -> TermId -> TermCount
binarySearch Int
a (Int
midInt -> Int -> Int
forall a. Num a => a -> a -> a
-Int
1) TermId
key
              Ordering
EQ -> TermIdAndCount -> TermCount
getTermCount TermIdAndCount
tidAndCount
              Ordering
GT -> Int -> Int -> TermId -> TermCount
binarySearch (Int
midInt -> Int -> Int
forall a. Num a => a -> a -> a
+Int
1) Int
b TermId
key

fromList :: [TermId] -> TermBag
fromList :: [TermId] -> TermBag
fromList [TermId]
termids =
    let bag :: Map TermId Int
bag = (Int -> Int -> Int) -> [(TermId, Int)] -> Map TermId Int
forall k a. Ord k => (a -> a -> a) -> [(k, a)] -> Map k a
Map.fromListWith Int -> Int -> Int
forall a. Num a => a -> a -> a
(+) [ (TermId
t, Int
1) | TermId
t <- [TermId]
termids ]
        sz :: Int
sz  = (Int -> Int -> Int) -> Int -> Map TermId Int -> Int
forall a b k. (a -> b -> a) -> a -> Map k b -> a
Map.foldl' Int -> Int -> Int
forall a. Num a => a -> a -> a
(+) Int
0 Map TermId Int
bag
        vec :: Vector TermIdAndCount
vec = Int -> [TermIdAndCount] -> Vector TermIdAndCount
forall a. Unbox a => Int -> [a] -> Vector a
Vec.fromListN (Map TermId Int -> Int
forall k a. Map k a -> Int
Map.size Map TermId Int
bag)
                            [ TermId -> Int -> TermIdAndCount
termIdAndCount TermId
termid Int
freq
                            | (TermId
termid, Int
freq) <- Map TermId Int -> [(TermId, Int)]
forall k a. Map k a -> [(k, a)]
Map.toAscList Map TermId Int
bag ]
     in Int -> Vector TermIdAndCount -> TermBag
TermBag Int
sz Vector TermIdAndCount
vec

-- | Given a bunch of term bags, merge them into a table for easier subsequent
-- processing. This is bascially a sparse to dense conversion. Missing entries
-- are filled in with 0. We represent the table as one vector for the
-- term ids and a 2d array for the counts.
--
-- Unfortunately vector does not directly support 2d arrays and array does
-- not make it easy to trim arrays.
--
denseTable :: [TermBag] -> (Vec.Vector TermId, Vec.Vector TermCount)
denseTable :: [TermBag] -> (Vector TermId, Vector TermCount)
denseTable [TermBag]
termbags =
    (Vector TermId
tids, Vector TermCount
tcts)
  where
    -- First merge the TermIds into one array
    -- then make a linear pass to create the counts array
    -- filling in 0s or the counts as we find them
    !numBags :: Int
numBags   = [TermBag] -> Int
forall a. [a] -> Int
forall (t :: * -> *) a. Foldable t => t a -> Int
length [TermBag]
termbags
    !tids :: Vector TermId
tids      = [TermBag] -> Vector TermId
unionsTermId [TermBag]
termbags
    !numTerms :: Int
numTerms  = Vector TermId -> Int
forall a. Unbox a => Vector a -> Int
Vec.length Vector TermId
tids
    !numCounts :: Int
numCounts = Int
numTerms Int -> Int -> Int
forall a. Num a => a -> a -> a
* Int
numBags
    !tcts :: Vector TermCount
tcts      = (forall s. ST s (MVector s TermCount)) -> Vector TermCount
forall a. Unbox a => (forall s. ST s (MVector s a)) -> Vector a
Vec.create (do
                   MVector s TermCount
out <- Int -> ST s (MVector (PrimState (ST s)) TermCount)
forall (m :: * -> *) a.
(PrimMonad m, Unbox a) =>
Int -> m (MVector (PrimState m) a)
MVec.new Int
numCounts
                   [ST s ()] -> ST s ()
forall (t :: * -> *) (m :: * -> *) a.
(Foldable t, Monad m) =>
t (m a) -> m ()
sequence_
                     [ Vector TermId
-> Vector TermIdAndCount -> MVector s TermCount -> Int -> ST s ()
forall s.
Vector TermId
-> Vector TermIdAndCount -> MVector s TermCount -> Int -> ST s ()
writeMergedTermCounts Vector TermId
tids Vector TermIdAndCount
bag MVector s TermCount
out Int
i
                     | (Int
n, TermBag Int
_ Vector TermIdAndCount
bag) <- [Int] -> [TermBag] -> [(Int, TermBag)]
forall a b. [a] -> [b] -> [(a, b)]
zip [Int
0..] [TermBag]
termbags
                     , let i :: Int
i = Int
n Int -> Int -> Int
forall a. Num a => a -> a -> a
* Int
numTerms ]
                   MVector s TermCount -> ST s (MVector s TermCount)
forall a. a -> ST s a
forall (m :: * -> *) a. Monad m => a -> m a
return MVector s TermCount
out
                 )

writeMergedTermCounts :: Vec.Vector TermId -> Vec.Vector TermIdAndCount ->
                         MVec.MVector s TermCount -> Int -> ST s ()
writeMergedTermCounts :: forall s.
Vector TermId
-> Vector TermIdAndCount -> MVector s TermCount -> Int -> ST s ()
writeMergedTermCounts Vector TermId
xs0 Vector TermIdAndCount
ys0 !MVector s TermCount
out Int
i0 =
    -- assume xs & ys are sorted, and ys contains a subset of xs
    Vector TermId -> Vector TermIdAndCount -> Int -> ST s ()
go Vector TermId
xs0 Vector TermIdAndCount
ys0 Int
i0
  where
    go :: Vector TermId -> Vector TermIdAndCount -> Int -> ST s ()
go !Vector TermId
xs !Vector TermIdAndCount
ys !Int
i
      | Vector TermIdAndCount -> Bool
forall a. Unbox a => Vector a -> Bool
Vec.null Vector TermIdAndCount
ys = MVector (PrimState (ST s)) TermCount -> TermCount -> ST s ()
forall (m :: * -> *) a.
(PrimMonad m, Unbox a) =>
MVector (PrimState m) a -> a -> m ()
MVec.set (Int -> Int -> MVector s TermCount -> MVector s TermCount
forall a s. Unbox a => Int -> Int -> MVector s a -> MVector s a
MVec.slice Int
i (Vector TermId -> Int
forall a. Unbox a => Vector a -> Int
Vec.length Vector TermId
xs) MVector s TermCount
out) TermCount
0
      | Vector TermId -> Bool
forall a. Unbox a => Vector a -> Bool
Vec.null Vector TermId
xs = () -> ST s ()
forall a. a -> ST s a
forall (m :: * -> *) a. Monad m => a -> m a
return ()
      | Bool
otherwise   = let x :: TermId
x   = Vector TermId -> TermId
forall a. Unbox a => Vector a -> a
Vec.head Vector TermId
xs
                          ytc :: TermIdAndCount
ytc = Vector TermIdAndCount -> TermIdAndCount
forall a. Unbox a => Vector a -> a
Vec.head Vector TermIdAndCount
ys
                          y :: TermId
y   = TermIdAndCount -> TermId
getTermId TermIdAndCount
ytc
                          c :: TermCount
c   = TermIdAndCount -> TermCount
getTermCount TermIdAndCount
ytc
                      in case TermId
x TermId -> TermId -> Bool
forall a. Eq a => a -> a -> Bool
== TermId
y of
                           Bool
True  -> do MVector (PrimState (ST s)) TermCount -> Int -> TermCount -> ST s ()
forall (m :: * -> *) a.
(PrimMonad m, Unbox a) =>
MVector (PrimState m) a -> Int -> a -> m ()
MVec.write MVector s TermCount
MVector (PrimState (ST s)) TermCount
out Int
i TermCount
c
                                       Vector TermId -> Vector TermIdAndCount -> Int -> ST s ()
go (Vector TermId -> Vector TermId
forall a. Unbox a => Vector a -> Vector a
Vec.tail Vector TermId
xs) (Vector TermIdAndCount -> Vector TermIdAndCount
forall a. Unbox a => Vector a -> Vector a
Vec.tail Vector TermIdAndCount
ys) (Int
iInt -> Int -> Int
forall a. Num a => a -> a -> a
+Int
1)
                           Bool
False -> do MVector (PrimState (ST s)) TermCount -> Int -> TermCount -> ST s ()
forall (m :: * -> *) a.
(PrimMonad m, Unbox a) =>
MVector (PrimState m) a -> Int -> a -> m ()
MVec.write MVector s TermCount
MVector (PrimState (ST s)) TermCount
out Int
i TermCount
0
                                       Vector TermId -> Vector TermIdAndCount -> Int -> ST s ()
go (Vector TermId -> Vector TermId
forall a. Unbox a => Vector a -> Vector a
Vec.tail Vector TermId
xs)           Vector TermIdAndCount
ys  (Int
iInt -> Int -> Int
forall a. Num a => a -> a -> a
+Int
1)

-- | Given a set of term bags, form the set of TermIds
--
unionsTermId :: [TermBag] -> Vec.Vector TermId
unionsTermId :: [TermBag] -> Vector TermId
unionsTermId [TermBag]
tbs =
    case (TermBag -> TermBag -> Ordering) -> [TermBag] -> [TermBag]
forall a. (a -> a -> Ordering) -> [a] -> [a]
List.sortBy (Int -> Int -> Ordering
forall a. Ord a => a -> a -> Ordering
compare (Int -> Int -> Ordering)
-> (TermBag -> Int) -> TermBag -> TermBag -> Ordering
forall b c a. (b -> b -> c) -> (a -> b) -> a -> a -> c
`on` TermBag -> Int
bagVecLength) [TermBag]
tbs of
      []             -> Vector TermId
forall a. Unbox a => Vector a
Vec.empty
      [TermBag Int
_ Vector TermIdAndCount
xs] -> ((TermIdAndCount -> TermId)
-> Vector TermIdAndCount -> Vector TermId
forall a b. (Unbox a, Unbox b) => (a -> b) -> Vector a -> Vector b
Vec.map TermIdAndCount -> TermId
getTermId Vector TermIdAndCount
xs)
      (TermBag
x0:TermBag
x1:[TermBag]
xs)     -> (Vector TermId -> TermBag -> Vector TermId)
-> Vector TermId -> [TermBag] -> Vector TermId
forall b a. (b -> a -> b) -> b -> [a] -> b
forall (t :: * -> *) b a.
Foldable t =>
(b -> a -> b) -> b -> t a -> b
List.foldl' Vector TermId -> TermBag -> Vector TermId
union3 (TermBag -> TermBag -> Vector TermId
union2 TermBag
x0 TermBag
x1) [TermBag]
xs
  where
    bagVecLength :: TermBag -> Int
bagVecLength (TermBag Int
_ Vector TermIdAndCount
vec) = Vector TermIdAndCount -> Int
forall a. Unbox a => Vector a -> Int
Vec.length Vector TermIdAndCount
vec

union2 :: TermBag -> TermBag -> Vec.Vector TermId
union2 :: TermBag -> TermBag -> Vector TermId
union2 (TermBag Int
_ Vector TermIdAndCount
xs) (TermBag Int
_ Vector TermIdAndCount
ys) =
    (forall s. ST s (MVector s TermId)) -> Vector TermId
forall a. Unbox a => (forall s. ST s (MVector s a)) -> Vector a
Vec.create (Int -> ST s (MVector (PrimState (ST s)) TermId)
forall (m :: * -> *) a.
(PrimMonad m, Unbox a) =>
Int -> m (MVector (PrimState m) a)
MVec.new Int
sizeBound ST s (MVector s TermId)
-> (MVector s TermId -> ST s (MVector s TermId))
-> ST s (MVector s TermId)
forall a b. ST s a -> (a -> ST s b) -> ST s b
forall (m :: * -> *) a b. Monad m => m a -> (a -> m b) -> m b
>>= Vector TermIdAndCount
-> Vector TermIdAndCount
-> MVector s TermId
-> ST s (MVector s TermId)
forall s.
Vector TermIdAndCount
-> Vector TermIdAndCount
-> MVector s TermId
-> ST s (MVector s TermId)
writeMergedUnion2 Vector TermIdAndCount
xs Vector TermIdAndCount
ys)
  where
    sizeBound :: Int
sizeBound = Vector TermIdAndCount -> Int
forall a. Unbox a => Vector a -> Int
Vec.length Vector TermIdAndCount
xs Int -> Int -> Int
forall a. Num a => a -> a -> a
+ Vector TermIdAndCount -> Int
forall a. Unbox a => Vector a -> Int
Vec.length Vector TermIdAndCount
ys

writeMergedUnion2 :: Vec.Vector TermIdAndCount -> Vec.Vector TermIdAndCount ->
                     MVec.MVector s TermId -> ST s (MVec.MVector s TermId)
writeMergedUnion2 :: forall s.
Vector TermIdAndCount
-> Vector TermIdAndCount
-> MVector s TermId
-> ST s (MVector s TermId)
writeMergedUnion2 Vector TermIdAndCount
xs0 Vector TermIdAndCount
ys0 !MVector s TermId
out = do
    Int
i <- Vector TermIdAndCount -> Vector TermIdAndCount -> Int -> ST s Int
go Vector TermIdAndCount
xs0 Vector TermIdAndCount
ys0 Int
0
    MVector s TermId -> ST s (MVector s TermId)
forall a. a -> ST s a
forall (m :: * -> *) a. Monad m => a -> m a
return (MVector s TermId -> ST s (MVector s TermId))
-> MVector s TermId -> ST s (MVector s TermId)
forall a b. (a -> b) -> a -> b
$! Int -> MVector s TermId -> MVector s TermId
forall a s. Unbox a => Int -> MVector s a -> MVector s a
MVec.take Int
i MVector s TermId
out
  where
    go :: Vector TermIdAndCount -> Vector TermIdAndCount -> Int -> ST s Int
go !Vector TermIdAndCount
xs !Vector TermIdAndCount
ys !Int
i
      | Vector TermIdAndCount -> Bool
forall a. Unbox a => Vector a -> Bool
Vec.null Vector TermIdAndCount
xs = do MVector (PrimState (ST s)) TermId -> Vector TermId -> ST s ()
forall a (m :: * -> *).
(Unbox a, PrimMonad m) =>
MVector (PrimState m) a -> Vector a -> m ()
Vec.copy (Int -> Int -> MVector s TermId -> MVector s TermId
forall a s. Unbox a => Int -> Int -> MVector s a -> MVector s a
MVec.slice Int
i (Vector TermIdAndCount -> Int
forall a. Unbox a => Vector a -> Int
Vec.length Vector TermIdAndCount
ys) MVector s TermId
out)
                                  ((TermIdAndCount -> TermId)
-> Vector TermIdAndCount -> Vector TermId
forall a b. (Unbox a, Unbox b) => (a -> b) -> Vector a -> Vector b
Vec.map TermIdAndCount -> TermId
getTermId Vector TermIdAndCount
ys)
                         Int -> ST s Int
forall a. a -> ST s a
forall (m :: * -> *) a. Monad m => a -> m a
return (Int
i Int -> Int -> Int
forall a. Num a => a -> a -> a
+ Vector TermIdAndCount -> Int
forall a. Unbox a => Vector a -> Int
Vec.length Vector TermIdAndCount
ys)
      | Vector TermIdAndCount -> Bool
forall a. Unbox a => Vector a -> Bool
Vec.null Vector TermIdAndCount
ys = do MVector (PrimState (ST s)) TermId -> Vector TermId -> ST s ()
forall a (m :: * -> *).
(Unbox a, PrimMonad m) =>
MVector (PrimState m) a -> Vector a -> m ()
Vec.copy (Int -> Int -> MVector s TermId -> MVector s TermId
forall a s. Unbox a => Int -> Int -> MVector s a -> MVector s a
MVec.slice Int
i (Vector TermIdAndCount -> Int
forall a. Unbox a => Vector a -> Int
Vec.length Vector TermIdAndCount
xs) MVector s TermId
out)
                                  ((TermIdAndCount -> TermId)
-> Vector TermIdAndCount -> Vector TermId
forall a b. (Unbox a, Unbox b) => (a -> b) -> Vector a -> Vector b
Vec.map TermIdAndCount -> TermId
getTermId Vector TermIdAndCount
xs)
                         Int -> ST s Int
forall a. a -> ST s a
forall (m :: * -> *) a. Monad m => a -> m a
return (Int
i Int -> Int -> Int
forall a. Num a => a -> a -> a
+ Vector TermIdAndCount -> Int
forall a. Unbox a => Vector a -> Int
Vec.length Vector TermIdAndCount
xs)
      | Bool
otherwise   = let x :: TermId
x = TermIdAndCount -> TermId
getTermId (Vector TermIdAndCount -> TermIdAndCount
forall a. Unbox a => Vector a -> a
Vec.head Vector TermIdAndCount
xs)
                          y :: TermId
y = TermIdAndCount -> TermId
getTermId (Vector TermIdAndCount -> TermIdAndCount
forall a. Unbox a => Vector a -> a
Vec.head Vector TermIdAndCount
ys)
                      in case TermId -> TermId -> Ordering
forall a. Ord a => a -> a -> Ordering
compare TermId
x TermId
y of
                          Ordering
GT -> do MVector (PrimState (ST s)) TermId -> Int -> TermId -> ST s ()
forall (m :: * -> *) a.
(PrimMonad m, Unbox a) =>
MVector (PrimState m) a -> Int -> a -> m ()
MVec.write MVector s TermId
MVector (PrimState (ST s)) TermId
out Int
i TermId
y
                                   Vector TermIdAndCount -> Vector TermIdAndCount -> Int -> ST s Int
go           Vector TermIdAndCount
xs  (Vector TermIdAndCount -> Vector TermIdAndCount
forall a. Unbox a => Vector a -> Vector a
Vec.tail Vector TermIdAndCount
ys) (Int
iInt -> Int -> Int
forall a. Num a => a -> a -> a
+Int
1)
                          Ordering
EQ -> do MVector (PrimState (ST s)) TermId -> Int -> TermId -> ST s ()
forall (m :: * -> *) a.
(PrimMonad m, Unbox a) =>
MVector (PrimState m) a -> Int -> a -> m ()
MVec.write MVector s TermId
MVector (PrimState (ST s)) TermId
out Int
i TermId
x
                                   Vector TermIdAndCount -> Vector TermIdAndCount -> Int -> ST s Int
go (Vector TermIdAndCount -> Vector TermIdAndCount
forall a. Unbox a => Vector a -> Vector a
Vec.tail Vector TermIdAndCount
xs) (Vector TermIdAndCount -> Vector TermIdAndCount
forall a. Unbox a => Vector a -> Vector a
Vec.tail Vector TermIdAndCount
ys) (Int
iInt -> Int -> Int
forall a. Num a => a -> a -> a
+Int
1)
                          Ordering
LT -> do MVector (PrimState (ST s)) TermId -> Int -> TermId -> ST s ()
forall (m :: * -> *) a.
(PrimMonad m, Unbox a) =>
MVector (PrimState m) a -> Int -> a -> m ()
MVec.write MVector s TermId
MVector (PrimState (ST s)) TermId
out Int
i TermId
x
                                   Vector TermIdAndCount -> Vector TermIdAndCount -> Int -> ST s Int
go (Vector TermIdAndCount -> Vector TermIdAndCount
forall a. Unbox a => Vector a -> Vector a
Vec.tail Vector TermIdAndCount
xs)           Vector TermIdAndCount
ys  (Int
iInt -> Int -> Int
forall a. Num a => a -> a -> a
+Int
1)

union3 :: Vec.Vector TermId -> TermBag -> Vec.Vector TermId
union3 :: Vector TermId -> TermBag -> Vector TermId
union3 Vector TermId
xs (TermBag Int
_ Vector TermIdAndCount
ys) =
    (forall s. ST s (MVector s TermId)) -> Vector TermId
forall a. Unbox a => (forall s. ST s (MVector s a)) -> Vector a
Vec.create (Int -> ST s (MVector (PrimState (ST s)) TermId)
forall (m :: * -> *) a.
(PrimMonad m, Unbox a) =>
Int -> m (MVector (PrimState m) a)
MVec.new Int
sizeBound ST s (MVector s TermId)
-> (MVector s TermId -> ST s (MVector s TermId))
-> ST s (MVector s TermId)
forall a b. ST s a -> (a -> ST s b) -> ST s b
forall (m :: * -> *) a b. Monad m => m a -> (a -> m b) -> m b
>>= Vector TermId
-> Vector TermIdAndCount
-> MVector s TermId
-> ST s (MVector s TermId)
forall s.
Vector TermId
-> Vector TermIdAndCount
-> MVector s TermId
-> ST s (MVector s TermId)
writeMergedUnion3 Vector TermId
xs Vector TermIdAndCount
ys)
  where
    sizeBound :: Int
sizeBound = Vector TermId -> Int
forall a. Unbox a => Vector a -> Int
Vec.length Vector TermId
xs Int -> Int -> Int
forall a. Num a => a -> a -> a
+ Vector TermIdAndCount -> Int
forall a. Unbox a => Vector a -> Int
Vec.length Vector TermIdAndCount
ys

writeMergedUnion3 :: Vec.Vector TermId -> Vec.Vector TermIdAndCount ->
                     MVec.MVector s TermId -> ST s (MVec.MVector s TermId)
writeMergedUnion3 :: forall s.
Vector TermId
-> Vector TermIdAndCount
-> MVector s TermId
-> ST s (MVector s TermId)
writeMergedUnion3 Vector TermId
xs0 Vector TermIdAndCount
ys0 !MVector s TermId
out = do
    Int
i <- Vector TermId -> Vector TermIdAndCount -> Int -> ST s Int
go Vector TermId
xs0 Vector TermIdAndCount
ys0 Int
0
    MVector s TermId -> ST s (MVector s TermId)
forall a. a -> ST s a
forall (m :: * -> *) a. Monad m => a -> m a
return (MVector s TermId -> ST s (MVector s TermId))
-> MVector s TermId -> ST s (MVector s TermId)
forall a b. (a -> b) -> a -> b
$! Int -> MVector s TermId -> MVector s TermId
forall a s. Unbox a => Int -> MVector s a -> MVector s a
MVec.take Int
i MVector s TermId
out
  where
    go :: Vector TermId -> Vector TermIdAndCount -> Int -> ST s Int
go !Vector TermId
xs !Vector TermIdAndCount
ys !Int
i
      | Vector TermId -> Bool
forall a. Unbox a => Vector a -> Bool
Vec.null Vector TermId
xs = do MVector (PrimState (ST s)) TermId -> Vector TermId -> ST s ()
forall a (m :: * -> *).
(Unbox a, PrimMonad m) =>
MVector (PrimState m) a -> Vector a -> m ()
Vec.copy (Int -> Int -> MVector s TermId -> MVector s TermId
forall a s. Unbox a => Int -> Int -> MVector s a -> MVector s a
MVec.slice Int
i (Vector TermIdAndCount -> Int
forall a. Unbox a => Vector a -> Int
Vec.length Vector TermIdAndCount
ys) MVector s TermId
out)
                                  ((TermIdAndCount -> TermId)
-> Vector TermIdAndCount -> Vector TermId
forall a b. (Unbox a, Unbox b) => (a -> b) -> Vector a -> Vector b
Vec.map TermIdAndCount -> TermId
getTermId Vector TermIdAndCount
ys)
                         Int -> ST s Int
forall a. a -> ST s a
forall (m :: * -> *) a. Monad m => a -> m a
return (Int
i Int -> Int -> Int
forall a. Num a => a -> a -> a
+ Vector TermIdAndCount -> Int
forall a. Unbox a => Vector a -> Int
Vec.length Vector TermIdAndCount
ys)
      | Vector TermIdAndCount -> Bool
forall a. Unbox a => Vector a -> Bool
Vec.null Vector TermIdAndCount
ys = do MVector (PrimState (ST s)) TermId -> Vector TermId -> ST s ()
forall a (m :: * -> *).
(Unbox a, PrimMonad m) =>
MVector (PrimState m) a -> Vector a -> m ()
Vec.copy (Int -> Int -> MVector s TermId -> MVector s TermId
forall a s. Unbox a => Int -> Int -> MVector s a -> MVector s a
MVec.slice Int
i (Vector TermId -> Int
forall a. Unbox a => Vector a -> Int
Vec.length Vector TermId
xs) MVector s TermId
out) Vector TermId
xs
                         Int -> ST s Int
forall a. a -> ST s a
forall (m :: * -> *) a. Monad m => a -> m a
return (Int
i Int -> Int -> Int
forall a. Num a => a -> a -> a
+ Vector TermId -> Int
forall a. Unbox a => Vector a -> Int
Vec.length Vector TermId
xs)
      | Bool
otherwise   = let x :: TermId
x =            Vector TermId -> TermId
forall a. Unbox a => Vector a -> a
Vec.head Vector TermId
xs
                          y :: TermId
y = TermIdAndCount -> TermId
getTermId (Vector TermIdAndCount -> TermIdAndCount
forall a. Unbox a => Vector a -> a
Vec.head Vector TermIdAndCount
ys)
                      in case TermId -> TermId -> Ordering
forall a. Ord a => a -> a -> Ordering
compare TermId
x TermId
y of
                          Ordering
GT -> do MVector (PrimState (ST s)) TermId -> Int -> TermId -> ST s ()
forall (m :: * -> *) a.
(PrimMonad m, Unbox a) =>
MVector (PrimState m) a -> Int -> a -> m ()
MVec.write MVector s TermId
MVector (PrimState (ST s)) TermId
out Int
i TermId
y
                                   Vector TermId -> Vector TermIdAndCount -> Int -> ST s Int
go           Vector TermId
xs  (Vector TermIdAndCount -> Vector TermIdAndCount
forall a. Unbox a => Vector a -> Vector a
Vec.tail Vector TermIdAndCount
ys) (Int
iInt -> Int -> Int
forall a. Num a => a -> a -> a
+Int
1)
                          Ordering
EQ -> do MVector (PrimState (ST s)) TermId -> Int -> TermId -> ST s ()
forall (m :: * -> *) a.
(PrimMonad m, Unbox a) =>
MVector (PrimState m) a -> Int -> a -> m ()
MVec.write MVector s TermId
MVector (PrimState (ST s)) TermId
out Int
i TermId
x
                                   Vector TermId -> Vector TermIdAndCount -> Int -> ST s Int
go (Vector TermId -> Vector TermId
forall a. Unbox a => Vector a -> Vector a
Vec.tail Vector TermId
xs) (Vector TermIdAndCount -> Vector TermIdAndCount
forall a. Unbox a => Vector a -> Vector a
Vec.tail Vector TermIdAndCount
ys) (Int
iInt -> Int -> Int
forall a. Num a => a -> a -> a
+Int
1)
                          Ordering
LT -> do MVector (PrimState (ST s)) TermId -> Int -> TermId -> ST s ()
forall (m :: * -> *) a.
(PrimMonad m, Unbox a) =>
MVector (PrimState m) a -> Int -> a -> m ()
MVec.write MVector s TermId
MVector (PrimState (ST s)) TermId
out Int
i TermId
x
                                   Vector TermId -> Vector TermIdAndCount -> Int -> ST s Int
go (Vector TermId -> Vector TermId
forall a. Unbox a => Vector a -> Vector a
Vec.tail Vector TermId
xs)           Vector TermIdAndCount
ys  (Int
iInt -> Int -> Int
forall a. Num a => a -> a -> a
+Int
1)

------------------------------------------------------------------------------
-- verbose Unbox instances
--

instance MVec.Unbox TermId

newtype instance MVec.MVector s TermId = MV_TermId (MVec.MVector s Word32)

instance GMVec.MVector MVec.MVector TermId where
    basicLength :: forall s. MVector s TermId -> Int
basicLength          (MV_TermId MVector s TermIdAndCount
v) = MVector s TermIdAndCount -> Int
forall s. MVector s TermIdAndCount -> Int
forall (v :: * -> * -> *) a s. MVector v a => v s a -> Int
GMVec.basicLength MVector s TermIdAndCount
v
    basicUnsafeSlice :: forall s. Int -> Int -> MVector s TermId -> MVector s TermId
basicUnsafeSlice Int
i Int
l (MV_TermId MVector s TermIdAndCount
v) = MVector s TermIdAndCount -> MVector s TermId
forall s. MVector s TermIdAndCount -> MVector s TermId
MV_TermId (Int -> Int -> MVector s TermIdAndCount -> MVector s TermIdAndCount
forall s.
Int -> Int -> MVector s TermIdAndCount -> MVector s TermIdAndCount
forall (v :: * -> * -> *) a s.
MVector v a =>
Int -> Int -> v s a -> v s a
GMVec.basicUnsafeSlice Int
i Int
l MVector s TermIdAndCount
v)
    basicUnsafeNew :: forall s. Int -> ST s (MVector s TermId)
basicUnsafeNew     Int
l               = MVector s TermIdAndCount -> MVector s TermId
forall s. MVector s TermIdAndCount -> MVector s TermId
MV_TermId (MVector s TermIdAndCount -> MVector s TermId)
-> ST s (MVector s TermIdAndCount) -> ST s (MVector s TermId)
forall (m :: * -> *) a1 r. Monad m => (a1 -> r) -> m a1 -> m r
`liftM` Int -> ST s (MVector s TermIdAndCount)
forall s. Int -> ST s (MVector s TermIdAndCount)
forall (v :: * -> * -> *) a s. MVector v a => Int -> ST s (v s a)
GMVec.basicUnsafeNew Int
l
    basicInitialize :: forall s. MVector s TermId -> ST s ()
basicInitialize      (MV_TermId MVector s TermIdAndCount
v) = MVector s TermIdAndCount -> ST s ()
forall s. MVector s TermIdAndCount -> ST s ()
forall (v :: * -> * -> *) a s. MVector v a => v s a -> ST s ()
GMVec.basicInitialize MVector s TermIdAndCount
v
    basicUnsafeReplicate :: forall s. Int -> TermId -> ST s (MVector s TermId)
basicUnsafeReplicate Int
l TermId
x           = MVector s TermIdAndCount -> MVector s TermId
forall s. MVector s TermIdAndCount -> MVector s TermId
MV_TermId (MVector s TermIdAndCount -> MVector s TermId)
-> ST s (MVector s TermIdAndCount) -> ST s (MVector s TermId)
forall (m :: * -> *) a1 r. Monad m => (a1 -> r) -> m a1 -> m r
`liftM` Int -> TermIdAndCount -> ST s (MVector s TermIdAndCount)
forall s. Int -> TermIdAndCount -> ST s (MVector s TermIdAndCount)
forall (v :: * -> * -> *) a s.
MVector v a =>
Int -> a -> ST s (v s a)
GMVec.basicUnsafeReplicate Int
l (TermId -> TermIdAndCount
unTermId TermId
x)
    basicUnsafeRead :: forall s. MVector s TermId -> Int -> ST s TermId
basicUnsafeRead  (MV_TermId MVector s TermIdAndCount
v) Int
i   = TermIdAndCount -> TermId
TermId (TermIdAndCount -> TermId) -> ST s TermIdAndCount -> ST s TermId
forall (m :: * -> *) a1 r. Monad m => (a1 -> r) -> m a1 -> m r
`liftM`    MVector s TermIdAndCount -> Int -> ST s TermIdAndCount
forall s. MVector s TermIdAndCount -> Int -> ST s TermIdAndCount
forall (v :: * -> * -> *) a s.
MVector v a =>
v s a -> Int -> ST s a
GMVec.basicUnsafeRead MVector s TermIdAndCount
v Int
i
    basicUnsafeWrite :: forall s. MVector s TermId -> Int -> TermId -> ST s ()
basicUnsafeWrite (MV_TermId MVector s TermIdAndCount
v) Int
i TermId
x = MVector s TermIdAndCount -> Int -> TermIdAndCount -> ST s ()
forall s.
MVector s TermIdAndCount -> Int -> TermIdAndCount -> ST s ()
forall (v :: * -> * -> *) a s.
MVector v a =>
v s a -> Int -> a -> ST s ()
GMVec.basicUnsafeWrite MVector s TermIdAndCount
v Int
i (TermId -> TermIdAndCount
unTermId TermId
x)
    basicClear :: forall s. MVector s TermId -> ST s ()
basicClear       (MV_TermId MVector s TermIdAndCount
v)     = MVector s TermIdAndCount -> ST s ()
forall s. MVector s TermIdAndCount -> ST s ()
forall (v :: * -> * -> *) a s. MVector v a => v s a -> ST s ()
GMVec.basicClear MVector s TermIdAndCount
v
    basicSet :: forall s. MVector s TermId -> TermId -> ST s ()
basicSet         (MV_TermId MVector s TermIdAndCount
v) TermId
x   = MVector s TermIdAndCount -> TermIdAndCount -> ST s ()
forall s. MVector s TermIdAndCount -> TermIdAndCount -> ST s ()
forall (v :: * -> * -> *) a s. MVector v a => v s a -> a -> ST s ()
GMVec.basicSet MVector s TermIdAndCount
v (TermId -> TermIdAndCount
unTermId TermId
x)
    basicUnsafeGrow :: forall s. MVector s TermId -> Int -> ST s (MVector s TermId)
basicUnsafeGrow  (MV_TermId MVector s TermIdAndCount
v) Int
l   = MVector s TermIdAndCount -> MVector s TermId
forall s. MVector s TermIdAndCount -> MVector s TermId
MV_TermId (MVector s TermIdAndCount -> MVector s TermId)
-> ST s (MVector s TermIdAndCount) -> ST s (MVector s TermId)
forall (m :: * -> *) a1 r. Monad m => (a1 -> r) -> m a1 -> m r
`liftM` MVector s TermIdAndCount -> Int -> ST s (MVector s TermIdAndCount)
forall s.
MVector s TermIdAndCount -> Int -> ST s (MVector s TermIdAndCount)
forall (v :: * -> * -> *) a s.
MVector v a =>
v s a -> Int -> ST s (v s a)
GMVec.basicUnsafeGrow MVector s TermIdAndCount
v Int
l
    basicUnsafeCopy :: forall s. MVector s TermId -> MVector s TermId -> ST s ()
basicUnsafeCopy  (MV_TermId MVector s TermIdAndCount
v) (MV_TermId MVector s TermIdAndCount
v') = MVector s TermIdAndCount -> MVector s TermIdAndCount -> ST s ()
forall s.
MVector s TermIdAndCount -> MVector s TermIdAndCount -> ST s ()
forall (v :: * -> * -> *) a s.
MVector v a =>
v s a -> v s a -> ST s ()
GMVec.basicUnsafeCopy MVector s TermIdAndCount
v MVector s TermIdAndCount
v'
    basicUnsafeMove :: forall s. MVector s TermId -> MVector s TermId -> ST s ()
basicUnsafeMove  (MV_TermId MVector s TermIdAndCount
v) (MV_TermId MVector s TermIdAndCount
v') = MVector s TermIdAndCount -> MVector s TermIdAndCount -> ST s ()
forall s.
MVector s TermIdAndCount -> MVector s TermIdAndCount -> ST s ()
forall (v :: * -> * -> *) a s.
MVector v a =>
v s a -> v s a -> ST s ()
GMVec.basicUnsafeMove MVector s TermIdAndCount
v MVector s TermIdAndCount
v'
    basicOverlaps :: forall s. MVector s TermId -> MVector s TermId -> Bool
basicOverlaps    (MV_TermId MVector s TermIdAndCount
v) (MV_TermId MVector s TermIdAndCount
v') = MVector s TermIdAndCount -> MVector s TermIdAndCount -> Bool
forall s.
MVector s TermIdAndCount -> MVector s TermIdAndCount -> Bool
forall (v :: * -> * -> *) a s.
MVector v a =>
v s a -> v s a -> Bool
GMVec.basicOverlaps   MVector s TermIdAndCount
v MVector s TermIdAndCount
v'
    {-# INLINE basicLength #-}
    {-# INLINE basicUnsafeSlice #-}
    {-# INLINE basicOverlaps #-}
    {-# INLINE basicUnsafeNew #-}
    {-# INLINE basicInitialize #-}
    {-# INLINE basicUnsafeReplicate #-}
    {-# INLINE basicUnsafeRead #-}
    {-# INLINE basicUnsafeWrite #-}
    {-# INLINE basicClear #-}
    {-# INLINE basicSet #-}
    {-# INLINE basicUnsafeCopy #-}
    {-# INLINE basicUnsafeMove #-}
    {-# INLINE basicUnsafeGrow #-}

newtype instance Vec.Vector TermId = V_TermId (Vec.Vector Word32)

instance GVec.Vector Vec.Vector TermId where
    basicUnsafeFreeze :: forall s. Mutable Vector s TermId -> ST s (Vector TermId)
basicUnsafeFreeze (MV_TermId MVector s TermIdAndCount
mv)  = Vector TermIdAndCount -> Vector TermId
V_TermId  (Vector TermIdAndCount -> Vector TermId)
-> ST s (Vector TermIdAndCount) -> ST s (Vector TermId)
forall (m :: * -> *) a1 r. Monad m => (a1 -> r) -> m a1 -> m r
`liftM` Mutable Vector s TermIdAndCount -> ST s (Vector TermIdAndCount)
forall s.
Mutable Vector s TermIdAndCount -> ST s (Vector TermIdAndCount)
forall (v :: * -> *) a s. Vector v a => Mutable v s a -> ST s (v a)
GVec.basicUnsafeFreeze MVector s TermIdAndCount
Mutable Vector s TermIdAndCount
mv
    basicUnsafeThaw :: forall s. Vector TermId -> ST s (Mutable Vector s TermId)
basicUnsafeThaw   (V_TermId  Vector TermIdAndCount
v)   = MVector s TermIdAndCount -> MVector s TermId
forall s. MVector s TermIdAndCount -> MVector s TermId
MV_TermId (MVector s TermIdAndCount -> MVector s TermId)
-> ST s (MVector s TermIdAndCount) -> ST s (MVector s TermId)
forall (m :: * -> *) a1 r. Monad m => (a1 -> r) -> m a1 -> m r
`liftM` Vector TermIdAndCount -> ST s (Mutable Vector s TermIdAndCount)
forall s.
Vector TermIdAndCount -> ST s (Mutable Vector s TermIdAndCount)
forall (v :: * -> *) a s. Vector v a => v a -> ST s (Mutable v s a)
GVec.basicUnsafeThaw Vector TermIdAndCount
v
    basicLength :: Vector TermId -> Int
basicLength       (V_TermId  Vector TermIdAndCount
v)   = Vector TermIdAndCount -> Int
forall (v :: * -> *) a. Vector v a => v a -> Int
GVec.basicLength Vector TermIdAndCount
v
    basicUnsafeSlice :: Int -> Int -> Vector TermId -> Vector TermId
basicUnsafeSlice Int
i Int
l (V_TermId Vector TermIdAndCount
v) = Vector TermIdAndCount -> Vector TermId
V_TermId (Int -> Int -> Vector TermIdAndCount -> Vector TermIdAndCount
forall (v :: * -> *) a. Vector v a => Int -> Int -> v a -> v a
GVec.basicUnsafeSlice Int
i Int
l Vector TermIdAndCount
v)
    basicUnsafeIndexM :: Vector TermId -> Int -> Box TermId
basicUnsafeIndexM (V_TermId  Vector TermIdAndCount
v) Int
i = TermIdAndCount -> TermId
TermId (TermIdAndCount -> TermId) -> Box TermIdAndCount -> Box TermId
forall (m :: * -> *) a1 r. Monad m => (a1 -> r) -> m a1 -> m r
`liftM` Vector TermIdAndCount -> Int -> Box TermIdAndCount
forall (v :: * -> *) a. Vector v a => v a -> Int -> Box a
GVec.basicUnsafeIndexM Vector TermIdAndCount
v Int
i
    basicUnsafeCopy :: forall s. Mutable Vector s TermId -> Vector TermId -> ST s ()
basicUnsafeCopy   (MV_TermId MVector s TermIdAndCount
mv)
                      (V_TermId  Vector TermIdAndCount
v)   = Mutable Vector s TermIdAndCount -> Vector TermIdAndCount -> ST s ()
forall s.
Mutable Vector s TermIdAndCount -> Vector TermIdAndCount -> ST s ()
forall (v :: * -> *) a s.
Vector v a =>
Mutable v s a -> v a -> ST s ()
GVec.basicUnsafeCopy MVector s TermIdAndCount
Mutable Vector s TermIdAndCount
mv Vector TermIdAndCount
v
    elemseq :: forall b. Vector TermId -> TermId -> b -> b
elemseq           (V_TermId  Vector TermIdAndCount
v) TermId
x = Vector TermIdAndCount -> TermIdAndCount -> b -> b
forall b. Vector TermIdAndCount -> TermIdAndCount -> b -> b
forall (v :: * -> *) a b. Vector v a => v a -> a -> b -> b
GVec.elemseq Vector TermIdAndCount
v (TermId -> TermIdAndCount
unTermId TermId
x)
    {-# INLINE basicUnsafeFreeze #-}
    {-# INLINE basicUnsafeThaw #-}
    {-# INLINE basicLength #-}
    {-# INLINE basicUnsafeSlice #-}
    {-# INLINE basicUnsafeIndexM #-}
    {-# INLINE basicUnsafeCopy #-}
    {-# INLINE elemseq #-}