diff --git a/book-monads b/book-monads
index f1a1703..5848712 160000
--- a/book-monads
+++ b/book-monads
@@ -1 +1 @@
-Subproject commit f1a17032d247d790dc1fc38fa4e33bc53ca7370d
+Subproject commit 58487121898c8da9c51479f1df4c1055c7df1e6d
diff --git a/src/core.rs b/src/core.rs
index 47244f4..5003ff7 100644
--- a/src/core.rs
+++ b/src/core.rs
@@ -28,11 +28,11 @@ pub use self::slice_deserializer::*;
 /// Basic support for tracing events across the execution.
 pub trait Diagnostic<T: Monad> {
     /// Specify that the evaluation happens after a specific event.
-    fn after<'a, A>(fa: T::F<'a, A>, event: &'a str) -> T::F<'a, A>;
+    fn after<'a: 'b, 'b, A>(fa: T::F<'a, A>, event: impl 'b + FnOnce() -> String) -> T::F<'a, A>;
     /// Specify that the evaluation happens before a specific event.
-    fn before<'a, A>(fa: T::F<'a, A>, event: &'a str) -> T::F<'a, A>;
+    fn before<'a: 'b, 'b, A>(fa: T::F<'a, A>, event: impl 'b + FnOnce() -> String) -> T::F<'a, A>;
     /// Label the evaluation step as a specific named action.
-    fn wrapped<'a, A>(fa: T::F<'a, A>, event: &'a str) -> T::F<'a, A>;
+    fn wrapped<'a: 'b, 'b, A>(fa: T::F<'a, A>, event: impl 'b + FnOnce() -> String) -> T::F<'a, A>;
 }
 
 /// Execution context.
diff --git a/src/std/tracing.rs b/src/std/tracing.rs
index 2fd8d61..e338b47 100644
--- a/src/std/tracing.rs
+++ b/src/std/tracing.rs
@@ -52,7 +52,7 @@ impl<A> WithTrace for A {
 }
 
 impl<A> Traced<A> {
-    fn wrapped(self, event: &str) -> Self {
+    fn wrapped(self, event: String) -> Self {
         Traced {
             value: self.value,
             effect: self.effect.wrapped(event),
@@ -87,15 +87,15 @@ impl<A> Traced<A> {
 }
 
 impl Diagnostic<TracedClass> for TracedDiagnostic {
-    fn after<A>(fa: Traced<A>, event: &str) -> Traced<A> {
-        fa.after(TraceBox::event(event))
+    fn after<'a: 'b, 'b, A>(fa: Traced<A>, event: impl FnOnce() -> String) -> Traced<A> {
+        fa.after(TraceBox::event(event()))
     }
 
-    fn before<A>(fa: Traced<A>, event: &str) -> Traced<A> {
-        fa.before(TraceBox::event(event))
+    fn before<'a: 'b, 'b, A>(fa: Traced<A>, event: impl FnOnce() -> String) -> Traced<A> {
+        fa.before(TraceBox::event(event()))
     }
 
-    fn wrapped<A>(fa: Traced<A>, event: &str) -> Traced<A> {
-        fa.wrapped(event)
+    fn wrapped<'a: 'b, 'b, A>(fa: Traced<A>, event: impl FnOnce() -> String) -> Traced<A> {
+        fa.wrapped(event())
     }
 }
diff --git a/src/std/tracing/trace.rs b/src/std/tracing/trace.rs
index d7f6ead..5714295 100644
--- a/src/std/tracing/trace.rs
+++ b/src/std/tracing/trace.rs
@@ -146,13 +146,13 @@ impl TraceBox {
         Trace::InvolvesOneResolution.into()
     }
 
-    pub fn event(event: &str) -> Self {
-        Trace::Event(event.into()).into()
+    pub fn event(event: String) -> Self {
+        Trace::Event(event).into()
     }
 
-    pub fn wrapped(self, event: &str) -> Self {
+    pub fn wrapped(self, event: String) -> Self {
         Trace::Wrapped {
-            name: event.into(),
+            name: event,
             trace: self,
         }
         .into()
diff --git a/src/testing.rs b/src/testing.rs
index 9fbf72f..8ac1bdc 100644
--- a/src/testing.rs
+++ b/src/testing.rs
@@ -13,15 +13,15 @@ use crate::std::typeless::*;
 pub struct NoDiagnostic;
 
 impl<T: Monad> Diagnostic<T> for NoDiagnostic {
-    fn after<'a, A>(fa: T::F<'a, A>, _event: &'a str) -> T::F<'a, A> {
+    fn after<'a: 'b, 'b, A>(fa: T::F<'a, A>, _event: impl FnOnce() -> String) -> T::F<'a, A> {
         fa
     }
 
-    fn before<'a, A>(fa: T::F<'a, A>, _event: &'a str) -> T::F<'a, A> {
+    fn before<'a: 'b, 'b, A>(fa: T::F<'a, A>, _event: impl FnOnce() -> String) -> T::F<'a, A> {
         fa
     }
 
-    fn wrapped<'a, A>(fa: T::F<'a, A>, _event: &'a str) -> T::F<'a, A> {
+    fn wrapped<'a: 'b, 'b, A>(fa: T::F<'a, A>, _event: impl FnOnce() -> String) -> T::F<'a, A> {
         fa
     }
 }