diff --git a/examples/reference-wrappers/Cargo.toml b/examples/reference-wrappers/Cargo.toml
index cb85e80..93c68ba 100644
--- a/examples/reference-wrappers/Cargo.toml
+++ b/examples/reference-wrappers/Cargo.toml
@@ -13,9 +13,9 @@
 edition = "2021"
 
 [dependencies]
-cxx = "1.0.68"
-autocxx = { path = "../..", version="0.22.3" }
+cxx = "1.0.78"
+autocxx = { path = "../..", version = "0.26.0" }
 
 [build-dependencies]
-autocxx-build = { path = "../../gen/build", version="0.22.3" }
-miette = { version="4.3", features=["fancy"]}
+autocxx-build = { path = "../../gen/build", version = "0.26.0" }
+miette = { version = "5", features = ["fancy"] }
diff --git a/examples/reference-wrappers/build.rs b/examples/reference-wrappers/build.rs
index 64c573d..8e15dd0 100644
--- a/examples/reference-wrappers/build.rs
+++ b/examples/reference-wrappers/build.rs
@@ -10,9 +10,11 @@
     let path = std::path::PathBuf::from("src");
     let mut b = autocxx_build::Builder::new("src/main.rs", &[&path]).build()?;
     b.flag_if_supported("-std=c++14")
-    .file("src/input.cc").compile("autocxx-reference-wrapper-example");
+        .file("src/input.cc")
+        .compile("autocxx-reference-wrapper-example");
 
     println!("cargo:rerun-if-changed=src/main.rs");
     println!("cargo:rerun-if-changed=src/input.h");
+
     Ok(())
 }
diff --git a/examples/reference-wrappers/src/input.h b/examples/reference-wrappers/src/input.h
index 5e3c6e9..dd37dfa 100644
--- a/examples/reference-wrappers/src/input.h
+++ b/examples/reference-wrappers/src/input.h
@@ -18,6 +18,7 @@
     Goat() : horns(0) {}
     void add_a_horn();
     std::string describe() const;
+    uint32_t& get_horns() { return horns; }
 private:
     uint32_t horns;
 };
diff --git a/examples/reference-wrappers/src/main.rs b/examples/reference-wrappers/src/main.rs
index 6bea2ff..ca3e0cd 100644
--- a/examples/reference-wrappers/src/main.rs
+++ b/examples/reference-wrappers/src/main.rs
@@ -23,16 +23,52 @@
 // especially in the absence of the Rust "arbitrary self types"
 // feature.
 
+// Necessary to be able to call methods on reference wrappers.
+// For that reason, this example only builds on nightly Rust.
+#![feature(arbitrary_self_types)]
+
 use autocxx::prelude::*;
+use std::pin::Pin;
 
 include_cpp! {
     #include "input.h"
     // This next line enables C++ reference wrappers
+    // This is what requires the 'arbitrary_self_types' feature.
     safety!(unsafe_references_wrapped)
     generate!("Goat")
     generate!("Field")
 }
 
+impl ffi::Goat {
+    // Methods can be called on a CppRef<T> or &CppRef<T>
+    fn bleat(self: CppRef<Self>) {
+        println!("Bleat");
+    }
+}
+
+trait FarmProduce {
+    // Traits can be defined on a CppRef<T> so long as Self: Sized
+    fn sell(self: &CppRef<Self>)
+    where
+        Self: Sized;
+}
+
+impl FarmProduce for ffi::Goat {
+    fn sell(self: &CppRef<Self>) {
+        println!("Selling goat");
+    }
+}
+
+trait FarmArea {
+    fn maintain(self: CppRef<Self>);
+}
+
+impl FarmArea for ffi::Field {
+    fn maintain(self: CppRef<Self>) {
+        println!("Maintaining");
+    }
+}
+
 fn main() {
     // Create a cxx::UniquePtr as normal for a Field object.
     let field = ffi::Field::new().within_unique_ptr();
@@ -47,21 +83,36 @@
     // However, as soon as we want to pass a reference to the field
     // back to C++, we have to ensure we have no Rust references
     // in existence. So: we imprison the object in a "CppPin":
-    let field = ffi::cpp_pin_uniqueptr(field);
+    let field = CppUniquePtrPin::new(field);
     // We can no longer take Rust references to the field...
     //   let _field_rust_ref = field.as_ref();
     // However, we can take C++ references. And use such references
-    // to call methods...
+    // to call methods in C++. Quite often those methods will
+    // return other references, like this.
     let another_goat = field.as_cpp_ref().get_goat();
     // The 'get_goat' method in C++ returns a reference, so this is
     // another CppRef, not a Rust reference.
+
+    // We can still use these C++ references to call Rust methods,
+    // so long as those methods have a "self" type of a
+    // C++ reference not a Rust reference.
+    another_goat.clone().bleat();
+    another_goat.sell();
+
+    // But most commonly, C++ references are simply used as the 'this'
+    // type when calling other C++ methods, like this.
     assert_eq!(
         another_goat
             .describe() // returns a UniquePtr<CxxString>, there
-                // are no Rust or C++ references involved at this point.
+            // are no Rust or C++ references involved at this point.
             .as_ref()
             .unwrap()
             .to_string_lossy(),
         "This goat has 0 horns."
     );
+
+    // We can even use trait objects, though it's a bit of a fiddle.
+    let farm_area: Pin<Box<dyn FarmArea>> = ffi::Field::new().within_box();
+    let farm_area = CppPin::from_pinned_box(farm_area);
+    farm_area.as_cpp_ref().maintain();
 }