diff --git a/CHANGELOG.md b/CHANGELOG.md
--- a/CHANGELOG.md
+++ b/CHANGELOG.md
@@ -22,7 +22,7 @@
 Addition of new helper functions, plotting tools, tests, and Integrator monad.
 
 - helpers include: `toEmpirical` (list of samples to empirical distribution) and `toBins` (simple histogramming)
-- `Integrator` is an instance of `MonadSample` for numerical integration
+- `Integrator` is an instance of `MonadDistribution` for numerical integration
 - `notebooks` now contains working notebook-based tutorials and examples
 - new tests, including with conjugate distributions to compare analytic solution against inferred posterior
 - `models` directory is cleaned up. New sequential models using `pipes` package to represent monadic streams
diff --git a/README.md b/README.md
new file mode 100644
--- /dev/null
+++ b/README.md
@@ -0,0 +1,70 @@
+# [Monad-Bayes](https://monad-bayes-site.netlify.app/_site/about.html)
+
+A library for probabilistic programming in Haskell. 
+
+<!-- [![Hackage](https://img.shields.io/hackage/v/monad-bayes.svg)](https://hackage.haskell.org/package/monad-bayes)
+[![Stackage](http://stackage.org/package/monad-bayes/badge/lts)](http://stackage.org/lts/package/monad-bayes)
+[![Hackage Deps](https://img.shields.io/hackage-deps/v/monad-bayes.svg)](http://packdeps.haskellers.com/reverse/monad-bayes)
+[![Build status](https://badge.buildkite.com/147af088063e8619fcf52ecf93fa7dd3353a2e8a252ef8e6ad.svg?branch=master)](https://buildkite.com/tweag-1/monad-bayes) -->
+
+[See the website](https://monad-bayes-site.netlify.app/_site/about.html) for an overview of the documentation, library, tutorials, examples (and a link to this very source code). 
+
+<!-- Monad-Bayes is a library for **probabilistic programming in Haskell**. The emphasis is on composition of inference algorithms, and is implemented in terms of monad transformers. -->
+
+<!-- See the [documentation](https://monad-bayes.netlify.app/) for a quick-start user guide and a reference overview of how it all works. -->
+
+Created by [Adam Scibior][adam-web] ([@adscib][adam-github]), documentation, website and newer features by [Reuben][reuben-web], maintained by [Tweag][tweagio].
+
+## Project status
+
+Now that `monad-bayes` has been released on Hackage, and the documentation and the API has been updated, we will focus on adding new features. See the Github issues to get a sense of what is being prepared, and please feel free to make requests.
+
+## Background
+
+The basis for the code in this repository is the ICFP 2018 paper [2]. For the
+code associated with the Haskell2015 paper [1], see the [`haskell2015`
+tag][haskell2015-tag].
+
+[1] Adam M. Ścibior, Zoubin Ghahramani, and Andrew D. Gordon. 2015. [Practical
+probabilistic programming with monads][haskell2015-doi]. In _Proceedings of the
+2015 ACM SIGPLAN Symposium on Haskell_ (Haskell ’15), Association for Computing
+Machinery, Vancouver, BC, Canada, 165–176.
+
+[2] Adam M. Ścibior, Ohad Kammar, and Zoubin Ghahramani. 2018. [Functional
+programming for modular Bayesian inference][icfp2018-doi]. In _Proceedings of
+the ACM on Programming Languages_ Volume 2, ICFP (July 2018), 83:1–83:29.
+
+[3] Adam M. Ścibior. 2019. [Formally justified and modular Bayesian inference
+for probabilistic programs][thesis-doi]. Thesis. University of Cambridge.
+
+## Hacking
+
+1. Install `stack` by following [these instructions][stack-install].
+
+2. Clone the repository using one of these URLs:
+   ```
+   git clone git@github.com:tweag/monad-bayes.git
+   git clone https://github.com/tweag/monad-bayes.git
+   ```
+
+Now you can use `stack build`, `stack test` and `stack ghci`.
+
+**To view the notebooks, go to the website**. To use the notebooks interactively:
+
+1. Compile the source: `stack build`
+2. If you do not have `nix` [install it](https://nixos.org/download.html).
+3. Run `nix develop --system x86_64-darwin --extra-experimental-features nix-command --extra-experimental-features flakes` - this should open a nix shell. For Linux use `x86_64-linux` for `--system` option instead. 
+4. Run `jupyter-lab` from the nix shell to load the notebooks.
+
+Your mileage may vary. 
+
+[adam-github]: https://github.com/adscib
+[adam-web]: https://www.cs.ubc.ca/~ascibior/
+[reuben-web]: https://reubencohngordon.com/
+[haskell2015-doi]: https://doi.org/10.1145/2804302.2804317
+[haskell2015-tag]: https://github.com/tweag/monad-bayes/tree/haskell2015
+[icfp2018-doi]: https://doi.org/10.1145/3236778
+[models]: https://github.com/tweag/monad-bayes/tree/master/models
+[stack-install]: https://docs.haskellstack.org/en/stable/install_and_upgrade/
+[thesis-doi]: https://doi.org/10.17863/CAM.42233
+[tweagio]: https://tweag.io
diff --git a/benchmark/Single.hs b/benchmark/Single.hs
--- a/benchmark/Single.hs
+++ b/benchmark/Single.hs
@@ -1,7 +1,7 @@
 {-# LANGUAGE DerivingStrategies #-}
 {-# LANGUAGE ImportQualifiedPost #-}
 
-import Control.Monad.Bayes.Class (MonadInfer)
+import Control.Monad.Bayes.Class (MonadMeasure)
 import Control.Monad.Bayes.Inference.MCMC (MCMCConfig (..), Proposal (SingleSiteMH))
 import Control.Monad.Bayes.Inference.RMSMC (rmsmcBasic)
 import Control.Monad.Bayes.Inference.SMC
@@ -42,7 +42,7 @@
     'L' : 'D' : 'A' : n -> Just $ LDA (5, read n)
     _ -> Nothing
 
-getModel :: MonadInfer m => Model -> (Int, m String)
+getModel :: MonadMeasure m => Model -> (Int, m String)
 getModel model = (size model, program model)
   where
     size (LR n) = n
diff --git a/benchmark/Speed.hs b/benchmark/Speed.hs
--- a/benchmark/Speed.hs
+++ b/benchmark/Speed.hs
@@ -4,7 +4,7 @@
 
 module Main (main) where
 
-import Control.Monad.Bayes.Class (MonadInfer, MonadSample)
+import Control.Monad.Bayes.Class (MonadDistribution, MonadMeasure)
 import Control.Monad.Bayes.Inference.MCMC (MCMCConfig (MCMCConfig, numBurnIn, numMCMCSteps, proposal), Proposal (SingleSiteMH))
 import Control.Monad.Bayes.Inference.RMSMC (rmsmcDynamic)
 import Control.Monad.Bayes.Inference.SMC (SMCConfig (SMCConfig, numParticles, numSteps, resampler), smc)
@@ -39,7 +39,7 @@
   show (HMM xs) = "HMM" ++ show (length xs)
   show (LDA xs) = "LDA" ++ show (length $ head xs)
 
-buildModel :: MonadInfer m => Model -> m String
+buildModel :: MonadMeasure m => Model -> m String
 buildModel (LR dataset) = show <$> LogReg.logisticRegression dataset
 buildModel (HMM dataset) = show <$> HMM.hmm dataset
 buildModel (LDA dataset) = show <$> LDA.lda dataset
diff --git a/models/BetaBin.hs b/models/BetaBin.hs
--- a/models/BetaBin.hs
+++ b/models/BetaBin.hs
@@ -8,8 +8,8 @@
 -- The two formulations should be exactly equivalent, but only urn works with Dist.
 import Control.Monad (replicateM)
 import Control.Monad.Bayes.Class
-  ( MonadInfer,
-    MonadSample (bernoulli, uniform),
+  ( MonadDistribution (bernoulli, uniform),
+    MonadMeasure,
     condition,
   )
 import Control.Monad.State.Lazy (evalStateT, get, put)
@@ -17,14 +17,14 @@
 import Pipes.Prelude qualified as P hiding (show)
 
 -- | Beta-binomial model as an i.i.d. sequence conditionally on weight.
-latent :: MonadSample m => Int -> m [Bool]
+latent :: MonadDistribution m => Int -> m [Bool]
 latent n = do
   weight <- uniform 0 1
   replicateM n (bernoulli weight)
 
 -- | Beta-binomial as a random process.
 -- Equivalent to the above by De Finetti's theorem.
-urn :: MonadSample m => Int -> m [Bool]
+urn :: MonadDistribution m => Int -> m [Bool]
 urn n = flip evalStateT (1, 1) $ do
   replicateM n do
     (a, b) <- get
@@ -36,7 +36,7 @@
 
 -- | Beta-binomial as a random process.
 -- This time using the Pipes library, for a more pure functional style
-urnP :: MonadSample m => Int -> m [Bool]
+urnP :: MonadDistribution m => Int -> m [Bool]
 urnP n = P.toListM $ P.take n <-< P.unfoldr toss (1, 1)
   where
     toss (a, b) = do
@@ -47,7 +47,7 @@
 
 -- | A beta-binomial model where the first three states are True,True,False.
 -- The resulting distribution is on the remaining outcomes.
-cond :: MonadInfer m => m [Bool] -> m [Bool]
+cond :: MonadMeasure m => m [Bool] -> m [Bool]
 cond d = do
   ~(first : second : third : rest) <- d
   condition first
@@ -56,7 +56,7 @@
   return rest
 
 -- | The final conditional model, abstracting the representation.
-model :: MonadInfer m => (Int -> m [Bool]) -> Int -> m Int
+model :: MonadMeasure m => (Int -> m [Bool]) -> Int -> m Int
 model repr n = fmap count $ cond $ repr (n + 3)
   where
     -- Post-processing by counting the number of True values.
diff --git a/models/ConjugatePriors.hs b/models/ConjugatePriors.hs
--- a/models/ConjugatePriors.hs
+++ b/models/ConjugatePriors.hs
@@ -7,7 +7,7 @@
 import Control.Applicative (Applicative (liftA2))
 import Control.Foldl (fold)
 import Control.Foldl qualified as F
-import Control.Monad.Bayes.Class (Bayesian (..), MonadInfer, MonadSample (bernoulli, beta, gamma, normal), normalPdf)
+import Control.Monad.Bayes.Class (Bayesian (..), MonadDistribution (bernoulli, beta, gamma, normal), MonadMeasure, normalPdf)
 import Numeric.Log (Log (Exp))
 import Prelude
 
@@ -19,7 +19,7 @@
 
 -- | Posterior on the precision of the normal after the points are observed
 gammaNormalAnalytic ::
-  (MonadInfer m, Foldable t, Functor t) =>
+  (MonadMeasure m, Foldable t, Functor t) =>
   GammaParams ->
   t Double ->
   m Double
@@ -34,7 +34,7 @@
     b' = b + sum (fmap (** 2) points) / 2
 
 -- | Posterior on beta after the bernoulli sample
-betaBernoulliAnalytic :: (MonadInfer m, Foldable t) => BetaParams -> t Bool -> m Double
+betaBernoulliAnalytic :: (MonadMeasure m, Foldable t) => BetaParams -> t Bool -> m Double
 betaBernoulliAnalytic (a, b) points = beta a' b'
   where
     (n, s) = fold (liftA2 (,) F.length (F.premap (\case True -> 1; False -> 0) F.sum)) points
@@ -44,17 +44,17 @@
 bernoulliPdf :: Floating a => a -> Bool -> Log a
 bernoulliPdf p x = let numBool = if x then 1.0 else 0 in Exp $ log (p ** numBool * (1 - p) ** (1 - numBool))
 
-betaBernoulli' :: MonadInfer m => (Double, Double) -> Bayesian m Double Bool
+betaBernoulli' :: MonadMeasure m => (Double, Double) -> Bayesian m Double Bool
 betaBernoulli' (a, b) = Bayesian (beta a b) bernoulli bernoulliPdf
 
-normalNormal' :: MonadInfer m => Double -> (Double, Double) -> Bayesian m Double Double
+normalNormal' :: MonadMeasure m => Double -> (Double, Double) -> Bayesian m Double Double
 normalNormal' var (mu0, var0) = Bayesian (normal mu0 (sqrt var0)) (`normal` (sqrt var)) (`normalPdf` (sqrt var))
 
-gammaNormal' :: MonadInfer m => (Double, Double) -> Bayesian m Double Double
+gammaNormal' :: MonadMeasure m => (Double, Double) -> Bayesian m Double Double
 gammaNormal' (a, b) = Bayesian (gamma a (recip b)) (normal 0 . sqrt . recip) (normalPdf 0 . sqrt . recip)
 
 normalNormalAnalytic ::
-  (MonadInfer m, Foldable t) =>
+  (MonadMeasure m, Foldable t) =>
   Double ->
   NormalParams ->
   t Double ->
diff --git a/models/Dice.hs b/models/Dice.hs
--- a/models/Dice.hs
+++ b/models/Dice.hs
@@ -5,30 +5,30 @@
 
 import Control.Applicative (liftA2)
 import Control.Monad.Bayes.Class
-  ( MonadCond (score),
-    MonadInfer,
-    MonadSample (uniformD),
+  ( MonadDistribution (uniformD),
+    MonadFactor (score),
+    MonadMeasure,
     condition,
   )
 
 -- | A toss of a six-sided die.
-die :: MonadSample m => m Int
+die :: MonadDistribution m => m Int
 die = uniformD [1 .. 6]
 
 -- | A sum of outcomes of n independent tosses of six-sided dice.
-dice :: MonadSample m => Int -> m Int
+dice :: MonadDistribution m => Int -> m Int
 dice 1 = die
 dice n = liftA2 (+) die (dice (n - 1))
 
 -- | Toss of two dice where the output is greater than 4.
-diceHard :: MonadInfer m => m Int
+diceHard :: MonadMeasure m => m Int
 diceHard = do
   result <- dice 2
   condition (result > 4)
   return result
 
 -- | Toss of two dice with an artificial soft constraint.
-diceSoft :: MonadInfer m => m Int
+diceSoft :: MonadMeasure m => m Int
 diceSoft = do
   result <- dice 2
   score (1 / fromIntegral result)
diff --git a/models/HMM.hs b/models/HMM.hs
--- a/models/HMM.hs
+++ b/models/HMM.hs
@@ -4,9 +4,9 @@
 
 import Control.Monad (replicateM, when)
 import Control.Monad.Bayes.Class
-  ( MonadCond,
-    MonadInfer,
-    MonadSample (categorical, normal, uniformD),
+  ( MonadDistribution (categorical, normal, uniformD),
+    MonadFactor,
+    MonadMeasure,
     factor,
     normalPdf,
   )
@@ -39,7 +39,7 @@
   ]
 
 -- | The transition model.
-trans :: MonadSample m => Int -> m Int
+trans :: MonadDistribution m => Int -> m Int
 trans 0 = categorical $ fromList [0.1, 0.4, 0.5]
 trans 1 = categorical $ fromList [0.2, 0.6, 0.2]
 trans 2 = categorical $ fromList [0.15, 0.7, 0.15]
@@ -53,11 +53,11 @@
 emissionMean _ = error "unreachable"
 
 -- | Initial state distribution
-start :: MonadSample m => m Int
+start :: MonadDistribution m => m Int
 start = uniformD [0, 1, 2]
 
 -- | Example HMM from http://dl.acm.org/citation.cfm?id=2804317
-hmm :: (MonadInfer m) => [Double] -> m [Int]
+hmm :: (MonadMeasure m) => [Double] -> m [Int]
 hmm dataset = f dataset (const . return)
   where
     expand x y = do
@@ -67,7 +67,7 @@
     f [] k = start >>= k []
     f (y : ys) k = f ys (\xs x -> expand x y >>= k (x : xs))
 
-syntheticData :: MonadSample m => Int -> m [Double]
+syntheticData :: MonadDistribution m => Int -> m [Double]
 syntheticData n = replicateM n syntheticPoint
   where
     syntheticPoint = uniformD [0, 1, 2]
@@ -75,7 +75,7 @@
 -- | Equivalent model, but using pipes for simplicity
 
 -- | Prior expressed as a stream
-hmmPrior :: MonadSample m => Producer Int m b
+hmmPrior :: MonadDistribution m => Producer Int m b
 hmmPrior = do
   x <- lift start
   yield x
@@ -86,19 +86,19 @@
 hmmObservations dataset = each (Nothing : (Just <$> reverse dataset))
 
 -- | Posterior expressed as a stream
-hmmPosterior :: (MonadInfer m) => [Double] -> Producer Int m ()
+hmmPosterior :: (MonadMeasure m) => [Double] -> Producer Int m ()
 hmmPosterior dataset =
   zipWithM
     hmmLikelihood
     hmmPrior
     (hmmObservations dataset)
   where
-    hmmLikelihood :: MonadCond f => (Int, Maybe Double) -> f ()
+    hmmLikelihood :: MonadFactor f => (Int, Maybe Double) -> f ()
     hmmLikelihood (l, o) = when (isJust o) (factor $ normalPdf (emissionMean l) 1 (fromJust o))
 
     zipWithM f p1 p2 = Pipes.zip p1 p2 >-> Pipes.chain f >-> Pipes.map fst
 
-hmmPosteriorPredictive :: MonadSample m => [Double] -> Producer Double m ()
+hmmPosteriorPredictive :: MonadDistribution m => [Double] -> Producer Double m ()
 hmmPosteriorPredictive dataset =
   Pipes.hoist enumerateToDistribution (hmmPosterior dataset)
     >-> Pipes.mapM (\x -> normal (emissionMean x) 1)
diff --git a/models/LDA.hs b/models/LDA.hs
--- a/models/LDA.hs
+++ b/models/LDA.hs
@@ -11,8 +11,8 @@
 
 import Control.Monad qualified as List (replicateM)
 import Control.Monad.Bayes.Class
-  ( MonadInfer,
-    MonadSample (categorical, dirichlet, uniformD),
+  ( MonadDistribution (categorical, dirichlet, uniformD),
+    MonadMeasure,
     factor,
   )
 import Control.Monad.Bayes.Sampler.Strict (sampleIO, sampleIOfixed)
@@ -43,17 +43,17 @@
     words "bear wolf bear python bear wolf bear wolf bear wolf"
   ]
 
-wordDistPrior :: MonadSample m => m (V.Vector Double)
+wordDistPrior :: MonadDistribution m => m (V.Vector Double)
 wordDistPrior = dirichlet $ V.replicate (length vocabulary) 1
 
-topicDistPrior :: MonadSample m => m (V.Vector Double)
+topicDistPrior :: MonadDistribution m => m (V.Vector Double)
 topicDistPrior = dirichlet $ V.replicate (length topics) 1
 
 wordIndex :: Map.Map Text Int
 wordIndex = Map.fromList $ zip vocabulary [0 ..]
 
 lda ::
-  MonadInfer m =>
+  MonadMeasure m =>
   Documents ->
   m (Map.Map Text (V.Vector (Text, Double)), [(Text, V.Vector (Text, Double))])
 lda docs = do
@@ -73,7 +73,7 @@
       zip (fmap (foldr1 (\x y -> x <> " " <> y)) docs) (fmap (V.zip $ V.fromList ["topic1", "topic2"]) td)
     )
 
-syntheticData :: MonadSample m => Int -> Int -> m [[Text]]
+syntheticData :: MonadDistribution m => Int -> Int -> m [[Text]]
 syntheticData d w = List.replicateM d (List.replicateM w syntheticWord)
   where
     syntheticWord = uniformD vocabulary
diff --git a/models/LogReg.hs b/models/LogReg.hs
--- a/models/LogReg.hs
+++ b/models/LogReg.hs
@@ -7,13 +7,13 @@
 
 import Control.Monad (replicateM)
 import Control.Monad.Bayes.Class
-  ( MonadInfer,
-    MonadSample (bernoulli, gamma, normal, uniform),
+  ( MonadDistribution (bernoulli, gamma, normal, uniform),
+    MonadMeasure,
     factor,
   )
 import Numeric.Log (Log (Exp))
 
-logisticRegression :: MonadInfer m => [(Double, Bool)] -> m Double
+logisticRegression :: MonadMeasure m => [(Double, Bool)] -> m Double
 logisticRegression dat = do
   m <- normal 0 1
   b <- normal 0 1
@@ -27,7 +27,7 @@
   sigmoid 8
 
 -- make a synthetic dataset by randomly choosing input-label pairs
-syntheticData :: MonadSample m => Int -> m [(Double, Bool)]
+syntheticData :: MonadDistribution m => Int -> m [(Double, Bool)]
 syntheticData n = replicateM n do
   x <- uniform (-1) 1
   label <- bernoulli 0.5
diff --git a/models/NonlinearSSM.hs b/models/NonlinearSSM.hs
--- a/models/NonlinearSSM.hs
+++ b/models/NonlinearSSM.hs
@@ -1,13 +1,13 @@
 module NonlinearSSM where
 
 import Control.Monad.Bayes.Class
-  ( MonadInfer,
-    MonadSample (gamma, normal),
+  ( MonadDistribution (gamma, normal),
+    MonadMeasure,
     factor,
     normalPdf,
   )
 
-param :: MonadSample m => m (Double, Double)
+param :: MonadDistribution m => m (Double, Double)
 param = do
   let a = 0.01
   let b = 0.01
@@ -23,7 +23,7 @@
 -- | A nonlinear series model from Doucet et al. (2000)
 -- "On sequential Monte Carlo sampling methods" section VI.B
 model ::
-  (MonadInfer m) =>
+  (MonadMeasure m) =>
   -- | observed data
   [Double] ->
   -- | prior on the parameters
@@ -43,7 +43,7 @@
   return $ reverse xs
 
 generateData ::
-  MonadSample m =>
+  MonadDistribution m =>
   -- | T
   Int ->
   -- | list of latent and observable states from t=1
diff --git a/models/Sprinkler.hs b/models/Sprinkler.hs
--- a/models/Sprinkler.hs
+++ b/models/Sprinkler.hs
@@ -3,7 +3,7 @@
 import Control.Monad (when)
 import Control.Monad.Bayes.Class
 
-hard :: MonadInfer m => m Bool
+hard :: MonadMeasure m => m Bool
 hard = do
   rain <- bernoulli 0.3
   sprinkler <- bernoulli $ if rain then 0.1 else 0.4
@@ -15,7 +15,7 @@
   condition (not wet)
   return rain
 
-soft :: MonadInfer m => m Bool
+soft :: MonadMeasure m => m Bool
 soft = do
   rain <- bernoulli 0.3
   when rain (factor 0.2)
diff --git a/monad-bayes.cabal b/monad-bayes.cabal
--- a/monad-bayes.cabal
+++ b/monad-bayes.cabal
@@ -1,6 +1,6 @@
 cabal-version:      2.0
 name:               monad-bayes
-version:            1.0.0
+version:            1.1.0
 license:            MIT
 license-file:       LICENSE.md
 copyright:          2015-2020 Adam Scibior
@@ -15,10 +15,15 @@
   A library for probabilistic programming using probability monads. The
   emphasis is on composition of inference algorithms implemented in
   terms of monad transformers.
+  Please refer to the [documentation](https://monad-bayes.netlify.app/)
+  for a quick-start user guide and a reference overview of how it all
+  works" and the included [README](#readme).
 
 category:           Statistics
 build-type:         Simple
-extra-source-files: CHANGELOG.md
+extra-source-files:
+  CHANGELOG.md
+  README.md
 
 source-repository head
   type:     git
@@ -60,7 +65,7 @@
   default-language:   Haskell2010
   build-depends:
       base             >=4.11   && <4.17
-    , brick
+    , brick            >=1.0    && <2.0
     , containers       >=0.5.10 && <0.7
     , foldl
     , free             >=5.0.2  && <5.2
@@ -97,7 +102,7 @@
 
   if flag(dev)
     ghc-options:
-      -O2 -Wall -Wno-missing-local-signatures -Wno-trustworthy-safe
+      -Wall -Wno-missing-local-signatures -Wno-trustworthy-safe
       -Wno-missing-import-lists -Wno-implicit-prelude
       -Wno-monomorphism-restriction
 
@@ -131,7 +136,7 @@
 
   if flag(dev)
     ghc-options:
-      -O2 -Wall -Wcompat -Wincomplete-record-updates
+      -Wall -Wcompat -Wincomplete-record-updates
       -Wincomplete-uni-patterns -Wnoncanonical-monad-instances
 
   else
diff --git a/src/Control/Monad/Bayes/Class.hs b/src/Control/Monad/Bayes/Class.hs
--- a/src/Control/Monad/Bayes/Class.hs
+++ b/src/Control/Monad/Bayes/Class.hs
@@ -12,14 +12,14 @@
 -- Stability   : experimental
 -- Portability : GHC
 --
--- This module defines 'MonadInfer', which can be used to represent any probabilistic program,
+-- This module defines 'MonadMeasure', which can be used to represent any probabilistic program,
 -- such as the following:
 --
 -- @
 -- import Control.Monad (when)
 -- import Control.Monad.Bayes.Class
 --
--- model :: MonadInfer m => m Bool
+-- model :: MonadMeasure m => m Bool
 -- model = do
 --   rain <- bernoulli 0.3
 --   sprinkler <-
@@ -37,7 +37,7 @@
 --   return rain
 -- @
 module Control.Monad.Bayes.Class
-  ( MonadSample,
+  ( MonadDistribution,
     random,
     uniform,
     normal,
@@ -50,11 +50,11 @@
     geometric,
     poisson,
     dirichlet,
-    MonadCond,
+    MonadFactor,
     score,
     factor,
     condition,
-    MonadInfer,
+    MonadMeasure,
     discrete,
     normalPdf,
     Bayesian (..),
@@ -106,7 +106,7 @@
 import Statistics.Distribution.Uniform (uniformDistr)
 
 -- | Monads that can draw random variables.
-class Monad m => MonadSample m where
+class Monad m => MonadDistribution m where
   -- | Draw from a uniform distribution.
   random ::
     -- | \(\sim \mathcal{U}(0, 1)\)
@@ -220,12 +220,12 @@
 
 -- | Draw from a continuous distribution using the inverse cumulative density
 -- function.
-draw :: (ContDistr d, MonadSample m) => d -> m Double
+draw :: (ContDistr d, MonadDistribution m) => d -> m Double
 draw d = fmap (quantile d) random
 
 -- | Draw from a discrete distribution using a sequence of draws from
 -- Bernoulli.
-fromPMF :: MonadSample m => (Int -> Double) -> m Int
+fromPMF :: MonadDistribution m => (Int -> Double) -> m Int
 fromPMF p = f 0 1
   where
     f i r = do
@@ -236,11 +236,11 @@
       if b then pure i else f (i + 1) (r - q)
 
 -- | Draw from a discrete distributions using the probability mass function.
-discrete :: (DiscreteDistr d, MonadSample m) => d -> m Int
+discrete :: (DiscreteDistr d, MonadDistribution m) => d -> m Int
 discrete = fromPMF . probability
 
 -- | Monads that can score different execution paths.
-class Monad m => MonadCond m where
+class Monad m => MonadFactor m where
   -- | Record a likelihood.
   score ::
     -- | likelihood of the execution path
@@ -249,7 +249,7 @@
 
 -- | Synonym for 'score'.
 factor ::
-  MonadCond m =>
+  MonadFactor m =>
   -- | likelihood of the execution path
   Log Double ->
   m ()
@@ -257,21 +257,21 @@
 
 -- | synonym for pretty type signatures, but note that (A -> Distribution B) won't work as intended: for that, use Kernel
 -- Also note that the use of RankNTypes means performance may take a hit: really the main point of these signatures is didactic
-type Distribution a = forall m. MonadSample m => m a
+type Distribution a = forall m. MonadDistribution m => m a
 
-type Measure a = forall m. MonadInfer m => m a
+type Measure a = forall m. MonadMeasure m => m a
 
-type Kernel a b = forall m. MonadInfer m => a -> m b
+type Kernel a b = forall m. MonadMeasure m => a -> m b
 
 -- | Hard conditioning.
-condition :: MonadCond m => Bool -> m ()
+condition :: MonadFactor m => Bool -> m ()
 condition b = score $ if b then 1 else 0
 
 independent :: Applicative m => Int -> m a -> m [a]
 independent = replicateM
 
 -- | Monads that support both sampling and scoring.
-class (MonadSample m, MonadCond m) => MonadInfer m
+class (MonadDistribution m, MonadFactor m) => MonadMeasure m
 
 -- | Probability density function of the normal distribution.
 normalPdf ::
@@ -286,7 +286,7 @@
 normalPdf mu sigma x = Exp $ logDensity (normalDistr mu sigma) x
 
 -- | multivariate normal
-mvNormal :: MonadSample m => V.Vector Double -> Matrix Double -> m (V.Vector Double)
+mvNormal :: MonadDistribution m => V.Vector Double -> Matrix Double -> m (V.Vector Double)
 mvNormal mu bigSigma = do
   let n = length mu
   ss <- replicateM n (normal 0 1)
@@ -296,12 +296,13 @@
 
 -- | a useful datatype for expressing bayesian models
 data Bayesian m z o = Bayesian
-  { prior :: m z, -- prior over latent variable Z
-    generative :: z -> m o, -- distribution over observations given Z=z
+  { prior :: m z, -- prior over latent variable Z; p(z)
+    generative :: z -> m o, -- distribution over observations given Z=z; p(o|Z=z)
     likelihood :: z -> o -> Log Double -- p(o|z)
   }
 
-posterior :: (MonadInfer m, Foldable f, Functor f) => Bayesian m z o -> f o -> m z
+-- | p(z|o)
+posterior :: (MonadMeasure m, Foldable f, Functor f) => Bayesian m z o -> f o -> m z
 posterior Bayesian {..} os = do
   z <- prior
   factor $ product $ fmap (likelihood z) os
@@ -311,7 +312,7 @@
 priorPredictive bm = prior bm >>= generative bm
 
 posteriorPredictive ::
-  (MonadInfer m, Foldable f, Functor f) =>
+  (MonadMeasure m, Foldable f, Functor f) =>
   Bayesian m a b ->
   f b ->
   m b
@@ -337,68 +338,68 @@
 ----------------------------------------------------------------------------
 -- Instances that lift probabilistic effects to standard tranformers.
 
-instance MonadSample m => MonadSample (IdentityT m) where
+instance MonadDistribution m => MonadDistribution (IdentityT m) where
   random = lift random
   bernoulli = lift . bernoulli
 
-instance MonadCond m => MonadCond (IdentityT m) where
+instance MonadFactor m => MonadFactor (IdentityT m) where
   score = lift . score
 
-instance MonadInfer m => MonadInfer (IdentityT m)
+instance MonadMeasure m => MonadMeasure (IdentityT m)
 
-instance MonadSample m => MonadSample (ExceptT e m) where
+instance MonadDistribution m => MonadDistribution (ExceptT e m) where
   random = lift random
   uniformD = lift . uniformD
 
-instance MonadCond m => MonadCond (ExceptT e m) where
+instance MonadFactor m => MonadFactor (ExceptT e m) where
   score = lift . score
 
-instance MonadInfer m => MonadInfer (ExceptT e m)
+instance MonadMeasure m => MonadMeasure (ExceptT e m)
 
-instance MonadSample m => MonadSample (ReaderT r m) where
+instance MonadDistribution m => MonadDistribution (ReaderT r m) where
   random = lift random
   bernoulli = lift . bernoulli
 
-instance MonadCond m => MonadCond (ReaderT r m) where
+instance MonadFactor m => MonadFactor (ReaderT r m) where
   score = lift . score
 
-instance MonadInfer m => MonadInfer (ReaderT r m)
+instance MonadMeasure m => MonadMeasure (ReaderT r m)
 
-instance (Monoid w, MonadSample m) => MonadSample (WriterT w m) where
+instance (Monoid w, MonadDistribution m) => MonadDistribution (WriterT w m) where
   random = lift random
   bernoulli = lift . bernoulli
   categorical = lift . categorical
 
-instance (Monoid w, MonadCond m) => MonadCond (WriterT w m) where
+instance (Monoid w, MonadFactor m) => MonadFactor (WriterT w m) where
   score = lift . score
 
-instance (Monoid w, MonadInfer m) => MonadInfer (WriterT w m)
+instance (Monoid w, MonadMeasure m) => MonadMeasure (WriterT w m)
 
-instance MonadSample m => MonadSample (StateT s m) where
+instance MonadDistribution m => MonadDistribution (StateT s m) where
   random = lift random
   bernoulli = lift . bernoulli
   categorical = lift . categorical
   uniformD = lift . uniformD
 
-instance MonadCond m => MonadCond (StateT s m) where
+instance MonadFactor m => MonadFactor (StateT s m) where
   score = lift . score
 
-instance MonadInfer m => MonadInfer (StateT s m)
+instance MonadMeasure m => MonadMeasure (StateT s m)
 
-instance MonadSample m => MonadSample (ListT m) where
+instance MonadDistribution m => MonadDistribution (ListT m) where
   random = lift random
   bernoulli = lift . bernoulli
   categorical = lift . categorical
 
-instance MonadCond m => MonadCond (ListT m) where
+instance MonadFactor m => MonadFactor (ListT m) where
   score = lift . score
 
-instance MonadInfer m => MonadInfer (ListT m)
+instance MonadMeasure m => MonadMeasure (ListT m)
 
-instance MonadSample m => MonadSample (ContT r m) where
+instance MonadDistribution m => MonadDistribution (ContT r m) where
   random = lift random
 
-instance MonadCond m => MonadCond (ContT r m) where
+instance MonadFactor m => MonadFactor (ContT r m) where
   score = lift . score
 
-instance MonadInfer m => MonadInfer (ContT r m)
+instance MonadMeasure m => MonadMeasure (ContT r m)
diff --git a/src/Control/Monad/Bayes/Density/Free.hs b/src/Control/Monad/Bayes/Density/Free.hs
--- a/src/Control/Monad/Bayes/Density/Free.hs
+++ b/src/Control/Monad/Bayes/Density/Free.hs
@@ -23,7 +23,7 @@
   )
 where
 
-import Control.Monad.Bayes.Class (MonadSample (random))
+import Control.Monad.Bayes.Class (MonadDistribution (random))
 import Control.Monad.RWS
 import Control.Monad.State (evalStateT)
 import Control.Monad.Trans.Free.Church (FT, MonadFree (..), hoistFT, iterT, iterTM, liftF)
@@ -42,7 +42,7 @@
 instance MonadFree SamF (Density m) where
   wrap = Density . wrap . fmap runDensity
 
-instance Monad m => MonadSample (Density m) where
+instance Monad m => MonadDistribution (Density m) where
   random = Density $ liftF (Random id)
 
 -- | Hoist 'Density' through a monad transform.
@@ -50,7 +50,7 @@
 hoist f (Density m) = Density (hoistFT f m)
 
 -- | Execute random sampling in the transformed monad.
-interpret :: MonadSample m => Density m a -> m a
+interpret :: MonadDistribution m => Density m a -> m a
 interpret (Density m) = iterT f m
   where
     f (Random k) = random >>= k
@@ -68,7 +68,7 @@
 -- | Execute computation with supplied values for a subset of random choices.
 -- Return the output value and a record of all random choices used, whether
 -- taken as input or drawn using the transformed monad.
-density :: MonadSample m => [Double] -> Density m a -> m (a, [Double])
+density :: MonadDistribution m => [Double] -> Density m a -> m (a, [Double])
 density randomness (Density m) =
   runWriterT $ evalStateT (iterTM f $ hoistFT lift m) randomness
   where
@@ -84,5 +84,5 @@
       k x
 
 -- | Like 'density', but use an arbitrary sampling monad.
-traced :: MonadSample m => [Double] -> Density Identity a -> m (a, [Double])
+traced :: MonadDistribution m => [Double] -> Density Identity a -> m (a, [Double])
 traced randomness m = density randomness $ hoist (return . runIdentity) m
diff --git a/src/Control/Monad/Bayes/Density/State.hs b/src/Control/Monad/Bayes/Density/State.hs
--- a/src/Control/Monad/Bayes/Density/State.hs
+++ b/src/Control/Monad/Bayes/Density/State.hs
@@ -9,7 +9,7 @@
 -- monad transformer techniques.
 module Control.Monad.Bayes.Density.State where
 
-import Control.Monad.Bayes.Class (MonadSample (random))
+import Control.Monad.Bayes.Class (MonadDistribution (random))
 import Control.Monad.State (MonadState (get, put), StateT, evalStateT)
 import Control.Monad.Writer
 
@@ -27,7 +27,7 @@
   listen = Density . listen . runDensity
   pass = Density . pass . runDensity
 
-instance MonadSample m => MonadSample (Density m) where
+instance MonadDistribution m => MonadDistribution (Density m) where
   random = do
     trace <- get
     x <- case trace of
diff --git a/src/Control/Monad/Bayes/Enumerator.hs b/src/Control/Monad/Bayes/Enumerator.hs
--- a/src/Control/Monad/Bayes/Enumerator.hs
+++ b/src/Control/Monad/Bayes/Enumerator.hs
@@ -33,9 +33,9 @@
 import Control.Applicative (Alternative)
 import Control.Arrow (second)
 import Control.Monad.Bayes.Class
-  ( MonadCond (..),
-    MonadInfer,
-    MonadSample (bernoulli, categorical, logCategorical, random),
+  ( MonadDistribution (bernoulli, categorical, logCategorical, random),
+    MonadFactor (..),
+    MonadMeasure,
   )
 import Control.Monad.Writer
 import Data.AEq (AEq, (===), (~==))
@@ -52,15 +52,15 @@
 newtype Enumerator a = Enumerator (WriterT (Product (Log Double)) [] a)
   deriving newtype (Functor, Applicative, Monad, Alternative, MonadPlus)
 
-instance MonadSample Enumerator where
+instance MonadDistribution Enumerator where
   random = error "Infinitely supported random variables not supported in Enumerator"
   bernoulli p = fromList [(True, (Exp . log) p), (False, (Exp . log) (1 - p))]
   categorical v = fromList $ zip [0 ..] $ map (Exp . log) (V.toList v)
 
-instance MonadCond Enumerator where
+instance MonadFactor Enumerator where
   score w = fromList [((), w)]
 
-instance MonadInfer Enumerator
+instance MonadMeasure Enumerator
 
 -- | Construct Enumerator from a list of values and associated weights.
 fromList :: [(a, Log Double)] -> Enumerator a
@@ -129,7 +129,7 @@
 toEmpiricalWeighted :: (Fractional b, Ord a, Ord b) => [(a, b)] -> [(a, b)]
 toEmpiricalWeighted = normalizeWeights . compact
 
-enumerateToDistribution :: (MonadSample n) => Enumerator a -> n a
+enumerateToDistribution :: (MonadDistribution n) => Enumerator a -> n a
 enumerateToDistribution model = do
   let samples = logExplicit model
   let (support, logprobs) = unzip samples
diff --git a/src/Control/Monad/Bayes/Inference/MCMC.hs b/src/Control/Monad/Bayes/Inference/MCMC.hs
--- a/src/Control/Monad/Bayes/Inference/MCMC.hs
+++ b/src/Control/Monad/Bayes/Inference/MCMC.hs
@@ -11,12 +11,17 @@
 -- Portability : GHC
 module Control.Monad.Bayes.Inference.MCMC where
 
-import Control.Monad.Bayes.Class
+import Control.Monad.Bayes.Class (MonadDistribution)
 import qualified Control.Monad.Bayes.Traced.Basic as Basic
 import Control.Monad.Bayes.Traced.Common
+  ( MHResult (MHResult, trace),
+    Trace (probDensity),
+    burnIn,
+    mhTransWithBool,
+  )
 import qualified Control.Monad.Bayes.Traced.Dynamic as Dynamic
 import qualified Control.Monad.Bayes.Traced.Static as Static
-import Control.Monad.Bayes.Weighted
+import Control.Monad.Bayes.Weighted (Weighted, unweighted)
 import Pipes ((>->))
 import qualified Pipes as P
 import qualified Pipes.Prelude as P
@@ -28,13 +33,13 @@
 defaultMCMCConfig :: MCMCConfig
 defaultMCMCConfig = MCMCConfig {proposal = SingleSiteMH, numMCMCSteps = 1, numBurnIn = 0}
 
-mcmc :: MonadSample m => MCMCConfig -> Static.Traced (Weighted m) a -> m [a]
+mcmc :: MonadDistribution m => MCMCConfig -> Static.Traced (Weighted m) a -> m [a]
 mcmc (MCMCConfig {..}) m = burnIn numBurnIn $ unweighted $ Static.mh numMCMCSteps m
 
-mcmcBasic :: MonadSample m => MCMCConfig -> Basic.Traced (Weighted m) a -> m [a]
+mcmcBasic :: MonadDistribution m => MCMCConfig -> Basic.Traced (Weighted m) a -> m [a]
 mcmcBasic (MCMCConfig {..}) m = burnIn numBurnIn $ unweighted $ Basic.mh numMCMCSteps m
 
-mcmcDynamic :: MonadSample m => MCMCConfig -> Dynamic.Traced (Weighted m) a -> m [a]
+mcmcDynamic :: MonadDistribution m => MCMCConfig -> Dynamic.Traced (Weighted m) a -> m [a]
 mcmcDynamic (MCMCConfig {..}) m = burnIn numBurnIn $ unweighted $ Dynamic.mh numMCMCSteps m
 
 -- -- | draw iid samples until you get one that has non-zero likelihood
@@ -45,7 +50,7 @@
     >-> P.map (MHResult False)
 
 -- | convert a probabilistic program into a producer of samples
-mcmcP :: MonadSample m => MCMCConfig -> Static.Traced m a -> P.Producer (MHResult a) m ()
+mcmcP :: MonadDistribution m => MCMCConfig -> Static.Traced m a -> P.Producer (MHResult a) m ()
 mcmcP MCMCConfig {..} m@(Static.Traced w _) = do
   initialValue <- independentSamples m >-> P.drain
   ( P.unfoldr (fmap (Right . (\k -> (k, trace k))) . mhTransWithBool w) initialValue
diff --git a/src/Control/Monad/Bayes/Inference/PMMH.hs b/src/Control/Monad/Bayes/Inference/PMMH.hs
--- a/src/Control/Monad/Bayes/Inference/PMMH.hs
+++ b/src/Control/Monad/Bayes/Inference/PMMH.hs
@@ -18,7 +18,7 @@
   )
 where
 
-import Control.Monad.Bayes.Class (Bayesian (generative), MonadInfer, MonadSample, prior)
+import Control.Monad.Bayes.Class (Bayesian (generative), MonadDistribution, MonadMeasure, prior)
 import Control.Monad.Bayes.Inference.MCMC (MCMCConfig, mcmc)
 import Control.Monad.Bayes.Inference.SMC (SMCConfig (), smc)
 import Control.Monad.Bayes.Population as Pop
@@ -35,7 +35,7 @@
 
 -- | Particle Marginal Metropolis-Hastings sampling.
 pmmh ::
-  MonadSample m =>
+  MonadDistribution m =>
   MCMCConfig ->
   SMCConfig (Weighted m) ->
   Traced (Weighted m) a1 ->
@@ -54,9 +54,9 @@
 
 -- | Particle Marginal Metropolis-Hastings sampling from a Bayesian model
 pmmhBayesianModel ::
-  MonadInfer m =>
+  MonadMeasure m =>
   MCMCConfig ->
   SMCConfig (Weighted m) ->
-  (forall m'. MonadInfer m' => Bayesian m' a1 a2) ->
+  (forall m'. MonadMeasure m' => Bayesian m' a1 a2) ->
   m [[(a2, Log Double)]]
 pmmhBayesianModel mcmcConf smcConf bm = pmmh mcmcConf smcConf (prior bm) (generative bm)
diff --git a/src/Control/Monad/Bayes/Inference/RMSMC.hs b/src/Control/Monad/Bayes/Inference/RMSMC.hs
--- a/src/Control/Monad/Bayes/Inference/RMSMC.hs
+++ b/src/Control/Monad/Bayes/Inference/RMSMC.hs
@@ -20,7 +20,7 @@
   )
 where
 
-import Control.Monad.Bayes.Class (MonadSample)
+import Control.Monad.Bayes.Class (MonadDistribution)
 import Control.Monad.Bayes.Inference.MCMC (MCMCConfig (..))
 import Control.Monad.Bayes.Inference.SMC
 import Control.Monad.Bayes.Population
@@ -42,7 +42,7 @@
 
 -- | Resample-move Sequential Monte Carlo.
 rmsmc ::
-  MonadSample m =>
+  MonadDistribution m =>
   MCMCConfig ->
   SMCConfig m ->
   -- | model
@@ -56,7 +56,7 @@
 -- | Resample-move Sequential Monte Carlo with a more efficient
 -- tracing representation.
 rmsmcBasic ::
-  MonadSample m =>
+  MonadDistribution m =>
   MCMCConfig ->
   SMCConfig m ->
   -- | model
@@ -71,7 +71,7 @@
 -- where only random variables since last resampling are considered
 -- for rejuvenation.
 rmsmcDynamic ::
-  MonadSample m =>
+  MonadDistribution m =>
   MCMCConfig ->
   SMCConfig m ->
   -- | model
diff --git a/src/Control/Monad/Bayes/Inference/SMC.hs b/src/Control/Monad/Bayes/Inference/SMC.hs
--- a/src/Control/Monad/Bayes/Inference/SMC.hs
+++ b/src/Control/Monad/Bayes/Inference/SMC.hs
@@ -20,7 +20,7 @@
   )
 where
 
-import Control.Monad.Bayes.Class (MonadInfer, MonadSample)
+import Control.Monad.Bayes.Class (MonadDistribution, MonadMeasure)
 import Control.Monad.Bayes.Population
   ( Population,
     pushEvidence,
@@ -37,7 +37,7 @@
 -- | Sequential importance resampling.
 -- Basically an SMC template that takes a custom resampler.
 smc ::
-  MonadSample m =>
+  MonadDistribution m =>
   SMCConfig m ->
   Coroutine.Sequential (Population m) a ->
   Population m a
@@ -49,5 +49,5 @@
 -- Weights are normalized at each timestep and the total weight is pushed
 -- as a score into the transformed monad.
 smcPush ::
-  MonadInfer m => SMCConfig m -> Coroutine.Sequential (Population m) a -> Population m a
+  MonadMeasure m => SMCConfig m -> Coroutine.Sequential (Population m) a -> Population m a
 smcPush config = smc config {resampler = (pushEvidence . resampler config)}
diff --git a/src/Control/Monad/Bayes/Inference/SMC2.hs b/src/Control/Monad/Bayes/Inference/SMC2.hs
--- a/src/Control/Monad/Bayes/Inference/SMC2.hs
+++ b/src/Control/Monad/Bayes/Inference/SMC2.hs
@@ -20,9 +20,9 @@
 where
 
 import Control.Monad.Bayes.Class
-  ( MonadCond (..),
-    MonadInfer,
-    MonadSample (random),
+  ( MonadDistribution (random),
+    MonadFactor (..),
+    MonadMeasure,
   )
 import Control.Monad.Bayes.Inference.MCMC
 import Control.Monad.Bayes.Inference.RMSMC (rmsmc)
@@ -43,17 +43,17 @@
 instance MonadTrans SMC2 where
   lift = SMC2 . lift . lift . lift
 
-instance MonadSample m => MonadSample (SMC2 m) where
+instance MonadDistribution m => MonadDistribution (SMC2 m) where
   random = lift random
 
-instance Monad m => MonadCond (SMC2 m) where
+instance Monad m => MonadFactor (SMC2 m) where
   score = SMC2 . score
 
-instance MonadSample m => MonadInfer (SMC2 m)
+instance MonadDistribution m => MonadMeasure (SMC2 m)
 
 -- | Sequential Monte Carlo squared.
 smc2 ::
-  MonadSample m =>
+  MonadDistribution m =>
   -- | number of time steps
   Int ->
   -- | number of inner particles
diff --git a/src/Control/Monad/Bayes/Inference/TUI.hs b/src/Control/Monad/Bayes/Inference/TUI.hs
--- a/src/Control/Monad/Bayes/Inference/TUI.hs
+++ b/src/Control/Monad/Bayes/Inference/TUI.hs
@@ -21,6 +21,7 @@
 import Control.Monad.Bayes.Traced (Traced)
 import Control.Monad.Bayes.Traced.Common
 import Control.Monad.Bayes.Weighted
+import Control.Monad.State.Class (put)
 import Data.Scientific (FPFormat (Exponent), formatScientific, fromFloatDigits)
 import Data.Text qualified as T
 import Data.Text.Lazy qualified as TL
@@ -108,14 +109,11 @@
 showVal = txt . T.pack . (\case [] -> ""; a -> show $ head a)
 
 -- | handler for events received by the TUI
-appEvent :: s -> B.BrickEvent n1 s -> B.EventM n2 (B.Next s)
-appEvent p (B.VtyEvent e) =
-  case e of
-    V.EvKey (V.KChar 'q') [] -> do
-      B.halt p
-    _ -> B.continue p
-appEvent _ (B.AppEvent d) = B.continue d
-appEvent _ _ = error "unknown event"
+appEvent :: B.BrickEvent n s -> B.EventM n s ()
+appEvent (B.VtyEvent (V.EvKey (V.KChar 'q') [])) = B.halt
+appEvent (B.VtyEvent _) = pure ()
+appEvent (B.AppEvent d) = put d
+appEvent _ = error "unknown event"
 
 doneAttr, toDoAttr :: B.AttrName
 doneAttr = B.attrName "theBase" <> B.attrName "done"
@@ -145,7 +143,7 @@
             { B.appDraw = drawUI visualizer,
               B.appChooseCursor = B.showFirstCursor,
               B.appHandleEvent = appEvent,
-              B.appStartEvent = return,
+              B.appStartEvent = return (),
               B.appAttrMap = const theMap
             }
         )
diff --git a/src/Control/Monad/Bayes/Integrator.hs b/src/Control/Monad/Bayes/Integrator.hs
--- a/src/Control/Monad/Bayes/Integrator.hs
+++ b/src/Control/Monad/Bayes/Integrator.hs
@@ -8,7 +8,7 @@
 
 -- |
 -- This is adapted from https://jtobin.io/giry-monad-implementation
--- but brought into the monad-bayes framework (i.e. Integrator is an instance of MonadInfer)
+-- but brought into the monad-bayes framework (i.e. Integrator is an instance of MonadMeasure)
 -- It's largely for debugging other inference methods and didactic use,
 -- because brute force integration of measures is
 -- only practical for small programs
@@ -34,7 +34,7 @@
 import Control.Applicative (Applicative (..))
 import Control.Foldl (Fold)
 import Control.Foldl qualified as Foldl
-import Control.Monad.Bayes.Class (MonadSample (bernoulli, random, uniformD))
+import Control.Monad.Bayes.Class (MonadDistribution (bernoulli, random, uniformD))
 import Control.Monad.Bayes.Weighted (Weighted, weighted)
 import Control.Monad.Cont
   ( Cont,
@@ -56,7 +56,7 @@
 integrator f (Integrator a) = runCont a f
 runIntegrator = integrator
 
-instance MonadSample Integrator where
+instance MonadDistribution Integrator where
   random = fromDensityFunction $ Statistics.density $ Statistics.uniformDistr 0 1
   bernoulli p = Integrator $ cont (\f -> p * f True + (1 - p) * f False)
   uniformD ls = fromMassFunction (const (1 / fromIntegral (length ls))) ls
diff --git a/src/Control/Monad/Bayes/Population.hs b/src/Control/Monad/Bayes/Population.hs
--- a/src/Control/Monad/Bayes/Population.hs
+++ b/src/Control/Monad/Bayes/Population.hs
@@ -41,9 +41,9 @@
 import Control.Arrow (second)
 import Control.Monad (replicateM)
 import Control.Monad.Bayes.Class
-  ( MonadCond,
-    MonadInfer,
-    MonadSample (categorical, logCategorical, random, uniform),
+  ( MonadDistribution (categorical, logCategorical, random, uniform),
+    MonadFactor,
+    MonadMeasure,
     factor,
   )
 import Control.Monad.Bayes.Weighted
@@ -65,7 +65,7 @@
 
 -- | A collection of weighted samples, or particles.
 newtype Population m a = Population (Weighted (ListT m) a)
-  deriving newtype (Functor, Applicative, Monad, MonadIO, MonadSample, MonadCond, MonadInfer)
+  deriving newtype (Functor, Applicative, Monad, MonadIO, MonadDistribution, MonadFactor, MonadMeasure)
 
 instance MonadTrans Population where
   lift = Population . lift . lift
@@ -97,7 +97,7 @@
 withParticles n = (spawn n >>)
 
 resampleGeneric ::
-  MonadSample m =>
+  MonadDistribution m =>
   -- | resampler
   (V.Vector Double -> m [Int]) ->
   Population m a ->
@@ -149,7 +149,7 @@
 -- | Resample the population using the underlying monad and a systematic resampling scheme.
 -- The total weight is preserved.
 resampleSystematic ::
-  (MonadSample m) =>
+  (MonadDistribution m) =>
   Population m a ->
   Population m a
 resampleSystematic = resampleGeneric (\ps -> (`systematic` ps) <$> random)
@@ -171,7 +171,7 @@
 -- and \(w^{(k)}\) are the weights.
 --
 -- The conditional variance of stratified sampling is always smaller than that of multinomial sampling and it is also unbiased - see  [Comparison of Resampling Schemes for Particle Filtering](https://arxiv.org/abs/cs/0507025).
-stratified :: MonadSample m => V.Vector Double -> m [Int]
+stratified :: MonadDistribution m => V.Vector Double -> m [Int]
 stratified weights = do
   let bigN = V.length weights
   dithers <- V.replicateM bigN (uniform 0.0 1.0)
@@ -191,7 +191,7 @@
 -- | Resample the population using the underlying monad and a stratified resampling scheme.
 -- The total weight is preserved.
 resampleStratified ::
-  (MonadSample m) =>
+  (MonadDistribution m) =>
   Population m a ->
   Population m a
 resampleStratified = resampleGeneric stratified
@@ -199,13 +199,13 @@
 -- | Multinomial sampler.  Sample from \(0, \ldots, n - 1\) \(n\)
 -- times drawn at random according to the weights where \(n\) is the
 -- length of vector of weights.
-multinomial :: MonadSample m => V.Vector Double -> m [Int]
+multinomial :: MonadDistribution m => V.Vector Double -> m [Int]
 multinomial ps = replicateM (V.length ps) (categorical ps)
 
 -- | Resample the population using the underlying monad and a multinomial resampling scheme.
 -- The total weight is preserved.
 resampleMultinomial ::
-  (MonadSample m) =>
+  (MonadDistribution m) =>
   Population m a ->
   Population m a
 resampleMultinomial = resampleGeneric multinomial
@@ -227,7 +227,7 @@
 -- | Push the evidence estimator as a score to the transformed monad.
 -- Weights are normalized after this operation.
 pushEvidence ::
-  MonadCond m =>
+  MonadFactor m =>
   Population m a ->
   Population m a
 pushEvidence = hoist applyWeight . extractEvidence
@@ -235,7 +235,7 @@
 -- | A properly weighted single sample, that is one picked at random according
 -- to the weights, with the sum of all weights.
 proper ::
-  (MonadSample m) =>
+  (MonadDistribution m) =>
   Population m a ->
   Weighted m a
 proper m = do
@@ -254,7 +254,7 @@
 -- This way a single sample can be selected from a population without
 -- introducing bias.
 collapse ::
-  (MonadInfer m) =>
+  (MonadMeasure m) =>
   Population m a ->
   m a
 collapse = applyWeight . proper
diff --git a/src/Control/Monad/Bayes/Sampler/Lazy.hs b/src/Control/Monad/Bayes/Sampler/Lazy.hs
--- a/src/Control/Monad/Bayes/Sampler/Lazy.hs
+++ b/src/Control/Monad/Bayes/Sampler/Lazy.hs
@@ -7,7 +7,7 @@
 module Control.Monad.Bayes.Sampler.Lazy where
 
 import Control.Monad (ap, liftM)
-import Control.Monad.Bayes.Class (MonadSample (random))
+import Control.Monad.Bayes.Class (MonadDistribution (random))
 import Control.Monad.Bayes.Weighted (Weighted, weighted)
 import Numeric.Log (Log (..))
 import System.Random
@@ -65,7 +65,7 @@
         (Sampler m') = f (m g1)
      in m' g2
 
-instance MonadSample Sampler where
+instance MonadDistribution Sampler where
   random = Sampler \(Tree r _) -> r
 
 sampler :: Sampler a -> IO a
diff --git a/src/Control/Monad/Bayes/Sampler/Strict.hs b/src/Control/Monad/Bayes/Sampler/Strict.hs
--- a/src/Control/Monad/Bayes/Sampler/Strict.hs
+++ b/src/Control/Monad/Bayes/Sampler/Strict.hs
@@ -12,8 +12,8 @@
 -- Stability   : experimental
 -- Portability : GHC
 --
--- 'SamplerIO' and 'SamplerST' are instances of 'MonadSample'. Apply a 'MonadCond'
--- transformer to obtain a 'MonadInfer' that can execute probabilistic models.
+-- 'SamplerIO' and 'SamplerST' are instances of 'MonadDistribution'. Apply a 'MonadFactor'
+-- transformer to obtain a 'MonadMeasure' that can execute probabilistic models.
 module Control.Monad.Bayes.Sampler.Strict
   ( Sampler,
     SamplerIO,
@@ -29,7 +29,7 @@
 
 import Control.Foldl qualified as F hiding (random)
 import Control.Monad.Bayes.Class
-  ( MonadSample
+  ( MonadDistribution
       ( bernoulli,
         beta,
         categorical,
@@ -58,7 +58,7 @@
 -- to particular pairs of monad and RNG
 type SamplerST s = Sampler (STGenM StdGen s) (ST s)
 
-instance StatefulGen g m => MonadSample (Sampler g m) where
+instance StatefulGen g m => MonadDistribution (Sampler g m) where
   random = Sampler (ReaderT uniformDouble01M)
 
   uniform a b = Sampler (ReaderT $ uniformRM (a, b))
diff --git a/src/Control/Monad/Bayes/Sequential/Coroutine.hs b/src/Control/Monad/Bayes/Sequential/Coroutine.hs
--- a/src/Control/Monad/Bayes/Sequential/Coroutine.hs
+++ b/src/Control/Monad/Bayes/Sequential/Coroutine.hs
@@ -26,9 +26,9 @@
 where
 
 import Control.Monad.Bayes.Class
-  ( MonadCond (..),
-    MonadInfer,
-    MonadSample (bernoulli, categorical, random),
+  ( MonadDistribution (bernoulli, categorical, random),
+    MonadFactor (..),
+    MonadMeasure,
   )
 import Control.Monad.Coroutine
   ( Coroutine (..),
@@ -54,16 +54,16 @@
 extract :: Await () a -> a
 extract (Await f) = f ()
 
-instance MonadSample m => MonadSample (Sequential m) where
+instance MonadDistribution m => MonadDistribution (Sequential m) where
   random = lift random
   bernoulli = lift . bernoulli
   categorical = lift . categorical
 
 -- | Execution is 'suspend'ed after each 'score'.
-instance MonadCond m => MonadCond (Sequential m) where
+instance MonadFactor m => MonadFactor (Sequential m) where
   score w = lift (score w) >> suspend
 
-instance MonadInfer m => MonadInfer (Sequential m)
+instance MonadMeasure m => MonadMeasure (Sequential m)
 
 -- | A point where the computation is paused.
 suspend :: Monad m => Sequential m ()
diff --git a/src/Control/Monad/Bayes/Traced/Basic.hs b/src/Control/Monad/Bayes/Traced/Basic.hs
--- a/src/Control/Monad/Bayes/Traced/Basic.hs
+++ b/src/Control/Monad/Bayes/Traced/Basic.hs
@@ -19,9 +19,9 @@
 
 import Control.Applicative (liftA2)
 import Control.Monad.Bayes.Class
-  ( MonadCond (..),
-    MonadInfer,
-    MonadSample (random),
+  ( MonadDistribution (random),
+    MonadFactor (..),
+    MonadMeasure,
   )
 import Control.Monad.Bayes.Density.Free (Density)
 import Control.Monad.Bayes.Traced.Common
@@ -56,13 +56,13 @@
       my = mx >>= model . f
       dy = dx `bind` (traceDist . f)
 
-instance MonadSample m => MonadSample (Traced m) where
+instance MonadDistribution m => MonadDistribution (Traced m) where
   random = Traced random (fmap singleton random)
 
-instance MonadCond m => MonadCond (Traced m) where
+instance MonadFactor m => MonadFactor (Traced m) where
   score w = Traced (score w) (score w >> pure (scored w))
 
-instance MonadInfer m => MonadInfer (Traced m)
+instance MonadMeasure m => MonadMeasure (Traced m)
 
 hoist :: (forall x. m x -> m x) -> Traced m a -> Traced m a
 hoist f (Traced m d) = Traced m (f d)
@@ -72,14 +72,14 @@
 marginal (Traced _ d) = fmap output d
 
 -- | A single step of the Trace Metropolis-Hastings algorithm.
-mhStep :: MonadSample m => Traced m a -> Traced m a
+mhStep :: MonadDistribution m => Traced m a -> Traced m a
 mhStep (Traced m d) = Traced m d'
   where
     d' = d >>= mhTrans' m
 
 -- | Full run of the Trace Metropolis-Hastings algorithm with a specified
 -- number of steps.
-mh :: MonadSample m => Int -> Traced m a -> m [a]
+mh :: MonadDistribution m => Int -> Traced m a -> m [a]
 mh n (Traced m d) = fmap (map output . NE.toList) (f n)
   where
     f k
diff --git a/src/Control/Monad/Bayes/Traced/Common.hs b/src/Control/Monad/Bayes/Traced/Common.hs
--- a/src/Control/Monad/Bayes/Traced/Common.hs
+++ b/src/Control/Monad/Bayes/Traced/Common.hs
@@ -21,7 +21,7 @@
 where
 
 import Control.Monad.Bayes.Class
-  ( MonadSample (bernoulli, random),
+  ( MonadDistribution (bernoulli, random),
     discrete,
   )
 import qualified Control.Monad.Bayes.Density.Free as Free
@@ -81,7 +81,7 @@
   return $ t2 {variables = variables t1 ++ variables t2, probDensity = probDensity t1 * probDensity t2}
 
 -- | A single Metropolis-corrected transition of single-site Trace MCMC.
-mhTrans :: MonadSample m => (Weighted (State.Density m)) a -> Trace a -> m (Trace a)
+mhTrans :: MonadDistribution m => (Weighted (State.Density m)) a -> Trace a -> m (Trace a)
 mhTrans m t@Trace {variables = us, probDensity = p} = do
   let n = length us
   us' <- do
@@ -95,11 +95,11 @@
   accept <- bernoulli ratio
   return $ if accept then Trace vs b q else t
 
-mhTransFree :: MonadSample m => Weighted (Free.Density m) a -> Trace a -> m (Trace a)
+mhTransFree :: MonadDistribution m => Weighted (Free.Density m) a -> Trace a -> m (Trace a)
 mhTransFree m t = trace <$> mhTransWithBool m t
 
 -- | A single Metropolis-corrected transition of single-site Trace MCMC.
-mhTransWithBool :: MonadSample m => Weighted (Free.Density m) a -> Trace a -> m (MHResult a)
+mhTransWithBool :: MonadDistribution m => Weighted (Free.Density m) a -> Trace a -> m (MHResult a)
 mhTransWithBool m t@Trace {variables = us, probDensity = p} = do
   let n = length us
   us' <- do
@@ -114,7 +114,7 @@
   return if accept then MHResult True (Trace vs b q) else MHResult False t
 
 -- | A variant of 'mhTrans' with an external sampling monad.
-mhTrans' :: MonadSample m => Weighted (Free.Density Identity) a -> Trace a -> m (Trace a)
+mhTrans' :: MonadDistribution m => Weighted (Free.Density Identity) a -> Trace a -> m (Trace a)
 mhTrans' m = mhTransFree (Weighted.hoist (Free.hoist (return . runIdentity)) m)
 
 -- | burn in an MCMC chain for n steps (which amounts to dropping samples of the end of the list)
diff --git a/src/Control/Monad/Bayes/Traced/Dynamic.hs b/src/Control/Monad/Bayes/Traced/Dynamic.hs
--- a/src/Control/Monad/Bayes/Traced/Dynamic.hs
+++ b/src/Control/Monad/Bayes/Traced/Dynamic.hs
@@ -20,9 +20,9 @@
 
 import Control.Monad (join)
 import Control.Monad.Bayes.Class
-  ( MonadCond (..),
-    MonadInfer,
-    MonadSample (random),
+  ( MonadDistribution (random),
+    MonadFactor (..),
+    MonadMeasure,
   )
 import Control.Monad.Bayes.Density.Free (Density)
 import Control.Monad.Bayes.Traced.Common
@@ -67,13 +67,13 @@
 instance MonadTrans Traced where
   lift m = Traced $ fmap ((,) (lift $ lift m) . pure) m
 
-instance MonadSample m => MonadSample (Traced m) where
+instance MonadDistribution m => MonadDistribution (Traced m) where
   random = Traced $ fmap ((,) random . singleton) random
 
-instance MonadCond m => MonadCond (Traced m) where
+instance MonadFactor m => MonadFactor (Traced m) where
   score w = Traced $ fmap (score w,) (score w >> pure (scored w))
 
-instance MonadInfer m => MonadInfer (Traced m)
+instance MonadMeasure m => MonadMeasure (Traced m)
 
 hoist :: (forall x. m x -> m x) -> Traced m a -> Traced m a
 hoist f (Traced c) = Traced (f c)
@@ -91,7 +91,7 @@
   return (return x, pure x)
 
 -- | A single step of the Trace Metropolis-Hastings algorithm.
-mhStep :: MonadSample m => Traced m a -> Traced m a
+mhStep :: MonadDistribution m => Traced m a -> Traced m a
 mhStep (Traced c) = Traced $ do
   (m, t) <- c
   t' <- mhTransFree m t
@@ -99,7 +99,7 @@
 
 -- | Full run of the Trace Metropolis-Hastings algorithm with a specified
 -- number of steps.
-mh :: MonadSample m => Int -> Traced m a -> m [a]
+mh :: MonadDistribution m => Int -> Traced m a -> m [a]
 mh n (Traced c) = do
   (m, t) <- c
   let f k
diff --git a/src/Control/Monad/Bayes/Traced/Static.hs b/src/Control/Monad/Bayes/Traced/Static.hs
--- a/src/Control/Monad/Bayes/Traced/Static.hs
+++ b/src/Control/Monad/Bayes/Traced/Static.hs
@@ -20,9 +20,9 @@
 
 import Control.Applicative (liftA2)
 import Control.Monad.Bayes.Class
-  ( MonadCond (..),
-    MonadInfer,
-    MonadSample (random),
+  ( MonadDistribution (random),
+    MonadFactor (..),
+    MonadMeasure,
   )
 import Control.Monad.Bayes.Density.Free (Density)
 import Control.Monad.Bayes.Traced.Common
@@ -61,13 +61,13 @@
 instance MonadTrans Traced where
   lift m = Traced (lift $ lift m) (fmap pure m)
 
-instance MonadSample m => MonadSample (Traced m) where
+instance MonadDistribution m => MonadDistribution (Traced m) where
   random = Traced random (fmap singleton random)
 
-instance MonadCond m => MonadCond (Traced m) where
+instance MonadFactor m => MonadFactor (Traced m) where
   score w = Traced (score w) (score w >> pure (scored w))
 
-instance MonadInfer m => MonadInfer (Traced m)
+instance MonadMeasure m => MonadMeasure (Traced m)
 
 hoist :: (forall x. m x -> m x) -> Traced m a -> Traced m a
 hoist f (Traced m d) = Traced m (f d)
@@ -77,14 +77,14 @@
 marginal (Traced _ d) = fmap output d
 
 -- | A single step of the Trace Metropolis-Hastings algorithm.
-mhStep :: MonadSample m => Traced m a -> Traced m a
+mhStep :: MonadDistribution m => Traced m a -> Traced m a
 mhStep (Traced m d) = Traced m d'
   where
     d' = d >>= mhTransFree m
 
 -- | Full run of the Trace Metropolis-Hastings algorithm with a specified
 -- number of steps. Newest samples are at the head of the list.
-mh :: MonadSample m => Int -> Traced m a -> m [a]
+mh :: MonadDistribution m => Int -> Traced m a -> m [a]
 mh n (Traced m d) = fmap (map output . NE.toList) (f n)
   where
     f k
diff --git a/src/Control/Monad/Bayes/Weighted.hs b/src/Control/Monad/Bayes/Weighted.hs
--- a/src/Control/Monad/Bayes/Weighted.hs
+++ b/src/Control/Monad/Bayes/Weighted.hs
@@ -11,8 +11,8 @@
 -- Stability   : experimental
 -- Portability : GHC
 --
--- 'Weighted' is an instance of 'MonadCond'. Apply a 'MonadSample' transformer to
--- obtain a 'MonadInfer' that can execute probabilistic models.
+-- 'Weighted' is an instance of 'MonadFactor'. Apply a 'MonadDistribution' transformer to
+-- obtain a 'MonadMeasure' that can execute probabilistic models.
 module Control.Monad.Bayes.Weighted
   ( Weighted,
     withWeight,
@@ -26,9 +26,9 @@
 where
 
 import Control.Monad.Bayes.Class
-  ( MonadCond (..),
-    MonadInfer,
-    MonadSample,
+  ( MonadDistribution,
+    MonadFactor (..),
+    MonadMeasure,
     factor,
   )
 import Control.Monad.State (MonadIO, MonadTrans, StateT (..), lift, mapStateT, modify)
@@ -37,12 +37,12 @@
 -- | Execute the program using the prior distribution, while accumulating likelihood.
 newtype Weighted m a = Weighted (StateT (Log Double) m a)
   -- StateT is more efficient than WriterT
-  deriving newtype (Functor, Applicative, Monad, MonadIO, MonadTrans, MonadSample)
+  deriving newtype (Functor, Applicative, Monad, MonadIO, MonadTrans, MonadDistribution)
 
-instance Monad m => MonadCond (Weighted m) where
+instance Monad m => MonadFactor (Weighted m) where
   score w = Weighted (modify (* w))
 
-instance MonadSample m => MonadInfer (Weighted m)
+instance MonadDistribution m => MonadMeasure (Weighted m)
 
 -- | Obtain an explicit value of the likelihood for a given value.
 weighted, runWeighted :: Weighted m a -> m (a, Log Double)
@@ -69,7 +69,7 @@
   return x
 
 -- | Use the weight as a factor in the transformed monad.
-applyWeight :: MonadCond m => Weighted m a -> m a
+applyWeight :: MonadFactor m => Weighted m a -> m a
 applyWeight m = do
   (x, w) <- weighted m
   factor w
diff --git a/test/TestAdvanced.hs b/test/TestAdvanced.hs
--- a/test/TestAdvanced.hs
+++ b/test/TestAdvanced.hs
@@ -26,7 +26,7 @@
 mcmcConfig :: MCMCConfig
 mcmcConfig = MCMCConfig {numMCMCSteps = 0, numBurnIn = 0, proposal = SingleSiteMH}
 
-smcConfig :: MonadSample m => SMCConfig m
+smcConfig :: MonadDistribution m => SMCConfig m
 smcConfig = SMCConfig {numSteps = 0, numParticles = 1000, resampler = resampleMultinomial}
 
 passed1, passed2, passed3, passed4, passed5, passed6, passed7 :: IO Bool
diff --git a/test/TestDistribution.hs b/test/TestDistribution.hs
--- a/test/TestDistribution.hs
+++ b/test/TestDistribution.hs
@@ -9,7 +9,7 @@
 where
 
 import Control.Monad (replicateM)
-import Control.Monad.Bayes.Class (MonadSample, mvNormal)
+import Control.Monad.Bayes.Class (MonadDistribution, mvNormal)
 import Control.Monad.Bayes.Sampler.Strict
 import Control.Monad.Identity (runIdentity)
 import Control.Monad.State (evalStateT)
diff --git a/test/TestEnumerator.hs b/test/TestEnumerator.hs
--- a/test/TestEnumerator.hs
+++ b/test/TestEnumerator.hs
@@ -3,7 +3,7 @@
 module TestEnumerator (passed1, passed2, passed3, passed4) where
 
 import Control.Monad.Bayes.Class
-  ( MonadSample (categorical, uniformD),
+  ( MonadDistribution (categorical, uniformD),
   )
 import Control.Monad.Bayes.Enumerator
   ( enumerator,
@@ -15,13 +15,13 @@
 import Numeric.Log (Log (ln))
 import Sprinkler (hard, soft)
 
-unnorm :: MonadSample m => m Int
+unnorm :: MonadDistribution m => m Int
 unnorm = categorical $ V.fromList [0.5, 0.8]
 
 passed1 :: Bool
 passed1 = (exp . ln) (evidence unnorm) ~== 1
 
-agg :: MonadSample m => m Int
+agg :: MonadDistribution m => m Int
 agg = do
   x <- uniformD [0, 1]
   y <- uniformD [2, 1]
diff --git a/test/TestInference.hs b/test/TestInference.hs
--- a/test/TestInference.hs
+++ b/test/TestInference.hs
@@ -14,7 +14,7 @@
     normalNormalAnalytic,
   )
 import Control.Monad (replicateM)
-import Control.Monad.Bayes.Class (MonadInfer, posterior)
+import Control.Monad.Bayes.Class (MonadMeasure, posterior)
 import Control.Monad.Bayes.Enumerator (enumerator)
 import Control.Monad.Bayes.Inference.SMC
 import Control.Monad.Bayes.Integrator (normalize)
@@ -30,7 +30,7 @@
 import Sprinkler (soft)
 import System.Random.Stateful (IOGenM, StdGen, mkStdGen, newIOGenM)
 
-sprinkler :: MonadInfer m => m Bool
+sprinkler :: MonadMeasure m => m Bool
 sprinkler = Sprinkler.soft
 
 -- | Count the number of particles produced by SMC
diff --git a/test/TestIntegrator.hs b/test/TestIntegrator.hs
--- a/test/TestIntegrator.hs
+++ b/test/TestIntegrator.hs
@@ -4,9 +4,9 @@
 
 import Control.Monad (replicateM)
 import Control.Monad.Bayes.Class
-  ( MonadCond (score),
-    MonadInfer,
-    MonadSample (bernoulli, gamma, normal, random, uniformD),
+  ( MonadDistribution (bernoulli, gamma, normal, random, uniformD),
+    MonadFactor (score),
+    MonadMeasure,
     condition,
     factor,
     normalPdf,
@@ -32,7 +32,7 @@
 volumeIsOne :: [Double] -> Bool
 volumeIsOne = (~== 1.0) . volume . uniformD
 
-agg :: MonadSample m => m Int
+agg :: MonadDistribution m => m Int
 agg = do
   x <- uniformD [0, 1]
   y <- uniformD [2, 1]
@@ -141,7 +141,7 @@
       quadrature = expectation $ normalize $ model1
    in abs (sample - quadrature) < 0.01
 
-model1 :: MonadInfer m => m Double
+model1 :: MonadMeasure m => m Double
 model1 = do
   x <- random
   y <- random
diff --git a/test/TestPopulation.hs b/test/TestPopulation.hs
--- a/test/TestPopulation.hs
+++ b/test/TestPopulation.hs
@@ -1,6 +1,6 @@
 module TestPopulation (weightedSampleSize, popSize, manySize, sprinkler, sprinklerExact, transCheck1, transCheck2, resampleCheck, popAvgCheck) where
 
-import Control.Monad.Bayes.Class (MonadInfer, MonadSample)
+import Control.Monad.Bayes.Class (MonadDistribution, MonadMeasure)
 import Control.Monad.Bayes.Enumerator (enumerator, expectation)
 import Control.Monad.Bayes.Population as Population
   ( Population,
@@ -16,7 +16,7 @@
 import Sprinkler (soft)
 import System.Random.Stateful (mkStdGen, newIOGenM)
 
-weightedSampleSize :: MonadSample m => Population m a -> m Int
+weightedSampleSize :: MonadDistribution m => Population m a -> m Int
 weightedSampleSize = fmap length . population
 
 popSize :: IO Int
@@ -27,7 +27,7 @@
 manySize =
   sampleIOfixed (weightedSampleSize $ spawn 5 >> sprinkler >> spawn 3)
 
-sprinkler :: MonadInfer m => m Bool
+sprinkler :: MonadMeasure m => m Bool
 sprinkler = Sprinkler.soft
 
 sprinklerExact :: [(Bool, Double)]
diff --git a/test/TestSampler.hs b/test/TestSampler.hs
--- a/test/TestSampler.hs
+++ b/test/TestSampler.hs
@@ -2,7 +2,7 @@
 
 import qualified Control.Foldl as Fold
 import Control.Monad (replicateM)
-import Control.Monad.Bayes.Class (MonadSample (normal))
+import Control.Monad.Bayes.Class (MonadDistribution (normal))
 import Control.Monad.Bayes.Sampler.Strict (sampleSTfixed)
 import Control.Monad.ST (ST, runST)
 
diff --git a/test/TestSequential.hs b/test/TestSequential.hs
--- a/test/TestSequential.hs
+++ b/test/TestSequential.hs
@@ -1,8 +1,8 @@
 module TestSequential (twoSync, finishedTwoSync, checkTwoSync, checkPreserve, pFinished, isFinished, checkSync) where
 
 import Control.Monad.Bayes.Class
-  ( MonadInfer,
-    MonadSample (uniformD),
+  ( MonadDistribution (uniformD),
+    MonadMeasure,
     factor,
   )
 import Control.Monad.Bayes.Enumerator as Dist (enumerator, mass)
@@ -10,7 +10,7 @@
 import Data.AEq (AEq ((~==)))
 import Sprinkler (soft)
 
-twoSync :: MonadInfer m => m Int
+twoSync :: MonadMeasure m => m Int
 twoSync = do
   x <- uniformD [0, 1]
   factor (fromIntegral x)
@@ -18,7 +18,7 @@
   factor (fromIntegral y)
   return (x + y)
 
-finishedTwoSync :: MonadInfer m => Int -> m Bool
+finishedTwoSync :: MonadMeasure m => Int -> m Bool
 finishedTwoSync n = finished (run n twoSync)
   where
     run 0 d = d
@@ -30,7 +30,7 @@
 checkTwoSync 2 = mass (finishedTwoSync 2) True ~== 1
 checkTwoSync _ = error "Unexpected argument"
 
-sprinkler :: MonadInfer m => m Bool
+sprinkler :: MonadMeasure m => m Bool
 sprinkler = Sprinkler.soft
 
 checkPreserve :: Bool
@@ -42,7 +42,7 @@
 pFinished 2 = 1
 pFinished _ = error "Unexpected argument"
 
-isFinished :: MonadInfer m => Int -> m Bool
+isFinished :: MonadMeasure m => Int -> m Bool
 isFinished n = finished (run n sprinkler)
   where
     run 0 d = d
diff --git a/test/TestWeighted.hs b/test/TestWeighted.hs
--- a/test/TestWeighted.hs
+++ b/test/TestWeighted.hs
@@ -3,8 +3,8 @@
 module TestWeighted (check, passed, result, model) where
 
 import Control.Monad.Bayes.Class
-  ( MonadInfer,
-    MonadSample (normal, uniformD),
+  ( MonadDistribution (normal, uniformD),
+    MonadMeasure,
     factor,
   )
 import Control.Monad.Bayes.Sampler.Strict (sampleIOfixed)
@@ -15,7 +15,7 @@
 import Numeric.Log (Log (Exp, ln))
 import System.Random.Stateful (mkStdGen, newIOGenM)
 
-model :: MonadInfer m => m (Int, Double)
+model :: MonadMeasure m => m (Int, Double)
 model = do
   n <- uniformD [0, 1, 2]
   unless (n == 0) (factor 0.5)
@@ -23,7 +23,7 @@
   when (n == 2) (factor $ (Exp . log) (x * x))
   return (n, x)
 
-result :: MonadSample m => m ((Int, Double), Double)
+result :: MonadDistribution m => m ((Int, Double), Double)
 result = second (exp . ln) <$> weighted model
 
 passed :: IO Bool