add more functions that operate on MutablePrimArray

I would like to see primitive have more functions that work on MutablePrimArray. Below are some of the ones I've thought might be useful.

EDIT: I have made this list more concise, leaving only type signatures to make it easier to read (especially since the implementation of all these functions is rather trivial).

```haskell
-- | Create a MutablePrimArray with exactly one element
singletonMutablePrimArray
:: forall m a. (Prim a, PrimMonad m)
=> a
-> m (MutablePrimArray (PrimState m) a)

-- | Create a MutablePrimArray of the given length with the same value in each position
replicateMutablePrimArray
:: forall m a. (Prim a, PrimMonad m)
=> Int
-> a
-> m (MutablePrimArray (PrimState m) a)

-- | Modify everything in the MutablePrimArray.
modifyMutablePrimArray
:: forall m a. (Prim a, PrimMonad m)
=> (a -> a)
-> MutablePrimArray (PrimState m) a
-> m ()

-- | Map a function over a MutablePrimArray.
mapMutablePrimArray
:: forall m a b. (Prim a, Prim b, PrimMonad m)
=> (a -> b)
-> MutablePrimArray (PrimState m) a
-> m (MutablePrimArray (PrimState m) b)

-- | Indexed map over the elements of a mutable primitive array.
imapMutablePrimArray
:: forall m a b. (Prim a, Prim b, PrimMonad m)
=> (Int -> a -> b)
-> MutablePrimArray (PrimState m) a
-> m (MutablePrimArray (PrimState m) b)

-- | Generate a mutable prim array by evaluating the monadic generator function
-- at each index.
generateMutablePrimArray
:: forall m a. (Prim a, PrimMonad m)
=> Int -- ^ length
-> (Int -> m a) -- ^ generator
-> m (MutablePrimArray (PrimState m) a)

-- | Filter elements of a mutable primitive array according to a predicate.
filterMutablePrimArray
:: forall m a. (Prim a, PrimMonad m)
=> (a -> Bool)
-> MutablePrimArray (PrimState m) a
-> m (MutablePrimArray (PrimState m) a)

-- | Apply the monadic action to all elements of the MutablePrimArray, yielding a MutablePrimArray of results
mapMMutablePrimArray
:: forall m a b. (Prim a, Prim b, PrimMonad m)
=> (a -> m b)
-> MutablePrimArray (PrimState m) a
-> m (MutablePrimArray (PrimState m) b)

-- | Apply the monadic action to all elements of the mutable prim array, yielding a mutable primitive array of results. Equivalent to 'flip' 'mapM'.
forMMutablePrimArray :: forall m a b. (Prim a, Prim b, PrimMonad m)
=> MutablePrimArray (PrimState m) a
-> (a -> m b)
-> m (MutablePrimArray (PrimState m) b)

-- swap the values at the given index
swap
:: forall m a. (Prim a, PrimMonad m)
=> MutablePrimArray (PrimState m) a
-> Int
-> Int
-> m ()

```

cc @andrewthad