The deadline for the proposal to add Applicative and Alternative
instances for STM has passed. Nobody rejected and some people
accepted.
It would be great if somebody can apply the patches:
* http://hackage.haskell.org/trac/ghc/attachment/ticket/4076/stm_applicative-i...
* http://hackage.haskell.org/trac/ghc/attachment/ticket/4076/base_add_applicat...
Thanks,
Bas
On Tue, May 25, 2010 at 1:20 AM, Bas van Dijk
Hello,
This is just a reminder and summary of my proposal to add Applicative and Alternative instances for STM. We're in the second and last week of this proposal.
Ticket: http://hackage.haskell.org/trac/ghc/ticket/4076
Here's a description of the proposed patches:
* stm_applicative-instance-sequential-stm.dpatch: This patch adds an Applicative instance for Control.Sequential.STM. Note that it doesn't add an Alternative instance because sequential STM does not support retrying transactions.
Now for the regular STM there are actually two modules where we can define the Applicative and Alternative instances: GHC.Conc (which defines the type) and Control.Applicative (which defines the classes).
The former has the advantage that the Functor, Applicative and Monad instances are grouped together. The disadvantage is that it requires to import Control.Applicative via {-# SOURCE #-} because we get an import cycle otherwise and so also requires the Control/Applicative.hs-boot file. The following patch makes this change: * base_applicative-instance-stm.dpatch
More people like to add the instances to Control.Applicative however. The following patch makes that change: * base_add_applicative_and_alternative_instances_for_STM_to_Control.Applicative.dpatch
Note there's a related proposal with patches for moving the MonadPlus instance for STM from Control.Monad.STM to GHC.Conc to avoid an orphaned instance. See: http://hackage.haskell.org/trac/ghc/ticket/4077
One last thing, I actually used to different Applicative instances for STM:
The one in Control.Applicative: instance Applicative STM where pure = return (<*>) = ap
Or the one in GHC.Conc: instance Applicative STM where {-# INLINE pure #-} {-# INLINE (<*>) #-} pure = returnSTM (<*>) = appSTM
returnSTM :: a -> STM a returnSTM x = STM (\s -> (# s, x #))
appSTM :: STM (a -> b) -> STM a -> STM b appSTM (STM mf) (STM mx) = STM ( \s -> case mf s of (# s', f #) -> case mx s' of (# s'', x #) -> (# s'', f x #) )
Currently I don't have time to investigate if one is more efficient than the other. Does anybody have a hunch?
Regards,
Bas