-- Hoogle documentation, generated by Haddock
-- See Hoogle, http://www.haskell.org/hoogle/


-- | Efficient vector-based mutable hashtables implementation.
--   
--   This package provides efficient vector-based hashtable implementation
--   similar to .NET Generic Dictionary implementation (at the time of
--   2015).
--   
--   See <a>Data.Vector.Hashtables</a> for documentation.
@package vector-hashtables
@version 0.1.2.1


module Data.Primitive.PrimArray.Utils
replicate :: (PrimMonad m, Prim a) => Int -> a -> m (MutablePrimArray (PrimState m) a)
clone :: (PrimMonad m, Prim a) => MutablePrimArray (PrimState m) a -> m (MutablePrimArray (PrimState m) a)
unsafeFreeze :: PrimMonad m => MutablePrimArray (PrimState m) a -> m (PrimArray a)
unsafeThaw :: PrimMonad m => PrimArray a -> m (MutablePrimArray (PrimState m) a)
growWith :: (PrimMonad m, Prim a) => a -> MutablePrimArray (PrimState m) a -> Int -> m (MutablePrimArray (PrimState m) a)
growNoZ :: (PrimMonad m, Prim a) => MutablePrimArray (PrimState m) a -> Int -> m (MutablePrimArray (PrimState m) a)
freeze :: (PrimMonad m, Prim a) => MutablePrimArray (PrimState m) a -> m (PrimArray a)
length :: (PrimMonad m, Prim a) => MutablePrimArray (PrimState m) a -> m Int


module Data.Vector.Hashtables.Internal.Mask

-- | <a>Int</a> mask. For 32-bit it is equal to <tt>0x7FFFFFFF</tt>.
--   Otherwise, <tt>0x7FFFFFFFFFFFFFFF</tt>.
mask :: Int


module Data.Vector.Hashtables.Internal

-- | Alias for <tt>MutablePrimArray</tt> <tt>s</tt> <a>Int</a>.
type IntArray s = MutablePrimArray s Int

-- | Single-element mutable array of <a>Dictionary_</a> with primitive
--   state token parameterized with state, keys and values types.
--   
--   Different flavors of <a>MVector</a> could be used for keys and values.
--   It's preferable to use <a>Data.Vector.Unboxed.Mutable</a> or
--   <a>Data.Vector.Storable.Mutable</a> if possible. Otherwise, if you
--   must use boxed vectors, consider employing strict ones from
--   <a><tt>strict-containers</tt></a> to eliminate potential accumulation
--   of thunks.
--   
--   <h4>Example</h4>
--   
--   <pre>
--   &gt;&gt;&gt; import qualified Data.Vector.Storable.Mutable as VM
--   
--   &gt;&gt;&gt; import qualified Data.Vector.Unboxed.Mutable  as UM
--   
--   &gt;&gt;&gt; import Data.Vector.Hashtables
--   
--   &gt;&gt;&gt; type HashTable k v = Dictionary (PrimState IO) VM.MVector k UM.MVector v
--   </pre>
newtype Dictionary s (ks :: Type -> Type -> Type) k (vs :: Type -> Type -> Type) v
DRef :: MutVar s (Dictionary_ s ks k vs v) -> Dictionary s (ks :: Type -> Type -> Type) k (vs :: Type -> Type -> Type) v
[getDRef] :: Dictionary s (ks :: Type -> Type -> Type) k (vs :: Type -> Type -> Type) v -> MutVar s (Dictionary_ s ks k vs v)

-- | Represents collection of hashtable internal primitive arrays and
--   vectors.
--   
--   <ul>
--   <li>hash codes,</li>
--   <li>references to the next element,</li>
--   <li>buckets,</li>
--   <li>keys</li>
--   <li>and values.</li>
--   </ul>
data Dictionary_ s (ks :: Type -> Type -> Type) k (vs :: Type -> Type -> Type) v
Dictionary :: !IntArray s -> !IntArray s -> !IntArray s -> !IntArray s -> !ks s k -> !vs s v -> {-# UNPACK #-} !FastRem -> Dictionary_ s (ks :: Type -> Type -> Type) k (vs :: Type -> Type -> Type) v
[hashCode] :: Dictionary_ s (ks :: Type -> Type -> Type) k (vs :: Type -> Type -> Type) v -> !IntArray s
[next] :: Dictionary_ s (ks :: Type -> Type -> Type) k (vs :: Type -> Type -> Type) v -> !IntArray s
[buckets] :: Dictionary_ s (ks :: Type -> Type -> Type) k (vs :: Type -> Type -> Type) v -> !IntArray s
[refs] :: Dictionary_ s (ks :: Type -> Type -> Type) k (vs :: Type -> Type -> Type) v -> !IntArray s
[key] :: Dictionary_ s (ks :: Type -> Type -> Type) k (vs :: Type -> Type -> Type) v -> !ks s k
[value] :: Dictionary_ s (ks :: Type -> Type -> Type) k (vs :: Type -> Type -> Type) v -> !vs s v
[remSize] :: Dictionary_ s (ks :: Type -> Type -> Type) k (vs :: Type -> Type -> Type) v -> {-# UNPACK #-} !FastRem
getCount :: Int
getFreeList :: Int
getFreeCount :: Int

-- | Represents immutable dictionary as collection of immutable arrays and
--   vectors. See <a>unsafeFreeze</a> and <a>unsafeThaw</a> for conversions
--   from/to mutable dictionary.
data FrozenDictionary (ks :: Type -> Type) k (vs :: Type -> Type) v
FrozenDictionary :: !PrimArray Int -> !PrimArray Int -> !PrimArray Int -> !Int -> !Int -> !Int -> !ks k -> !vs v -> {-# UNPACK #-} !FastRem -> FrozenDictionary (ks :: Type -> Type) k (vs :: Type -> Type) v
[fhashCode] :: FrozenDictionary (ks :: Type -> Type) k (vs :: Type -> Type) v -> !PrimArray Int
[fnext] :: FrozenDictionary (ks :: Type -> Type) k (vs :: Type -> Type) v -> !PrimArray Int
[fbuckets] :: FrozenDictionary (ks :: Type -> Type) k (vs :: Type -> Type) v -> !PrimArray Int
[count] :: FrozenDictionary (ks :: Type -> Type) k (vs :: Type -> Type) v -> !Int
[freeList] :: FrozenDictionary (ks :: Type -> Type) k (vs :: Type -> Type) v -> !Int
[freeCount] :: FrozenDictionary (ks :: Type -> Type) k (vs :: Type -> Type) v -> !Int
[fkey] :: FrozenDictionary (ks :: Type -> Type) k (vs :: Type -> Type) v -> !ks k
[fvalue] :: FrozenDictionary (ks :: Type -> Type) k (vs :: Type -> Type) v -> !vs v
[fremSize] :: FrozenDictionary (ks :: Type -> Type) k (vs :: Type -> Type) v -> {-# UNPACK #-} !FastRem

-- | <i>O(1)</i> in the best case, <i>O(n)</i> in the worst case. Find
--   dictionary entry by given key in immutable <a>FrozenDictionary</a>. If
--   entry not found <tt>-1</tt> returned.
findElem :: forall (ks :: Type -> Type) k (vs :: Type -> Type) v. (Vector ks k, Vector vs v, Hashable k, Eq k) => FrozenDictionary ks k vs v -> k -> Int

-- | Infix version of <tt>unsafeRead</tt>.
(!~) :: (MVector v a, PrimMonad m) => v (PrimState m) a -> Int -> m a

-- | Infix version of <tt>unsafeIndex</tt>.
(!.~) :: Vector v a => v a -> Int -> a

-- | Infix version of <tt>unsafeWrite</tt>.
(<~~) :: (MVector v a, PrimMonad m) => v (PrimState m) a -> Int -> a -> m ()

-- | Infix version of <tt>readPrimArray</tt>.
(!) :: PrimMonad m => MutablePrimArray (PrimState m) Int -> Int -> m Int

-- | Infix version of <tt>indexPrimArray</tt>.
(!.) :: PrimArray Int -> Int -> Int

-- | Infix version of <tt>writePrimArray</tt>.
(<~) :: PrimMonad m => MutablePrimArray (PrimState m) Int -> Int -> Int -> m ()

-- | <i>O(1)</i> Dictionary with given capacity.
initialize :: forall (ks :: Type -> Type -> Type) k (vs :: Type -> Type -> Type) v m. (MVector ks k, MVector vs v, PrimMonad m) => Int -> m (Dictionary (PrimState m) ks k vs v)

-- | Create a copy of mutable dictionary.
clone :: forall (ks :: Type -> Type -> Type) k (vs :: Type -> Type -> Type) v m. (MVector ks k, MVector vs v, PrimMonad m) => Dictionary (PrimState m) ks k vs v -> m (Dictionary (PrimState m) ks k vs v)

-- | <i>O(1)</i> Unsafe convert a mutable dictionary to an immutable one
--   without copying. The mutable dictionary may not be used after this
--   operation.
unsafeFreeze :: forall (ks :: Type -> Type) k (vs :: Type -> Type) v m. (Vector ks k, Vector vs v, PrimMonad m) => Dictionary (PrimState m) (Mutable ks) k (Mutable vs) v -> m (FrozenDictionary ks k vs v)

-- | <i>O(1)</i> Unsafely convert immutable <a>FrozenDictionary</a> to a
--   mutable <a>Dictionary</a> without copying. The immutable dictionary
--   may not be used after this operation.
unsafeThaw :: forall (ks :: Type -> Type) k (vs :: Type -> Type) v m. (Vector ks k, Vector vs v, PrimMonad m) => FrozenDictionary ks k vs v -> m (Dictionary (PrimState m) (Mutable ks) k (Mutable vs) v)

-- | <i>O(n)</i> Retrieve list of keys from <a>Dictionary</a>.
keys :: forall ks k m (vs :: Type -> Type -> Type) v. (Vector ks k, PrimMonad m) => Dictionary (PrimState m) (Mutable ks) k vs v -> m (ks k)

-- | <i>O(n)</i> Retrieve list of values from <a>Dictionary</a>.
values :: forall vs v m (ks :: Type -> Type -> Type) k. (Vector vs v, PrimMonad m) => Dictionary (PrimState m) ks k (Mutable vs) v -> m (vs v)

-- | <i>O(1)</i> in the best case, <i>O(n)</i> in the worst case. Find
--   value by given key in <a>Dictionary</a>. Throws an error if value not
--   found.
at :: forall (ks :: Type -> Type -> Type) k (vs :: Type -> Type -> Type) v m. (MVector ks k, MVector vs v, PrimMonad m, Hashable k, Eq k) => Dictionary (PrimState m) ks k vs v -> k -> m v

-- | <i>O(1)</i> in the best case, <i>O(n)</i> in the worst case. Find
--   value by given key in <a>Dictionary</a>. Like <a>at'</a> but return
--   <a>Nothing</a> if value not found.
at' :: forall (ks :: Type -> Type -> Type) k (vs :: Type -> Type -> Type) v m. (MVector ks k, MVector vs v, PrimMonad m, Hashable k, Eq k) => Dictionary (PrimState m) ks k vs v -> k -> m (Maybe v)
atWithOrElse :: forall (ks :: Type -> Type -> Type) k (vs :: Type -> Type -> Type) v m a. (MVector ks k, MVector vs v, PrimMonad m, Hashable k, Eq k) => Dictionary (PrimState m) ks k vs v -> k -> (Dictionary (PrimState m) ks k vs v -> Int -> m a) -> (Dictionary (PrimState m) ks k vs v -> m a) -> m a

-- | <i>O(1)</i> in the best case, <i>O(n)</i> in the worst case. Find
--   dictionary entry by given key. If entry not found <tt>-1</tt>
--   returned.
findEntry :: forall (ks :: Type -> Type -> Type) k (vs :: Type -> Type -> Type) v m. (MVector ks k, MVector vs v, PrimMonad m, Hashable k, Eq k) => Dictionary (PrimState m) ks k vs v -> k -> m Int

-- | <i>O(1)</i> in the best case, <i>O(n)</i> in the worst case. Same as
--   <a>findEntry</a>, but for <a>Dictionary_</a>.
findEntry_ :: forall (ks :: Type -> Type -> Type) k (vs :: Type -> Type -> Type) v m. (MVector ks k, MVector vs v, PrimMonad m, Hashable k, Eq k) => Dictionary_ (PrimState m) ks k vs v -> k -> m Int

-- | <i>O(1)</i> in the best case, <i>O(n)</i> in the worst case. Insert
--   key and value in dictionary by key's hash. If entry with given key
--   found value will be replaced.
insert :: forall (ks :: Type -> Type -> Type) k (vs :: Type -> Type -> Type) v m. (MVector ks k, MVector vs v, PrimMonad m, Hashable k, Eq k) => Dictionary (PrimState m) ks k vs v -> k -> v -> m ()
insertWithIndex :: forall (ks :: Type -> Type -> Type) k (vs :: Type -> Type -> Type) v m. (MVector ks k, MVector vs v, PrimMonad m, Hashable k, Eq k) => Int -> Int -> k -> v -> MutVar (PrimState m) (Dictionary_ (PrimState m) ks k vs v) -> Dictionary_ (PrimState m) ks k vs v -> Int -> m ()
addOrResize :: forall (ks :: Type -> Type -> Type) k (vs :: Type -> Type -> Type) v m. (MVector ks k, MVector vs v, PrimMonad m, Hashable k, Eq k) => Int -> Int -> k -> v -> MutVar (PrimState m) (Dictionary_ (PrimState m) ks k vs v) -> Dictionary_ (PrimState m) ks k vs v -> m ()
add :: forall (ks :: Type -> Type -> Type) k (vs :: Type -> Type -> Type) v m. (MVector ks k, MVector vs v, PrimMonad m, Hashable k, Eq k) => Int -> Int -> Int -> k -> v -> Dictionary_ (PrimState m) ks k vs v -> m ()
resize :: forall (ks :: Type -> Type -> Type) k (vs :: Type -> Type -> Type) v m. (MVector ks k, MVector vs v, PrimMonad m, Hashable k, Eq k) => Dictionary_ (PrimState m) ks k vs v -> Int -> Int -> k -> v -> m (Dictionary_ (PrimState m) ks k vs v)
class DeleteEntry (xs :: Type -> Type -> Type)
deleteEntry :: (DeleteEntry xs, MVector xs x, PrimMonad m) => xs (PrimState m) x -> Int -> m ()

-- | <i>O(1)</i> in the best case, <i>O(n)</i> in the worst case. Delete
--   entry from <a>Dictionary</a> by given key.
delete :: forall k (ks :: Type -> Type -> Type) (vs :: Type -> Type -> Type) v m. (Eq k, MVector ks k, MVector vs v, Hashable k, PrimMonad m, DeleteEntry ks, DeleteEntry vs) => Dictionary (PrimState m) ks k vs v -> k -> m ()
deleteWithIndex :: forall k (ks :: Type -> Type -> Type) (vs :: Type -> Type -> Type) v m. (Eq k, MVector ks k, MVector vs v, Hashable k, PrimMonad m, DeleteEntry ks, DeleteEntry vs) => Int -> Int -> Dictionary_ (PrimState m) ks k vs v -> k -> Int -> Int -> m ()

-- | <i>O(1)</i> in the best case, <i>O(n)</i> in the worst case. Find
--   value by given key in <a>Dictionary</a>. Like <a>lookup'</a> but
--   return <a>Nothing</a> if value not found.
lookup :: forall (ks :: Type -> Type -> Type) k (vs :: Type -> Type -> Type) v m. (MVector ks k, MVector vs v, PrimMonad m, Hashable k, Eq k) => Dictionary (PrimState m) ks k vs v -> k -> m (Maybe v)

-- | <i>O(1)</i> in the best case, <i>O(n)</i> in the worst case. Find
--   value by given key in <a>Dictionary</a>. Throws an error if value not
--   found.
lookup' :: forall (ks :: Type -> Type -> Type) k (vs :: Type -> Type -> Type) v m. (MVector ks k, MVector vs v, PrimMonad m, Hashable k, Eq k) => Dictionary (PrimState m) ks k vs v -> k -> m v

-- | <i>O(1)</i> in the best case, <i>O(n)</i> in the worst case. Lookup
--   the index of a key, which is its zero-based index in the sequence
--   sorted by keys. The index is a number from 0 up to, but not including,
--   the size of the dictionary.
lookupIndex :: forall (ks :: Type -> Type -> Type) k (vs :: Type -> Type -> Type) v m. (MVector ks k, MVector vs v, PrimMonad m, Hashable k, Eq k) => Dictionary (PrimState m) ks k vs v -> k -> m (Maybe Int)

-- | <i>O(1)</i> Return <a>True</a> if dictionary is empty, <a>False</a>
--   otherwise.
null :: forall (ks :: Type -> Type -> Type) k m (vs :: Type -> Type -> Type) v. (MVector ks k, PrimMonad m) => Dictionary (PrimState m) ks k vs v -> m Bool

-- | <i>O(1)</i> Return the number of non-empty entries of dictionary.
length :: forall (ks :: Type -> Type -> Type) k m (vs :: Type -> Type -> Type) v. (MVector ks k, PrimMonad m) => Dictionary (PrimState m) ks k vs v -> m Int

-- | <i>O(1)</i> Return the number of non-empty entries of dictionary.
--   Synonym of <a>length</a>.
size :: forall (ks :: Type -> Type -> Type) k m (vs :: Type -> Type -> Type) v. (MVector ks k, PrimMonad m) => Dictionary (PrimState m) ks k vs v -> m Int

-- | <i>O(1)</i> in the best case, <i>O(n)</i> in the worst case. Return
--   <a>True</a> if the specified key is present in the dictionary,
--   <a>False</a> otherwise.
member :: forall (ks :: Type -> Type -> Type) k (vs :: Type -> Type -> Type) v m. (MVector ks k, MVector vs v, PrimMonad m, Hashable k, Eq k) => Dictionary (PrimState m) ks k vs v -> k -> m Bool

-- | <i>O(1)</i> in the best case, <i>O(n)</i> in the worst case. The
--   expression <tt><a>findWithDefault</a> ht def k</tt> returns the value
--   at key <tt>k</tt> or returns default value <tt>def</tt> when the key
--   is not in the dictionary.
findWithDefault :: forall (ks :: Type -> Type -> Type) k (vs :: Type -> Type -> Type) v m. (MVector ks k, MVector vs v, PrimMonad m, Hashable k, Eq k) => Dictionary (PrimState m) ks k vs v -> v -> k -> m v

-- | <i>O(1)</i> in the best case, <i>O(n)</i> in the worst case. The
--   expression (<tt><a>upsert</a> ht f k</tt>) updates or inserts the
--   value <tt>x</tt> at <tt>k</tt>.
--   
--   It's a responsibility of <a>MVector</a> <tt>vs</tt> to force
--   evaluation of the updated value. Unboxed / storable vectors do it
--   automatically. If you use boxed vectors, consider employing strict
--   ones from <a><tt>strict-containers</tt></a> to eliminate potential
--   accumulation of thunks.
--   
--   <pre>
--   let f _ = "c"
--   ht &lt;- fromList [(5,"a"), (3,"b")]
--   upsert ht f 7
--   toList ht
--   [(3, "b"), (5, "a"), (7, "c")]
--   </pre>
--   
--   <pre>
--   ht &lt;- fromList [(5,"a"), (3,"b")]
--   upsert ht f 5
--   toList ht
--   [(3, "b"), (5, "c")]
--   </pre>
upsert :: forall (ks :: Type -> Type -> Type) k (vs :: Type -> Type -> Type) v m. (MVector ks k, MVector vs v, PrimMonad m, Hashable k, Eq k) => Dictionary (PrimState m) ks k vs v -> (Maybe v -> v) -> k -> m ()

-- | <i>O(1)</i> in the best case, <i>O(n)</i> in the worst case. The
--   expression (<tt><a>alter</a> ht f k</tt>) alters the value <tt>x</tt>
--   at <tt>k</tt>, or absence thereof. <a>alter</a> can be used to insert,
--   delete, or update a value in a <a>Dictionary</a>.
--   
--   It's a responsibility of <a>MVector</a> <tt>vs</tt> to force
--   evaluation of the updated value. Unboxed / storable vectors do it
--   automatically. If you use boxed vectors, consider employing strict
--   ones from <a><tt>strict-containers</tt></a> to eliminate potential
--   accumulation of thunks.
--   
--   <pre>
--   let f _ = Nothing
--   ht &lt;- fromList [(5,"a"), (3,"b")]
--   alter ht f 7
--   toList ht
--   [(3, "b"), (5, "a")]
--   </pre>
--   
--   <pre>
--   ht &lt;- fromList [(5,"a"), (3,"b")]
--   alter ht f 5
--   toList ht
--   [(3 "b")]
--   </pre>
--   
--   <pre>
--   let f _ = Just "c"
--   ht &lt;- fromList [(5,"a"), (3,"b")]
--   alter ht f 7
--   toList ht
--   [(3, "b"), (5, "a"), (7, "c")]
--   </pre>
--   
--   <pre>
--   ht &lt;- fromList [(5,"a"), (3,"b")]
--   alter ht f 5
--   toList ht
--   [(3, "b"), (5, "c")]
--   </pre>
alter :: forall (ks :: Type -> Type -> Type) k (vs :: Type -> Type -> Type) v m. (MVector ks k, MVector vs v, DeleteEntry ks, DeleteEntry vs, PrimMonad m, Hashable k, Eq k) => Dictionary (PrimState m) ks k vs v -> (Maybe v -> Maybe v) -> k -> m ()

-- | <i>O(1)</i> in the best case, <i>O(n)</i> in the worst case. The
--   expression (<tt><a>alterM</a> ht f k</tt>) alters the value <tt>x</tt>
--   at <tt>k</tt>, or absence thereof. <a>alterM</a> can be used to
--   insert, delete, or update a value in a <a>Dictionary</a> in the same
--   <tt><a>PrimMonad</a> m</tt>.
alterM :: forall (ks :: Type -> Type -> Type) k (vs :: Type -> Type -> Type) v m. (MVector ks k, MVector vs v, DeleteEntry ks, DeleteEntry vs, PrimMonad m, Hashable k, Eq k) => Dictionary (PrimState m) ks k vs v -> (Maybe v -> m (Maybe v)) -> k -> m ()

-- | <i>O(min n m)</i> in the best case, <i>O(min n m * max n m)</i> in the
--   worst case. The union of two maps. If a key occurs in both maps, the
--   mapping from the first will be the mapping in the result.
union :: forall (ks :: Type -> Type -> Type) k (vs :: Type -> Type -> Type) v m. (MVector ks k, MVector vs v, PrimMonad m, Hashable k, Eq k) => Dictionary (PrimState m) ks k vs v -> Dictionary (PrimState m) ks k vs v -> m (Dictionary (PrimState m) ks k vs v)

-- | <i>O(min n m)</i> in the best case, <i>O(min n m * max n m)</i> in the
--   worst case. The union of two maps. The provided function (first
--   argument) will be used to compute the result.
unionWith :: forall (ks :: Type -> Type -> Type) k (vs :: Type -> Type -> Type) v m. (MVector ks k, MVector ks k, MVector vs v, PrimMonad m, Hashable k, Eq k) => (v -> v -> v) -> Dictionary (PrimState m) ks k vs v -> Dictionary (PrimState m) ks k vs v -> m (Dictionary (PrimState m) ks k vs v)

-- | <i>O(min n m)</i> in the best case, <i>O(min n m * max n m)</i> in the
--   worst case. The union of two maps. If a key occurs in both maps, the
--   provided function (first argument) will be used to compute the result.
unionWithKey :: forall (ks :: Type -> Type -> Type) k (vs :: Type -> Type -> Type) v m. (MVector ks k, MVector vs v, PrimMonad m, Hashable k, Eq k) => (k -> v -> v -> v) -> Dictionary (PrimState m) ks k vs v -> Dictionary (PrimState m) ks k vs v -> m (Dictionary (PrimState m) ks k vs v)

-- | <i>O(n)</i> in the best case, <i>O(n * m)</i> in the worst case.
--   Difference of two tables. Return elements of the first table not
--   existing in the second.
difference :: forall (ks :: Type -> Type -> Type) k (vs :: Type -> Type -> Type) v w m. (MVector ks k, MVector vs v, MVector vs w, PrimMonad m, Hashable k, Eq k) => Dictionary (PrimState m) ks k vs v -> Dictionary (PrimState m) ks k vs w -> m (Dictionary (PrimState m) ks k vs v)

-- | <i>O(n)</i> in the best case, <i>O(n * m)</i> in the worst case.
--   Difference with a combining function. When two equal keys are
--   encountered, the combining function is applied to the values of these
--   keys. If it returns <a>Nothing</a>, the element is discarded (proper
--   set difference). If it returns (<tt><a>Just</a> y</tt>), the element
--   is updated with a new value <tt>y</tt>.
differenceWith :: forall (ks :: Type -> Type -> Type) k (vs :: Type -> Type -> Type) v w m. (MVector ks k, MVector vs v, MVector vs w, PrimMonad m, Hashable k, Eq k) => (v -> w -> Maybe v) -> Dictionary (PrimState m) ks k vs v -> Dictionary (PrimState m) ks k vs w -> m (Dictionary (PrimState m) ks k vs v)

-- | <i>O(n)</i> in the best case, <i>O(n * m)</i> in the worst case.
--   Intersection of two maps. Return elements of the first map for keys
--   existing in the second.
intersection :: forall (ks :: Type -> Type -> Type) k (vs :: Type -> Type -> Type) v w m. (MVector ks k, MVector vs v, MVector vs w, PrimMonad m, Hashable k, Eq k) => Dictionary (PrimState m) ks k vs v -> Dictionary (PrimState m) ks k vs w -> m (Dictionary (PrimState m) ks k vs v)

-- | Intersection of two maps. If a key occurs in both maps the provided
--   function is used to combine the values from the two maps.
intersectionWith :: forall (ks :: Type -> Type -> Type) k (vs :: Type -> Type -> Type) v1 v2 v3 m. (MVector ks k, MVector vs v1, MVector vs v2, MVector vs v3, PrimMonad m, Hashable k, Eq k) => (v1 -> v2 -> v3) -> Dictionary (PrimState m) ks k vs v1 -> Dictionary (PrimState m) ks k vs v2 -> m (Dictionary (PrimState m) ks k vs v3)

-- | Intersection of two maps. If a key occurs in both maps the provided
--   function is used to combine the values from the two maps.
intersectionWithKey :: forall (ks :: Type -> Type -> Type) k (vs :: Type -> Type -> Type) v1 v2 v3 m. (MVector ks k, MVector vs v1, MVector vs v2, MVector vs v3, PrimMonad m, Hashable k, Eq k) => (k -> v1 -> v2 -> v3) -> Dictionary (PrimState m) ks k vs v1 -> Dictionary (PrimState m) ks k vs v2 -> m (Dictionary (PrimState m) ks k vs v3)

-- | <i>O(n)</i> Convert list to a <a>Dictionary</a>.
fromList :: forall (ks :: Type -> Type -> Type) k (vs :: Type -> Type -> Type) v m. (MVector ks k, MVector vs v, PrimMonad m, Hashable k, Eq k) => [(k, v)] -> m (Dictionary (PrimState m) ks k vs v)

-- | <i>O(n)</i> Convert <a>Dictionary</a> to a list.
toList :: forall (ks :: Type -> Type -> Type) k (vs :: Type -> Type -> Type) v m. (MVector ks k, MVector vs v, PrimMonad m, Hashable k, Eq k) => Dictionary (PrimState m) ks k vs v -> m [(k, v)]

-- | This data is auto-generated by GenPrimes.hs. The vector contains
--   tuples (p, m, s) such that p is prime and (assuming 64-bit
--   architecture) for every n &gt;= 0 it holds that n `<a>quot</a>` p = (n
--   * m) `<a>shiftR</a>` (64 + s), enabling faster computation of
--   remainders.
primesWithFastRem :: Vector (Int, Int, Int)
getFastRem :: Int -> FastRem

-- | For 64-bit architectures <a>frmPrime</a> is a prime number such that
--   for each <tt>n</tt> &gt;= 0 it holds that <tt>n</tt> `<a>quot</a>`
--   <a>frmPrime</a> = (n * <a>_frmMulHi</a>) `<a>shiftR</a>` (64 + s).
data FastRem
FastRem :: !Int -> !Int -> !Int -> FastRem
[frmPrime] :: FastRem -> !Int
[_frmMulHi] :: FastRem -> !Int
[_frmShift] :: FastRem -> !Int
fastRem :: Int -> FastRem -> Int
instance Data.Vector.Hashtables.Internal.DeleteEntry Data.Vector.Mutable.MVector
instance Data.Vector.Hashtables.Internal.DeleteEntry Data.Vector.Unboxed.Base.MVector
instance Data.Vector.Hashtables.Internal.DeleteEntry Data.Vector.Storable.Mutable.MVector
instance GHC.Classes.Eq Data.Vector.Hashtables.Internal.FastRem
instance (GHC.Classes.Eq (ks k), GHC.Classes.Eq (vs v)) => GHC.Classes.Eq (Data.Vector.Hashtables.Internal.FrozenDictionary ks k vs v)
instance GHC.Classes.Ord Data.Vector.Hashtables.Internal.FastRem
instance (GHC.Classes.Ord (ks k), GHC.Classes.Ord (vs v)) => GHC.Classes.Ord (Data.Vector.Hashtables.Internal.FrozenDictionary ks k vs v)
instance GHC.Internal.Show.Show Data.Vector.Hashtables.Internal.FastRem
instance (GHC.Internal.Show.Show (ks k), GHC.Internal.Show.Show (vs v)) => GHC.Internal.Show.Show (Data.Vector.Hashtables.Internal.FrozenDictionary ks k vs v)


module Data.Vector.Hashtables

-- | Single-element mutable array of <a>Dictionary_</a> with primitive
--   state token parameterized with state, keys and values types.
--   
--   Different flavors of <a>MVector</a> could be used for keys and values.
--   It's preferable to use <a>Data.Vector.Unboxed.Mutable</a> or
--   <a>Data.Vector.Storable.Mutable</a> if possible. Otherwise, if you
--   must use boxed vectors, consider employing strict ones from
--   <a><tt>strict-containers</tt></a> to eliminate potential accumulation
--   of thunks.
--   
--   <h4>Example</h4>
--   
--   <pre>
--   &gt;&gt;&gt; import qualified Data.Vector.Storable.Mutable as VM
--   
--   &gt;&gt;&gt; import qualified Data.Vector.Unboxed.Mutable  as UM
--   
--   &gt;&gt;&gt; import Data.Vector.Hashtables
--   
--   &gt;&gt;&gt; type HashTable k v = Dictionary (PrimState IO) VM.MVector k UM.MVector v
--   </pre>
newtype Dictionary s (ks :: Type -> Type -> Type) k (vs :: Type -> Type -> Type) v
DRef :: MutVar s (Dictionary_ s ks k vs v) -> Dictionary s (ks :: Type -> Type -> Type) k (vs :: Type -> Type -> Type) v
[getDRef] :: Dictionary s (ks :: Type -> Type -> Type) k (vs :: Type -> Type -> Type) v -> MutVar s (Dictionary_ s ks k vs v)

-- | Represents immutable dictionary as collection of immutable arrays and
--   vectors. See <a>unsafeFreeze</a> and <a>unsafeThaw</a> for conversions
--   from/to mutable dictionary.
data FrozenDictionary (ks :: Type -> Type) k (vs :: Type -> Type) v
FrozenDictionary :: !PrimArray Int -> !PrimArray Int -> !PrimArray Int -> !Int -> !Int -> !Int -> !ks k -> !vs v -> {-# UNPACK #-} !FastRem -> FrozenDictionary (ks :: Type -> Type) k (vs :: Type -> Type) v
[fhashCode] :: FrozenDictionary (ks :: Type -> Type) k (vs :: Type -> Type) v -> !PrimArray Int
[fnext] :: FrozenDictionary (ks :: Type -> Type) k (vs :: Type -> Type) v -> !PrimArray Int
[fbuckets] :: FrozenDictionary (ks :: Type -> Type) k (vs :: Type -> Type) v -> !PrimArray Int
[count] :: FrozenDictionary (ks :: Type -> Type) k (vs :: Type -> Type) v -> !Int
[freeList] :: FrozenDictionary (ks :: Type -> Type) k (vs :: Type -> Type) v -> !Int
[freeCount] :: FrozenDictionary (ks :: Type -> Type) k (vs :: Type -> Type) v -> !Int
[fkey] :: FrozenDictionary (ks :: Type -> Type) k (vs :: Type -> Type) v -> !ks k
[fvalue] :: FrozenDictionary (ks :: Type -> Type) k (vs :: Type -> Type) v -> !vs v
[fremSize] :: FrozenDictionary (ks :: Type -> Type) k (vs :: Type -> Type) v -> {-# UNPACK #-} !FastRem

-- | <i>O(1)</i> in the best case, <i>O(n)</i> in the worst case. Find
--   dictionary entry by given key in immutable <a>FrozenDictionary</a>. If
--   entry not found <tt>-1</tt> returned.
findElem :: forall (ks :: Type -> Type) k (vs :: Type -> Type) v. (Vector ks k, Vector vs v, Hashable k, Eq k) => FrozenDictionary ks k vs v -> k -> Int

-- | <i>O(1)</i> Dictionary with given capacity.
initialize :: forall (ks :: Type -> Type -> Type) k (vs :: Type -> Type -> Type) v m. (MVector ks k, MVector vs v, PrimMonad m) => Int -> m (Dictionary (PrimState m) ks k vs v)

-- | Create a copy of mutable dictionary.
clone :: forall (ks :: Type -> Type -> Type) k (vs :: Type -> Type -> Type) v m. (MVector ks k, MVector vs v, PrimMonad m) => Dictionary (PrimState m) ks k vs v -> m (Dictionary (PrimState m) ks k vs v)

-- | <i>O(1)</i> Return <a>True</a> if dictionary is empty, <a>False</a>
--   otherwise.
null :: forall (ks :: Type -> Type -> Type) k m (vs :: Type -> Type -> Type) v. (MVector ks k, PrimMonad m) => Dictionary (PrimState m) ks k vs v -> m Bool

-- | <i>O(1)</i> Return the number of non-empty entries of dictionary.
--   Synonym of <a>length</a>.
size :: forall (ks :: Type -> Type -> Type) k m (vs :: Type -> Type -> Type) v. (MVector ks k, PrimMonad m) => Dictionary (PrimState m) ks k vs v -> m Int

-- | <i>O(n)</i> Retrieve list of keys from <a>Dictionary</a>.
keys :: forall ks k m (vs :: Type -> Type -> Type) v. (Vector ks k, PrimMonad m) => Dictionary (PrimState m) (Mutable ks) k vs v -> m (ks k)

-- | <i>O(n)</i> Retrieve list of values from <a>Dictionary</a>.
values :: forall vs v m (ks :: Type -> Type -> Type) k. (Vector vs v, PrimMonad m) => Dictionary (PrimState m) ks k (Mutable vs) v -> m (vs v)

-- | <i>O(1)</i> in the best case, <i>O(n)</i> in the worst case. Find
--   value by given key in <a>Dictionary</a>. Like <a>lookup'</a> but
--   return <a>Nothing</a> if value not found.
lookup :: forall (ks :: Type -> Type -> Type) k (vs :: Type -> Type -> Type) v m. (MVector ks k, MVector vs v, PrimMonad m, Hashable k, Eq k) => Dictionary (PrimState m) ks k vs v -> k -> m (Maybe v)

-- | <i>O(1)</i> in the best case, <i>O(n)</i> in the worst case. Find
--   value by given key in <a>Dictionary</a>. Throws an error if value not
--   found.
lookup' :: forall (ks :: Type -> Type -> Type) k (vs :: Type -> Type -> Type) v m. (MVector ks k, MVector vs v, PrimMonad m, Hashable k, Eq k) => Dictionary (PrimState m) ks k vs v -> k -> m v

-- | <i>O(1)</i> in the best case, <i>O(n)</i> in the worst case. Insert
--   key and value in dictionary by key's hash. If entry with given key
--   found value will be replaced.
insert :: forall (ks :: Type -> Type -> Type) k (vs :: Type -> Type -> Type) v m. (MVector ks k, MVector vs v, PrimMonad m, Hashable k, Eq k) => Dictionary (PrimState m) ks k vs v -> k -> v -> m ()

-- | <i>O(1)</i> in the best case, <i>O(n)</i> in the worst case. Delete
--   entry from <a>Dictionary</a> by given key.
delete :: forall k (ks :: Type -> Type -> Type) (vs :: Type -> Type -> Type) v m. (Eq k, MVector ks k, MVector vs v, Hashable k, PrimMonad m, DeleteEntry ks, DeleteEntry vs) => Dictionary (PrimState m) ks k vs v -> k -> m ()

-- | <i>O(1)</i> in the best case, <i>O(n)</i> in the worst case. The
--   expression (<tt><a>upsert</a> ht f k</tt>) updates or inserts the
--   value <tt>x</tt> at <tt>k</tt>.
--   
--   It's a responsibility of <a>MVector</a> <tt>vs</tt> to force
--   evaluation of the updated value. Unboxed / storable vectors do it
--   automatically. If you use boxed vectors, consider employing strict
--   ones from <a><tt>strict-containers</tt></a> to eliminate potential
--   accumulation of thunks.
--   
--   <pre>
--   let f _ = "c"
--   ht &lt;- fromList [(5,"a"), (3,"b")]
--   upsert ht f 7
--   toList ht
--   [(3, "b"), (5, "a"), (7, "c")]
--   </pre>
--   
--   <pre>
--   ht &lt;- fromList [(5,"a"), (3,"b")]
--   upsert ht f 5
--   toList ht
--   [(3, "b"), (5, "c")]
--   </pre>
upsert :: forall (ks :: Type -> Type -> Type) k (vs :: Type -> Type -> Type) v m. (MVector ks k, MVector vs v, PrimMonad m, Hashable k, Eq k) => Dictionary (PrimState m) ks k vs v -> (Maybe v -> v) -> k -> m ()

-- | <i>O(1)</i> in the best case, <i>O(n)</i> in the worst case. The
--   expression (<tt><a>alter</a> ht f k</tt>) alters the value <tt>x</tt>
--   at <tt>k</tt>, or absence thereof. <a>alter</a> can be used to insert,
--   delete, or update a value in a <a>Dictionary</a>.
--   
--   It's a responsibility of <a>MVector</a> <tt>vs</tt> to force
--   evaluation of the updated value. Unboxed / storable vectors do it
--   automatically. If you use boxed vectors, consider employing strict
--   ones from <a><tt>strict-containers</tt></a> to eliminate potential
--   accumulation of thunks.
--   
--   <pre>
--   let f _ = Nothing
--   ht &lt;- fromList [(5,"a"), (3,"b")]
--   alter ht f 7
--   toList ht
--   [(3, "b"), (5, "a")]
--   </pre>
--   
--   <pre>
--   ht &lt;- fromList [(5,"a"), (3,"b")]
--   alter ht f 5
--   toList ht
--   [(3 "b")]
--   </pre>
--   
--   <pre>
--   let f _ = Just "c"
--   ht &lt;- fromList [(5,"a"), (3,"b")]
--   alter ht f 7
--   toList ht
--   [(3, "b"), (5, "a"), (7, "c")]
--   </pre>
--   
--   <pre>
--   ht &lt;- fromList [(5,"a"), (3,"b")]
--   alter ht f 5
--   toList ht
--   [(3, "b"), (5, "c")]
--   </pre>
alter :: forall (ks :: Type -> Type -> Type) k (vs :: Type -> Type -> Type) v m. (MVector ks k, MVector vs v, DeleteEntry ks, DeleteEntry vs, PrimMonad m, Hashable k, Eq k) => Dictionary (PrimState m) ks k vs v -> (Maybe v -> Maybe v) -> k -> m ()

-- | <i>O(1)</i> in the best case, <i>O(n)</i> in the worst case. The
--   expression (<tt><a>alterM</a> ht f k</tt>) alters the value <tt>x</tt>
--   at <tt>k</tt>, or absence thereof. <a>alterM</a> can be used to
--   insert, delete, or update a value in a <a>Dictionary</a> in the same
--   <tt><a>PrimMonad</a> m</tt>.
alterM :: forall (ks :: Type -> Type -> Type) k (vs :: Type -> Type -> Type) v m. (MVector ks k, MVector vs v, DeleteEntry ks, DeleteEntry vs, PrimMonad m, Hashable k, Eq k) => Dictionary (PrimState m) ks k vs v -> (Maybe v -> m (Maybe v)) -> k -> m ()

-- | <i>O(1)</i> in the best case, <i>O(n)</i> in the worst case. Find
--   dictionary entry by given key. If entry not found <tt>-1</tt>
--   returned.
findEntry :: forall (ks :: Type -> Type -> Type) k (vs :: Type -> Type -> Type) v m. (MVector ks k, MVector vs v, PrimMonad m, Hashable k, Eq k) => Dictionary (PrimState m) ks k vs v -> k -> m Int

-- | <i>O(min n m)</i> in the best case, <i>O(min n m * max n m)</i> in the
--   worst case. The union of two maps. If a key occurs in both maps, the
--   mapping from the first will be the mapping in the result.
union :: forall (ks :: Type -> Type -> Type) k (vs :: Type -> Type -> Type) v m. (MVector ks k, MVector vs v, PrimMonad m, Hashable k, Eq k) => Dictionary (PrimState m) ks k vs v -> Dictionary (PrimState m) ks k vs v -> m (Dictionary (PrimState m) ks k vs v)

-- | <i>O(min n m)</i> in the best case, <i>O(min n m * max n m)</i> in the
--   worst case. The union of two maps. The provided function (first
--   argument) will be used to compute the result.
unionWith :: forall (ks :: Type -> Type -> Type) k (vs :: Type -> Type -> Type) v m. (MVector ks k, MVector ks k, MVector vs v, PrimMonad m, Hashable k, Eq k) => (v -> v -> v) -> Dictionary (PrimState m) ks k vs v -> Dictionary (PrimState m) ks k vs v -> m (Dictionary (PrimState m) ks k vs v)

-- | <i>O(min n m)</i> in the best case, <i>O(min n m * max n m)</i> in the
--   worst case. The union of two maps. If a key occurs in both maps, the
--   provided function (first argument) will be used to compute the result.
unionWithKey :: forall (ks :: Type -> Type -> Type) k (vs :: Type -> Type -> Type) v m. (MVector ks k, MVector vs v, PrimMonad m, Hashable k, Eq k) => (k -> v -> v -> v) -> Dictionary (PrimState m) ks k vs v -> Dictionary (PrimState m) ks k vs v -> m (Dictionary (PrimState m) ks k vs v)

-- | <i>O(n)</i> in the best case, <i>O(n * m)</i> in the worst case.
--   Difference of two tables. Return elements of the first table not
--   existing in the second.
difference :: forall (ks :: Type -> Type -> Type) k (vs :: Type -> Type -> Type) v w m. (MVector ks k, MVector vs v, MVector vs w, PrimMonad m, Hashable k, Eq k) => Dictionary (PrimState m) ks k vs v -> Dictionary (PrimState m) ks k vs w -> m (Dictionary (PrimState m) ks k vs v)

-- | <i>O(n)</i> in the best case, <i>O(n * m)</i> in the worst case.
--   Difference with a combining function. When two equal keys are
--   encountered, the combining function is applied to the values of these
--   keys. If it returns <a>Nothing</a>, the element is discarded (proper
--   set difference). If it returns (<tt><a>Just</a> y</tt>), the element
--   is updated with a new value <tt>y</tt>.
differenceWith :: forall (ks :: Type -> Type -> Type) k (vs :: Type -> Type -> Type) v w m. (MVector ks k, MVector vs v, MVector vs w, PrimMonad m, Hashable k, Eq k) => (v -> w -> Maybe v) -> Dictionary (PrimState m) ks k vs v -> Dictionary (PrimState m) ks k vs w -> m (Dictionary (PrimState m) ks k vs v)

-- | <i>O(n)</i> in the best case, <i>O(n * m)</i> in the worst case.
--   Intersection of two maps. Return elements of the first map for keys
--   existing in the second.
intersection :: forall (ks :: Type -> Type -> Type) k (vs :: Type -> Type -> Type) v w m. (MVector ks k, MVector vs v, MVector vs w, PrimMonad m, Hashable k, Eq k) => Dictionary (PrimState m) ks k vs v -> Dictionary (PrimState m) ks k vs w -> m (Dictionary (PrimState m) ks k vs v)

-- | Intersection of two maps. If a key occurs in both maps the provided
--   function is used to combine the values from the two maps.
intersectionWith :: forall (ks :: Type -> Type -> Type) k (vs :: Type -> Type -> Type) v1 v2 v3 m. (MVector ks k, MVector vs v1, MVector vs v2, MVector vs v3, PrimMonad m, Hashable k, Eq k) => (v1 -> v2 -> v3) -> Dictionary (PrimState m) ks k vs v1 -> Dictionary (PrimState m) ks k vs v2 -> m (Dictionary (PrimState m) ks k vs v3)

-- | Intersection of two maps. If a key occurs in both maps the provided
--   function is used to combine the values from the two maps.
intersectionWithKey :: forall (ks :: Type -> Type -> Type) k (vs :: Type -> Type -> Type) v1 v2 v3 m. (MVector ks k, MVector vs v1, MVector vs v2, MVector vs v3, PrimMonad m, Hashable k, Eq k) => (k -> v1 -> v2 -> v3) -> Dictionary (PrimState m) ks k vs v1 -> Dictionary (PrimState m) ks k vs v2 -> m (Dictionary (PrimState m) ks k vs v3)

-- | <i>O(1)</i> Unsafe convert a mutable dictionary to an immutable one
--   without copying. The mutable dictionary may not be used after this
--   operation.
unsafeFreeze :: forall (ks :: Type -> Type) k (vs :: Type -> Type) v m. (Vector ks k, Vector vs v, PrimMonad m) => Dictionary (PrimState m) (Mutable ks) k (Mutable vs) v -> m (FrozenDictionary ks k vs v)

-- | <i>O(1)</i> Unsafely convert immutable <a>FrozenDictionary</a> to a
--   mutable <a>Dictionary</a> without copying. The immutable dictionary
--   may not be used after this operation.
unsafeThaw :: forall (ks :: Type -> Type) k (vs :: Type -> Type) v m. (Vector ks k, Vector vs v, PrimMonad m) => FrozenDictionary ks k vs v -> m (Dictionary (PrimState m) (Mutable ks) k (Mutable vs) v)

-- | <i>O(n)</i> Convert list to a <a>Dictionary</a>.
fromList :: forall (ks :: Type -> Type -> Type) k (vs :: Type -> Type -> Type) v m. (MVector ks k, MVector vs v, PrimMonad m, Hashable k, Eq k) => [(k, v)] -> m (Dictionary (PrimState m) ks k vs v)

-- | <i>O(n)</i> Convert <a>Dictionary</a> to a list.
toList :: forall (ks :: Type -> Type -> Type) k (vs :: Type -> Type -> Type) v m. (MVector ks k, MVector vs v, PrimMonad m, Hashable k, Eq k) => Dictionary (PrimState m) ks k vs v -> m [(k, v)]

-- | Represents collection of hashtable internal primitive arrays and
--   vectors.
--   
--   <ul>
--   <li>hash codes,</li>
--   <li>references to the next element,</li>
--   <li>buckets,</li>
--   <li>keys</li>
--   <li>and values.</li>
--   </ul>
data Dictionary_ s (ks :: Type -> Type -> Type) k (vs :: Type -> Type -> Type) v
Dictionary :: !IntArray s -> !IntArray s -> !IntArray s -> !IntArray s -> !ks s k -> !vs s v -> {-# UNPACK #-} !FastRem -> Dictionary_ s (ks :: Type -> Type -> Type) k (vs :: Type -> Type -> Type) v
[hashCode] :: Dictionary_ s (ks :: Type -> Type -> Type) k (vs :: Type -> Type -> Type) v -> !IntArray s
[next] :: Dictionary_ s (ks :: Type -> Type -> Type) k (vs :: Type -> Type -> Type) v -> !IntArray s
[buckets] :: Dictionary_ s (ks :: Type -> Type -> Type) k (vs :: Type -> Type -> Type) v -> !IntArray s
[refs] :: Dictionary_ s (ks :: Type -> Type -> Type) k (vs :: Type -> Type -> Type) v -> !IntArray s
[key] :: Dictionary_ s (ks :: Type -> Type -> Type) k (vs :: Type -> Type -> Type) v -> !ks s k
[value] :: Dictionary_ s (ks :: Type -> Type -> Type) k (vs :: Type -> Type -> Type) v -> !vs s v
[remSize] :: Dictionary_ s (ks :: Type -> Type -> Type) k (vs :: Type -> Type -> Type) v -> {-# UNPACK #-} !FastRem

-- | <i>O(1)</i> in the best case, <i>O(n)</i> in the worst case. Same as
--   <a>findEntry</a>, but for <a>Dictionary_</a>.
findEntry_ :: forall (ks :: Type -> Type -> Type) k (vs :: Type -> Type -> Type) v m. (MVector ks k, MVector vs v, PrimMonad m, Hashable k, Eq k) => Dictionary_ (PrimState m) ks k vs v -> k -> m Int
class Monad m => PrimMonad (m :: Type -> Type) where {
    type PrimState (m :: Type -> Type);
}
primitive :: PrimMonad m => (State# (PrimState m) -> (# State# (PrimState m), a #)) -> m a

-- | <a>RealWorld</a> is deeply magical. It is <i>primitive</i>, but it is
--   not <i>unlifted</i> (hence <tt>ptrArg</tt>). We never manipulate
--   values of type <a>RealWorld</a>; it's only used in the type system, to
--   parameterise <a>State#</a>.
data RealWorld
noDuplicate :: PrimMonad m => m ()
class (PrimBase m, MonadPrim s m) => MonadPrimBase s (m :: Type -> Type)
class (PrimMonad m, s ~ PrimState m) => MonadPrim s (m :: Type -> Type)
class PrimMonad m => PrimBase (m :: Type -> Type)
internal :: PrimBase m => m a -> State# (PrimState m) -> (# State# (PrimState m), a #)
type family PrimState (m :: Type -> Type)
primitive_ :: PrimMonad m => (State# (PrimState m) -> State# (PrimState m)) -> m ()
liftPrim :: (PrimBase m1, PrimMonad m2, PrimState m1 ~ PrimState m2) => m1 a -> m2 a
primToPrim :: (PrimBase m1, PrimMonad m2, PrimState m1 ~ PrimState m2) => m1 a -> m2 a
primToIO :: (PrimBase m, PrimState m ~ RealWorld) => m a -> IO a
primToST :: PrimBase m => m a -> ST (PrimState m) a
ioToPrim :: (PrimMonad m, PrimState m ~ RealWorld) => IO a -> m a
stToPrim :: PrimMonad m => ST (PrimState m) a -> m a
unsafePrimToPrim :: (PrimBase m1, PrimMonad m2) => m1 a -> m2 a
unsafePrimToST :: PrimBase m => m a -> ST s a
unsafePrimToIO :: PrimBase m => m a -> IO a
unsafeSTToPrim :: PrimMonad m => ST s a -> m a
unsafeIOToPrim :: PrimMonad m => IO a -> m a
unsafeInlinePrim :: PrimBase m => m a -> a
unsafeInlineIO :: IO a -> a
unsafeInlineST :: ST s a -> a
touch :: PrimMonad m => a -> m ()
touchUnlifted :: forall m (a :: UnliftedType). PrimMonad m => a -> m ()
keepAlive :: PrimBase m => a -> m r -> m r
keepAliveUnlifted :: forall m (a :: UnliftedType) r. PrimBase m => a -> m r -> m r
evalPrim :: forall a m. PrimMonad m => a -> m a
unsafeInterleave :: PrimBase m => m a -> m a
unsafeDupableInterleave :: PrimBase m => m a -> m a
