Question

I want to compose operations that may fail, but there is a way to roll back.

For example – an external call to book a hotel room, and an external call to charge a credit card. Both of those calls may fail such as no rooms left, invalid credit card. Both have ways to roll back – cancel hotel room, cancel credit charge.

1. Is there a name for this type of (not real) atomic. Whenever i search for haskell transaction, I get STM.
2. Is there an abstraction, a way to compose them, or a library in haskell or any other language?

I feel you could write a monad Atomic T which will track these operations and roll them back if there is an exception.

Edit:

These operations may be IO operations. If the operations were only memory operations, as the two answers suggest, STM would suffice.

For example booking hotels would via HTTP requests. Database operations such as inserting records via socket communication.

In the real world, for irreversible operations there is a grace period before the operation will be done – e.g. credit cards payments and hotel bookings may be settled at the end of the day, and therefore it is fine to cancel before then.

Answer 1

If you need to resort to making your own monad, it will look something like this:

import Control.Exception (onException, throwIO)

newtype Rollbackable a = Rollbackable (IO (IO (), a))

runRollbackable :: Rollbackable a -> IO a
runRollbackable (Rollbackable m) = fmap snd m
    -- you might want this to catch exceptions and return IO (Either SomeException a) instead

instance Monad Rollbackable where
    return x = Rollbackable $ return (return (), x)
    Rollbackable m >>= f
       = do (rollback, x) <- m
            Rollbackable (f x `onException` rollback)

(You will probably want Functor and Applicative instances also, but they’re trivial.)

You would define your rollbackable primitive actions in this way:

rollbackableChargeCreditCard :: CardNumber -> CurrencyAmount -> Rollbackable CCTransactionRef
rollbackableChargeCreditCard ccno amount = Rollbackable
   $ do ref <- ioChargeCreditCard ccno amount
        return (ioUnchargeCreditCard ref, ref)

ioChargeCreditCard :: CardNumber -> CurrencyAmount -> IO CCTransactionRef
-- use throwIO on failure
ioUnchargeCreditCard :: CCTransactionRef -> IO ()
-- these both just do ordinary i/o

Then run them like so:

runRollbackable
   $ do price <- rollbackableReserveRoom roomRequirements when
        paymentRef <- rollbackableChargeCreditCard ccno price
        -- etc