Merge pull request #108 from input-output-hk/jdral/factor-out-checked-strict-mvar

Factor out checked `StrictMVar`s

Author: coot

.github/workflows/haskell.yml

@@ -130,11 +130,9 @@ jobs:
     - name: si-timers [test]
       run: cabal run si-timers:test
 
-    - name: strict-mvar [test] [unchecked]
-      run: cabal run --flag="-testchecked" strict-mvar:test
+    - name: strict-mvar [test]
+      run: cabal run strict-mvar:test
 
-    - name: strict-mvar [test] [checked]
-      run: cabal run --flag="+testchecked" strict-mvar:test
 
   stylish-haskell:
     runs-on: ubuntu-22.04

strict-mvar/CHANGELOG.md

@@ -6,19 +6,13 @@
 
 * Remove the `asserts` package flag.
 
-### Non breaking changes
+### Non-breaking changes
 
-* Add a `StrictMVar` with invariant checking in
-  `Control.Concurrent.Class.MonadMVar.Strict.Checked`.
-* Make the checked/unchecked `StrictMVar` modules drop-in replacements of one
-  another by unifying the interfaces. As a result,
-  `Control.Concurrent.Class.MonadMVar.Strict` now has `newMVarWithInvariant` and
-  `newEmptyMVarWithInvariant` functions that ignore the invariant argument.
+* Export `LazyMVar`.
 
 ### Patch
 
-* Functions that use invariant checking now correctly propagate `HasCallStack`
-  constraints.
+* Update cabal header fields like `author` and `category`.
 
 ## 1.1.0.0
 

strict-mvar/README.md

@@ -5,47 +5,3 @@ The `strict-mvar` package provides a strict interface to mutable variables
 for `MVar`s implementations from both
 [base](https://hackage.haskell.org/package/base-4.17.0.0/docs/Control-Concurrent-MVar.html)
 and [io-sim](https://github.com/input-output-hk/io-sim).
-
-## Checked and unchecked `StrictMVar`s
-
-There are currently two variant implementations of `StrictMVar`s in this package:
-* `Control.Concurrent.Class.MonadMVar.Strict`
-* `Control.Concurrent.Class.MonadMVar.Strict.Checked`
-
-The _unchecked_ module provides the simplest implementation of a `StrictMVar`: a
-light wrapper around lazy MVars that forces values to WHNF before they are put
-into the MVar. The _checked_ module does the exact same thing, but it has the
-additional feature that the user can provide an invariant that is checked each
-time a new value is placed inside the MVar. The two modules are drop-in
-replacements for one another: switching from `*.Strict` to `*.Strict.Checked`
-will enable invariant checking, while the converse will disable invariant
-checking. To facilitate drop-in replacement, both modules share the same
-interface, though in case of the `*.Strict` module, everything related to
-invariants will be ignored. This will be explicitly mentioned in the Haddock
-documentation of said definitions. For example:
-
-```haskell
--- | The given invariant will never be checked. 'newMVarWithInvariant' is a
--- light wrapper around 'newMVar', and is only included here to ensure that the
--- current module and "Control.Concurrent.Class.MonadMVar.Strict.Checked" are
--- drop-in replacements for one another.
-newMVarWithInvariant :: MonadMVar m
-                     => (a -> Maybe String)
-                     -> a
-                     -> m (StrictMVar m a)
-```
-
-**Note:** though the two modules are drop-in replacements for one another, the
-`StrictMVar` type from `*.Strict` and the `StrictMVar` type from
-`*.Strict.Checked` do not share the same internal representation, and so they
-are distinct types.
-
-## Guarantees for invariant checking
-
-Although all functions that modify a checked `StrictMVar` will check the
-invariant, we do *not* guarantee that the value inside the `StrictMVar` always
-satisfies the invariant. Instead, we *do* guarantee that if the `StrictMVar` is
-updated with a value that does not satisfy the invariant, an exception is thrown
-*after* the new value is written to the `StrictMVar`. The reason for this weaker
-guarantee is that leaving an `MVar` empty can lead to very hard to debug
-"blocked indefinitely" problems.

strict-mvar/src/Control/Concurrent/Class/MonadMVar/Strict.hs

@@ -3,10 +3,6 @@
 {-# LANGUAGE TypeOperators #-}
 
 -- | This module corresponds to "Control.Concurrent.MVar" in the @base@ package.
---
--- Use "Control.Concurrent.Class.MonadMVar.Strict.Checked" as a drop-in
--- replacement for the current module in case you want to check invariants on
--- the values inside 'StrictMVar's.
 module Control.Concurrent.Class.MonadMVar.Strict
   ( -- * StrictMVar
     StrictMVar
@@ -15,9 +11,7 @@ module Control.Concurrent.Class.MonadMVar.Strict
   , toLazyMVar
   , fromLazyMVar
   , newEmptyMVar
-  , newEmptyMVarWithInvariant
   , newMVar
-  , newMVarWithInvariant
   , takeMVar
   , putMVar
   , readMVar
@@ -71,28 +65,9 @@ fromLazyMVar = StrictMVar
 newEmptyMVar :: MonadMVar m => m (StrictMVar m a)
 newEmptyMVar = fromLazyMVar <$> Lazy.newEmptyMVar
 
--- | The given invariant will never be checked. 'newEmptyMVarWithInvariant' is a
--- light wrapper around 'newEmptyMVar', and is only included here to ensure that
--- the current module and "Control.Concurrent.Class.MonadMVar.Strict.Checked"
--- are drop-in replacements for one another.
-newEmptyMVarWithInvariant :: MonadMVar m
-                          => (a -> Maybe String)
-                          -> m (StrictMVar m a)
-newEmptyMVarWithInvariant _inv = StrictMVar <$> Lazy.newEmptyMVar
-
 newMVar :: MonadMVar m => a -> m (StrictMVar m a)
 newMVar !a = fromLazyMVar <$> Lazy.newMVar a
 
--- | The given invariant will never be checked. 'newMVarWithInvariant' is a
--- light wrapper around 'newMVar', and is only included here to ensure that the
--- current module and "Control.Concurrent.Class.MonadMVar.Strict.Checked" are
--- drop-in replacements for one another.
-newMVarWithInvariant :: MonadMVar m
-                     => (a -> Maybe String)
-                     -> a
-                     -> m (StrictMVar m a)
-newMVarWithInvariant _inv !a = StrictMVar <$> Lazy.newMVar a
-
 takeMVar :: MonadMVar m => StrictMVar m a -> m a
 takeMVar = Lazy.takeMVar . mvar
 

strict-mvar/src/Control/Concurrent/Class/MonadMVar/Strict/Checked.hs

@@ -26,10 +26,9 @@ library
   hs-source-dirs:      src
 
   exposed-modules:     Control.Concurrent.Class.MonadMVar.Strict
-                     , Control.Concurrent.Class.MonadMVar.Strict.Checked
   default-language:    Haskell2010
   build-depends:       base        >= 4.9 && <4.19,
-                       io-classes  >= 1.0 && <1.2
+                       io-classes  ^>= 1.1,
   ghc-options:         -Wall
                        -Wno-unticked-promoted-constructors
                        -Wcompat
@@ -38,18 +37,12 @@ library
                        -Wpartial-fields
                        -Widentities
 
-flag testchecked
-  description: Run tests for checked Strict MVars.
-  Default: False
-  Manual: True
-
 test-suite test
   type:                exitcode-stdio-1.0
   hs-source-dirs:      test
   main-is:             Main.hs
 
-  other-modules:       Test.Control.Concurrent.Class.MonadMVar.Strict.Checked
-                       Test.Control.Concurrent.Class.MonadMVar.Strict.WHNF
+  other-modules:       Test.Control.Concurrent.Class.MonadMVar.Strict.WHNF
                        Test.Utils
   default-language:    Haskell2010
   build-depends:       base >=4.9 && <4.19,
@@ -68,6 +61,3 @@ test-suite test
                        -Wpartial-fields
                        -Widentities
                        -fno-ignore-asserts
-
-  if flag(testchecked)
-    CPP-Options: -DTEST_CHECKED

strict-mvar/strict-mvar.cabal

@@ -1,11 +1,9 @@
 module Main where
 
-import qualified Test.Control.Concurrent.Class.MonadMVar.Strict.Checked as Checked
 import qualified Test.Control.Concurrent.Class.MonadMVar.Strict.WHNF as WHNF
 import           Test.Tasty
 
 main :: IO ()
 main = defaultMain $ testGroup "strict-mvar" [
-      Checked.tests
-    , WHNF.tests
+      WHNF.tests
     ]