Hi friends,

I have an STM transaction that needs some private, temporary state.
The most obvious way is to simply pass pure state as arguments, but
for efficiency, I would like this state to be some kind of mutable
array, like STArray.

I know, STM has TVars and TArray, but since this state is private to
the transaction, I am wondering if using TVars/TArrays for private
state might be overkill that will unnecessarily slow down the STM
commit process. The private state is, by definition, not shared, so
including it in the STM log and commit process is, as far as I can
tell, pointless.

ST and STArray still appear to be the most appropriate tools for the
private state, because STRefs and STArrays really, really are private.

So this basically means I want to interleave ST and STM in a "safe"
way. That is, if the STM transaction retries, I want the ST state to
be vaporised as well.

Ideally, I would love to be able to say something like this:

-- | Copy the value from the shared TVar into the private STRef.
load :: TVar a -> STRef a -> STSTM s ()
load shared private = do
  value <- liftSTM (readTVar shared)
  liftST (writeSTRef private value)

Naturally, that STRef must originate from a call to newSTRef earlier
in the same transaction and is private to it, just like the real ST
monad. As far as I can tell, I am not trying to weaken either ST or
STM in any way here.

I found the STMonadTrans package on Hackage [1] that claims to
implement ST as a monad transformer, STT, which sounds close to what I
want. While its documentation does not mention STM, it does say that
some monads are unsafe to use as a base monad for STT.

Is STMonadTrans safe to use with STM?

[1] https://hackage.haskell.org/package/STMonadTrans

Thanks,
Thomas Koster
_______________________________________________
Haskell-Cafe mailing list
Haskell-Cafe@haskell.org
http://mail.haskell.org/cgi-bin/mailman/listinfo/haskell-cafe