diff --git a/examples/forward_simulation.rs b/examples/forward_simulation.rs
index 9c249664b..808590429 100644
--- a/examples/forward_simulation.rs
+++ b/examples/forward_simulation.rs
@@ -373,7 +373,7 @@ fn update_bookmark(
         for a in alive {
             for node in [a.node0, a.node1] {
                 match nodes.time(node) {
-                    Ok(time) => {
+                    Some(time) => {
                         most_recent_birth_time = if time < most_recent_birth_time {
                             time.into()
                         } else {
@@ -385,7 +385,7 @@ fn update_bookmark(
                             most_ancient_birth_time
                         };
                     }
-                    Err(e) => return Err(e),
+                    None => return Err(tskit::TskitError::IndexError {}),
                 }
             }
         }
diff --git a/src/_macros.rs b/src/_macros.rs
index ed8d77817..9592dfd17 100644
--- a/src/_macros.rs
+++ b/src/_macros.rs
@@ -30,27 +30,33 @@ macro_rules! panic_on_tskit_error {
 macro_rules! unsafe_tsk_column_access {
     ($i: expr, $lo: expr, $hi: expr, $array: expr) => {{
         if $i < $lo || ($i as $crate::tsk_size_t) >= $hi {
-            Err($crate::error::TskitError::IndexError {})
+            None
         } else {
-            Ok(unsafe { *$array.offset($i as isize) })
+            Some(unsafe { *$array.offset($i as isize) })
         }
     }};
     ($i: expr, $lo: expr, $hi: expr, $array: expr, $output_id_type: expr) => {{
         if $i < $lo || ($i as $crate::tsk_size_t) >= $hi {
-            Err($crate::error::TskitError::IndexError {})
+            None
         } else {
-            Ok($output_id_type(unsafe { *$array.offset($i as isize) }))
+            Some($output_id_type(unsafe { *$array.offset($i as isize) }))
         }
     }};
 }
 
+macro_rules! unsafe_tsk_column_access_and_map_into {
+    ($i: expr, $lo: expr, $hi: expr, $array: expr) => {{
+        unsafe_tsk_column_access!($i, $lo, $hi, $array).map(|v| v.into())
+    }};
+}
+
 macro_rules! unsafe_tsk_ragged_column_access {
     ($i: expr, $lo: expr, $hi: expr, $array: expr, $offset_array: expr, $offset_array_len: expr) => {{
-        let i = $crate::SizeType::try_from($i)?;
+        let i = $crate::SizeType::try_from($i).ok()?;
         if $i < $lo || i >= $hi {
-            Err(TskitError::IndexError {})
+            None
         } else if $offset_array_len == 0 {
-            Ok(None)
+            None
         } else {
             let start = unsafe { *$offset_array.offset($i as isize) };
             let stop = if i < $hi {
@@ -59,23 +65,23 @@ macro_rules! unsafe_tsk_ragged_column_access {
                 $offset_array_len as tsk_size_t
             };
             if start == stop {
-                Ok(None)
+                None
             } else {
                 let mut buffer = vec![];
                 for i in start..stop {
                     buffer.push(unsafe { *$array.offset(i as isize) });
                 }
-                Ok(Some(buffer))
+                Some(buffer)
             }
         }
     }};
 
     ($i: expr, $lo: expr, $hi: expr, $array: expr, $offset_array: expr, $offset_array_len: expr, $output_id_type: ty) => {{
-        let i = $crate::SizeType::try_from($i)?;
+        let i = $crate::SizeType::try_from($i).ok()?;
         if $i < $lo || i >= $hi {
-            Err(TskitError::IndexError {})
+            None
         } else if $offset_array_len == 0 {
-            Ok(None)
+            None
         } else {
             let start = unsafe { *$offset_array.offset($i as isize) };
             let stop = if i < $hi {
@@ -84,14 +90,14 @@ macro_rules! unsafe_tsk_ragged_column_access {
                 $offset_array_len as tsk_size_t
             };
             if start == stop {
-                Ok(None)
+                None
             } else {
-                Ok(Some(unsafe {
+                Some(unsafe {
                     std::slice::from_raw_parts(
                         $array.offset(start as isize) as *const $output_id_type,
                         stop as usize - start as usize,
                     )
-                }))
+                })
             }
         }
     }};
diff --git a/src/edge_table.rs b/src/edge_table.rs
index eb6902656..84f66d6bb 100644
--- a/src/edge_table.rs
+++ b/src/edge_table.rs
@@ -30,10 +30,10 @@ fn make_edge_table_row(table: &EdgeTable, pos: tsk_id_t) -> Option<EdgeTableRow>
     let table_ref = table.table_;
     Some(EdgeTableRow {
         id: pos.into(),
-        left: table.left(pos).ok()?,
-        right: table.right(pos).ok()?,
-        parent: table.parent(pos).ok()?,
-        child: table.child(pos).ok()?,
+        left: table.left(pos)?,
+        right: table.right(pos)?,
+        parent: table.parent(pos)?,
+        child: table.child(pos)?,
         metadata: table_row_decode_metadata!(table, table_ref, pos).map(|m| m.to_vec()),
     })
 }
@@ -83,48 +83,42 @@ impl<'a> EdgeTable<'a> {
 
     /// Return the ``parent`` value from row ``row`` of the table.
     ///
-    /// # Errors
+    /// # Returns
     ///
-    /// Will return [``IndexError``](crate::TskitError::IndexError)
-    /// if ``row`` is out of range.
-    pub fn parent<E: Into<EdgeId> + Copy>(&'a self, row: E) -> Result<NodeId, TskitError> {
+    /// * `Some(parent)` if `u` is valid.
+    /// * `None` otherwise.
+    pub fn parent<E: Into<EdgeId> + Copy>(&'a self, row: E) -> Option<NodeId> {
         unsafe_tsk_column_access!(row.into().0, 0, self.num_rows(), self.table_.parent, NodeId)
     }
 
     /// Return the ``child`` value from row ``row`` of the table.
     ///
-    /// # Errors
+    /// # Returns
     ///
-    /// Will return [``IndexError``](crate::TskitError::IndexError)
-    /// if ``row`` is out of range.
-    pub fn child<E: Into<EdgeId> + Copy>(&'a self, row: E) -> Result<NodeId, TskitError> {
+    /// * `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)
     }
 
     /// Return the ``left`` value from row ``row`` of the table.
     ///
-    /// # Errors
+    /// # Returns
     ///
-    /// Will return [``IndexError``](crate::TskitError::IndexError)
-    /// if ``row`` is out of range.
-    pub fn left<E: Into<EdgeId> + Copy>(&'a self, row: E) -> Result<Position, TskitError> {
-        match unsafe_tsk_column_access!(row.into().0, 0, self.num_rows(), self.table_.left) {
-            Ok(p) => Ok(p.into()),
-            Err(e) => Err(e),
-        }
+    /// * `Some(position)` if `u` is valid.
+    /// * `None` otherwise.
+    pub fn left<E: Into<EdgeId> + Copy>(&'a self, row: E) -> Option<Position> {
+        unsafe_tsk_column_access!(row.into().0, 0, self.num_rows(), self.table_.left, Position)
     }
 
     /// Return the ``right`` value from row ``row`` of the table.
     ///
-    /// # Errors
+    /// # Returns
     ///
-    /// Will return [``IndexError``](crate::TskitError::IndexError)
-    /// if ``row`` is out of range.
-    pub fn right<E: Into<EdgeId> + Copy>(&'a self, row: E) -> Result<Position, TskitError> {
-        match unsafe_tsk_column_access!(row.into().0, 0, self.num_rows(), self.table_.right) {
-            Ok(p) => Ok(p.into()),
-            Err(e) => Err(e),
-        }
+    /// * `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 metadata<T: metadata::MetadataRoundtrip>(
diff --git a/src/individual_table.rs b/src/individual_table.rs
index 06f6c6996..c5c40efa0 100644
--- a/src/individual_table.rs
+++ b/src/individual_table.rs
@@ -55,9 +55,9 @@ fn make_individual_table_row(table: &IndividualTable, pos: tsk_id_t) -> Option<I
     let table_ref = table.table_;
     Some(IndividualTableRow {
         id: pos.into(),
-        flags: table.flags(pos).ok()?,
-        location: table.location(pos).ok()?.map(|s| s.to_vec()),
-        parents: table.parents(pos).ok()?.map(|s| s.to_vec()),
+        flags: table.flags(pos)?,
+        location: table.location(pos).map(|s| s.to_vec()),
+        parents: table.parents(pos).map(|s| s.to_vec()),
         metadata: table_row_decode_metadata!(table, table_ref, pos).map(|m| m.to_vec()),
     })
 }
@@ -101,28 +101,21 @@ impl<'a> IndividualTable<'a> {
 
     /// Return the flags for a given row.
     ///
-    /// # Errors
+    /// # Returns
     ///
-    /// * [`TskitError::IndexError`] if `row` is out of range.
-    pub fn flags<I: Into<IndividualId> + Copy>(
-        &self,
-        row: I,
-    ) -> Result<IndividualFlags, TskitError> {
-        match unsafe_tsk_column_access!(row.into().0, 0, self.num_rows(), self.table_.flags) {
-            Ok(f) => Ok(IndividualFlags::from(f)),
-            Err(e) => Err(e),
-        }
+    /// * `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)
     }
 
     /// Return the locations for a given row.
     ///
-    /// # Errors
+    /// # Returns
     ///
-    /// * [`TskitError::IndexError`] if `row` is out of range.
-    pub fn location<I: Into<IndividualId> + Copy>(
-        &self,
-        row: I,
-    ) -> Result<Option<&[Location]>, TskitError> {
+    /// * `Some(location)` if `row` is valid.
+    /// * `None` otherwise.
+    pub fn location<I: Into<IndividualId> + Copy>(&self, row: I) -> Option<&[Location]> {
         unsafe_tsk_ragged_column_access!(
             row.into().0,
             0,
@@ -136,13 +129,11 @@ impl<'a> IndividualTable<'a> {
 
     /// Return the parents for a given row.
     ///
-    /// # Errors
+    /// # Returns
     ///
-    /// * [`TskitError::IndexError`] if `row` is out of range.
-    pub fn parents<I: Into<IndividualId> + Copy>(
-        &self,
-        row: I,
-    ) -> Result<Option<&[IndividualId]>, TskitError> {
+    /// * `Some(parents)` if `row` is valid.
+    /// * `None` otherwise.
+    pub fn parents<I: Into<IndividualId> + Copy>(&self, row: I) -> Option<&[IndividualId]> {
         unsafe_tsk_ragged_column_access!(
             row.into().0,
             0,
diff --git a/src/migration_table.rs b/src/migration_table.rs
index 96aaa8ea2..62fecbcf7 100644
--- a/src/migration_table.rs
+++ b/src/migration_table.rs
@@ -36,12 +36,12 @@ fn make_migration_table_row(table: &MigrationTable, pos: tsk_id_t) -> Option<Mig
     let table_ref = table.table_;
     Some(MigrationTableRow {
         id: pos.into(),
-        left: table.left(pos).ok()?,
-        right: table.right(pos).ok()?,
-        node: table.node(pos).ok()?,
-        source: table.source(pos).ok()?,
-        dest: table.dest(pos).ok()?,
-        time: table.time(pos).ok()?,
+        left: table.left(pos)?,
+        right: table.right(pos)?,
+        node: table.node(pos)?,
+        source: table.source(pos)?,
+        dest: table.dest(pos)?,
+        time: table.time(pos)?,
         metadata: table_row_decode_metadata!(table, table_ref, pos).map(|m| m.to_vec()),
     })
 }
@@ -92,46 +92,41 @@ impl<'a> MigrationTable<'a> {
 
     /// Return the left coordinate for a given row.
     ///
-    /// # Errors
+    /// # Returns
     ///
-    /// * [`TskitError::IndexError`] if `row` is out of range.
-    pub fn left<M: Into<MigrationId> + Copy>(&'a self, row: M) -> Result<Position, TskitError> {
-        match unsafe_tsk_column_access!(row.into().0, 0, self.num_rows(), self.table_.left) {
-            Ok(p) => Ok(p.into()),
-            Err(e) => Err(e),
-        }
+    /// * `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)
     }
 
     /// Return the right coordinate for a given row.
     ///
-    /// # Errors
+    /// # Returns
     ///
-    /// * [`TskitError::IndexError`] if `row` is out of range.
-    pub fn right<M: Into<MigrationId> + Copy>(&'a self, row: M) -> Result<Position, TskitError> {
-        match unsafe_tsk_column_access!(row.into().0, 0, self.num_rows(), self.table_.right) {
-            Ok(p) => Ok(p.into()),
-            Err(e) => Err(e),
-        }
+    /// * `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)
     }
 
     /// Return the node for a given row.
     ///
-    /// # Errors
+    /// # Returns
     ///
-    /// * [`TskitError::IndexError`] if `row` is out of range.
-    pub fn node<M: Into<MigrationId> + Copy>(&'a self, row: M) -> Result<NodeId, TskitError> {
+    /// * `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)
     }
 
     /// Return the source population for a given row.
     ///
-    /// # Errors
+    /// # Returns
     ///
-    /// * [`TskitError::IndexError`] if `row` is out of range.
-    pub fn source<M: Into<MigrationId> + Copy>(
-        &'a self,
-        row: M,
-    ) -> Result<PopulationId, TskitError> {
+    /// * `Some(population)` if `row` is valid.
+    /// * `None` otherwise.
+    pub fn source<M: Into<MigrationId> + Copy>(&'a self, row: M) -> Option<PopulationId> {
         unsafe_tsk_column_access!(
             row.into().0,
             0,
@@ -143,10 +138,11 @@ impl<'a> MigrationTable<'a> {
 
     /// Return the destination population for a given row.
     ///
-    /// # Errors
+    /// # Returns
     ///
-    /// * [`TskitError::IndexError`] if `row` is out of range.
-    pub fn dest<M: Into<MigrationId> + Copy>(&'a self, row: M) -> Result<PopulationId, TskitError> {
+    /// * `Some(population)` if `row` is valid.
+    /// * `None` otherwise.
+    pub fn dest<M: Into<MigrationId> + Copy>(&'a self, row: M) -> Option<PopulationId> {
         unsafe_tsk_column_access!(
             row.into().0,
             0,
@@ -158,21 +154,21 @@ impl<'a> MigrationTable<'a> {
 
     /// Return the time of the migration event for a given row.
     ///
-    /// # Errors
+    /// # Returns
     ///
-    /// * [`TskitError::IndexError`] if `row` is out of range.
-    pub fn time<M: Into<MigrationId> + Copy>(&'a self, row: M) -> Result<Time, TskitError> {
-        match unsafe_tsk_column_access!(row.into().0, 0, self.num_rows(), self.table_.time) {
-            Ok(t) => Ok(t.into()),
-            Err(e) => Err(e),
-        }
+    /// * `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)
     }
 
     /// Return the metadata for a given row.
     ///
-    /// # Errors
+    /// # Returns
     ///
-    /// * [`TskitError::IndexError`] if `row` is out of range.
+    /// * `Some(Ok(metadata))` if `row` is valid and decoding succeeded
+    /// * `Some(Err(_))` if `row` is valid and decoding failed.
+    /// * `None` if `row` is not valid.
     pub fn metadata<T: metadata::MetadataRoundtrip>(
         &'a self,
         row: MigrationId,
diff --git a/src/mutation_table.rs b/src/mutation_table.rs
index d9d4f6539..01257b704 100644
--- a/src/mutation_table.rs
+++ b/src/mutation_table.rs
@@ -37,10 +37,10 @@ fn make_mutation_table_row(table: &MutationTable, pos: tsk_id_t) -> Option<Mutat
             let derived_state = table.derived_state(pos).map(|s| s.to_vec());
             Some(MutationTableRow {
                 id: pos.into(),
-                site: table.site(pos).ok()?,
-                node: table.node(pos).ok()?,
-                parent: table.parent(pos).ok()?,
-                time: table.time(pos).ok()?,
+                site: table.site(pos)?,
+                node: table.node(pos)?,
+                parent: table.parent(pos)?,
+                time: table.time(pos)?,
                 derived_state,
                 metadata: table_row_decode_metadata!(table, table_ref, pos).map(|m| m.to_vec()),
             })
@@ -98,7 +98,7 @@ 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) -> Result<SiteId, TskitError> {
+    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)
     }
 
@@ -108,7 +108,7 @@ 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) -> Result<NodeId, TskitError> {
+    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)
     }
 
@@ -118,7 +118,7 @@ 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) -> Result<MutationId, TskitError> {
+    pub fn parent<M: Into<MutationId> + Copy>(&'a self, row: M) -> Option<MutationId> {
         unsafe_tsk_column_access!(
             row.into().0,
             0,
@@ -134,11 +134,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) -> Result<Time, TskitError> {
-        match unsafe_tsk_column_access!(row.into().0, 0, self.num_rows(), self.table_.time) {
-            Ok(t) => Ok(t.into()),
-            Err(e) => Err(e),
-        }
+    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)
     }
 
     /// Get the ``derived_state`` value from row ``row`` of the table.
diff --git a/src/node_table.rs b/src/node_table.rs
index 55e126fff..6b92af1b6 100644
--- a/src/node_table.rs
+++ b/src/node_table.rs
@@ -32,10 +32,10 @@ fn make_node_table_row(table: &NodeTable, pos: tsk_id_t) -> Option<NodeTableRow>
     let table_ref = table.table_;
     Some(NodeTableRow {
         id: pos.into(),
-        time: table.time(pos).ok()?,
-        flags: table.flags(pos).ok()?,
-        population: table.population(pos).ok()?,
-        individual: table.individual(pos).ok()?,
+        time: table.time(pos)?,
+        flags: table.flags(pos)?,
+        population: table.population(pos)?,
+        individual: table.individual(pos)?,
         metadata: table_row_decode_metadata!(table, table_ref, pos).map(|m| m.to_vec()),
     })
 }
@@ -84,28 +84,22 @@ impl<'a> NodeTable<'a> {
 
     /// Return the ``time`` value from row ``row`` of the table.
     ///
-    /// # Errors
+    /// # Returns
     ///
-    /// Will return [``IndexError``](crate::TskitError::IndexError)
-    /// if ``row`` is out of range.
-    pub fn time<N: Into<NodeId> + Copy>(&'a self, row: N) -> Result<Time, TskitError> {
-        match unsafe_tsk_column_access!(row.into().0, 0, self.num_rows(), self.table_.time) {
-            Ok(t) => Ok(t.into()),
-            Err(e) => Err(e),
-        }
+    /// * `Some(time)` if `row` is valid.
+    /// * `None` otherwise.
+    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)
     }
 
     /// Return the ``flags`` value from row ``row`` of the table.
     ///
-    /// # Errors
+    /// # Returns
     ///
-    /// Will return [``IndexError``](crate::TskitError::IndexError)
-    /// if ``row`` is out of range.
-    pub fn flags<N: Into<NodeId> + Copy>(&'a self, row: N) -> Result<NodeFlags, TskitError> {
-        match unsafe_tsk_column_access!(row.into().0, 0, self.num_rows(), self.table_.flags) {
-            Ok(f) => Ok(NodeFlags::from(f)),
-            Err(e) => Err(e),
-        }
+    /// * `Some(flags)` if `row` is valid.
+    /// * `None` otherwise.
+    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)
     }
 
     /// Mutable access to node flags.
@@ -142,14 +136,11 @@ impl<'a> NodeTable<'a> {
 
     /// Return the ``population`` value from row ``row`` of the table.
     ///
-    /// # Errors
+    /// # Returns
     ///
-    /// Will return [``IndexError``](crate::TskitError::IndexError)
-    /// if ``row`` is out of range.
-    pub fn population<N: Into<NodeId> + Copy>(
-        &'a self,
-        row: N,
-    ) -> Result<PopulationId, TskitError> {
+    /// * `Some(population)` if `row` is valid.
+    /// * `None` otherwise.
+    pub fn population<N: Into<NodeId> + Copy>(&'a self, row: N) -> Option<PopulationId> {
         unsafe_tsk_column_access!(
             row.into().0,
             0,
@@ -161,24 +152,21 @@ impl<'a> NodeTable<'a> {
 
     /// Return the ``population`` value from row ``row`` of the table.
     ///
-    /// # Errors
+    /// # Returns
     ///
-    /// Will return [``IndexError``](crate::TskitError::IndexError)
-    /// if ``row`` is out of range.
-    pub fn deme<N: Into<NodeId> + Copy>(&'a self, row: N) -> Result<PopulationId, TskitError> {
+    /// * `Some(population)` if `row` is valid.
+    /// * `None` otherwise.
+    pub fn deme<N: Into<NodeId> + Copy>(&'a self, row: N) -> Option<PopulationId> {
         self.population(row)
     }
 
     /// Return the ``individual`` value from row ``row`` of the table.
     ///
-    /// # Errors
+    /// # Returns
     ///
-    /// Will return [``IndexError``](crate::TskitError::IndexError)
-    /// if ``row`` is out of range.
-    pub fn individual<N: Into<NodeId> + Copy>(
-        &'a self,
-        row: N,
-    ) -> Result<IndividualId, TskitError> {
+    /// * `Some(individual)` if `row` is valid.
+    /// * `None` otherwise.
+    pub fn individual<N: Into<NodeId> + Copy>(&'a self, row: N) -> Option<IndividualId> {
         unsafe_tsk_column_access!(
             row.into().0,
             0,
diff --git a/src/site_table.rs b/src/site_table.rs
index 99c5ac8ff..cf6fa5c42 100644
--- a/src/site_table.rs
+++ b/src/site_table.rs
@@ -29,7 +29,7 @@ fn make_site_table_row(table: &SiteTable, pos: tsk_id_t) -> Option<SiteTableRow>
     let ancestral_state = table.ancestral_state(pos).map(|s| s.to_vec());
     Some(SiteTableRow {
         id: pos.into(),
-        position: table.position(pos).ok()?,
+        position: table.position(pos)?,
         ancestral_state,
         metadata: table_row_decode_metadata!(table, table_ref, pos).map(|m| m.to_vec()),
     })
@@ -79,27 +79,26 @@ impl<'a> SiteTable<'a> {
 
     /// Return the ``position`` value from row ``row`` of the table.
     ///
-    /// # Errors
+    /// # Returns
     ///
-    /// Will return [``IndexError``](crate::TskitError::IndexError)
-    /// if ``row`` is out of range.
-    pub fn position<S: Into<SiteId> + Copy>(&'a self, row: S) -> Result<Position, TskitError> {
-        match unsafe_tsk_column_access!(row.into().0, 0, self.num_rows(), self.table_.position) {
-            Ok(p) => Ok(p.into()),
-            Err(e) => Err(e),
-        }
+    /// * `Some(position)` if `row` is valid.
+    /// * `None` otherwise.
+    pub fn position<S: Into<SiteId> + Copy>(&'a self, row: S) -> Option<Position> {
+        unsafe_tsk_column_access!(
+            row.into().0,
+            0,
+            self.num_rows(),
+            self.table_.position,
+            Position
+        )
     }
 
     /// Get the ``ancestral_state`` value from row ``row`` of the table.
     ///
-    /// # Return
-    ///
-    /// Will return `None` if there is no ancestral state.
-    ///
-    /// # Errors
+    /// # Returns
     ///
-    /// Will return [``IndexError``](crate::TskitError::IndexError)
-    /// if ``row`` is out of range.
+    /// * `Some(ancestral state)` if `row` is valid.
+    /// * `None` otherwise.
     pub fn ancestral_state<S: Into<SiteId>>(&'a self, row: S) -> Option<&[u8]> {
         crate::metadata::char_column_to_slice(
             self,
diff --git a/src/table_collection.rs b/src/table_collection.rs
index 54712c972..a9addc679 100644
--- a/src/table_collection.rs
+++ b/src/table_collection.rs
@@ -300,8 +300,8 @@ impl TableCollection {
     /// # use tskit::TableAccess;
     /// # let mut tables = tskit::TableCollection::new(1.0).unwrap();
     /// tables.add_individual(0, None, None).unwrap();
-    /// # assert!(tables.individuals().location(0).unwrap().is_none());
-    /// # assert!(tables.individuals().parents(0).unwrap().is_none());
+    /// # assert!(tables.individuals().location(0).is_none());
+    /// # assert!(tables.individuals().parents(0).is_none());
     /// ```
     ///
     /// ## No flags, a 3d location, no parents
@@ -310,7 +310,7 @@ impl TableCollection {
     /// # 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).unwrap() {
+    /// # match tables.individuals().location(0) {
     /// #     Some(loc) => loc.iter().zip([-0.5, 0.3, 10.0].iter()).for_each(|(a,b)| assert_eq!(a, b)),
     /// #     None => panic!("expected a location"),
     /// # }
@@ -320,8 +320,8 @@ impl TableCollection {
     /// ```
     /// # let mut tables = tskit::TableCollection::new(1.0).unwrap();
     /// # use tskit::TableAccess;
-    /// tables.add_individual(0, None, &[1, 11]).unwrap();
-    /// # match tables.individuals().parents(0).unwrap() {
+    /// 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)),
     /// #     None => panic!("expected parents"),
     /// # }
@@ -1070,7 +1070,7 @@ impl TableCollection {
     /// tables.set_individuals(&individuals).unwrap();
     /// assert_eq!(tables.individuals().num_rows(), 1);
     /// let expected = vec![tskit::Location::from(0.1), tskit::Location::from(10.0)];
-    /// assert_eq!(tables.individuals().location(0).unwrap(), Some(expected.as_slice()));
+    /// assert_eq!(tables.individuals().location(0), Some(expected.as_slice()));
     /// # individuals.clear().unwrap();
     /// # assert_eq!(individuals.num_rows(), 0);
     /// ```
@@ -1930,7 +1930,7 @@ mod test_adding_individual {
             .unwrap();
         assert_eq!(row_id, 2);
         assert_eq!(
-            tables.individuals().location(row_id).unwrap(),
+            tables.individuals().location(row_id),
             Some(
                 [
                     crate::Location::from(0.2),
@@ -1941,7 +1941,7 @@ mod test_adding_individual {
             )
         );
         assert_eq!(
-            tables.individuals().parents(row_id).unwrap(),
+            tables.individuals().parents(row_id),
             Some(
                 [
                     crate::IndividualId::from(1),
diff --git a/src/tree_interface.rs b/src/tree_interface.rs
index 6f07a0590..b1247f1da 100644
--- a/src/tree_interface.rs
+++ b/src/tree_interface.rs
@@ -293,29 +293,21 @@ impl TreeInterface {
         tree_array_slice!(self, right_child, self.array_len)
     }
 
-    fn left_sample(&self, u: NodeId) -> Result<NodeId, TskitError> {
-        err_if_not_tracking_samples!(
-            self.flags,
-            unsafe_tsk_column_access!(
-                u.0,
-                0,
-                self.num_nodes,
-                (*self.as_ptr()).left_sample,
-                NodeId
-            )?
-        )
-    }
-
-    fn right_sample(&self, u: NodeId) -> Result<NodeId, TskitError> {
-        err_if_not_tracking_samples!(
-            self.flags,
-            unsafe_tsk_column_access!(
-                u.0,
-                0,
-                self.num_nodes,
-                (*self.as_ptr()).right_sample,
-                NodeId
-            )?
+    // error if we are not tracking samples,
+    // Ok(None) if u is out of range
+    fn left_sample(&self, u: NodeId) -> Option<NodeId> {
+        unsafe_tsk_column_access!(u.0, 0, self.num_nodes, (*self.as_ptr()).left_sample, NodeId)
+    }
+
+    // error if we are not tracking samples,
+    // Ok(None) if u is out of range
+    fn right_sample(&self, u: NodeId) -> Option<NodeId> {
+        unsafe_tsk_column_access!(
+            u.0,
+            0,
+            self.num_nodes,
+            (*self.as_ptr()).right_sample,
+            NodeId
         )
     }
 
@@ -336,46 +328,36 @@ impl TreeInterface {
 
     /// Get the parent of node `u`.
     ///
-    /// # Errors
-    ///
-    /// [`TskitError`] if `u` is out of range.
-    pub fn parent(&self, u: NodeId) -> Result<NodeId, TskitError> {
+    /// Returns `None` if `u` is out of range.
+    pub fn parent(&self, u: NodeId) -> Option<NodeId> {
         unsafe_tsk_column_access!(u.0, 0, self.array_len, (*self.as_ptr()).parent, NodeId)
     }
 
     /// Get the left child of node `u`.
     ///
-    /// # Errors
-    ///
-    /// [`TskitError`] if `u` is out of range.
-    pub fn left_child(&self, u: NodeId) -> Result<NodeId, TskitError> {
+    /// Returns `None` if `u` is out of range.
+    pub fn left_child(&self, u: NodeId) -> Option<NodeId> {
         unsafe_tsk_column_access!(u.0, 0, self.array_len, (*self.as_ptr()).left_child, NodeId)
     }
 
     /// Get the right child of node `u`.
     ///
-    /// # Errors
-    ///
-    /// [`TskitError`] if `u` is out of range.
-    pub fn right_child(&self, u: NodeId) -> Result<NodeId, TskitError> {
+    /// Returns `None` if `u` is out of range.
+    pub fn right_child(&self, u: NodeId) -> Option<NodeId> {
         unsafe_tsk_column_access!(u.0, 0, self.array_len, (*self.as_ptr()).right_child, NodeId)
     }
 
     /// Get the left sib of node `u`.
     ///
-    /// # Errors
-    ///
-    /// [`TskitError`] if `u` is out of range.
-    pub fn left_sib(&self, u: NodeId) -> Result<NodeId, TskitError> {
+    /// Returns `None` if `u` is out of range.
+    pub fn left_sib(&self, u: NodeId) -> Option<NodeId> {
         unsafe_tsk_column_access!(u.0, 0, self.array_len, (*self.as_ptr()).left_sib, NodeId)
     }
 
     /// Get the right sib of node `u`.
     ///
-    /// # Errors
-    ///
-    /// [`TskitError::IndexError`] if `u` is out of range.
-    pub fn right_sib(&self, u: NodeId) -> Result<NodeId, TskitError> {
+    /// Returns `None` if `u` is out of range.
+    pub fn right_sib(&self, u: NodeId) -> Option<NodeId> {
         unsafe_tsk_column_access!(u.0, 0, self.array_len, (*self.as_ptr()).right_sib, NodeId)
     }
 
@@ -410,45 +392,50 @@ impl TreeInterface {
 
     /// Return an [`Iterator`] from the node `u` to the root of the tree.
     ///
-    /// # Errors
+    /// # Returns
     ///
-    /// [`TskitError::IndexError`] if `u` is out of range.
+    /// * `Some(iterator)` if `u` us valid
+    /// * `None` otherwise
     #[deprecated(since = "0.2.3", note = "Please use Tree::parents instead")]
-    pub fn path_to_root(&self, u: NodeId) -> Result<impl Iterator<Item = NodeId> + '_, TskitError> {
+    pub fn path_to_root(&self, u: NodeId) -> Option<impl Iterator<Item = NodeId> + '_> {
         self.parents(u)
     }
 
     /// Return an [`Iterator`] from the node `u` to the root of the tree,
     /// travering all parent nodes.
     ///
-    /// # Errors
+    /// # Returns
     ///
-    /// [`TskitError::IndexError`] if `u` is out of range.
-    pub fn parents(&self, u: NodeId) -> Result<impl Iterator<Item = NodeId> + '_, TskitError> {
+    /// * `Some(iterator)` if `u` is valid
+    /// * `None` otherwise
+    pub fn parents(&self, u: NodeId) -> Option<impl Iterator<Item = NodeId> + '_> {
         ParentsIterator::new(self, u)
     }
 
     /// Return an [`Iterator`] over the children of node `u`.
+    /// # Returns
     ///
-    /// # Errors
-    ///
-    /// [`TskitError::IndexError`] if `u` is out of range.
-    pub fn children(&self, u: NodeId) -> Result<impl Iterator<Item = NodeId> + '_, TskitError> {
+    /// * `Some(iterator)` if `u` is valid
+    /// * `None` otherwise
+    pub fn children(&self, u: NodeId) -> Option<impl Iterator<Item = NodeId> + '_> {
         ChildIterator::new(self, u)
     }
+
     /// Return an [`Iterator`] over the sample nodes descending from node `u`.
     ///
     /// # Note
     ///
     /// If `u` is itself a sample, then it is included in the values returned.
     ///
-    /// # Errors
-    ///
-    /// [`TskitError::IndexError`] if `u` is out of range.
+    /// # Returns
     ///
-    /// [`TskitError::NotTrackingSamples`] if [`TreeFlags::SAMPLE_LISTS`] was not used
-    /// to initialize `self`.
-    pub fn samples(&self, u: NodeId) -> Result<impl Iterator<Item = NodeId> + '_, TskitError> {
+    /// * Some(Ok(iterator)) if [`TreeFlags::SAMPLE_LISTS`] is in [`TreeInterface::flags`]
+    /// * Some(Err(_)) if [`TreeFlags::SAMPLE_LISTS`] is not in [`TreeInterface::flags`]
+    /// * None if `u` is not valid.
+    pub fn samples(
+        &self,
+        u: NodeId,
+    ) -> Option<Result<impl Iterator<Item = NodeId> + '_, TskitError>> {
         SamplesIterator::new(self, u)
     }
 
@@ -513,9 +500,10 @@ impl TreeInterface {
         let nt = self.node_table();
         let mut b = Time::from(0.);
         for n in self.traverse_nodes(NodeTraversalOrder::Preorder) {
-            let p = self.parent(n)?;
+            let p = self.parent(n).ok_or(TskitError::IndexError {})?;
             if p != NodeId::NULL {
-                b += nt.time(p)? - nt.time(n)?;
+                b += nt.time(p).ok_or(TskitError::IndexError {})?
+                    - nt.time(n).ok_or(TskitError::IndexError {})?;
             }
         }
 
@@ -592,7 +580,7 @@ struct PreorderNodeIterator<'a> {
 
 impl<'a> PreorderNodeIterator<'a> {
     fn new(tree: &'a TreeInterface) -> Self {
-        debug_assert!(tree.right_child(tree.virtual_root()).is_ok());
+        debug_assert!(tree.right_child(tree.virtual_root()).is_some());
         let mut rv = PreorderNodeIterator {
             current_root: tree
                 .right_child(tree.virtual_root())
@@ -604,7 +592,7 @@ impl<'a> PreorderNodeIterator<'a> {
         let mut c = rv.current_root;
         while !c.is_null() {
             rv.node_stack.push(c);
-            debug_assert!(rv.tree.left_sib(c).is_ok());
+            debug_assert!(rv.tree.left_sib(c).is_some());
             c = rv.tree.left_sib(c).unwrap_or(NodeId::NULL);
         }
         rv
@@ -618,11 +606,11 @@ impl NodeIterator for PreorderNodeIterator<'_> {
             // NOTE: process children right-to-left
             // because we later pop them from a steck
             // to generate the expected left-to-right ordering.
-            debug_assert!(self.tree.right_child(u).is_ok());
+            debug_assert!(self.tree.right_child(u).is_some());
             let mut c = self.tree.right_child(u).unwrap_or(NodeId::NULL);
             while c != NodeId::NULL {
                 self.node_stack.push(c);
-                debug_assert!(self.tree.right_child(c).is_ok());
+                debug_assert!(self.tree.right_child(c).is_some());
                 c = self.tree.left_sib(c).unwrap_or(NodeId::NULL);
             }
         };
@@ -702,7 +690,7 @@ struct RootIterator<'a> {
 
 impl<'a> RootIterator<'a> {
     fn new(tree: &'a TreeInterface) -> Self {
-        debug_assert!(tree.left_child(tree.virtual_root()).is_ok());
+        debug_assert!(tree.left_child(tree.virtual_root()).is_some());
         RootIterator {
             current_root: None,
             next_root: tree.left_child(tree.virtual_root()).unwrap_or(NodeId::NULL),
@@ -718,7 +706,7 @@ impl NodeIterator for RootIterator<'_> {
             r => {
                 assert!(r >= 0);
                 let cr = Some(r);
-                debug_assert!(self.tree.right_sib(r).is_ok());
+                debug_assert!(self.tree.right_sib(r).is_some());
                 self.next_root = self.tree.right_sib(r).unwrap_or(NodeId::NULL);
                 cr
             }
@@ -739,10 +727,10 @@ struct ChildIterator<'a> {
 }
 
 impl<'a> ChildIterator<'a> {
-    fn new(tree: &'a TreeInterface, u: NodeId) -> Result<Self, TskitError> {
+    fn new(tree: &'a TreeInterface, u: NodeId) -> Option<Self> {
         let c = tree.left_child(u)?;
 
-        Ok(ChildIterator {
+        Some(ChildIterator {
             current_child: None,
             next_child: c,
             tree,
@@ -757,7 +745,7 @@ impl NodeIterator for ChildIterator<'_> {
             r => {
                 assert!(r >= 0);
                 let cr = Some(r);
-                debug_assert!(self.tree.right_sib(r).is_ok());
+                debug_assert!(self.tree.right_sib(r).is_some());
                 self.next_child = self.tree.right_sib(r).unwrap_or(NodeId::NULL);
                 cr
             }
@@ -778,23 +766,16 @@ struct ParentsIterator<'a> {
 }
 
 impl<'a> ParentsIterator<'a> {
-    fn new(tree: &'a TreeInterface, u: NodeId) -> Result<Self, TskitError> {
-        let num_nodes = match tsk_id_t::try_from(tree.num_nodes) {
-            Ok(n) => n,
-            Err(_) => {
-                return Err(TskitError::RangeError(format!(
-                    "could not convert {} into tsk_id_t",
-                    stringify!(num_nodes)
-                )))
-            }
-        };
-        match u.0 >= num_nodes {
-            true => Err(TskitError::IndexError),
-            false => Ok(ParentsIterator {
+    fn new(tree: &'a TreeInterface, u: NodeId) -> Option<Self> {
+        let num_nodes = tsk_id_t::try_from(tree.num_nodes).ok()?;
+
+        match u {
+            x if x < num_nodes => Some(ParentsIterator {
                 current_node: None,
                 next_node: u,
                 tree,
             }),
+            _ => None,
         }
     }
 }
@@ -806,7 +787,7 @@ impl NodeIterator for ParentsIterator<'_> {
             r => {
                 assert!(r >= 0);
                 let cr = Some(r);
-                debug_assert!(self.tree.parent(r).is_ok());
+                debug_assert!(self.tree.parent(r).is_some());
                 self.next_node = self.tree.parent(r).unwrap_or(NodeId::NULL);
                 cr
             }
@@ -830,15 +811,20 @@ struct SamplesIterator<'a> {
 }
 
 impl<'a> SamplesIterator<'a> {
-    fn new(tree: &'a TreeInterface, u: NodeId) -> Result<Self, TskitError> {
-        let rv = SamplesIterator {
-            current_node: None,
-            next_sample_index: tree.left_sample(u)?,
-            last_sample_index: tree.right_sample(u)?,
-            tree,
-        };
-
-        Ok(rv)
+    fn new(tree: &'a TreeInterface, u: NodeId) -> Option<Result<Self, TskitError>> {
+        match tree.flags.contains(TreeFlags::SAMPLE_LISTS) {
+            false => Some(Err(TskitError::NotTrackingSamples {})),
+            true => {
+                let next_sample_index = tree.left_sample(u)?;
+                let last_sample_index = tree.right_sample(u)?;
+                Some(Ok(SamplesIterator {
+                    current_node: None,
+                    next_sample_index,
+                    last_sample_index,
+                    tree,
+                }))
+            }
+        }
     }
 }
 
diff --git a/src/trees.rs b/src/trees.rs
index 7a5649db4..e3b86b881 100644
--- a/src/trees.rs
+++ b/src/trees.rs
@@ -629,7 +629,6 @@ pub(crate) mod test_trees {
         }
     }
 
-    #[should_panic]
     #[test]
     fn test_samples_iterator_error_when_not_tracking_samples() {
         let tables = make_small_table_collection();
@@ -638,7 +637,10 @@ pub(crate) mod test_trees {
         let mut tree_iter = treeseq.tree_iterator(TreeFlags::default()).unwrap();
         if let Some(tree) = tree_iter.next() {
             for n in tree.traverse_nodes(NodeTraversalOrder::Preorder) {
-                for _ in tree.samples(n).unwrap() {}
+                match tree.samples(n) {
+                    Some(Err(_)) => (),
+                    _ => panic!("should not be Ok(_) or None"),
+                }
             }
         }
     }
@@ -657,7 +659,7 @@ pub(crate) mod test_trees {
 
     #[should_panic]
     #[test]
-    fn test_num_tracked_samples_not_tracking_samples() {
+    fn test_num_tracked_samples_not_tracking_sample_counts() {
         let treeseq = treeseq_from_small_table_collection();
         assert_eq!(treeseq.num_samples(), 2);
         let mut tree_iter = treeseq.tree_iterator(TreeFlags::NO_SAMPLE_COUNTS).unwrap();
@@ -678,8 +680,11 @@ pub(crate) mod test_trees {
             assert!(!tree.flags().contains(TreeFlags::NO_SAMPLE_COUNTS));
             assert!(tree.flags().contains(TreeFlags::SAMPLE_LISTS));
             let mut s = vec![];
-            for i in tree.samples(0.into()).unwrap() {
-                s.push(i);
+
+            if let Some(Ok(iter)) = tree.samples(0.into()) {
+                for i in iter {
+                    s.push(i);
+                }
             }
             assert_eq!(s.len(), 2);
             assert_eq!(
@@ -691,8 +696,10 @@ pub(crate) mod test_trees {
 
             for u in 1..3 {
                 let mut s = vec![];
-                for i in tree.samples(u.into()).unwrap() {
-                    s.push(i);
+                if let Some(Ok(iter)) = tree.samples(u.into()) {
+                    for i in iter {
+                        s.push(i);
+                    }
                 }
                 assert_eq!(s.len(), 1);
                 assert_eq!(s[0], u);
@@ -733,8 +740,10 @@ pub(crate) mod test_trees {
             for n in tree.traverse_nodes(NodeTraversalOrder::Preorder) {
                 let mut nsamples = 0;
                 preoder_nodes.push(n);
-                for _ in tree.samples(n).unwrap() {
-                    nsamples += 1;
+                if let Some(Ok(iter)) = tree.samples(n) {
+                    for _ in iter {
+                        nsamples += 1;
+                    }
                 }
                 assert!(nsamples > 0);
                 assert_eq!(nsamples, tree.num_tracked_samples(n).unwrap());
@@ -742,8 +751,10 @@ pub(crate) mod test_trees {
             for n in tree.traverse_nodes(NodeTraversalOrder::Postorder) {
                 let mut nsamples = 0;
                 postoder_nodes.push(n);
-                for _ in tree.samples(n).unwrap() {
-                    nsamples += 1;
+                if let Some(Ok(iter)) = tree.samples(n) {
+                    for _ in iter {
+                        nsamples += 1;
+                    }
                 }
                 assert!(nsamples > 0);
                 assert_eq!(nsamples, tree.num_tracked_samples(n).unwrap());