diff --git a/examples/forward_simulation.rs b/examples/forward_simulation.rs
index 808590429..77b3d8521 100644
--- a/examples/forward_simulation.rs
+++ b/examples/forward_simulation.rs
@@ -23,7 +23,6 @@ use rand::rngs::StdRng;
 use rand::Rng;
 use rand::SeedableRng;
 use rand_distr::{Exp, Uniform};
-use tskit::TableAccess;
 use tskit::TskitTypeAccess;
 
 #[derive(clap::Parser)]
diff --git a/src/_macros.rs b/src/_macros.rs
index 9aa5db7a9..1942875cc 100644
--- a/src/_macros.rs
+++ b/src/_macros.rs
@@ -518,7 +518,7 @@ macro_rules! build_owned_tables {
         }
 
         impl std::ops::Deref for $name {
-            type Target = $deref<'static>;
+            type Target = $deref;
 
             fn deref(&self) -> &Self::Target {
                 // SAFETY: that T* and &T have same layout,
diff --git a/src/edge_table.rs b/src/edge_table.rs
index 3fa00af81..b660d24ea 100644
--- a/src/edge_table.rs
+++ b/src/edge_table.rs
@@ -1,3 +1,5 @@
+use std::ptr::NonNull;
+
 use crate::bindings as ll_bindings;
 use crate::metadata;
 use crate::Position;
@@ -28,7 +30,7 @@ impl PartialEq for EdgeTableRow {
 }
 
 fn make_edge_table_row(table: &EdgeTable, pos: tsk_id_t) -> Option<EdgeTableRow> {
-    let table_ref = table.table_;
+    let table_ref = table.as_ref();
     Some(EdgeTableRow {
         id: pos.into(),
         left: table.left(pos)?,
@@ -39,8 +41,8 @@ fn make_edge_table_row(table: &EdgeTable, pos: tsk_id_t) -> Option<EdgeTableRow>
     })
 }
 
-pub(crate) type EdgeTableRefIterator<'a> = crate::table_iterator::TableIterator<&'a EdgeTable<'a>>;
-pub(crate) type EdgeTableIterator<'a> = crate::table_iterator::TableIterator<EdgeTable<'a>>;
+pub(crate) type EdgeTableRefIterator<'a> = crate::table_iterator::TableIterator<&'a EdgeTable>;
+pub(crate) type EdgeTableIterator = crate::table_iterator::TableIterator<EdgeTable>;
 
 impl<'a> Iterator for EdgeTableRefIterator<'a> {
     type Item = EdgeTableRow;
@@ -52,7 +54,7 @@ impl<'a> Iterator for EdgeTableRefIterator<'a> {
     }
 }
 
-impl<'a> Iterator for EdgeTableIterator<'a> {
+impl Iterator for EdgeTableIterator {
     type Item = EdgeTableRow;
 
     fn next(&mut self) -> Option<Self::Item> {
@@ -64,22 +66,32 @@ impl<'a> Iterator for EdgeTableIterator<'a> {
 
 /// An immutable view of an edge table.
 ///
-/// These are not created directly.
-/// Instead, use [`TableAccess::edges`](crate::TableAccess::edges)
-/// to get a reference to an existing edge table;
+/// These are not created directly but are accessed
+/// by types implementing [`std::ops::Deref`] to
+/// [`crate::table_views::TableViews`]
 #[repr(transparent)]
-pub struct EdgeTable<'a> {
-    table_: &'a ll_bindings::tsk_edge_table_t,
+pub struct EdgeTable {
+    pub(crate) table_: NonNull<ll_bindings::tsk_edge_table_t>,
 }
 
-impl<'a> EdgeTable<'a> {
-    pub(crate) fn new_from_table(edges: &'a ll_bindings::tsk_edge_table_t) -> Self {
-        EdgeTable { table_: edges }
+impl EdgeTable {
+    pub(crate) fn new_from_table(
+        edges: *mut ll_bindings::tsk_edge_table_t,
+    ) -> Result<Self, TskitError> {
+        let n = NonNull::new(edges).ok_or_else(|| {
+            TskitError::LibraryError("null pointer to tsk_edge_table_t".to_string())
+        })?;
+        Ok(EdgeTable { table_: n })
+    }
+
+    pub(crate) fn as_ref(&self) -> &ll_bindings::tsk_edge_table_t {
+        // SAFETY: NonNull
+        unsafe { self.table_.as_ref() }
     }
 
     /// Return the number of rows
-    pub fn num_rows(&'a self) -> crate::SizeType {
-        self.table_.num_rows.into()
+    pub fn num_rows(&self) -> crate::SizeType {
+        self.as_ref().num_rows.into()
     }
 
     /// Return the ``parent`` value from row ``row`` of the table.
@@ -88,12 +100,12 @@ impl<'a> EdgeTable<'a> {
     ///
     /// * `Some(parent)` if `u` is valid.
     /// * `None` otherwise.
-    pub fn parent<E: Into<EdgeId> + Copy>(&'a self, row: E) -> Option<NodeId> {
+    pub fn parent<E: Into<EdgeId> + Copy>(&self, row: E) -> Option<NodeId> {
         unsafe_tsk_column_access!(
             row.into().0,
             0,
             self.num_rows(),
-            self.table_,
+            self.as_ref(),
             parent,
             NodeId
         )
@@ -105,8 +117,15 @@ impl<'a> EdgeTable<'a> {
     ///
     /// * `Some(child)` if `u` is valid.
     /// * `None` otherwise.
-    pub fn child<E: Into<EdgeId> + Copy>(&'a self, row: E) -> Option<NodeId> {
-        unsafe_tsk_column_access!(row.into().0, 0, self.num_rows(), self.table_, child, NodeId)
+    pub fn child<E: Into<EdgeId> + Copy>(&self, row: E) -> Option<NodeId> {
+        unsafe_tsk_column_access!(
+            row.into().0,
+            0,
+            self.num_rows(),
+            self.as_ref(),
+            child,
+            NodeId
+        )
     }
 
     /// Return the ``left`` value from row ``row`` of the table.
@@ -115,12 +134,12 @@ impl<'a> EdgeTable<'a> {
     ///
     /// * `Some(position)` if `u` is valid.
     /// * `None` otherwise.
-    pub fn left<E: Into<EdgeId> + Copy>(&'a self, row: E) -> Option<Position> {
+    pub fn left<E: Into<EdgeId> + Copy>(&self, row: E) -> Option<Position> {
         unsafe_tsk_column_access!(
             row.into().0,
             0,
             self.num_rows(),
-            self.table_,
+            self.as_ref(),
             left,
             Position
         )
@@ -132,8 +151,14 @@ impl<'a> EdgeTable<'a> {
     ///
     /// * `Some(position)` if `u` is valid.
     /// * `None` otherwise.
-    pub fn right<E: Into<EdgeId> + Copy>(&'a self, row: E) -> Option<Position> {
-        unsafe_tsk_column_access_and_map_into!(row.into().0, 0, self.num_rows(), self.table_, right)
+    pub fn right<E: Into<EdgeId> + Copy>(&self, row: E) -> Option<Position> {
+        unsafe_tsk_column_access_and_map_into!(
+            row.into().0,
+            0,
+            self.num_rows(),
+            self.as_ref(),
+            right
+        )
     }
 
     /// Retrieve decoded metadata for a `row`.
@@ -153,10 +178,10 @@ impl<'a> EdgeTable<'a> {
     /// The big-picture semantics are the same for all table types.
     /// See [`crate::IndividualTable::metadata`] for examples.
     pub fn metadata<T: metadata::EdgeMetadata>(
-        &'a self,
+        &self,
         row: EdgeId,
     ) -> Option<Result<T, TskitError>> {
-        let table_ref = self.table_;
+        let table_ref = self.as_ref();
         let buffer = metadata_to_vector!(self, table_ref, row.0)?;
         Some(decode_metadata_row!(T, buffer).map_err(|e| e.into()))
     }
@@ -165,7 +190,7 @@ impl<'a> EdgeTable<'a> {
     /// The value of the iterator is [`EdgeTableRow`].
     ///
     pub fn iter(&self) -> impl Iterator<Item = EdgeTableRow> + '_ {
-        crate::table_iterator::make_table_iterator::<&EdgeTable<'a>>(self)
+        crate::table_iterator::make_table_iterator::<&EdgeTable>(self)
     }
 
     /// Return row `r` of the table.
diff --git a/src/individual_table.rs b/src/individual_table.rs
index c233b7102..9014f42d5 100644
--- a/src/individual_table.rs
+++ b/src/individual_table.rs
@@ -1,3 +1,5 @@
+use std::ptr::NonNull;
+
 use crate::bindings as ll_bindings;
 use crate::metadata;
 use crate::IndividualFlags;
@@ -45,15 +47,15 @@ impl PartialEq for IndividualTableRow {
 
 /// An immutable view of a individual table.
 ///
-/// These are not created directly.
-/// Instead, use [`TableAccess::individuals`](crate::TableAccess::individuals)
-/// to get a reference to an existing node table;
-pub struct IndividualTable<'a> {
-    table_: &'a ll_bindings::tsk_individual_table_t,
+/// These are not created directly but are accessed
+/// by types implementing [`std::ops::Deref`] to
+/// [`crate::table_views::TableViews`]
+pub struct IndividualTable {
+    table_: NonNull<ll_bindings::tsk_individual_table_t>,
 }
 
 fn make_individual_table_row(table: &IndividualTable, pos: tsk_id_t) -> Option<IndividualTableRow> {
-    let table_ref = table.table_;
+    let table_ref = table.as_ref();
     Some(IndividualTableRow {
         id: pos.into(),
         flags: table.flags(pos)?,
@@ -64,9 +66,8 @@ fn make_individual_table_row(table: &IndividualTable, pos: tsk_id_t) -> Option<I
 }
 
 pub(crate) type IndividualTableRefIterator<'a> =
-    crate::table_iterator::TableIterator<&'a IndividualTable<'a>>;
-pub(crate) type IndividualTableIterator<'a> =
-    crate::table_iterator::TableIterator<IndividualTable<'a>>;
+    crate::table_iterator::TableIterator<&'a IndividualTable>;
+pub(crate) type IndividualTableIterator = crate::table_iterator::TableIterator<IndividualTable>;
 
 impl<'a> Iterator for IndividualTableRefIterator<'a> {
     type Item = IndividualTableRow;
@@ -78,7 +79,7 @@ impl<'a> Iterator for IndividualTableRefIterator<'a> {
     }
 }
 
-impl<'a> Iterator for IndividualTableIterator<'a> {
+impl Iterator for IndividualTableIterator {
     type Item = IndividualTableRow;
 
     fn next(&mut self) -> Option<Self::Item> {
@@ -88,16 +89,24 @@ impl<'a> Iterator for IndividualTableIterator<'a> {
     }
 }
 
-impl<'a> IndividualTable<'a> {
-    pub(crate) fn new_from_table(individuals: &'a ll_bindings::tsk_individual_table_t) -> Self {
-        IndividualTable {
-            table_: individuals,
-        }
+impl IndividualTable {
+    pub(crate) fn new_from_table(
+        individuals: *mut ll_bindings::tsk_individual_table_t,
+    ) -> Result<Self, TskitError> {
+        let n = NonNull::new(individuals).ok_or_else(|| {
+            TskitError::LibraryError("null pointer to tsk_individual_table_t".to_string())
+        })?;
+        Ok(IndividualTable { table_: n })
+    }
+
+    pub(crate) fn as_ref(&self) -> &ll_bindings::tsk_individual_table_t {
+        // SAFETY: NonNull
+        unsafe { self.table_.as_ref() }
     }
 
     /// Return the number of rows
-    pub fn num_rows(&'a self) -> crate::SizeType {
-        self.table_.num_rows.into()
+    pub fn num_rows(&self) -> crate::SizeType {
+        self.as_ref().num_rows.into()
     }
 
     /// Return the flags for a given row.
@@ -107,7 +116,13 @@ impl<'a> IndividualTable<'a> {
     /// * `Some(flags)` if `row` is valid.
     /// * `None` otherwise.
     pub fn flags<I: Into<IndividualId> + Copy>(&self, row: I) -> Option<IndividualFlags> {
-        unsafe_tsk_column_access_and_map_into!(row.into().0, 0, self.num_rows(), self.table_, flags)
+        unsafe_tsk_column_access_and_map_into!(
+            row.into().0,
+            0,
+            self.num_rows(),
+            self.as_ref(),
+            flags
+        )
     }
 
     /// Return the locations for a given row.
@@ -121,7 +136,7 @@ impl<'a> IndividualTable<'a> {
             row.into().0,
             0,
             self.num_rows(),
-            self.table_,
+            self.as_ref(),
             location,
             location_offset,
             location_length,
@@ -140,7 +155,7 @@ impl<'a> IndividualTable<'a> {
             row.into().0,
             0,
             self.num_rows(),
-            self.table_,
+            self.as_ref(),
             parents,
             parents_offset,
             parents_length,
@@ -179,7 +194,7 @@ impl<'a> IndividualTable<'a> {
     ///
     /// ```
     /// # #[cfg(feature = "derive")] {
-    /// # use tskit::TableAccess;
+    /// #
     /// # let mut tables = tskit::TableCollection::new(100.).unwrap();
     /// # #[derive(serde::Serialize, serde::Deserialize, tskit::metadata::IndividualMetadata)]
     /// # #[serializer("serde_json")]
@@ -202,7 +217,7 @@ impl<'a> IndividualTable<'a> {
     ///
     /// ```
     /// # #[cfg(feature = "derive")] {
-    /// # use tskit::TableAccess;
+    /// #
     /// # let mut tables = tskit::TableCollection::new(100.).unwrap();
     /// # #[derive(serde::Serialize, serde::Deserialize, tskit::metadata::IndividualMetadata)]
     /// # #[serializer("serde_json")]
@@ -248,7 +263,7 @@ impl<'a> IndividualTable<'a> {
 # struct MutationMetadata {
 #    x: i32,
 # }
-# use tskit::TableAccess;
+# 
 # let mut tables = tskit::TableCollection::new(10.).unwrap();
 match tables.individuals().metadata::<MutationMetadata>(0.into())
 {
@@ -280,7 +295,7 @@ match tables.individuals().metadata::<MutationMetadata>(0.into())
     ///
     /// ```
     /// # #[cfg(feature = "derive")] {
-    /// # use tskit::TableAccess;
+    /// #
     /// # #[derive(serde::Serialize, serde::Deserialize, tskit::metadata::IndividualMetadata)]
     /// # #[serializer("serde_json")]
     /// # struct IndividualMetadata {
@@ -319,10 +334,10 @@ match tables.individuals().metadata::<MutationMetadata>(0.into())
     /// types](https://doc.rust-lang.org/book/ch19-03-advanced-traits.html#specifying-placeholder-types-in-trait-definitions-with-associated-types) to enforce at *compile time* that exactly one type (`struct/enum`, etc.) is a valid
     /// metadata type for a table.
     pub fn metadata<T: metadata::IndividualMetadata>(
-        &'a self,
+        &self,
         row: IndividualId,
     ) -> Option<Result<T, TskitError>> {
-        let table_ref = self.table_;
+        let table_ref = self.as_ref();
         let buffer = metadata_to_vector!(self, table_ref, row.0)?;
         Some(decode_metadata_row!(T, buffer).map_err(|e| e.into()))
     }
@@ -331,7 +346,7 @@ match tables.individuals().metadata::<MutationMetadata>(0.into())
     /// The value of the iterator is [`IndividualTableRow`].
     ///
     pub fn iter(&self) -> impl Iterator<Item = IndividualTableRow> + '_ {
-        crate::table_iterator::make_table_iterator::<&IndividualTable<'a>>(self)
+        crate::table_iterator::make_table_iterator::<&IndividualTable>(self)
     }
 
     /// Return row `r` of the table.
diff --git a/src/lib.rs b/src/lib.rs
index f596e5b23..40138b398 100644
--- a/src/lib.rs
+++ b/src/lib.rs
@@ -92,6 +92,7 @@ pub mod prelude;
 mod site_table;
 mod table_collection;
 mod table_iterator;
+pub mod table_views;
 mod traits;
 mod tree_interface;
 mod trees;
@@ -438,8 +439,6 @@ pub use site_table::{OwnedSiteTable, SiteTable, SiteTableRow};
 pub use table_collection::TableCollection;
 pub use traits::IndividualLocation;
 pub use traits::IndividualParents;
-pub use traits::NodeListGenerator;
-pub use traits::TableAccess;
 pub use traits::TskitTypeAccess;
 pub use tree_interface::{NodeTraversalOrder, TreeInterface};
 pub use trees::{Tree, TreeSequence};
diff --git a/src/metadata.rs b/src/metadata.rs
index bc81bbf22..f448a64c2 100644
--- a/src/metadata.rs
+++ b/src/metadata.rs
@@ -30,7 +30,7 @@
 //! ```
 //! # #[cfg(feature = "derive")] {
 //! use tskit::handle_metadata_return;
-//! use tskit::TableAccess;
+//!
 //!
 //! #[derive(serde::Serialize, serde::Deserialize, tskit::metadata::MutationMetadata)]
 //! #[serializer("serde_json")]
@@ -75,7 +75,7 @@
 //!
 //! ```
 //! # #[cfg(feature = "derive")] {
-//! use tskit::TableAccess;
+//!
 //! #[derive(serde::Serialize, serde::Deserialize, PartialEq, PartialOrd)]
 //! struct GeneticValue(f64);
 //!
@@ -101,7 +101,7 @@
 //! For fun, we'll use the Python [`pickle`](https://docs.rs/crate/serde-pickle/) format.
 //!
 //! ```
-//! use tskit::TableAccess;
+//!
 //!
 //! #[derive(serde::Serialize, serde::Deserialize)]
 //! struct Metadata {
diff --git a/src/migration_table.rs b/src/migration_table.rs
index 41285cd3d..1adbbd240 100644
--- a/src/migration_table.rs
+++ b/src/migration_table.rs
@@ -1,3 +1,5 @@
+use std::ptr::NonNull;
+
 use crate::bindings as ll_bindings;
 use crate::metadata;
 use crate::Position;
@@ -34,7 +36,7 @@ impl PartialEq for MigrationTableRow {
 }
 
 fn make_migration_table_row(table: &MigrationTable, pos: tsk_id_t) -> Option<MigrationTableRow> {
-    let table_ref = table.table_;
+    let table_ref = table.as_ref();
     Some(MigrationTableRow {
         id: pos.into(),
         left: table.left(pos)?,
@@ -48,9 +50,8 @@ fn make_migration_table_row(table: &MigrationTable, pos: tsk_id_t) -> Option<Mig
 }
 
 pub(crate) type MigrationTableRefIterator<'a> =
-    crate::table_iterator::TableIterator<&'a MigrationTable<'a>>;
-pub(crate) type MigrationTableIterator<'a> =
-    crate::table_iterator::TableIterator<MigrationTable<'a>>;
+    crate::table_iterator::TableIterator<&'a MigrationTable>;
+pub(crate) type MigrationTableIterator = crate::table_iterator::TableIterator<MigrationTable>;
 
 impl<'a> Iterator for MigrationTableRefIterator<'a> {
     type Item = MigrationTableRow;
@@ -62,7 +63,7 @@ impl<'a> Iterator for MigrationTableRefIterator<'a> {
     }
 }
 
-impl<'a> Iterator for MigrationTableIterator<'a> {
+impl Iterator for MigrationTableIterator {
     type Item = crate::migration_table::MigrationTableRow;
 
     fn next(&mut self) -> Option<Self::Item> {
@@ -74,21 +75,31 @@ impl<'a> Iterator for MigrationTableIterator<'a> {
 
 /// An immutable view of a migration table.
 ///
-/// These are not created directly.
-/// Instead, use [`TableAccess::migrations`](crate::TableAccess::migrations)
-/// to get a reference to an existing node table;
-pub struct MigrationTable<'a> {
-    table_: &'a ll_bindings::tsk_migration_table_t,
+/// These are not created directly but are accessed
+/// by types implementing [`std::ops::Deref`] to
+/// [`crate::table_views::TableViews`]
+pub struct MigrationTable {
+    table_: NonNull<ll_bindings::tsk_migration_table_t>,
 }
 
-impl<'a> MigrationTable<'a> {
-    pub(crate) fn new_from_table(migrations: &'a ll_bindings::tsk_migration_table_t) -> Self {
-        MigrationTable { table_: migrations }
+impl MigrationTable {
+    pub(crate) fn new_from_table(
+        migrations: *mut ll_bindings::tsk_migration_table_t,
+    ) -> Result<Self, TskitError> {
+        let n = NonNull::new(migrations).ok_or_else(|| {
+            TskitError::LibraryError("null pointer to tsk_migration_table_t".to_string())
+        })?;
+        Ok(MigrationTable { table_: n })
+    }
+
+    pub(crate) fn as_ref(&self) -> &ll_bindings::tsk_migration_table_t {
+        // SAFETY: NonNull
+        unsafe { self.table_.as_ref() }
     }
 
     /// Return the number of rows
-    pub fn num_rows(&'a self) -> SizeType {
-        self.table_.num_rows.into()
+    pub fn num_rows(&self) -> SizeType {
+        self.as_ref().num_rows.into()
     }
 
     /// Return the left coordinate for a given row.
@@ -97,8 +108,14 @@ impl<'a> MigrationTable<'a> {
     ///
     /// * `Some(position)` if `row` is valid.
     /// * `None` otherwise.
-    pub fn left<M: Into<MigrationId> + Copy>(&'a self, row: M) -> Option<Position> {
-        unsafe_tsk_column_access_and_map_into!(row.into().0, 0, self.num_rows(), self.table_, left)
+    pub fn left<M: Into<MigrationId> + Copy>(&self, row: M) -> Option<Position> {
+        unsafe_tsk_column_access_and_map_into!(
+            row.into().0,
+            0,
+            self.num_rows(),
+            self.as_ref(),
+            left
+        )
     }
 
     /// Return the right coordinate for a given row.
@@ -107,8 +124,14 @@ impl<'a> MigrationTable<'a> {
     ///
     /// * `Some(positions)` if `row` is valid.
     /// * `None` otherwise.
-    pub fn right<M: Into<MigrationId> + Copy>(&'a self, row: M) -> Option<Position> {
-        unsafe_tsk_column_access_and_map_into!(row.into().0, 0, self.num_rows(), self.table_, right)
+    pub fn right<M: Into<MigrationId> + Copy>(&self, row: M) -> Option<Position> {
+        unsafe_tsk_column_access_and_map_into!(
+            row.into().0,
+            0,
+            self.num_rows(),
+            self.as_ref(),
+            right
+        )
     }
 
     /// Return the node for a given row.
@@ -117,8 +140,15 @@ impl<'a> MigrationTable<'a> {
     ///
     /// * `Some(node)` if `row` is valid.
     /// * `None` otherwise.
-    pub fn node<M: Into<MigrationId> + Copy>(&'a self, row: M) -> Option<NodeId> {
-        unsafe_tsk_column_access!(row.into().0, 0, self.num_rows(), self.table_, node, NodeId)
+    pub fn node<M: Into<MigrationId> + Copy>(&self, row: M) -> Option<NodeId> {
+        unsafe_tsk_column_access!(
+            row.into().0,
+            0,
+            self.num_rows(),
+            self.as_ref(),
+            node,
+            NodeId
+        )
     }
 
     /// Return the source population for a given row.
@@ -127,12 +157,12 @@ impl<'a> MigrationTable<'a> {
     ///
     /// * `Some(population)` if `row` is valid.
     /// * `None` otherwise.
-    pub fn source<M: Into<MigrationId> + Copy>(&'a self, row: M) -> Option<PopulationId> {
+    pub fn source<M: Into<MigrationId> + Copy>(&self, row: M) -> Option<PopulationId> {
         unsafe_tsk_column_access!(
             row.into().0,
             0,
             self.num_rows(),
-            self.table_,
+            self.as_ref(),
             source,
             PopulationId
         )
@@ -144,12 +174,12 @@ impl<'a> MigrationTable<'a> {
     ///
     /// * `Some(population)` if `row` is valid.
     /// * `None` otherwise.
-    pub fn dest<M: Into<MigrationId> + Copy>(&'a self, row: M) -> Option<PopulationId> {
+    pub fn dest<M: Into<MigrationId> + Copy>(&self, row: M) -> Option<PopulationId> {
         unsafe_tsk_column_access!(
             row.into().0,
             0,
             self.num_rows(),
-            self.table_,
+            self.as_ref(),
             dest,
             PopulationId
         )
@@ -161,8 +191,14 @@ impl<'a> MigrationTable<'a> {
     ///
     /// * `Some(time)` if `row` is valid.
     /// * `None` otherwise.
-    pub fn time<M: Into<MigrationId> + Copy>(&'a self, row: M) -> Option<Time> {
-        unsafe_tsk_column_access_and_map_into!(row.into().0, 0, self.num_rows(), self.table_, time)
+    pub fn time<M: Into<MigrationId> + Copy>(&self, row: M) -> Option<Time> {
+        unsafe_tsk_column_access_and_map_into!(
+            row.into().0,
+            0,
+            self.num_rows(),
+            self.as_ref(),
+            time
+        )
     }
 
     /// Retrieve decoded metadata for a `row`.
@@ -182,10 +218,10 @@ impl<'a> MigrationTable<'a> {
     /// The big-picture semantics are the same for all table types.
     /// See [`crate::IndividualTable::metadata`] for examples.
     pub fn metadata<T: metadata::MigrationMetadata>(
-        &'a self,
+        &self,
         row: MigrationId,
     ) -> Option<Result<T, TskitError>> {
-        let table_ref = self.table_;
+        let table_ref = self.as_ref();
         let buffer = metadata_to_vector!(self, table_ref, row.0)?;
         Some(decode_metadata_row!(T, buffer).map_err(|e| e.into()))
     }
@@ -193,7 +229,7 @@ impl<'a> MigrationTable<'a> {
     /// Return an iterator over rows of the table.
     /// The value of the iterator is [`MigrationTableRow`].
     pub fn iter(&self) -> impl Iterator<Item = MigrationTableRow> + '_ {
-        crate::table_iterator::make_table_iterator::<&MigrationTable<'a>>(self)
+        crate::table_iterator::make_table_iterator::<&MigrationTable>(self)
     }
 
     /// Return row `r` of the table.
diff --git a/src/mutation_table.rs b/src/mutation_table.rs
index e8cdea7f0..14b0c54de 100644
--- a/src/mutation_table.rs
+++ b/src/mutation_table.rs
@@ -1,3 +1,5 @@
+use std::ptr::NonNull;
+
 use crate::bindings as ll_bindings;
 use crate::metadata;
 use crate::SizeType;
@@ -34,7 +36,7 @@ fn make_mutation_table_row(table: &MutationTable, pos: tsk_id_t) -> Option<Mutat
     let index = ll_bindings::tsk_size_t::try_from(pos).ok()?;
     match index {
         i if i < table.num_rows() => {
-            let table_ref = table.table_;
+            let table_ref = table.as_ref();
             let derived_state = table.derived_state(pos).map(|s| s.to_vec());
             Some(MutationTableRow {
                 id: pos.into(),
@@ -51,8 +53,8 @@ fn make_mutation_table_row(table: &MutationTable, pos: tsk_id_t) -> Option<Mutat
 }
 
 pub(crate) type MutationTableRefIterator<'a> =
-    crate::table_iterator::TableIterator<&'a MutationTable<'a>>;
-pub(crate) type MutationTableIterator<'a> = crate::table_iterator::TableIterator<MutationTable<'a>>;
+    crate::table_iterator::TableIterator<&'a MutationTable>;
+pub(crate) type MutationTableIterator = crate::table_iterator::TableIterator<MutationTable>;
 
 impl<'a> Iterator for MutationTableRefIterator<'a> {
     type Item = MutationTableRow;
@@ -64,7 +66,7 @@ impl<'a> Iterator for MutationTableRefIterator<'a> {
     }
 }
 
-impl<'a> Iterator for MutationTableIterator<'a> {
+impl Iterator for MutationTableIterator {
     type Item = MutationTableRow;
 
     fn next(&mut self) -> Option<Self::Item> {
@@ -76,21 +78,31 @@ impl<'a> Iterator for MutationTableIterator<'a> {
 
 /// An immutable view of site table.
 ///
-/// These are not created directly.
-/// Instead, use [`TableAccess::mutations`](crate::TableAccess::mutations)
-/// to get a reference to an existing mutation table;
-pub struct MutationTable<'a> {
-    table_: &'a ll_bindings::tsk_mutation_table_t,
+/// These are not created directly but are accessed
+/// by types implementing [`std::ops::Deref`] to
+/// [`crate::table_views::TableViews`]
+pub struct MutationTable {
+    table_: NonNull<ll_bindings::tsk_mutation_table_t>,
 }
 
-impl<'a> MutationTable<'a> {
-    pub(crate) fn new_from_table(mutations: &'a ll_bindings::tsk_mutation_table_t) -> Self {
-        MutationTable { table_: mutations }
+impl MutationTable {
+    pub(crate) fn new_from_table(
+        mutations: *mut ll_bindings::tsk_mutation_table_t,
+    ) -> Result<Self, TskitError> {
+        let n = NonNull::new(mutations).ok_or_else(|| {
+            TskitError::LibraryError("null pointer to tsk_mutation_table_t".to_string())
+        })?;
+        Ok(MutationTable { table_: n })
+    }
+
+    pub(crate) fn as_ref(&self) -> &ll_bindings::tsk_mutation_table_t {
+        // SAFETY: NonNull
+        unsafe { self.table_.as_ref() }
     }
 
     /// Return the number of rows.
-    pub fn num_rows(&'a self) -> SizeType {
-        self.table_.num_rows.into()
+    pub fn num_rows(&self) -> SizeType {
+        self.as_ref().num_rows.into()
     }
 
     /// Return the ``site`` value from row ``row`` of the table.
@@ -99,8 +111,15 @@ impl<'a> MutationTable<'a> {
     ///
     /// Will return [``IndexError``](crate::TskitError::IndexError)
     /// if ``row`` is out of range.
-    pub fn site<M: Into<MutationId> + Copy>(&'a self, row: M) -> Option<SiteId> {
-        unsafe_tsk_column_access!(row.into().0, 0, self.num_rows(), self.table_, site, SiteId)
+    pub fn site<M: Into<MutationId> + Copy>(&self, row: M) -> Option<SiteId> {
+        unsafe_tsk_column_access!(
+            row.into().0,
+            0,
+            self.num_rows(),
+            self.as_ref(),
+            site,
+            SiteId
+        )
     }
 
     /// Return the ``node`` value from row ``row`` of the table.
@@ -109,8 +128,15 @@ impl<'a> MutationTable<'a> {
     ///
     /// Will return [``IndexError``](crate::TskitError::IndexError)
     /// if ``row`` is out of range.
-    pub fn node<M: Into<MutationId> + Copy>(&'a self, row: M) -> Option<NodeId> {
-        unsafe_tsk_column_access!(row.into().0, 0, self.num_rows(), self.table_, node, NodeId)
+    pub fn node<M: Into<MutationId> + Copy>(&self, row: M) -> Option<NodeId> {
+        unsafe_tsk_column_access!(
+            row.into().0,
+            0,
+            self.num_rows(),
+            self.as_ref(),
+            node,
+            NodeId
+        )
     }
 
     /// Return the ``parent`` value from row ``row`` of the table.
@@ -119,12 +145,12 @@ impl<'a> MutationTable<'a> {
     ///
     /// Will return [``IndexError``](crate::TskitError::IndexError)
     /// if ``row`` is out of range.
-    pub fn parent<M: Into<MutationId> + Copy>(&'a self, row: M) -> Option<MutationId> {
+    pub fn parent<M: Into<MutationId> + Copy>(&self, row: M) -> Option<MutationId> {
         unsafe_tsk_column_access!(
             row.into().0,
             0,
             self.num_rows(),
-            self.table_,
+            self.as_ref(),
             parent,
             MutationId
         )
@@ -136,8 +162,8 @@ impl<'a> MutationTable<'a> {
     ///
     /// Will return [``IndexError``](crate::TskitError::IndexError)
     /// if ``row`` is out of range.
-    pub fn time<M: Into<MutationId> + Copy>(&'a self, row: M) -> Option<Time> {
-        unsafe_tsk_column_access!(row.into().0, 0, self.num_rows(), self.table_, time, Time)
+    pub fn time<M: Into<MutationId> + Copy>(&self, row: M) -> Option<Time> {
+        unsafe_tsk_column_access!(row.into().0, 0, self.num_rows(), self.as_ref(), time, Time)
     }
 
     /// Get the ``derived_state`` value from row ``row`` of the table.
@@ -150,14 +176,14 @@ impl<'a> MutationTable<'a> {
     ///
     /// Will return [``IndexError``](crate::TskitError::IndexError)
     /// if ``row`` is out of range.
-    pub fn derived_state<M: Into<MutationId>>(&'a self, row: M) -> Option<&[u8]> {
+    pub fn derived_state<M: Into<MutationId>>(&self, row: M) -> Option<&[u8]> {
         metadata::char_column_to_slice(
             self,
-            self.table_.derived_state,
-            self.table_.derived_state_offset,
+            self.as_ref().derived_state,
+            self.as_ref().derived_state_offset,
             row.into().0,
-            self.table_.num_rows,
-            self.table_.derived_state_length,
+            self.as_ref().num_rows,
+            self.as_ref().derived_state_length,
         )
     }
 
@@ -178,10 +204,10 @@ impl<'a> MutationTable<'a> {
     /// The big-picture semantics are the same for all table types.
     /// See [`crate::IndividualTable::metadata`] for examples.
     pub fn metadata<T: metadata::MutationMetadata>(
-        &'a self,
+        &self,
         row: MutationId,
     ) -> Option<Result<T, TskitError>> {
-        let table_ref = self.table_;
+        let table_ref = self.as_ref();
         let buffer = metadata_to_vector!(self, table_ref, row.0)?;
         Some(decode_metadata_row!(T, buffer).map_err(|e| e.into()))
     }
@@ -189,7 +215,7 @@ impl<'a> MutationTable<'a> {
     /// Return an iterator over rows of the table.
     /// The value of the iterator is [`MutationTableRow`].
     pub fn iter(&self) -> impl Iterator<Item = MutationTableRow> + '_ {
-        crate::table_iterator::make_table_iterator::<&MutationTable<'a>>(self)
+        crate::table_iterator::make_table_iterator::<&MutationTable>(self)
     }
 
     /// Return row `r` of the table.
diff --git a/src/node_table.rs b/src/node_table.rs
index b2731a41f..81dca121e 100644
--- a/src/node_table.rs
+++ b/src/node_table.rs
@@ -1,3 +1,5 @@
+use std::ptr::NonNull;
+
 use crate::bindings as ll_bindings;
 use crate::metadata;
 use crate::NodeFlags;
@@ -30,7 +32,7 @@ impl PartialEq for NodeTableRow {
 }
 
 fn make_node_table_row(table: &NodeTable, pos: tsk_id_t) -> Option<NodeTableRow> {
-    let table_ref = table.table_;
+    let table_ref = table.as_ref();
     Some(NodeTableRow {
         id: pos.into(),
         time: table.time(pos)?,
@@ -41,8 +43,8 @@ fn make_node_table_row(table: &NodeTable, pos: tsk_id_t) -> Option<NodeTableRow>
     })
 }
 
-pub(crate) type NodeTableRefIterator<'a> = crate::table_iterator::TableIterator<&'a NodeTable<'a>>;
-pub(crate) type NodeTableIterator<'a> = crate::table_iterator::TableIterator<NodeTable<'a>>;
+pub(crate) type NodeTableRefIterator<'a> = crate::table_iterator::TableIterator<&'a NodeTable>;
+pub(crate) type NodeTableIterator = crate::table_iterator::TableIterator<NodeTable>;
 
 impl<'a> Iterator for NodeTableRefIterator<'a> {
     type Item = NodeTableRow;
@@ -54,7 +56,7 @@ impl<'a> Iterator for NodeTableRefIterator<'a> {
     }
 }
 
-impl<'a> Iterator for NodeTableIterator<'a> {
+impl Iterator for NodeTableIterator {
     type Item = crate::node_table::NodeTableRow;
 
     fn next(&mut self) -> Option<Self::Item> {
@@ -66,21 +68,31 @@ impl<'a> Iterator for NodeTableIterator<'a> {
 
 /// An immtable view of a node table.
 ///
-/// These are not created directly.
-/// Instead, use [`TableAccess::nodes`](crate::TableAccess::nodes)
-/// to get a reference to an existing node table;
-pub struct NodeTable<'a> {
-    table_: &'a ll_bindings::tsk_node_table_t,
+/// These are not created directly but are accessed
+/// by types implementing [`std::ops::Deref`] to
+/// [`crate::table_views::TableViews`]
+pub struct NodeTable {
+    table_: NonNull<ll_bindings::tsk_node_table_t>,
 }
 
-impl<'a> NodeTable<'a> {
-    pub(crate) fn new_from_table(nodes: &'a ll_bindings::tsk_node_table_t) -> Self {
-        NodeTable { table_: nodes }
+impl NodeTable {
+    pub(crate) fn new_from_table(
+        nodes: *mut ll_bindings::tsk_node_table_t,
+    ) -> Result<Self, TskitError> {
+        let n = NonNull::new(nodes).ok_or_else(|| {
+            TskitError::LibraryError("null pointer to tsk_node_table_t".to_string())
+        })?;
+        Ok(NodeTable { table_: n })
+    }
+
+    pub(crate) fn as_ref(&self) -> &ll_bindings::tsk_node_table_t {
+        // SAFETY: NonNull
+        unsafe { self.table_.as_ref() }
     }
 
     /// Return the number of rows
-    pub fn num_rows(&'a self) -> SizeType {
-        self.table_.num_rows.into()
+    pub fn num_rows(&self) -> SizeType {
+        self.as_ref().num_rows.into()
     }
 
     /// Return the ``time`` value from row ``row`` of the table.
@@ -104,8 +116,8 @@ impl<'a> NodeTable<'a> {
     /// #   panic!("expected 0 to be a valid row id")
     /// # }
     /// ```
-    pub fn time<N: Into<NodeId> + Copy>(&'a self, row: N) -> Option<Time> {
-        unsafe_tsk_column_access!(row.into().0, 0, self.num_rows(), self.table_, time, Time)
+    pub fn time<N: Into<NodeId> + Copy>(&self, row: N) -> Option<Time> {
+        unsafe_tsk_column_access!(row.into().0, 0, self.num_rows(), self.as_ref(), time, Time)
     }
 
     /// Return the ``flags`` value from row ``row`` of the table.
@@ -129,32 +141,37 @@ impl<'a> NodeTable<'a> {
     /// #   panic!("expected 0 to be a valid row id")
     /// # }
     /// ```
-    pub fn flags<N: Into<NodeId> + Copy>(&'a self, row: N) -> Option<NodeFlags> {
-        unsafe_tsk_column_access_and_map_into!(row.into().0, 0, self.num_rows(), self.table_, flags)
+    pub fn flags<N: Into<NodeId> + Copy>(&self, row: N) -> Option<NodeFlags> {
+        unsafe_tsk_column_access_and_map_into!(
+            row.into().0,
+            0,
+            self.num_rows(),
+            self.as_ref(),
+            flags
+        )
     }
 
     /// Mutable access to node flags.
     ///
     /// # Examples
     ///
-    /// For a [`crate::TableCollection`], accessing the table creates a temporary
-    /// that will be dropped, causing this code to not compile:
     ///
-    /// ```compile_fail
+    /// ```
     /// # use tskit::prelude::*;
     /// # let mut tables = tskit::TableCollection::new(10.).unwrap();
     /// # tables.add_node(tskit::NodeFlags::IS_SAMPLE, 10.0, -1, -1).unwrap();
-    /// let flags = tables.nodes().flags_array_mut();
-    /// println!("{}", flags.len()); // ERROR: the temporary node table is dropped by now
+    /// let flags = tables.nodes_mut().flags_array_mut();
+    /// for flag in flags {
+    /// // Can do something...
+    /// # assert!(flag.is_sample());
+    /// }
     /// ```
     ///
-    /// Treating the returned slice as an iterable succeeds:
-    ///
     /// ```
     /// # use tskit::prelude::*;
     /// # let mut tables = tskit::TableCollection::new(10.).unwrap();
     /// # tables.add_node(tskit::NodeFlags::IS_SAMPLE, 10.0, -1, -1).unwrap();
-    /// for flag in  tables.nodes().flags_array_mut() {
+    /// for flag in  tables.nodes_mut().flags_array_mut() {
     /// # assert!(flag.is_sample());
     /// }
     /// ```
@@ -168,17 +185,17 @@ impl<'a> NodeTable<'a> {
     /// # use tskit::prelude::*;
     /// # let mut tables = tskit::TableCollection::new(10.).unwrap();
     /// # tables.add_node(tskit::NodeFlags::IS_SAMPLE, 10.0, -1, -1).unwrap();
-    /// for flag in tables.nodes().flags_array_mut() {
+    /// for flag in tables.nodes_mut().flags_array_mut() {
     ///     flag.remove(tskit::NodeFlags::IS_SAMPLE);
     /// }
-    /// assert!(!tables.nodes().flags_array_mut().iter().any(|f| f.is_sample()));
+    /// assert!(!tables.nodes_mut().flags_array_mut().iter().any(|f| f.is_sample()));
     /// ```
     ///
     /// ```
     /// # use tskit::prelude::*;
     /// # let mut tables = tskit::TableCollection::new(10.).unwrap();
     /// # tables.add_node(tskit::NodeFlags::IS_SAMPLE, 10.0, -1, -1).unwrap();
-    /// let flags = tables.nodes().flags_array_mut().to_vec();
+    /// let flags = tables.nodes_mut().flags_array_mut().to_vec();
     /// # assert!(flags.iter().all(|f| f.is_sample()));
     /// ```
     ///
@@ -197,11 +214,11 @@ impl<'a> NodeTable<'a> {
     ///
     /// // while we are at it, let's use our node
     /// // table to populate a table collection.
-    /// # use tskit::TableAccess;
+    /// #
     /// let mut tables = tskit::TableCollection::new(10.0).unwrap();
     /// tables.set_nodes(&nodes);
     /// assert_eq!(tables.nodes().num_rows(), 1);
-    /// assert_eq!(tables.nodes().flags_array_mut().iter().filter(|f| f.is_sample()).count(), 1);
+    /// assert_eq!(tables.nodes_mut().flags_array_mut().iter().filter(|f| f.is_sample()).count(), 1);
     /// ```
     ///
     /// # Note
@@ -212,8 +229,8 @@ impl<'a> NodeTable<'a> {
     pub fn flags_array_mut(&mut self) -> &mut [NodeFlags] {
         unsafe {
             std::slice::from_raw_parts_mut(
-                self.table_.flags.cast::<NodeFlags>(),
-                usize::try_from(self.table_.num_rows).unwrap_or(0),
+                self.as_ref().flags.cast::<NodeFlags>(),
+                usize::try_from(self.as_ref().num_rows).unwrap_or(0),
             )
         }
     }
@@ -239,10 +256,10 @@ impl<'a> NodeTable<'a> {
     /// # use tskit::prelude::*;
     /// # let mut tables = tskit::TableCollection::new(10.).unwrap();
     /// # tables.add_node(tskit::NodeFlags::IS_SAMPLE, 10.0, -1, -1).unwrap();
-    /// for time in tables.nodes().time_array_mut() {
+    /// for time in tables.nodes_mut().time_array_mut() {
     ///     *time = 55.0.into(); // change each node's time value
     /// }
-    /// assert!(tables.nodes().time_array_mut().iter().all(|t| t == &55.0));
+    /// assert!(tables.nodes_mut().time_array_mut().iter().all(|t| t == &55.0));
     /// ```
     ///
     /// # Note
@@ -253,8 +270,8 @@ impl<'a> NodeTable<'a> {
     pub fn time_array_mut(&mut self) -> &mut [Time] {
         unsafe {
             std::slice::from_raw_parts_mut(
-                self.table_.time.cast::<Time>(),
-                usize::try_from(self.table_.num_rows).unwrap_or(0),
+                self.as_ref().time.cast::<Time>(),
+                usize::try_from(self.as_ref().num_rows).unwrap_or(0),
             )
         }
     }
@@ -280,12 +297,12 @@ impl<'a> NodeTable<'a> {
     ///
     /// * `Some(population)` if `row` is valid.
     /// * `None` otherwise.
-    pub fn population<N: Into<NodeId> + Copy>(&'a self, row: N) -> Option<PopulationId> {
+    pub fn population<N: Into<NodeId> + Copy>(&self, row: N) -> Option<PopulationId> {
         unsafe_tsk_column_access!(
             row.into().0,
             0,
             self.num_rows(),
-            self.table_,
+            self.as_ref(),
             population,
             PopulationId
         )
@@ -301,7 +318,7 @@ impl<'a> NodeTable<'a> {
     ///
     /// * `Some(population)` if `row` is valid.
     /// * `None` otherwise.
-    pub fn deme<N: Into<NodeId> + Copy>(&'a self, row: N) -> Option<PopulationId> {
+    pub fn deme<N: Into<NodeId> + Copy>(&self, row: N) -> Option<PopulationId> {
         self.population(row)
     }
 
@@ -326,12 +343,12 @@ impl<'a> NodeTable<'a> {
     ///
     /// * `Some(individual)` if `row` is valid.
     /// * `None` otherwise.
-    pub fn individual<N: Into<NodeId> + Copy>(&'a self, row: N) -> Option<IndividualId> {
+    pub fn individual<N: Into<NodeId> + Copy>(&self, row: N) -> Option<IndividualId> {
         unsafe_tsk_column_access!(
             row.into().0,
             0,
             self.num_rows(),
-            self.table_,
+            self.as_ref(),
             individual,
             IndividualId
         )
@@ -354,10 +371,10 @@ impl<'a> NodeTable<'a> {
     /// The big-picture semantics are the same for all table types.
     /// See [`crate::IndividualTable::metadata`] for examples.
     pub fn metadata<T: metadata::NodeMetadata>(
-        &'a self,
+        &self,
         row: NodeId,
     ) -> Option<Result<T, TskitError>> {
-        let table_ref = self.table_;
+        let table_ref = self.as_ref();
         let buffer = metadata_to_vector!(self, table_ref, row.0)?;
         Some(decode_metadata_row!(T, buffer).map_err(|e| e.into()))
     }
@@ -365,7 +382,7 @@ impl<'a> NodeTable<'a> {
     /// Return an iterator over rows of the table.
     /// The value of the iterator is [`NodeTableRow`].
     pub fn iter(&self) -> impl Iterator<Item = NodeTableRow> + '_ {
-        crate::table_iterator::make_table_iterator::<&NodeTable<'a>>(self)
+        crate::table_iterator::make_table_iterator::<&NodeTable>(self)
     }
 
     /// Return row `r` of the table.
diff --git a/src/population_table.rs b/src/population_table.rs
index 84bb74965..84390205e 100644
--- a/src/population_table.rs
+++ b/src/population_table.rs
@@ -1,3 +1,5 @@
+use std::ptr::NonNull;
+
 use crate::bindings as ll_bindings;
 use crate::metadata;
 use crate::tsk_id_t;
@@ -20,7 +22,7 @@ impl PartialEq for PopulationTableRow {
 }
 
 fn make_population_table_row(table: &PopulationTable, pos: tsk_id_t) -> Option<PopulationTableRow> {
-    let table_ref = table.table_;
+    let table_ref = table.as_ref();
     let index = ll_bindings::tsk_size_t::try_from(pos).ok()?;
 
     match index {
@@ -36,9 +38,8 @@ fn make_population_table_row(table: &PopulationTable, pos: tsk_id_t) -> Option<P
 }
 
 pub(crate) type PopulationTableRefIterator<'a> =
-    crate::table_iterator::TableIterator<&'a PopulationTable<'a>>;
-pub(crate) type PopulationTableIterator<'a> =
-    crate::table_iterator::TableIterator<PopulationTable<'a>>;
+    crate::table_iterator::TableIterator<&'a PopulationTable>;
+pub(crate) type PopulationTableIterator = crate::table_iterator::TableIterator<PopulationTable>;
 
 impl<'a> Iterator for PopulationTableRefIterator<'a> {
     type Item = PopulationTableRow;
@@ -50,7 +51,7 @@ impl<'a> Iterator for PopulationTableRefIterator<'a> {
     }
 }
 
-impl<'a> Iterator for PopulationTableIterator<'a> {
+impl Iterator for PopulationTableIterator {
     type Item = PopulationTableRow;
 
     fn next(&mut self) -> Option<Self::Item> {
@@ -62,22 +63,32 @@ impl<'a> Iterator for PopulationTableIterator<'a> {
 
 /// An immutable view of site table.
 ///
-/// These are not created directly.
-/// Instead, use [`TableAccess::populations`](crate::TableAccess::populations)
-/// to get a reference to an existing population table;
+/// These are not created directly but are accessed
+/// by types implementing [`std::ops::Deref`] to
+/// [`crate::table_views::TableViews`]
 #[repr(transparent)]
-pub struct PopulationTable<'a> {
-    table_: &'a ll_bindings::tsk_population_table_t,
+pub struct PopulationTable {
+    table_: NonNull<ll_bindings::tsk_population_table_t>,
 }
 
-impl<'a> PopulationTable<'a> {
-    pub(crate) fn new_from_table(mutations: &'a ll_bindings::tsk_population_table_t) -> Self {
-        PopulationTable { table_: mutations }
+impl PopulationTable {
+    pub(crate) fn new_from_table(
+        populations: *mut ll_bindings::tsk_population_table_t,
+    ) -> Result<Self, TskitError> {
+        let n = NonNull::new(populations).ok_or_else(|| {
+            TskitError::LibraryError("null pointer to tsk_population_table_t".to_string())
+        })?;
+        Ok(PopulationTable { table_: n })
+    }
+
+    pub(crate) fn as_ref(&self) -> &ll_bindings::tsk_population_table_t {
+        // SAFETY: NonNull
+        unsafe { self.table_.as_ref() }
     }
 
     /// Return the number of rows.
-    pub fn num_rows(&'a self) -> SizeType {
-        self.table_.num_rows.into()
+    pub fn num_rows(&self) -> SizeType {
+        self.as_ref().num_rows.into()
     }
 
     /// Retrieve decoded metadata for a `row`.
@@ -97,10 +108,10 @@ impl<'a> PopulationTable<'a> {
     /// The big-picture semantics are the same for all table types.
     /// See [`crate::IndividualTable::metadata`] for examples.
     pub fn metadata<T: metadata::PopulationMetadata>(
-        &'a self,
+        &self,
         row: PopulationId,
     ) -> Option<Result<T, TskitError>> {
-        let table_ref = self.table_;
+        let table_ref = self.as_ref();
         let buffer = metadata_to_vector!(self, table_ref, row.0)?;
         Some(decode_metadata_row!(T, buffer).map_err(TskitError::from))
     }
@@ -108,7 +119,7 @@ impl<'a> PopulationTable<'a> {
     /// Return an iterator over rows of the table.
     /// The value of the iterator is [`PopulationTableRow`].
     pub fn iter(&self) -> impl Iterator<Item = PopulationTableRow> + '_ {
-        crate::table_iterator::make_table_iterator::<&PopulationTable<'a>>(self)
+        crate::table_iterator::make_table_iterator::<&PopulationTable>(self)
     }
 
     /// Return row `r` of the table.
diff --git a/src/prelude.rs b/src/prelude.rs
index f93423a83..c68c2b947 100644
--- a/src/prelude.rs
+++ b/src/prelude.rs
@@ -1,8 +1,6 @@
 //! Export commonly-use types and traits
 
 pub use crate::tsk_flags_t;
-pub use crate::NodeListGenerator;
-pub use crate::TableAccess;
 pub use crate::TskitTypeAccess;
 pub use crate::TSK_NODE_IS_SAMPLE;
 pub use streaming_iterator::DoubleEndedStreamingIterator;
diff --git a/src/provenance.rs b/src/provenance.rs
index 82cf92c1b..4acaac465 100644
--- a/src/provenance.rs
+++ b/src/provenance.rs
@@ -4,14 +4,14 @@
 //! the following:
 //!
 //! * [`crate::TableCollection::add_provenance`]
-//! * [`crate::TableAccess::provenances`]
-//! * [`crate::TableAccess::provenances_iter`]
 //! * [`crate::TreeSequence::add_provenance`]
 //! * [`ProvenanceTable`].
 //! * [`ProvenanceTableRow`], which is the value type returned by
 //!   [`ProvenanceTable::iter`].
 //!
 
+use std::ptr::NonNull;
+
 use crate::bindings as ll_bindings;
 use crate::SizeType;
 use crate::{tsk_id_t, tsk_size_t, ProvenanceId};
@@ -52,8 +52,8 @@ fn make_provenance_row(table: &ProvenanceTable, pos: tsk_id_t) -> Option<Provena
     })
 }
 
-type ProvenanceTableRefIterator<'a> = crate::table_iterator::TableIterator<&'a ProvenanceTable<'a>>;
-type ProvenanceTableIterator<'a> = crate::table_iterator::TableIterator<ProvenanceTable<'a>>;
+type ProvenanceTableRefIterator<'a> = crate::table_iterator::TableIterator<&'a ProvenanceTable>;
+type ProvenanceTableIterator = crate::table_iterator::TableIterator<ProvenanceTable>;
 
 impl<'a> Iterator for ProvenanceTableRefIterator<'a> {
     type Item = ProvenanceTableRow;
@@ -65,7 +65,7 @@ impl<'a> Iterator for ProvenanceTableRefIterator<'a> {
     }
 }
 
-impl<'a> Iterator for ProvenanceTableIterator<'a> {
+impl Iterator for ProvenanceTableIterator {
     type Item = ProvenanceTableRow;
 
     fn next(&mut self) -> Option<Self::Item> {
@@ -78,27 +78,36 @@ impl<'a> Iterator for ProvenanceTableIterator<'a> {
 /// An immutable view of a provenance table.
 ///
 /// These are not created directly.
-/// Instead, use [`crate::TableAccess::provenances`]
 /// to get a reference to an existing provenance table;
 ///
 /// # Notes
 ///
 /// * The type is enabled by the `"provenance"` feature.
 ///
-pub struct ProvenanceTable<'a> {
-    table_: &'a ll_bindings::tsk_provenance_table_t,
+pub struct ProvenanceTable {
+    table_: NonNull<ll_bindings::tsk_provenance_table_t>,
 }
 
-impl<'a> ProvenanceTable<'a> {
-    pub(crate) fn new_from_table(provenances: &'a ll_bindings::tsk_provenance_table_t) -> Self {
-        ProvenanceTable {
-            table_: provenances,
-        }
+impl ProvenanceTable {
+    pub(crate) fn new_from_table(
+        provenances: *mut ll_bindings::tsk_provenance_table_t,
+    ) -> Result<Self, crate::TskitError> {
+        // FIXME: unwrap
+        let n = NonNull::new(provenances).ok_or_else(|| {
+            crate::TskitError::LibraryError("null pointer to tsk_provenance_table_t".to_string())
+        })?;
+        Ok(ProvenanceTable { table_: n })
+    }
+
+    pub(crate) fn as_ref(&self) -> &ll_bindings::tsk_provenance_table_t {
+        // SAFETY: NonNull
+        unsafe { self.table_.as_ref() }
     }
 
     /// Return the number of rows
-    pub fn num_rows(&'a self) -> SizeType {
-        self.table_.num_rows.into()
+    pub fn num_rows(&self) -> SizeType {
+        println!("internal: {}", unsafe { self.table_.as_ref() }.num_rows);
+        self.as_ref().num_rows.into()
     }
 
     /// Get the ISO-formatted time stamp for row `row`.
@@ -111,7 +120,7 @@ impl<'a> ProvenanceTable<'a> {
     /// # Examples
     ///
     /// ```
-    /// use tskit::TableAccess;
+    ///
     /// let mut tables = tskit::TableCollection::new(10.).unwrap();
     /// assert!(tables.add_provenance("foo").is_ok());
     /// if let Some(timestamp) = tables.provenances().timestamp(0) {
@@ -121,12 +130,12 @@ impl<'a> ProvenanceTable<'a> {
     /// # panic!("Expected Some(timestamp)");
     /// # }
     /// ```
-    pub fn timestamp<P: Into<ProvenanceId> + Copy>(&'a self, row: P) -> Option<String> {
+    pub fn timestamp<P: Into<ProvenanceId> + Copy>(&self, row: P) -> Option<String> {
         unsafe_tsk_ragged_char_column_access!(
             row.into().0,
             0,
             self.num_rows(),
-            self.table_,
+            self.as_ref(),
             timestamp,
             timestamp_offset,
             timestamp_length
@@ -143,7 +152,7 @@ impl<'a> ProvenanceTable<'a> {
     /// # Examples
     ///
     /// ```
-    /// use tskit::TableAccess;
+    ///
     /// let mut tables = tskit::TableCollection::new(10.).unwrap();
     /// assert!(tables.add_provenance("foo").is_ok());
     /// if let Some(record) = tables.provenances().record(0) {
@@ -153,12 +162,12 @@ impl<'a> ProvenanceTable<'a> {
     /// # else {
     /// # panic!("Expected Some(timestamp)");
     /// # }
-    pub fn record<P: Into<ProvenanceId> + Copy>(&'a self, row: P) -> Option<String> {
+    pub fn record<P: Into<ProvenanceId> + Copy>(&self, row: P) -> Option<String> {
         unsafe_tsk_ragged_char_column_access!(
             row.into().0,
             0,
             self.num_rows(),
-            self.table_,
+            self.as_ref(),
             record,
             record_offset,
             record_length
@@ -171,14 +180,14 @@ impl<'a> ProvenanceTable<'a> {
     ///
     /// * `Some(row)` if `r` is valid
     /// * `None` otherwise
-    pub fn row<P: Into<ProvenanceId> + Copy>(&'a self, row: P) -> Option<ProvenanceTableRow> {
+    pub fn row<P: Into<ProvenanceId> + Copy>(&self, row: P) -> Option<ProvenanceTableRow> {
         make_provenance_row(self, row.into().0)
     }
 
     /// Return an iterator over rows of the table.
     /// The value of the iterator is [`ProvenanceTableRow`].
     pub fn iter(&self) -> impl Iterator<Item = ProvenanceTableRow> + '_ {
-        crate::table_iterator::make_table_iterator::<&ProvenanceTable<'a>>(self)
+        crate::table_iterator::make_table_iterator::<&ProvenanceTable>(self)
     }
 }
 
@@ -213,7 +222,6 @@ impl OwnedProvenanceTable {
 #[cfg(test)]
 mod test_provenances {
     use super::*;
-    use crate::TableAccess;
 
     #[test]
     fn test_empty_record_string() {
diff --git a/src/site_table.rs b/src/site_table.rs
index 7b8a14e42..f7ee4c75b 100644
--- a/src/site_table.rs
+++ b/src/site_table.rs
@@ -1,3 +1,5 @@
+use std::ptr::NonNull;
+
 use crate::bindings as ll_bindings;
 use crate::metadata;
 use crate::tsk_id_t;
@@ -26,7 +28,7 @@ impl PartialEq for SiteTableRow {
 }
 
 fn make_site_table_row(table: &SiteTable, pos: tsk_id_t) -> Option<SiteTableRow> {
-    let table_ref = table.table_;
+    let table_ref = table.as_ref();
     let ancestral_state = table.ancestral_state(pos).map(|s| s.to_vec());
     Some(SiteTableRow {
         id: pos.into(),
@@ -36,8 +38,8 @@ fn make_site_table_row(table: &SiteTable, pos: tsk_id_t) -> Option<SiteTableRow>
     })
 }
 
-pub(crate) type SiteTableRefIterator<'a> = crate::table_iterator::TableIterator<&'a SiteTable<'a>>;
-pub(crate) type SiteTableIterator<'a> = crate::table_iterator::TableIterator<SiteTable<'a>>;
+pub(crate) type SiteTableRefIterator<'a> = crate::table_iterator::TableIterator<&'a SiteTable>;
+pub(crate) type SiteTableIterator = crate::table_iterator::TableIterator<SiteTable>;
 
 impl<'a> Iterator for SiteTableRefIterator<'a> {
     type Item = SiteTableRow;
@@ -49,7 +51,7 @@ impl<'a> Iterator for SiteTableRefIterator<'a> {
     }
 }
 
-impl<'a> Iterator for SiteTableIterator<'a> {
+impl Iterator for SiteTableIterator {
     type Item = SiteTableRow;
 
     fn next(&mut self) -> Option<Self::Item> {
@@ -61,21 +63,31 @@ impl<'a> Iterator for SiteTableIterator<'a> {
 
 /// An immutable view of site table.
 ///
-/// These are not created directly.
-/// Instead, use [`TableAccess::sites`](crate::TableAccess::sites)
-/// to get a reference to an existing site table;
-pub struct SiteTable<'a> {
-    table_: &'a ll_bindings::tsk_site_table_t,
+/// These are not created directly but are accessed
+/// by types implementing [`std::ops::Deref`] to
+/// [`crate::table_views::TableViews`]
+pub struct SiteTable {
+    table_: NonNull<ll_bindings::tsk_site_table_t>,
 }
 
-impl<'a> SiteTable<'a> {
-    pub(crate) fn new_from_table(sites: &'a ll_bindings::tsk_site_table_t) -> Self {
-        SiteTable { table_: sites }
+impl SiteTable {
+    pub(crate) fn new_from_table(
+        sites: *mut ll_bindings::tsk_site_table_t,
+    ) -> Result<Self, TskitError> {
+        let n = NonNull::new(sites).ok_or_else(|| {
+            TskitError::LibraryError("null pointer to tsk_site_table_t".to_string())
+        })?;
+        Ok(SiteTable { table_: n })
+    }
+
+    pub(crate) fn as_ref(&self) -> &ll_bindings::tsk_site_table_t {
+        // SAFETY: NonNull
+        unsafe { self.table_.as_ref() }
     }
 
     /// Return the number of rows
-    pub fn num_rows(&'a self) -> SizeType {
-        self.table_.num_rows.into()
+    pub fn num_rows(&self) -> SizeType {
+        self.as_ref().num_rows.into()
     }
 
     /// Return the ``position`` value from row ``row`` of the table.
@@ -84,12 +96,12 @@ impl<'a> SiteTable<'a> {
     ///
     /// * `Some(position)` if `row` is valid.
     /// * `None` otherwise.
-    pub fn position<S: Into<SiteId> + Copy>(&'a self, row: S) -> Option<Position> {
+    pub fn position<S: Into<SiteId> + Copy>(&self, row: S) -> Option<Position> {
         unsafe_tsk_column_access!(
             row.into().0,
             0,
             self.num_rows(),
-            self.table_,
+            self.as_ref(),
             position,
             Position
         )
@@ -101,14 +113,14 @@ impl<'a> SiteTable<'a> {
     ///
     /// * `Some(ancestral state)` if `row` is valid.
     /// * `None` otherwise.
-    pub fn ancestral_state<S: Into<SiteId>>(&'a self, row: S) -> Option<&[u8]> {
+    pub fn ancestral_state<S: Into<SiteId>>(&self, row: S) -> Option<&[u8]> {
         crate::metadata::char_column_to_slice(
             self,
-            self.table_.ancestral_state,
-            self.table_.ancestral_state_offset,
+            self.as_ref().ancestral_state,
+            self.as_ref().ancestral_state_offset,
             row.into().0,
-            self.table_.num_rows,
-            self.table_.ancestral_state_length,
+            self.as_ref().num_rows,
+            self.as_ref().ancestral_state_length,
         )
     }
 
@@ -129,10 +141,10 @@ impl<'a> SiteTable<'a> {
     /// The big-picture semantics are the same for all table types.
     /// See [`crate::IndividualTable::metadata`] for examples.
     pub fn metadata<T: metadata::SiteMetadata>(
-        &'a self,
+        &self,
         row: SiteId,
     ) -> Option<Result<T, TskitError>> {
-        let table_ref = self.table_;
+        let table_ref = self.as_ref();
         let buffer = metadata_to_vector!(self, table_ref, row.0)?;
         Some(decode_metadata_row!(T, buffer).map_err(TskitError::from))
     }
@@ -140,7 +152,7 @@ impl<'a> SiteTable<'a> {
     /// Return an iterator over rows of the table.
     /// The value of the iterator is [`SiteTableRow`].
     pub fn iter(&self) -> impl Iterator<Item = SiteTableRow> + '_ {
-        crate::table_iterator::make_table_iterator::<&SiteTable<'a>>(self)
+        crate::table_iterator::make_table_iterator::<&SiteTable>(self)
     }
 
     /// Return row `r` of the table.
diff --git a/src/table_collection.rs b/src/table_collection.rs
index 19b146a8e..ca9b41a1f 100644
--- a/src/table_collection.rs
+++ b/src/table_collection.rs
@@ -1,19 +1,12 @@
+use std::ops::{Deref, DerefMut};
 use std::vec;
 
 use crate::bindings as ll_bindings;
 use crate::error::TskitError;
 use crate::types::Bookmark;
-use crate::EdgeTable;
-use crate::IndividualTable;
 use crate::IndividualTableSortOptions;
-use crate::MigrationTable;
-use crate::MutationTable;
-use crate::NodeTable;
-use crate::PopulationTable;
 use crate::Position;
 use crate::SimplificationOptions;
-use crate::SiteTable;
-use crate::TableAccess;
 use crate::TableClearOptions;
 use crate::TableEqualityOptions;
 use crate::TableIntegrityCheckFlags;
@@ -39,7 +32,7 @@ use mbox::MBox;
 /// # Examples
 ///
 /// ```
-/// use tskit::TableAccess;
+///
 /// let mut tables = tskit::TableCollection::new(100.).unwrap();
 /// assert_eq!(tables.sequence_length(), 100.);
 ///
@@ -63,6 +56,7 @@ use mbox::MBox;
 pub struct TableCollection {
     inner: MBox<ll_bindings::tsk_table_collection_t>,
     idmap: Vec<NodeId>,
+    views: crate::table_views::TableViews,
 }
 
 impl TskitTypeAccess<ll_bindings::tsk_table_collection_t> for TableCollection {
@@ -82,6 +76,20 @@ impl Drop for TableCollection {
     }
 }
 
+impl Deref for TableCollection {
+    type Target = crate::table_views::TableViews;
+
+    fn deref(&self) -> &Self::Target {
+        &self.views
+    }
+}
+
+impl DerefMut for TableCollection {
+    fn deref_mut(&mut self) -> &mut Self::Target {
+        &mut self.views
+    }
+}
+
 /// Returns a pointer to an uninitialized tsk_table_collection_t
 pub(crate) fn uninit_table_collection() -> MBox<ll_bindings::tsk_table_collection_t> {
     let temp = unsafe {
@@ -122,9 +130,16 @@ impl TableCollection {
         if rv < 0 {
             return Err(crate::error::TskitError::ErrorCode { code: rv });
         }
+        let views = crate::table_views::TableViews::new_from_mbox_table_collection(&mut mbox)?;
+        // AHA?
+        assert!(std::ptr::eq(
+            &mbox.as_ref().edges as *const ll_bindings::tsk_edge_table_t,
+            views.edges().table_.as_ptr() as *const ll_bindings::tsk_edge_table_t
+        ));
         let mut tables = Self {
             inner: mbox,
             idmap: vec![],
+            views,
         };
         unsafe {
             (*tables.as_mut_ptr()).sequence_length = sequence_length.0;
@@ -139,11 +154,16 @@ impl TableCollection {
     /// Or, it may be initialized and about to be used in a part of the C API
     /// requiring an uninitialized table collection.
     /// Consult the C API docs before using!
-    pub(crate) unsafe fn new_from_mbox(mbox: MBox<ll_bindings::tsk_table_collection_t>) -> Self {
-        Self {
+    pub(crate) unsafe fn new_from_mbox(
+        mbox: MBox<ll_bindings::tsk_table_collection_t>,
+    ) -> Result<Self, TskitError> {
+        let mut mbox = mbox;
+        let views = crate::table_views::TableViews::new_from_mbox_table_collection(&mut mbox)?;
+        Ok(Self {
             inner: mbox,
             idmap: vec![],
-        }
+            views,
+        })
     }
 
     pub(crate) fn into_raw(self) -> Result<*mut ll_bindings::tsk_table_collection_t, TskitError> {
@@ -297,7 +317,7 @@ impl TableCollection {
     /// ## No flags, location, nor parents
     ///
     /// ```
-    /// # use tskit::TableAccess;
+    /// # 
     /// # let mut tables = tskit::TableCollection::new(1.0).unwrap();
     /// tables.add_individual(0, None, None).unwrap();
     /// # assert!(tables.individuals().location(0).is_none());
@@ -307,7 +327,7 @@ impl TableCollection {
     /// ## No flags, a 3d location, no parents
     ///
     /// ```
-    /// # use tskit::TableAccess;
+    /// # 
     /// # let mut tables = tskit::TableCollection::new(1.0).unwrap();
     /// tables.add_individual(0, &[-0.5, 0.3, 10.0], None).unwrap();
     /// # match tables.individuals().location(0) {
@@ -319,7 +339,7 @@ impl TableCollection {
     /// ## No flags, no location, two parents
     /// ```
     /// # let mut tables = tskit::TableCollection::new(1.0).unwrap();
-    /// # use tskit::TableAccess;
+    /// # 
     /// tables.add_individual(0, None, &[1, 11]);
     /// # match tables.individuals().parents(0) {
     /// #     Some(parents) => parents.iter().zip([1, 11].iter()).for_each(|(a,b)| assert_eq!(a, b)),
@@ -339,7 +359,7 @@ impl TableCollection {
     ///
     /// ```
     /// # #[cfg(feature = "derive")] {
-    /// use tskit::TableAccess;
+    /// 
     /// # let mut tables = tskit::TableCollection::new(100.).unwrap();
     /// # #[derive(serde::Serialize, serde::Deserialize, tskit::metadata::IndividualMetadata)]
     /// # #[serializer("serde_json")]
@@ -744,7 +764,7 @@ impl TableCollection {
 
         // SAFETY: we just initialized it.
         // The C API doesn't free NULL pointers.
-        handle_tsk_return_value!(rv, unsafe { Self::new_from_mbox(inner) })
+        handle_tsk_return_value!(rv, unsafe { Self::new_from_mbox(inner)? })
     }
 
     /// Return a [`crate::TreeSequence`] based on the tables.
@@ -871,7 +891,7 @@ impl TableCollection {
     ///
     /// # Examples
     /// ```
-    /// use tskit::TableAccess;
+    /// 
     /// let mut tables = tskit::TableCollection::new(1000.).unwrap();
     /// # #[cfg(feature = "provenance")] {
     /// tables.add_provenance(&String::from("Some provenance")).unwrap();
@@ -914,7 +934,7 @@ impl TableCollection {
     /// # Example
     ///
     /// ```rust
-    /// # use tskit::TableAccess;
+    /// #
     /// let mut tables = tskit::TableCollection::new(1.0).unwrap();
     /// let mut edges = tskit::OwnedEdgeTable::default();
     /// edges.add_row(0., 1., 0, 12).unwrap();
@@ -951,7 +971,7 @@ impl TableCollection {
     /// # Example
     ///
     /// ```rust
-    /// # use tskit::TableAccess;
+    /// #
     /// let mut tables = tskit::TableCollection::new(1.0).unwrap();
     /// let mut nodes = tskit::OwnedNodeTable::default();
     /// nodes.add_row(0, 10.0, -1, -1).unwrap();
@@ -988,7 +1008,7 @@ impl TableCollection {
     /// # Example
     ///
     /// ```rust
-    /// # use tskit::TableAccess;
+    /// #
     /// let mut tables = tskit::TableCollection::new(1.0).unwrap();
     /// let mut sites = tskit::OwnedSiteTable::default();
     /// sites.add_row(11.0, None).unwrap();
@@ -1024,7 +1044,7 @@ impl TableCollection {
     /// # Example
     ///
     /// ```rust
-    /// # use tskit::TableAccess;
+    /// #
     /// let mut tables = tskit::TableCollection::new(1.0).unwrap();
     /// let mut mutations = tskit::OwnedMutationTable::default();
     /// mutations.add_row(14, 12, -1, 11.3, None).unwrap();
@@ -1063,7 +1083,7 @@ impl TableCollection {
     /// # Example
     ///
     /// ```rust
-    /// # use tskit::TableAccess;
+    /// #
     /// let mut tables = tskit::TableCollection::new(1.0).unwrap();
     /// let mut individuals = tskit::OwnedIndividualTable::default();
     /// individuals.add_row(0, [0.1, 10.0], None).unwrap();
@@ -1102,7 +1122,7 @@ impl TableCollection {
     /// # Example
     ///
     /// ```rust
-    /// # use tskit::TableAccess;
+    /// #
     /// let mut tables = tskit::TableCollection::new(1.0).unwrap();
     /// let mut migrations = tskit::OwnedMigrationTable::default();
     /// migrations.add_row((0.25, 0.37), 1, (0, 1), 111.0).unwrap();
@@ -1141,7 +1161,7 @@ impl TableCollection {
     /// # Example
     ///
     /// ```rust
-    /// # use tskit::TableAccess;
+    /// #
     /// let mut tables = tskit::TableCollection::new(1.0).unwrap();
     /// let mut populations = tskit::OwnedPopulationTable::default();
     /// populations.add_row().unwrap();
@@ -1177,7 +1197,7 @@ impl TableCollection {
     ///
     /// ```rust
     /// # #[cfg(feature="provenance")] {
-    /// # use tskit::TableAccess;
+    /// #
     /// let mut tables = tskit::TableCollection::new(1.0).unwrap();
     /// let mut provenances = tskit::provenance::OwnedProvenanceTable::default();
     /// provenances.add_row("I like pancakes").unwrap();
@@ -1207,41 +1227,3 @@ impl TableCollection {
         handle_tsk_return_value!(rv)
     }
 }
-
-impl TableAccess for TableCollection {
-    fn edges(&self) -> EdgeTable {
-        EdgeTable::new_from_table(&self.inner.edges)
-    }
-
-    fn individuals(&self) -> IndividualTable {
-        IndividualTable::new_from_table(&self.inner.individuals)
-    }
-
-    fn migrations(&self) -> MigrationTable {
-        MigrationTable::new_from_table(&self.inner.migrations)
-    }
-
-    fn nodes(&self) -> NodeTable {
-        NodeTable::new_from_table(&self.inner.nodes)
-    }
-
-    fn sites(&self) -> SiteTable {
-        SiteTable::new_from_table(&self.inner.sites)
-    }
-
-    fn mutations(&self) -> MutationTable {
-        MutationTable::new_from_table(&self.inner.mutations)
-    }
-
-    fn populations(&self) -> PopulationTable {
-        PopulationTable::new_from_table(&self.inner.populations)
-    }
-
-    #[cfg(feature = "provenance")]
-    #[cfg_attr(doc_cfg, doc(cfg(feature = "provenance")))]
-    fn provenances(&self) -> crate::provenance::ProvenanceTable {
-        crate::provenance::ProvenanceTable::new_from_table(&self.inner.provenances)
-    }
-}
-
-impl crate::traits::NodeListGenerator for TableCollection {}
diff --git a/src/table_views.rs b/src/table_views.rs
new file mode 100644
index 000000000..812d679e1
--- /dev/null
+++ b/src/table_views.rs
@@ -0,0 +1,276 @@
+use std::ptr::NonNull;
+
+use crate::bindings as ll_bindings;
+#[cfg(feature = "provenance")]
+use crate::provenance::ProvenanceTable;
+use crate::EdgeTable;
+use crate::IndividualTable;
+use crate::MigrationTable;
+use crate::MutationTable;
+use crate::NodeTable;
+use crate::PopulationTable;
+use crate::SiteTable;
+use crate::TskitError;
+
+pub struct TableViews {
+    edges: EdgeTable,
+    nodes: NodeTable,
+    sites: SiteTable,
+    mutations: MutationTable,
+    individuals: IndividualTable,
+    populations: PopulationTable,
+    migrations: MigrationTable,
+    #[cfg(feature = "provenance")]
+    provenances: ProvenanceTable,
+}
+
+impl TableViews {
+    pub(crate) fn new_from_mbox_table_collection(
+        tables: &mut mbox::MBox<ll_bindings::tsk_table_collection_t>,
+    ) -> Result<Self, TskitError> {
+        Ok(Self {
+            edges: crate::EdgeTable::new_from_table(&mut tables.as_mut().edges)?,
+            nodes: crate::NodeTable::new_from_table(&mut tables.as_mut().nodes)?,
+            sites: crate::SiteTable::new_from_table(&mut tables.as_mut().sites)?,
+            mutations: crate::MutationTable::new_from_table(&mut tables.as_mut().mutations)?,
+            individuals: crate::IndividualTable::new_from_table(&mut tables.as_mut().individuals)?,
+            populations: crate::PopulationTable::new_from_table(&mut tables.as_mut().populations)?,
+            migrations: crate::MigrationTable::new_from_table(&mut tables.as_mut().migrations)?,
+            #[cfg(feature = "provenance")]
+            provenances: crate::provenance::ProvenanceTable::new_from_table(
+                &mut tables.as_mut().provenances,
+            )?,
+        })
+    }
+
+    pub(crate) fn new_from_NonNull_table_collection(
+        tables: &mut NonNull<ll_bindings::tsk_table_collection_t>,
+    ) -> Result<Self, TskitError> {
+        Ok(Self {
+            edges: crate::EdgeTable::new_from_table(&mut unsafe { tables.as_mut() }.edges)?,
+            nodes: crate::NodeTable::new_from_table(&mut unsafe { tables.as_mut() }.nodes)?,
+            sites: crate::SiteTable::new_from_table(&mut unsafe { tables.as_mut() }.sites)?,
+            mutations: crate::MutationTable::new_from_table(
+                &mut unsafe { tables.as_mut() }.mutations,
+            )?,
+            individuals: crate::IndividualTable::new_from_table(
+                &mut unsafe { tables.as_mut() }.individuals,
+            )?,
+            populations: crate::PopulationTable::new_from_table(
+                &mut unsafe { tables.as_mut() }.populations,
+            )?,
+            migrations: crate::MigrationTable::new_from_table(
+                &mut unsafe { tables.as_mut() }.migrations,
+            )?,
+            #[cfg(feature = "provenance")]
+            provenances: crate::provenance::ProvenanceTable::new_from_table(
+                &mut unsafe { tables.as_mut() }.provenances,
+            )?,
+        })
+    }
+
+    pub(crate) fn new_from_tree_sequence(
+        treeseq: *mut ll_bindings::tsk_treeseq_t,
+    ) -> Result<Self, TskitError> {
+        if treeseq.is_null() {
+            return Err(TskitError::LibraryError(
+                "tree sequence pointer is null".to_string(),
+            ));
+        }
+        let mut n = NonNull::new(unsafe { *treeseq }.tables).ok_or_else(|| {
+            TskitError::LibraryError(
+                "tree sequence contains NULL pointer to table collection".to_string(),
+            )
+        })?;
+        Self::new_from_NonNull_table_collection(&mut n)
+    }
+
+    /// Get reference to the [``EdgeTable``](crate::EdgeTable).
+    pub fn edges(&self) -> &EdgeTable {
+        &self.edges
+    }
+
+    /// Get reference to the [``NodeTable``](crate::NodeTable).
+    pub fn nodes(&self) -> &NodeTable {
+        &self.nodes
+    }
+
+    /// Get mutable reference to the [``NodeTable``](crate::NodeTable).
+    pub fn nodes_mut(&mut self) -> &mut NodeTable {
+        &mut self.nodes
+    }
+
+    /// Get reference to the [``SiteTable``](crate::SiteTable).
+    pub fn sites(&self) -> &SiteTable {
+        &self.sites
+    }
+
+    /// Get reference to the [``MutationTable``](crate::MutationTable).
+    pub fn mutations(&self) -> &MutationTable {
+        &self.mutations
+    }
+
+    /// Get reference to the [``IndividualTable``](crate::IndividualTable).
+    pub fn individuals(&self) -> &IndividualTable {
+        &self.individuals
+    }
+
+    /// Get reference to the [``PopulationTable``](crate::PopulationTable).
+    pub fn populations(&self) -> &PopulationTable {
+        &self.populations
+    }
+
+    /// Get reference to the [``MigrationTable``](crate::MigrationTable).
+    pub fn migrations(&self) -> &MigrationTable {
+        &self.migrations
+    }
+
+    #[cfg(feature = "provenance")]
+    #[cfg_attr(doc_cfg, doc(cfg(feature = "provenance")))]
+    /// Get reference to the [``ProvenanceTable``](crate::provenance::ProvenanceTable)
+    pub fn provenances(&self) -> &ProvenanceTable {
+        &self.provenances
+    }
+
+    /// Return an iterator over the edges.
+    pub fn edges_iter(&self) -> impl Iterator<Item = crate::EdgeTableRow> + '_ {
+        self.edges.iter()
+    }
+
+    /// Return an iterator over the nodes.
+    pub fn nodes_iter(&self) -> impl Iterator<Item = crate::NodeTableRow> + '_ {
+        self.nodes.iter()
+    }
+
+    /// Return an iterator over the sites.
+    pub fn sites_iter(&self) -> impl Iterator<Item = crate::SiteTableRow> + '_ {
+        self.sites.iter()
+    }
+
+    /// Return an iterator over the mutations.
+    pub fn mutations_iter(&self) -> impl Iterator<Item = crate::MutationTableRow> + '_ {
+        self.mutations.iter()
+    }
+
+    /// Return an iterator over the individuals.
+    pub fn individuals_iter(&self) -> impl Iterator<Item = crate::IndividualTableRow> + '_ {
+        self.individuals.iter()
+    }
+
+    /// Return an iterator over the populations.
+    pub fn populations_iter(&self) -> impl Iterator<Item = crate::PopulationTableRow> + '_ {
+        self.populations.iter()
+    }
+
+    /// Return an iterator over the migrations.
+    pub fn migrations_iter(&self) -> impl Iterator<Item = crate::MigrationTableRow> + '_ {
+        self.migrations.iter()
+    }
+
+    #[cfg(feature = "provenance")]
+    #[cfg_attr(doc_cfg, doc(cfg(feature = "provenance")))]
+    /// Return an iterator over provenances
+    pub fn provenances_iter(
+        &self,
+    ) -> impl Iterator<Item = crate::provenance::ProvenanceTableRow> + '_ {
+        self.provenances.iter()
+    }
+
+    /// Obtain a vector containing the indexes ("ids")
+    /// of all nodes for which [`crate::TSK_NODE_IS_SAMPLE`]
+    /// is `true`.
+    ///
+    /// The provided implementation dispatches to
+    /// [`crate::NodeTable::samples_as_vector`].
+    pub fn samples_as_vector(&self) -> Vec<crate::NodeId> {
+        self.nodes().samples_as_vector()
+    }
+
+    /// Obtain a vector containing the indexes ("ids") of all nodes
+    /// satisfying a certain criterion.
+    ///
+    /// The provided implementation dispatches to
+    /// [`crate::NodeTable::create_node_id_vector`].
+    ///
+    /// # Parameters
+    ///
+    /// * `f`: a function.  The function is passed the current table
+    ///    collection and each [`crate::node_table::NodeTableRow`].
+    ///    If `f` returns `true`, the index of that row is included
+    ///    in the return value.
+    ///
+    /// # Examples
+    ///
+    /// Get all nodes with time > 0.0:
+    ///
+    /// ```
+    /// use tskit::bindings::tsk_id_t;
+    ///
+    /// let mut tables = tskit::TableCollection::new(100.).unwrap();
+    /// tables
+    ///     .add_node(tskit::TSK_NODE_IS_SAMPLE, 0.0, tskit::PopulationId::NULL,
+    ///     tskit::IndividualId::NULL)
+    ///     .unwrap();
+    /// tables
+    ///     .add_node(tskit::TSK_NODE_IS_SAMPLE, 1.0, tskit::PopulationId::NULL,
+    ///     tskit::IndividualId::NULL)
+    ///     .unwrap();
+    /// let samples = tables.create_node_id_vector(
+    ///     |row: &tskit::NodeTableRow| row.time > 0.,
+    /// );
+    /// assert_eq!(samples[0], 1);
+    ///
+    /// // Get all nodes that have a mutation:
+    ///
+    /// fn node_has_mutation(
+    ///     // dyn trait here means this
+    ///     // will work with TreeSequence, too.
+    ///     tables_type: &dyn std::ops::Deref<Target=tskit::table_views::TableViews>,
+    ///     row: &tskit::NodeTableRow,
+    /// ) -> bool {
+    ///     for mrow in tables_type.mutations_iter() {
+    ///         if mrow.node == row.id {
+    ///             return true;
+    ///         }
+    ///     }
+    ///     false
+    /// }
+    ///
+    /// // Get all nodes that have a mutation:
+    ///
+    /// tables.add_mutation(0, 0, tskit::MutationId::NULL, 0.0, None).unwrap();
+    /// let samples_with_mut = tables.create_node_id_vector(
+    ///     |row: &tskit::NodeTableRow| node_has_mutation(&tables, row));
+    /// assert_eq!(samples_with_mut[0], 0);
+    /// ```
+    pub fn create_node_id_vector(
+        &self,
+        f: impl FnMut(&crate::NodeTableRow) -> bool,
+    ) -> Vec<crate::NodeId> {
+        self.nodes().create_node_id_vector(f)
+    }
+}
+
+#[cfg(test)]
+mod table_views_tests {
+    #[test]
+    fn test_treeseq() {
+        let mut tables = crate::TableCollection::new(100.).unwrap();
+        tables.add_node(0, 0.0, -1, -1).unwrap(); // child
+        tables.add_node(0, 1.0, -1, -1).unwrap(); // parent
+        tables.add_edge(0., 100., 1, 0).unwrap();
+        let ts = tables
+            .tree_sequence(crate::TreeSequenceFlags::BUILD_INDEXES)
+            .unwrap();
+        assert_eq!(ts.edges().num_rows(), 1);
+        assert_eq!(ts.nodes().num_rows(), 2);
+
+        #[cfg(feature = "provenance")]
+        {
+            let mut ts = ts;
+            assert_eq!(ts.provenances().num_rows(), 0);
+            ts.add_provenance("bananas").unwrap();
+            assert_eq!(ts.provenances().num_rows(), 1);
+        }
+    }
+}
diff --git a/src/test_simplification.rs b/src/test_simplification.rs
index 10215724e..25cad774c 100644
--- a/src/test_simplification.rs
+++ b/src/test_simplification.rs
@@ -5,7 +5,6 @@ mod tests {
     use crate::NodeFlags;
     use crate::NodeId;
     use crate::SimplificationOptions;
-    use crate::TableAccess;
 
     #[test]
     fn test_simplify_tables() {
diff --git a/src/traits.rs b/src/traits.rs
index 840266ead..becb6852e 100644
--- a/src/traits.rs
+++ b/src/traits.rs
@@ -1,14 +1,5 @@
 //! Traits related to user-facing types
 
-use crate::table_iterator::make_table_iterator;
-use crate::EdgeTable;
-use crate::IndividualTable;
-use crate::MigrationTable;
-use crate::MutationTable;
-use crate::NodeTable;
-use crate::PopulationTable;
-use crate::SiteTable;
-
 /// Provide pointer access to underlying C types
 pub trait TskitTypeAccess<T> {
     /// Return const pointer
@@ -17,200 +8,6 @@ pub trait TskitTypeAccess<T> {
     fn as_mut_ptr(&mut self) -> *mut T;
 }
 
-/// Immutable access to tables.
-///
-/// For objects that contain the full suite of tables,
-/// implementing this trait provides immutable access
-/// to their data.
-///
-/// For most types, the provided implementations of `_iter`
-/// methods should do.
-///
-/// # Examples
-///
-/// ```
-/// use tskit::TableAccess;
-///
-/// let mut tables = tskit::TableCollection::new(1.).unwrap();
-/// // The borrows are immuatble, so we can
-/// // take multiple table references from the same object.
-/// let e = tables.edges();
-/// let n = tables.nodes();
-/// ```
-///
-/// The borrow checker will keep you from getting in trouble:
-///
-/// ```compile_fail
-/// use tskit::TableAccess;
-///
-/// let mut tables = tskit::TableCollection::new(1.).unwrap();
-/// let e = tables.edges();
-/// tables.add_edge(0.0, 1.0, 0, 1).unwrap();
-/// let p = e.parent(0).unwrap();   // FAIL!
-/// ```
-pub trait TableAccess {
-    /// Get reference to the [``EdgeTable``](crate::EdgeTable).
-    fn edges(&self) -> EdgeTable;
-
-    /// Return an iterator over the edges.
-    fn edges_iter(&self) -> Box<dyn Iterator<Item = crate::edge_table::EdgeTableRow> + '_> {
-        Box::new(make_table_iterator::<EdgeTable>(self.edges()))
-    }
-
-    /// Get reference to the [``NodeTable``](crate::NodeTable).
-    fn nodes(&self) -> NodeTable;
-
-    /// Return an iterator over the nodes.
-    fn nodes_iter(&self) -> Box<dyn Iterator<Item = crate::node_table::NodeTableRow> + '_> {
-        Box::new(make_table_iterator::<NodeTable>(self.nodes()))
-    }
-
-    /// Get reference to the [``MutationTable``](crate::MutationTable).
-    fn mutations(&self) -> MutationTable;
-
-    /// Return an iterator over the mutations.
-    fn mutations_iter(
-        &self,
-    ) -> Box<dyn Iterator<Item = crate::mutation_table::MutationTableRow> + '_> {
-        Box::new(make_table_iterator::<MutationTable>(self.mutations()))
-    }
-
-    /// Get reference to the [``SiteTable``](crate::SiteTable).
-    fn sites(&self) -> SiteTable;
-
-    /// Return an iterator over the sites.
-    fn sites_iter(&self) -> Box<dyn Iterator<Item = crate::site_table::SiteTableRow> + '_> {
-        Box::new(make_table_iterator::<SiteTable>(self.sites()))
-    }
-
-    /// Get reference to the [``PopulationTable``](crate::PopulationTable).
-    fn populations(&self) -> PopulationTable;
-
-    /// Return an iterator over the populations.
-    fn populations_iter(
-        &self,
-    ) -> Box<dyn Iterator<Item = crate::population_table::PopulationTableRow> + '_> {
-        Box::new(make_table_iterator::<PopulationTable>(self.populations()))
-    }
-
-    /// Get reference to the [``MigrationTable``](crate::MigrationTable).
-    fn migrations(&self) -> MigrationTable;
-
-    /// Return an iterator over the migration events.
-    fn migrations_iter(
-        &self,
-    ) -> Box<dyn Iterator<Item = crate::migration_table::MigrationTableRow> + '_> {
-        Box::new(make_table_iterator::<MigrationTable>(self.migrations()))
-    }
-
-    /// Get reference to the [``IndividualTable``](crate::IndividualTable).
-    fn individuals(&self) -> IndividualTable;
-
-    /// Return an iterator over the individuals.
-    fn individuals_iter(
-        &self,
-    ) -> Box<dyn Iterator<Item = crate::individual_table::IndividualTableRow> + '_> {
-        Box::new(make_table_iterator::<IndividualTable>(self.individuals()))
-    }
-
-    #[cfg(feature = "provenance")]
-    #[cfg_attr(doc_cfg, doc(cfg(feature = "provenance")))]
-    /// Get reference to the [``ProvenanceTable``](crate::provenance::ProvenanceTable)
-    fn provenances(&self) -> crate::provenance::ProvenanceTable;
-
-    #[cfg(feature = "provenance")]
-    #[cfg_attr(doc_cfg, doc(cfg(feature = "provenance")))]
-    /// Return an iterator over provenances
-    fn provenances_iter(
-        &self,
-    ) -> Box<dyn Iterator<Item = crate::provenance::ProvenanceTableRow> + '_> {
-        Box::new(crate::table_iterator::make_table_iterator::<
-            crate::provenance::ProvenanceTable,
-        >(self.provenances()))
-    }
-}
-
-/// Interface for returning lists of node ids from
-/// types implementing [`TableAccess`].
-pub trait NodeListGenerator: TableAccess {
-    /// Obtain a vector containing the indexes ("ids")
-    /// of all nodes for which [`crate::TSK_NODE_IS_SAMPLE`]
-    /// is `true`.
-    ///
-    /// The provided implementation dispatches to
-    /// [`crate::NodeTable::samples_as_vector`].
-    fn samples_as_vector(&self) -> Vec<crate::NodeId> {
-        self.nodes().samples_as_vector()
-    }
-
-    /// Obtain a vector containing the indexes ("ids") of all nodes
-    /// satisfying a certain criterion.
-    ///
-    /// The provided implementation dispatches to
-    /// [`crate::NodeTable::create_node_id_vector`].
-    ///
-    /// # Parameters
-    ///
-    /// * `f`: a function.  The function is passed the current table
-    ///    collection and each [`crate::node_table::NodeTableRow`].
-    ///    If `f` returns `true`, the index of that row is included
-    ///    in the return value.
-    ///
-    /// # Examples
-    ///
-    /// Get all nodes with time > 0.0:
-    ///
-    /// ```
-    /// use tskit::bindings::tsk_id_t;
-    /// use tskit::TableAccess;
-    /// use tskit::NodeListGenerator;
-    ///
-    /// let mut tables = tskit::TableCollection::new(100.).unwrap();
-    /// tables
-    ///     .add_node(tskit::TSK_NODE_IS_SAMPLE, 0.0, tskit::PopulationId::NULL,
-    ///     tskit::IndividualId::NULL)
-    ///     .unwrap();
-    /// tables
-    ///     .add_node(tskit::TSK_NODE_IS_SAMPLE, 1.0, tskit::PopulationId::NULL,
-    ///     tskit::IndividualId::NULL)
-    ///     .unwrap();
-    /// let samples = tables.create_node_id_vector(
-    ///     |row: &tskit::NodeTableRow| row.time > 0.,
-    /// );
-    /// assert_eq!(samples[0], 1);
-    ///
-    /// // Get all nodes that have a mutation:
-    ///
-    /// fn node_has_mutation(
-    ///     // dyn trait here means this
-    ///     // will work with TreeSequence, too.
-    ///     tables_type: &dyn tskit::TableAccess,
-    ///     row: &tskit::NodeTableRow,
-    /// ) -> bool {
-    ///     for mrow in tables_type.mutations_iter() {
-    ///         if mrow.node == row.id {
-    ///             return true;
-    ///         }
-    ///     }
-    ///     false
-    /// }
-    ///
-    /// // Get all nodes that have a mutation:
-    ///
-    /// tables.add_mutation(0, 0, tskit::MutationId::NULL, 0.0, None).unwrap();
-    /// let samples_with_mut = tables.create_node_id_vector(
-    ///     |row: &tskit::NodeTableRow| node_has_mutation(&tables, row));
-    /// assert_eq!(samples_with_mut[0], 0);
-    /// ```
-
-    fn create_node_id_vector(
-        &self,
-        f: impl FnMut(&crate::NodeTableRow) -> bool,
-    ) -> Vec<crate::NodeId> {
-        self.nodes().create_node_id_vector(f)
-    }
-}
-
 /// Abstraction of individual location.
 ///
 /// This trait exists to streamline the API of
diff --git a/src/tree_interface.rs b/src/tree_interface.rs
index de618d5b7..518df8507 100644
--- a/src/tree_interface.rs
+++ b/src/tree_interface.rs
@@ -490,10 +490,11 @@ impl TreeInterface {
     /// (and the tree sequence from which it came).
     ///
     /// This is a convenience function for accessing node times, etc..
-    pub fn node_table<'a>(&'a self) -> crate::NodeTable<'a> {
-        crate::NodeTable::<'a>::new_from_table(unsafe {
-            &(*(*(*self.as_ptr()).tree_sequence).tables).nodes
-        })
+    pub fn node_table(&self) -> crate::NodeTable {
+        unimplemented!("this needs to return &NodeTable");
+        // crate::NodeTable::new_from_table(unsafe {
+        //     &(*(*(*self.as_ptr()).tree_sequence).tables).nodes
+        // })
     }
 
     /// Calculate the total length of the tree via a preorder traversal.
diff --git a/src/trees.rs b/src/trees.rs
index 2b195f5b7..892e70062 100644
--- a/src/trees.rs
+++ b/src/trees.rs
@@ -4,17 +4,9 @@ use std::ops::DerefMut;
 
 use crate::bindings as ll_bindings;
 use crate::error::TskitError;
-use crate::EdgeTable;
-use crate::IndividualTable;
-use crate::MigrationTable;
-use crate::MutationTable;
 use crate::NodeId;
-use crate::NodeTable;
-use crate::PopulationTable;
 use crate::SimplificationOptions;
-use crate::SiteTable;
 use crate::SizeType;
-use crate::TableAccess;
 use crate::TableOutputOptions;
 use crate::TreeFlags;
 use crate::TreeInterface;
@@ -171,9 +163,30 @@ impl streaming_iterator::DoubleEndedStreamingIterator for Tree {
 ///
 /// // tables gets moved into our treeseq variable:
 /// let treeseq = tables.tree_sequence(tskit::TreeSequenceFlags::default()).unwrap();
+/// assert_eq!(treeseq.nodes().num_rows(), 3);
+/// assert_eq!(treeseq.edges().num_rows(), 2);
+/// ```
+///
+/// This type does not [`std::ops::DerefMut`] to [`crate::table_views::TableViews`]:
+///
+/// ```compile_fail
+/// # let mut tables = tskit::TableCollection::new(1000.).unwrap();
+/// # tables.add_node(0, 1.0, tskit::PopulationId::NULL, tskit::IndividualId::NULL).unwrap();
+/// # tables.add_node(0, 0.0, tskit::PopulationId::NULL, tskit::IndividualId::NULL).unwrap();
+/// # tables.add_node(0, 0.0, tskit::PopulationId::NULL, tskit::IndividualId::NULL).unwrap();
+/// # tables.add_edge(0., 1000., 0, 1).unwrap();
+/// # tables.add_edge(0., 1000., 0, 2).unwrap();
+///
+/// # // index
+/// # tables.build_index();
+///
+/// # // tables gets moved into our treeseq variable:
+/// # let treeseq = tables.tree_sequence(tskit::TreeSequenceFlags::default()).unwrap();
+/// assert_eq!(treeseq.nodes_mut().num_rows(), 3);
 /// ```
 pub struct TreeSequence {
     pub(crate) inner: ll_bindings::tsk_treeseq_t,
+    views: crate::table_views::TableViews,
 }
 
 unsafe impl Send for TreeSequence {}
@@ -196,6 +209,14 @@ impl Drop for TreeSequence {
     }
 }
 
+impl std::ops::Deref for TreeSequence {
+    type Target = crate::table_views::TableViews;
+
+    fn deref(&self) -> &Self::Target {
+        &self.views
+    }
+}
+
 impl TreeSequence {
     /// Create a tree sequence from a [`TableCollection`].
     /// In general, [`TableCollection::tree_sequence`] may be preferred.
@@ -250,9 +271,10 @@ impl TreeSequence {
         let raw_tables_ptr = tables.into_raw()?;
         let rv =
             unsafe { ll_bindings::tsk_treeseq_init(inner.as_mut_ptr(), raw_tables_ptr, flags) };
+        let views = crate::table_views::TableViews::new_from_tree_sequence(inner.as_mut_ptr())?;
         handle_tsk_return_value!(rv, {
             let inner = unsafe { inner.assume_init() };
-            Self { inner }
+            Self { inner, views }
         })
     }
 
@@ -304,7 +326,7 @@ impl TreeSequence {
 
         // SAFETY: we just initialized it.
         // The C API doesn't free NULL pointers.
-        handle_tsk_return_value!(rv, unsafe { TableCollection::new_from_mbox(inner) })
+        handle_tsk_return_value!(rv, unsafe { TableCollection::new_from_mbox(inner)? })
     }
 
     /// Create an iterator over trees.
@@ -451,12 +473,14 @@ impl TreeSequence {
                 },
             )
         };
+        // TODO: is it possible that this can leak somehow?
         handle_tsk_return_value!(
             rv,
             (
                 {
-                    let inner = unsafe { ts.assume_init() };
-                    Self { inner }
+                    let mut inner = unsafe { ts.assume_init() };
+                    let views = crate::table_views::TableViews::new_from_tree_sequence(&mut inner)?;
+                    Self { inner, views }
                 },
                 match idmap {
                     true => Some(output_node_map),
@@ -481,9 +505,10 @@ impl TreeSequence {
     /// # Parameters
     ///
     /// * `record`: the provenance record
-    /// ```
-    /// use tskit::TableAccess;
     ///
+    /// # Examples
+    ///
+    /// ```
     /// let mut tables = tskit::TableCollection::new(1000.).unwrap();
     /// let mut treeseq = tables.tree_sequence(tskit::TreeSequenceFlags::BUILD_INDEXES).unwrap();
     /// # #[cfg(feature = "provenance")] {
@@ -530,46 +555,6 @@ impl TryFrom<TableCollection> for TreeSequence {
     }
 }
 
-impl TableAccess for TreeSequence {
-    fn edges(&self) -> EdgeTable {
-        EdgeTable::new_from_table(unsafe { &(*self.inner.tables).edges })
-    }
-
-    fn individuals(&self) -> IndividualTable {
-        IndividualTable::new_from_table(unsafe { &(*self.inner.tables).individuals })
-    }
-
-    fn migrations(&self) -> MigrationTable {
-        MigrationTable::new_from_table(unsafe { &(*self.inner.tables).migrations })
-    }
-
-    fn nodes(&self) -> NodeTable {
-        NodeTable::new_from_table(unsafe { &(*self.inner.tables).nodes })
-    }
-
-    fn sites(&self) -> SiteTable {
-        SiteTable::new_from_table(unsafe { &(*self.inner.tables).sites })
-    }
-
-    fn mutations(&self) -> MutationTable {
-        MutationTable::new_from_table(unsafe { &(*self.inner.tables).mutations })
-    }
-
-    fn populations(&self) -> PopulationTable {
-        PopulationTable::new_from_table(unsafe { &(*self.inner.tables).populations })
-    }
-
-    #[cfg(feature = "provenance")]
-    #[cfg_attr(doc_cfg, doc(cfg(feature = "provenance")))]
-    fn provenances(&self) -> crate::provenance::ProvenanceTable {
-        crate::provenance::ProvenanceTable::new_from_table(unsafe {
-            &(*self.inner.tables).provenances
-        })
-    }
-}
-
-impl crate::traits::NodeListGenerator for TreeSequence {}
-
 #[cfg(test)]
 pub(crate) mod test_trees {
     use super::*;
diff --git a/tests/experimental.rs b/tests/experimental.rs
index 1b60666d6..3007f027e 100644
--- a/tests/experimental.rs
+++ b/tests/experimental.rs
@@ -2,8 +2,6 @@
 
 mod experimental_features {
 
-    use tskit::TableAccess;
-
     // Goal: proc macro this up
     // Design notes for future:
     // * We can probably drop this trait.
@@ -73,9 +71,6 @@ mod experimental_features {
         }
     }
 
-    // Name is not great.
-    // We'd like to have this be : tskit::TableAccess,
-    // but that's a big ask at this stage.
     trait MutationMetadataExtraction {
         type Item: tskit::metadata::MutationMetadata;
 
@@ -221,15 +216,11 @@ mod experimental_features_refined {
     // * What kind of proc-macro can we use to implement that,
     //   again "easily"?
 
-    use tskit::TableAccess;
-
     trait AsTableCollection {
         fn as_tables(&self) -> &tskit::TableCollection;
     }
 
     // Name is not great.
-    // We'd like to have this be : tskit::TableAccess,
-    // but that's a big ask at this stage.
     // See notes above.
     trait MutationMetadataExtraction: AsTableCollection {
         type Item: tskit::metadata::MutationMetadata;
diff --git a/tests/test_tables.rs b/tests/test_tables.rs
index 7af9bc2bb..647ace8f1 100644
--- a/tests/test_tables.rs
+++ b/tests/test_tables.rs
@@ -8,7 +8,6 @@ fn test_empty_table_collection() {
             assert_eq!($tables.$table_iter().count(), 0);
         };
     }
-    use tskit::TableAccess;
     let tables = tskit::TableCollection::new(10.).unwrap();
 
     for row in [0, -1, 303] {
@@ -33,7 +32,6 @@ mod test_adding_rows_without_metadata {
     macro_rules! add_row_without_metadata {
         ($table: ident, $adder: ident, $($payload: expr),* ) => {{
             {
-                use tskit::TableAccess;
                 let mut tables = tskit::TableCollection::new(10.).unwrap();
                 match tables.$adder($($payload ), *) {
                     Ok(id) => {
@@ -317,7 +315,6 @@ mod test_metadata_round_trips {
         ($table: ident, $adder: ident, $md: ident) => {{
             {
                 build_metadata_types!($md);
-                use tskit::TableAccess;
                 let mut tables = tskit::TableCollection::new(10.).unwrap();
                 let md = MyMetadata::new();
                 let row = tables.$adder(&md);
@@ -327,7 +324,6 @@ mod test_metadata_round_trips {
         ($table: ident, $adder: ident, $md: ident $(,$payload: expr) + ) => {{
             {
                 build_metadata_types!($md);
-                use tskit::TableAccess;
                 let mut tables = tskit::TableCollection::new(10.).unwrap();
                 let md = MyMetadata::new();
                 let row =  tables.$adder($($payload ), *, &md);