Ported IO#ensuring (and renamed to avoid mass confusion)

core/src/main/scala/cats/MonadError.scala

@@ -13,6 +13,23 @@ trait MonadError[F[_], E] extends ApplicativeError[F, E] with Monad[F] {
   def ensure[A](fa: F[A])(error: => E)(predicate: A => Boolean): F[A] =
     flatMap(fa)(a => if (predicate(a)) pure(a) else raiseError(error))
 
+  /**
+   * Sequences the specified finalizer ensuring evaluation regardless of
+   * whether or not the target `F[A]` raises an error.
+   *
+   * If `raiseError` is analogous to `throw` and `handleErrorWith` is analogous to
+   * `catch`, then `guarantee` is analogous to `finally`.  JVM exception semantics
+   * are mirrored with respect to error raised within the finalizer (i.e. errors
+   * raised within the finalizer will shade any errors raised by the primary action).
+   *
+   * @see [[raiseError]]
+   * @see [[handleErrorWith]]
+   */
+  def guarantee[A](fa: F[A], finalizer: F[Unit]): F[A] = {
+    flatMap(attempt(fa)) { e =>
+      flatMap(finalizer)(_ => e.fold(raiseError, pure))
+    }
+  }
 }
 
 object MonadError {

core/src/main/scala/cats/syntax/monadError.scala

@@ -7,6 +7,10 @@ trait MonadErrorSyntax {
 }
 
 final class MonadErrorOps[F[_], E, A](val fa: F[A]) extends AnyVal {
+
   def ensure(error: => E)(predicate: A => Boolean)(implicit F: MonadError[F, E]): F[A] =
     F.ensure(fa)(error)(predicate)
+
+  def guarantee(finalizer: F[Unit])(implicit F: MonadError[F, E]): F[A] =
+    F.guarantee(fa, finalizer)
 }