diff --git a/tensorstore/array.h b/tensorstore/array.h
index 3e13c9be..aa94ed56 100644
--- a/tensorstore/array.h
+++ b/tensorstore/array.h
@@ -2079,6 +2079,9 @@ bool IsBroadcastScalar(
 }
 
 /// Returns minimum number of contiguous bytes into which the array fits.
+///
+/// \relates Array
+/// \id array
 template <typename ElementTag, DimensionIndex Rank, ArrayOriginKind OriginKind,
           ContainerKind LayoutCKind>
 Index GetByteExtent(
diff --git a/tensorstore/array_storage_statistics.h b/tensorstore/array_storage_statistics.h
index 61608d6a..ab6412ad 100644
--- a/tensorstore/array_storage_statistics.h
+++ b/tensorstore/array_storage_statistics.h
@@ -25,7 +25,11 @@
 
 namespace tensorstore {
 
+/// Response from a storage statistics query.
+///
+/// \relates GetStorageStatistics
 struct ArrayStorageStatistics {
+  /// Indicates the information to request.
   enum Mask {
     /// Query if no data is stored.
     query_not_stored = 1,
@@ -34,25 +38,22 @@ struct ArrayStorageStatistics {
     query_fully_stored = 2,
   };
 
+  /// Set operations.
   friend constexpr Mask operator~(Mask a) {
     return static_cast<Mask>(~static_cast<std::underlying_type_t<Mask>>(a));
   }
-
   friend constexpr Mask operator|(Mask a, Mask b) {
     using U = std::underlying_type_t<Mask>;
     return static_cast<Mask>(static_cast<U>(a) | static_cast<U>(b));
   }
-
   friend constexpr Mask& operator|=(Mask& a, Mask b) {
     using U = std::underlying_type_t<Mask>;
     return a = static_cast<Mask>(static_cast<U>(a) | static_cast<U>(b));
   }
-
   friend constexpr Mask operator&(Mask a, Mask b) {
     using U = std::underlying_type_t<Mask>;
     return static_cast<Mask>(static_cast<U>(a) & static_cast<U>(b));
   }
-
   friend constexpr Mask operator&=(Mask& a, Mask b) {
     using U = std::underlying_type_t<Mask>;
     return a = static_cast<Mask>(static_cast<U>(a) & static_cast<U>(b));
@@ -88,6 +89,7 @@ struct ArrayStorageStatistics {
     return !(a == b);
   }
 
+  /// Prints a debug representation.
   friend std::ostream& operator<<(std::ostream& os,
                                   const ArrayStorageStatistics& a);
 
@@ -96,6 +98,14 @@ struct ArrayStorageStatistics {
   };
 };
 
+/// Specifies options for computing array storage statistics.
+///
+/// Supported option types are:
+///
+///   - `Batch`
+///   - `ArrayStorageStatistics::Mask`
+///
+/// \relates GetStorageStatistics
 struct GetArrayStorageStatisticsOptions {
   ArrayStorageStatistics::Mask mask = {};
 
diff --git a/tensorstore/batch.h b/tensorstore/batch.h
index 04fd5520..7a90f328 100644
--- a/tensorstore/batch.h
+++ b/tensorstore/batch.h
@@ -29,6 +29,8 @@ namespace tensorstore {
 ///
 /// For some operations, there are batch implementations there are batch
 /// implementations that reduce the number of separate I/O requests performed.
+///
+/// \ingroup core
 class Batch {
   class ImplBase {
    public:
@@ -55,10 +57,14 @@ class Batch {
   class View {
    public:
     /// Constructs a view that refers to `no_batch`.
+    ///
+    /// \id no_batch
     constexpr View() = default;
     constexpr View(no_batch_t) {}
 
     /// Constructs a view that refers to an existing batch.
+    ///
+    /// \id batch
     constexpr View(const Batch& batch) : impl_(batch.impl_.get()) {}
 
     /// Returns `true` if this refers to a batch (as opposed to `no_batch`).
@@ -113,6 +119,9 @@ class Batch {
   internal::IntrusivePtr<ImplBase> impl_;
 };
 
+/// Alias for indicating not to use a batch.
+///
+/// \relates Batch
 constexpr inline Batch::no_batch_t no_batch = Batch::no_batch_t{};
 
 }  // namespace tensorstore
diff --git a/tensorstore/box.h b/tensorstore/box.h
index b3af8d5e..3b0aa523 100644
--- a/tensorstore/box.h
+++ b/tensorstore/box.h
@@ -96,7 +96,7 @@ constexpr inline bool IsMutableBoxLike =
 /// type with `Box::static_rank` implicitly convertible to `Rank`.
 ///
 /// \relates Box
-template <typename T, DimensionIndex Rank, typename = void>
+template <typename T, DimensionIndex Rank, typename Sfinae = void>
 constexpr inline bool IsBoxLikeImplicitlyConvertibleToRank = false;
 
 template <typename T, DimensionIndex Rank>
@@ -108,7 +108,7 @@ constexpr inline bool IsBoxLikeImplicitlyConvertibleToRank<
 /// type with `Box::static_rank` explicitly convertible to `Rank`.
 ///
 /// \relates Box
-template <typename T, DimensionIndex Rank, typename = void>
+template <typename T, DimensionIndex Rank, typename Sfinae = void>
 constexpr inline bool IsBoxLikeExplicitlyConvertibleToRank = false;
 
 template <typename T, DimensionIndex Rank>
@@ -439,8 +439,8 @@ Box(const Index (&shape)[Rank]) -> Box<Rank>;
 template <typename Origin, typename Shape,
           std::enable_if_t<(IsIndexConvertibleVector<Origin> &&
                             IsIndexConvertibleVector<Shape>)>* = nullptr>
-Box(const Origin& origin, const Shape& shape)
-    -> Box<SpanStaticExtent<Origin, Shape>::value>;
+Box(const Origin& origin,
+    const Shape& shape) -> Box<SpanStaticExtent<Origin, Shape>::value>;
 
 template <DimensionIndex Rank>
 Box(const Index (&origin)[Rank], const Index (&shape)[Rank]) -> Box<Rank>;
@@ -557,12 +557,11 @@ class BoxView : public internal_box::BoxViewStorage<Rank, Mutable> {
   /// \requires If `Mutable == true`, `BoxType` must be a mutable Box-like type
   ///     (such as a non-const `Box` reference or a `MutableBoxView`).
   /// \id convert
-  template <
-      typename BoxType,
-      typename = std::enable_if_t<
-          (IsBoxLike<BoxType> &&
-           (!Mutable || IsMutableBoxLike<BoxType>)&&RankConstraint::Implies(
-               absl::remove_cvref_t<BoxType>::static_rank, Rank))>>
+  template <typename BoxType,
+            typename = std::enable_if_t<(
+                IsBoxLike<BoxType> && (!Mutable || IsMutableBoxLike<BoxType>) &&
+                RankConstraint::Implies(
+                    absl::remove_cvref_t<BoxType>::static_rank, Rank))>>
   // NONITPICK: std::remove_cvref_t<BoxType>::static_rank
   BoxView(BoxType&& other)
       : BoxView(other.rank(), other.origin().data(), other.shape().data()) {}
@@ -587,7 +586,7 @@ class BoxView : public internal_box::BoxViewStorage<Rank, Mutable> {
       typename BoxType,
       std::enable_if_t<
           (IsBoxLike<absl::remove_cvref_t<BoxType>> &&
-           (!Mutable || IsMutableBoxLike<std::remove_reference_t<BoxType>>)&&
+           (!Mutable || IsMutableBoxLike<std::remove_reference_t<BoxType>>) &&
 
            RankConstraint::Implies(absl::remove_cvref_t<BoxType>::static_rank,
                                    Rank))>* = nullptr>
@@ -704,8 +703,8 @@ BoxView(Origin&& origin, Shape&& shape)
                (IsMutableIndexVector<Origin> && IsMutableIndexVector<Shape>)>;
 
 template <DimensionIndex Rank>
-BoxView(const Index (&origin)[Rank], const Index (&shape)[Rank])
-    -> BoxView<Rank>;
+BoxView(const Index (&origin)[Rank],
+        const Index (&shape)[Rank]) -> BoxView<Rank>;
 
 template <DimensionIndex Rank, bool Mutable>
 struct StaticCastTraits<BoxView<Rank, Mutable>>
@@ -897,10 +896,12 @@ std::enable_if_t<HasBoxDomain<BoxType>, bool> ContainsPartial(
 /// Returns a view of the sub-box corresponding to the specified dimension
 /// range.
 ///
-/// \params box The existing box from which to extract the sub-box.
-/// \param  begin Inclusive start dimension of the sub-box.
-/// \param end Exclusive end dimension of the sub-box.  The default value of
-///     `-1` is treated the same as `box.rank()`.
+/// \param box The existing box from which to extract the sub-box.
+/// \param begin Inclusive start dimension of the sub-box.
+/// \param end Exclusive end dimension of the sub-box.
+///     The default value of ``-1`` is treated the same as `box.rank()`.
+///
+/// \relates Box
 template <typename BoxType>
 std::enable_if_t<IsBoxLike<BoxType>,
                  BoxView<dynamic_rank, IsMutableBoxLike<BoxType>>>
diff --git a/tensorstore/cast.h b/tensorstore/cast.h
index 9d00a892..508dd674 100644
--- a/tensorstore/cast.h
+++ b/tensorstore/cast.h
@@ -61,6 +61,7 @@ namespace tensorstore {
 /// \error `absl::StatusCode::kInvalidArgument` if neither reading nor writing
 ///     would be supported by the returned `TensorStore`.
 /// \relates TensorStore
+/// \id TensorStore
 template <typename TargetElementType, int&... ExplicitArgumentBarrier,
           typename ElementType, DimensionIndex Rank, ReadWriteMode Mode>
 Result<TensorStore<
@@ -100,6 +101,7 @@ Cast(TensorStore<ElementType, Rank, Mode> store, DataType target_dtype) {
 /// \error `absl::StatusCode::kInvalidArgument` if the conversion is not
 ///     supported.
 /// \relates Spec
+/// \id Spec
 Result<Spec> Cast(const Spec& base_spec, DataType target_dtype);
 
 }  // namespace tensorstore
diff --git a/tensorstore/data_type.h b/tensorstore/data_type.h
index f8be9fac..7fb63286 100644
--- a/tensorstore/data_type.h
+++ b/tensorstore/data_type.h
@@ -466,6 +466,8 @@ inline constexpr DataTypeConversionFlags operator&(DataTypeConversionFlags a,
 }
 
 /// Specifies an equality comparison method.
+///
+/// \relates DataType
 enum class EqualityComparisonKind {
   /// Compare using regular equality (``operator==``).  For floating point
   /// types, this considers positive and negative zero equal, and NaN unequal to
@@ -476,7 +478,7 @@ enum class EqualityComparisonKind {
   ///
   /// For integer and floating point types, this performs a bitwise comparison.
   ///
-  /// For integer types this is equivalent to `kCompareEqual`.
+  /// For integer types this is equivalent to `equal`.
   identical,
 };
 
@@ -1551,6 +1553,7 @@ constexpr DataType kDataTypes[] = {
 ///
 /// \relates ElementPointer
 template <typename Pointer>
+// NONITPICK: std::pointer_traits<std::remove_cvref_t<Pointer>>::element_type
 using pointee_dtype_t = dtype_t<
     typename std::pointer_traits<absl::remove_cvref_t<Pointer>>::element_type>;
 
diff --git a/tensorstore/index_space/dim_expression.h b/tensorstore/index_space/dim_expression.h
index 7efc0670..04c2c3db 100644
--- a/tensorstore/index_space/dim_expression.h
+++ b/tensorstore/index_space/dim_expression.h
@@ -148,42 +148,44 @@ class DimExpression {
   //     with compatible static ranks, that are compatible with the static
   //     selection rank.
   template <template <typename...> class OpTemplate, typename... IndexVector>
-  using IndexVectorOpExpr = NewExpr<DimExpressionHelper::IndexVectorOp<
+  using IndexVectorOpExprImpl = NewExpr<DimExpressionHelper::IndexVectorOp<
       OpTemplate, static_selection_rank::value, IndexVector...>>;
 
   // Defines the return type for TranslateBy.
   template <typename IndexVector>
-  using TranslateByOpExpr =
-      IndexVectorOpExpr<internal_index_space::TranslateByOp, IndexVector>;
+  using TranslateByOpExprImpl =
+      IndexVectorOpExprImpl<internal_index_space::TranslateByOp, IndexVector>;
 
   // Defines the return type for TranslateBackwardBy.
   template <typename IndexVector>
-  using TranslateBackwardByOpExpr =
-      IndexVectorOpExpr<internal_index_space::TranslateBackwardByOp,
-                        IndexVector>;
+  using TranslateBackwardByOpExprImpl =
+      IndexVectorOpExprImpl<internal_index_space::TranslateBackwardByOp,
+                            IndexVector>;
 
   // Defines the return type for TranslateTo.
   template <typename IndexVector>
-  using TranslateToOpExpr =
-      IndexVectorOpExpr<internal_index_space::TranslateToOp, IndexVector>;
+  using TranslateToOpExprImpl =
+      IndexVectorOpExprImpl<internal_index_space::TranslateToOp, IndexVector>;
 
   // Defines the return type for Stride.
   template <typename IndexVector>
-  using StrideOpExpr =
-      IndexVectorOpExpr<internal_index_space::StrideOp, IndexVector>;
+  using StrideOpExprImpl =
+      IndexVectorOpExprImpl<internal_index_space::StrideOp, IndexVector>;
 
   // Defines the return type for IndexSlice with an index vector.
   template <typename IndexVector>
-  using SingleIndexSliceOpExpr =
-      IndexVectorOpExpr<internal_index_space::SingleIndexSliceOp, IndexVector>;
+  using SingleIndexSliceOpExprImpl =
+      IndexVectorOpExprImpl<internal_index_space::SingleIndexSliceOp,
+                            IndexVector>;
 
   // Defines the return type for the *Interval member functions.
   template <typename... IndexVector>
-  using IntervalSliceOpExpr =
-      IndexVectorOpExpr<internal_index_space::IntervalSliceOp, IndexVector...>;
+  using IntervalSliceOpExprImpl =
+      IndexVectorOpExprImpl<internal_index_space::IntervalSliceOp,
+                            IndexVector...>;
 
   template <typename BoxType>
-  using BoxSliceOpExpr = NewExpr<std::enable_if_t<
+  using BoxSliceOpExprImpl = NewExpr<std::enable_if_t<
       (IsBoxLike<BoxType> &&
        RankConstraint::EqualOrUnspecified(static_selection_rank::value,
                                           BoxType::static_rank)),
@@ -192,7 +194,7 @@ class DimExpression {
   // Defines the return type for IndexArraySlice with a parameter pack of index
   // arrays.
   template <typename... IndexArray>
-  using IndexArraySliceOpExpr = std::enable_if_t<
+  using IndexArraySliceOpExprImpl = std::enable_if_t<
       (sizeof...(IndexArray) >= 1) &&
           RankConstraint::EqualOrUnspecified(sizeof...(IndexArray),
                                              static_selection_rank::value) &&
@@ -204,7 +206,7 @@ class DimExpression {
           std::array<SharedArrayView<const Index>, sizeof...(IndexArray)>>>>;
 
   // Defines the return type for IndexArraySlice with a span of index arrays.
-  using DynamicIndexArraySliceOpExpr =
+  using DynamicIndexArraySliceOpExprImpl =
       NewExpr<internal_index_space::IndexArraySliceOp<
           /*OuterIndexing=*/false, dynamic_rank,
           span<const SharedArrayView<const Index>>>>;
@@ -212,7 +214,7 @@ class DimExpression {
   // Defines the return type for OuterIndexArraySlice with a parameter pack of
   // index arrays.
   template <typename... IndexArray>
-  using IndexArrayOuterSliceOpExpr = std::enable_if_t<
+  using IndexArrayOuterSliceOpExprImpl = std::enable_if_t<
       RankConstraint::EqualOrUnspecified(sizeof...(IndexArray),
                                          static_selection_rank::value) &&
           (IsIndexArray<IndexArray> && ...),
@@ -223,7 +225,7 @@ class DimExpression {
 
   // Defines the return type for OuterIndexArraySlice with a span of index
   // arrays.
-  using DynamicIndexArrayOuterSliceOpExpr =
+  using DynamicIndexArrayOuterSliceOpExprImpl =
       NewExpr<internal_index_space::IndexArraySliceOp<
           /*OuterIndexing=*/true, dynamic_rank,
           span<const SharedArrayView<const Index>>>>;
@@ -231,7 +233,7 @@ class DimExpression {
   // Defines the return type for Label using the specified `Labels` container
   // with the specified static `Rank`.
   template <typename Labels, DimensionIndex Rank>
-  using LabelOpExpr =
+  using LabelOpExprImpl =
       std::enable_if_t<RankConstraint::EqualOrUnspecified(
                            Rank, static_selection_rank::value),
                        NewExpr<internal_index_space::LabelOp<Labels>>>;
@@ -240,46 +242,46 @@ class DimExpression {
   // converted to a `span`.
   template <typename Labels,
             typename LabelsSpan = internal::ConstSpanType<Labels>>
-  using LabelSpanOpExpr =
+  using LabelSpanOpExprImpl =
       std::enable_if_t<internal::IsStringLike<typename LabelsSpan::value_type>,
-                       LabelOpExpr<LabelsSpan, LabelsSpan::extent>>;
+                       LabelOpExprImpl<LabelsSpan, LabelsSpan::extent>>;
 
   // Defines the return type for Label, where the labels are specified as an
   // argument pack.
   template <typename... Label>
-  using LabelPackOpExpr = std::enable_if_t<
+  using LabelPackOpExprImpl = std::enable_if_t<
       internal::IsPackConvertibleWithoutNarrowing<std::string_view, Label...>,
-      LabelOpExpr<std::array<std::string_view, sizeof...(Label)>,
-                  sizeof...(Label)>>;
+      LabelOpExprImpl<std::array<std::string_view, sizeof...(Label)>,
+                      sizeof...(Label)>>;
 
   // Defines the return type for MoveTo, MoveToFront, and MoveToBack.
-  using MoveToOpExpr = NewExpr<internal_index_space::MoveToOp>;
+  using MoveToOpExprImpl = NewExpr<internal_index_space::MoveToOp>;
 
   // Defines the return type for Diagonal.
-  using DiagonalOpExpr = NewExpr<internal_index_space::DiagonalOp>;
+  using DiagonalOpExprImpl = NewExpr<internal_index_space::DiagonalOp>;
 
   // Defines the return type for AddNew.
-  using AddNewOpExpr = NewExpr<internal_index_space::AddNewDimsOp>;
+  using AddNewOpExprImpl = NewExpr<internal_index_space::AddNewDimsOp>;
 
   // Defines the return type for `Transpose()`.
-  using TransposeOpExpr = NewExpr<internal_index_space::TransposeOp>;
+  using TransposeOpExprImpl = NewExpr<internal_index_space::TransposeOp>;
 
   // Defines the return type for `Transpose(target_dimensions)`.
   template <typename TargetDims,
             typename TargetDimsSpan = internal::ConstSpanType<TargetDims>>
-  using TransposeToOpExpr = std::enable_if_t<
+  using TransposeToOpExprImpl = std::enable_if_t<
       (RankConstraint::EqualOrUnspecified(TargetDimsSpan::extent,
                                           static_selection_rank::value) &&
        std::is_same_v<typename TargetDimsSpan::value_type, DimensionIndex>),
       NewExpr<internal_index_space::TransposeToOp<TargetDimsSpan>>>;
 
   // Defines the return type for {Unsafe,}MarkBounds{Explicit,Implicit}.
-  using ChangeImplicitStateOpExpr =
+  using ChangeImplicitStateOpExprImpl =
       NewExpr<internal_index_space::ChangeImplicitStateOp>;
 
   // Defines the return type for IndexVectorArraySlice.
   template <typename IndexVectorArray>
-  using IndexVectorArraySliceOpExpr =
+  using IndexVectorArraySliceOpExprImpl =
       std::enable_if_t<IsIndexArray<IndexVectorArray> &&
                            RankConstraint::GreaterOrUnspecified(
                                IndexVectorArray::static_rank, 0),
@@ -350,13 +352,13 @@ class DimExpression {
   /// \error `absl::StatusCode::kInvalidArgument` if a shifted interval is
   ///     outside the valid range.
   template <typename Offsets>
-  TranslateByOpExpr<Offsets> TranslateBy(const Offsets& offsets) const {
+  TranslateByOpExprImpl<Offsets> TranslateBy(const Offsets& offsets) const {
     return {{offsets}, *this};
   }
 
   // Overload that permits the offset vector to be specified as a braced list.
   template <DimensionIndex Rank>
-  TranslateByOpExpr<const Index (&)[Rank]> TranslateBy(
+  TranslateByOpExprImpl<const Index (&)[Rank]> TranslateBy(
       const Index (&offsets)[Rank]) const {
     return {{span(offsets)}, *this};
   }
@@ -425,14 +427,14 @@ class DimExpression {
   /// \error `absl::StatusCode::kInvalidArgument` if a shifted interval is
   ///     outside the valid range.
   template <typename Offsets>
-  TranslateBackwardByOpExpr<Offsets> TranslateBackwardBy(
+  TranslateBackwardByOpExprImpl<Offsets> TranslateBackwardBy(
       const Offsets& offsets) const {
     return {{offsets}, *this};
   }
 
   // Overload that permits the offset vector to be specified as a braced list.
   template <DimensionIndex Rank>
-  TranslateBackwardByOpExpr<const Index (&)[Rank]> TranslateBackwardBy(
+  TranslateBackwardByOpExprImpl<const Index (&)[Rank]> TranslateBackwardBy(
       const Index (&offsets)[Rank]) const {
     return {{span(offsets)}, *this};
   }
@@ -501,13 +503,13 @@ class DimExpression {
   /// \error `absl::StatusCode::kInvalidArgument` if a shifted interval is
   ///     outside the valid range.
   template <typename Origins>
-  TranslateToOpExpr<Origins> TranslateTo(const Origins& origins) const {
+  TranslateToOpExprImpl<Origins> TranslateTo(const Origins& origins) const {
     return {{origins}, *this};
   }
 
   // Overload that permits the origin vector to be specified as a braced list.
   template <DimensionIndex Rank>
-  TranslateToOpExpr<const Index (&)[Rank]> TranslateTo(
+  TranslateToOpExprImpl<const Index (&)[Rank]> TranslateTo(
       const Index (&origins)[Rank]) const {
     return {{span(origins)}, *this};
   }
@@ -567,13 +569,13 @@ class DimExpression {
   /// \error `absl::StatusCode::kInvalidArgument` if integer overflow occurs
   ///     when computing the resultant transform.
   template <typename Indices>
-  SingleIndexSliceOpExpr<Indices> IndexSlice(const Indices& indices) const {
+  SingleIndexSliceOpExprImpl<Indices> IndexSlice(const Indices& indices) const {
     return {{indices}, *this};
   }
 
   // Overload that permits the indices vector to be specified as a braced list.
   template <DimensionIndex Rank>
-  SingleIndexSliceOpExpr<const Index (&)[Rank]> IndexSlice(
+  SingleIndexSliceOpExprImpl<const Index (&)[Rank]> IndexSlice(
       const Index (&indices)[Rank]) const {
     return {{span(indices)}, *this};
   }
@@ -614,7 +616,7 @@ class DimExpression {
   ///     the static rank of the dimension selection.
   /// \param box The box to extract.
   template <typename BoxType>
-  BoxSliceOpExpr<BoxType> BoxSlice(const BoxType& box) const {
+  BoxSliceOpExprImpl<BoxType> BoxSlice(const BoxType& box) const {
     return {{box, false}, *this};
   }
 
@@ -655,7 +657,7 @@ class DimExpression {
   ///     the static rank of the dimension selection.
   /// \param box The box to extract.
   template <typename BoxType>
-  BoxSliceOpExpr<BoxType> TranslateBoxSlice(const BoxType& box) const {
+  BoxSliceOpExprImpl<BoxType> TranslateBoxSlice(const BoxType& box) const {
     return {{box, true}, *this};
   }
 
@@ -764,14 +766,14 @@ class DimExpression {
   /// \error `absl::StatusCode::kInvalidArgument` if integer overflow occurs
   ///     when computing the resultant transform.
   template <typename Start, typename Stop, typename Strides = Index>
-  IntervalSliceOpExpr<Start, Stop, Strides> ClosedInterval(
+  IntervalSliceOpExprImpl<Start, Stop, Strides> ClosedInterval(
       const Start& start, const Stop& stop, const Strides& strides = 1) const {
     return {{IntervalForm::closed, false, start, stop, strides}, *this};
   }
 
   // Overload that permits arguments to be specified as braced lists.
   template <typename Stop, typename Strides = Index, DimensionIndex Rank>
-  IntervalSliceOpExpr<const Index (&)[Rank], Stop, Strides> ClosedInterval(
+  IntervalSliceOpExprImpl<const Index (&)[Rank], Stop, Strides> ClosedInterval(
       const Index (&start)[Rank], const Stop& stop,
       const Strides& strides = 1) const {
     return {{IntervalForm::closed, false, start, stop, strides}, *this};
@@ -779,7 +781,7 @@ class DimExpression {
 
   // Overload that permits arguments to be specified as braced lists.
   template <typename Start, typename Strides = Index, DimensionIndex Rank>
-  IntervalSliceOpExpr<Start, const Index (&)[Rank], Strides> ClosedInterval(
+  IntervalSliceOpExprImpl<Start, const Index (&)[Rank], Strides> ClosedInterval(
       const Start& start, const Index (&stop)[Rank],
       const Strides& strides = 1) const {
     return {{IntervalForm::closed, false, start, stop, strides}, *this};
@@ -787,7 +789,7 @@ class DimExpression {
 
   // Overload that permits arguments to be specified as braced lists.
   template <typename Strides = Index, DimensionIndex Rank>
-  IntervalSliceOpExpr<const Index (&)[Rank], const Index (&)[Rank], Strides>
+  IntervalSliceOpExprImpl<const Index (&)[Rank], const Index (&)[Rank], Strides>
   ClosedInterval(const Index (&start)[Rank], const Index (&stop)[Rank],
                  const Strides& strides = 1) const {
     return {{IntervalForm::closed, false, start, stop, strides}, *this};
@@ -795,7 +797,7 @@ class DimExpression {
 
   // Overload that permits arguments to be specified as braced lists.
   template <typename Start, typename Stop, DimensionIndex Rank>
-  IntervalSliceOpExpr<Start, Stop, const Index (&)[Rank]> ClosedInterval(
+  IntervalSliceOpExprImpl<Start, Stop, const Index (&)[Rank]> ClosedInterval(
       const Start& start, const Stop& stop,
       const Index (&strides)[Rank]) const {
     return {{IntervalForm::closed, false, start, stop, strides}, *this};
@@ -803,7 +805,7 @@ class DimExpression {
 
   // Overload that permits arguments to be specified as braced lists.
   template <typename Stop, DimensionIndex Rank>
-  IntervalSliceOpExpr<const Index (&)[Rank], Stop, const Index (&)[Rank]>
+  IntervalSliceOpExprImpl<const Index (&)[Rank], Stop, const Index (&)[Rank]>
   ClosedInterval(const Index (&start)[Rank], const Stop& stop,
                  const Index (&strides)[Rank]) const {
     return {{IntervalForm::closed, false, start, stop, strides}, *this};
@@ -811,7 +813,7 @@ class DimExpression {
 
   // Overload that permits arguments to be specified as braced lists.
   template <typename Start, DimensionIndex Rank>
-  IntervalSliceOpExpr<Start, const Index (&)[Rank], const Index (&)[Rank]>
+  IntervalSliceOpExprImpl<Start, const Index (&)[Rank], const Index (&)[Rank]>
   ClosedInterval(const Start& start, const Index (&stop)[Rank],
                  const Index (&strides)[Rank]) const {
     return {{IntervalForm::closed, false, start, stop, strides}, *this};
@@ -819,8 +821,8 @@ class DimExpression {
 
   // Overload that permits arguments to be specified as braced lists.
   template <DimensionIndex Rank>
-  IntervalSliceOpExpr<const Index (&)[Rank], const Index (&)[Rank],
-                      const Index (&)[Rank]>
+  IntervalSliceOpExprImpl<const Index (&)[Rank], const Index (&)[Rank],
+                          const Index (&)[Rank]>
   ClosedInterval(const Index (&start)[Rank], const Index (&stop)[Rank],
                  const Index (&strides)[Rank]) const {
     return {{IntervalForm::closed, false, start, stop, strides}, *this};
@@ -896,30 +898,30 @@ class DimExpression {
   /// \error `absl::StatusCode::kInvalidArgument` if integer overflow occurs
   ///     when computing the resultant transform.
   template <typename Start, typename Stop, typename Strides = Index>
-  IntervalSliceOpExpr<Start, Stop, Strides> HalfOpenInterval(
+  IntervalSliceOpExprImpl<Start, Stop, Strides> HalfOpenInterval(
       const Start& start, const Stop& stop, const Strides& strides = 1) const {
     return {{IntervalForm::half_open, false, start, stop, strides}, *this};
   }
 
   // Overload that permits arguments to be specified as braced lists.
   template <typename Stop, typename Strides = Index, DimensionIndex Rank>
-  IntervalSliceOpExpr<const Index (&)[Rank], Stop, Strides> HalfOpenInterval(
-      const Index (&start)[Rank], const Stop& stop,
-      const Strides& strides = 1) const {
+  IntervalSliceOpExprImpl<const Index (&)[Rank], Stop, Strides>
+  HalfOpenInterval(const Index (&start)[Rank], const Stop& stop,
+                   const Strides& strides = 1) const {
     return {{IntervalForm::half_open, false, start, stop, strides}, *this};
   }
 
   // Overload that permits arguments to be specified as braced lists.
   template <typename Start, typename Strides = Index, DimensionIndex Rank>
-  IntervalSliceOpExpr<Start, const Index (&)[Rank], Strides> HalfOpenInterval(
-      const Start& start, const Index (&stop)[Rank],
-      const Strides& strides = 1) const {
+  IntervalSliceOpExprImpl<Start, const Index (&)[Rank], Strides>
+  HalfOpenInterval(const Start& start, const Index (&stop)[Rank],
+                   const Strides& strides = 1) const {
     return {{IntervalForm::half_open, false, start, stop, strides}, *this};
   }
 
   // Overload that permits arguments to be specified as braced lists.
   template <typename Strides = Index, DimensionIndex Rank>
-  IntervalSliceOpExpr<const Index (&)[Rank], const Index (&)[Rank], Strides>
+  IntervalSliceOpExprImpl<const Index (&)[Rank], const Index (&)[Rank], Strides>
   HalfOpenInterval(const Index (&start)[Rank], const Index (&stop)[Rank],
                    const Strides& strides = 1) const {
     return {{IntervalForm::half_open, false, start, stop, strides}, *this};
@@ -927,7 +929,7 @@ class DimExpression {
 
   // Overload that permits arguments to be specified as braced lists.
   template <typename Start, typename Stop, DimensionIndex Rank>
-  IntervalSliceOpExpr<Start, Stop, const Index (&)[Rank]> HalfOpenInterval(
+  IntervalSliceOpExprImpl<Start, Stop, const Index (&)[Rank]> HalfOpenInterval(
       const Start& start, const Stop& stop,
       const Index (&strides)[Rank]) const {
     return {{IntervalForm::half_open, false, start, stop, strides}, *this};
@@ -935,7 +937,7 @@ class DimExpression {
 
   // Overload that permits arguments to be specified as braced lists.
   template <typename Stop, DimensionIndex Rank>
-  IntervalSliceOpExpr<const Index (&)[Rank], Stop, const Index (&)[Rank]>
+  IntervalSliceOpExprImpl<const Index (&)[Rank], Stop, const Index (&)[Rank]>
   HalfOpenInterval(const Index (&start)[Rank], const Stop& stop,
                    const Index (&strides)[Rank]) const {
     return {{IntervalForm::half_open, false, start, stop, strides}, *this};
@@ -943,7 +945,7 @@ class DimExpression {
 
   // Overload that permits arguments to be specified as braced lists.
   template <typename Start, DimensionIndex Rank>
-  IntervalSliceOpExpr<Start, const Index (&)[Rank], const Index (&)[Rank]>
+  IntervalSliceOpExprImpl<Start, const Index (&)[Rank], const Index (&)[Rank]>
   HalfOpenInterval(const Start& start, const Index (&stop)[Rank],
                    const Index (&strides)[Rank]) const {
     return {{IntervalForm::half_open, false, start, stop, strides}, *this};
@@ -951,8 +953,8 @@ class DimExpression {
 
   // Overload that permits arguments to be specified as braced lists.
   template <DimensionIndex Rank>
-  IntervalSliceOpExpr<const Index (&)[Rank], const Index (&)[Rank],
-                      const Index (&)[Rank]>
+  IntervalSliceOpExprImpl<const Index (&)[Rank], const Index (&)[Rank],
+                          const Index (&)[Rank]>
   HalfOpenInterval(const Index (&start)[Rank], const Index (&stop)[Rank],
                    const Index (&strides)[Rank]) const {
     return {{IntervalForm::half_open, false, start, stop, strides}, *this};
@@ -1028,14 +1030,14 @@ class DimExpression {
   /// \error `absl::StatusCode::kInvalidArgument` if integer overflow occurs
   ///     when computing the resultant transform.
   template <typename Start, typename Size, typename Strides = Index>
-  IntervalSliceOpExpr<Start, Size, Strides> SizedInterval(
+  IntervalSliceOpExprImpl<Start, Size, Strides> SizedInterval(
       const Start& start, const Size& size, const Strides& strides = 1) const {
     return {{IntervalForm::sized, false, start, size, strides}, *this};
   }
 
   // Overload that permits arguments to be specified as braced lists.
   template <typename Size, typename Strides = Index, DimensionIndex Rank>
-  IntervalSliceOpExpr<const Index (&)[Rank], Size, Strides> SizedInterval(
+  IntervalSliceOpExprImpl<const Index (&)[Rank], Size, Strides> SizedInterval(
       const Index (&start)[Rank], const Size& size,
       const Strides& strides = 1) const {
     return {{IntervalForm::sized, false, start, size, strides}, *this};
@@ -1043,7 +1045,7 @@ class DimExpression {
 
   // Overload that permits arguments to be specified as braced lists.
   template <typename Start, typename Strides = Index, DimensionIndex Rank>
-  IntervalSliceOpExpr<Start, const Index (&)[Rank], Strides> SizedInterval(
+  IntervalSliceOpExprImpl<Start, const Index (&)[Rank], Strides> SizedInterval(
       const Start& start, const Index (&size)[Rank],
       const Strides& strides = 1) const {
     return {{IntervalForm::sized, false, start, size, strides}, *this};
@@ -1051,7 +1053,7 @@ class DimExpression {
 
   // Overload that permits arguments to be specified as braced lists.
   template <typename Strides = Index, DimensionIndex Rank>
-  IntervalSliceOpExpr<const Index (&)[Rank], const Index (&)[Rank], Strides>
+  IntervalSliceOpExprImpl<const Index (&)[Rank], const Index (&)[Rank], Strides>
   SizedInterval(const Index (&start)[Rank], const Index (&size)[Rank],
                 const Strides& strides = 1) const {
     return {{IntervalForm::sized, false, start, size, strides}, *this};
@@ -1059,7 +1061,7 @@ class DimExpression {
 
   // Overload that permits arguments to be specified as braced lists.
   template <typename Start, typename Size, DimensionIndex Rank>
-  IntervalSliceOpExpr<Start, Size, const Index (&)[Rank]> SizedInterval(
+  IntervalSliceOpExprImpl<Start, Size, const Index (&)[Rank]> SizedInterval(
       const Start& start, const Size& size,
       const Index (&strides)[Rank]) const {
     return {{IntervalForm::sized, false, start, size, strides}, *this};
@@ -1067,7 +1069,7 @@ class DimExpression {
 
   // Overload that permits arguments to be specified as braced lists.
   template <typename Size, DimensionIndex Rank>
-  IntervalSliceOpExpr<const Index (&)[Rank], Size, const Index (&)[Rank]>
+  IntervalSliceOpExprImpl<const Index (&)[Rank], Size, const Index (&)[Rank]>
   SizedInterval(const Index (&start)[Rank], const Size& size,
                 const Index (&strides)[Rank]) const {
     return {{IntervalForm::sized, false, start, size, strides}, *this};
@@ -1075,7 +1077,7 @@ class DimExpression {
 
   // Overload that permits arguments to be specified as braced lists.
   template <typename Start, DimensionIndex Rank>
-  IntervalSliceOpExpr<Start, const Index (&)[Rank], const Index (&)[Rank]>
+  IntervalSliceOpExprImpl<Start, const Index (&)[Rank], const Index (&)[Rank]>
   SizedInterval(const Start& start, const Index (&size)[Rank],
                 const Index (&strides)[Rank]) const {
     return {{IntervalForm::sized, false, start, size, strides}, *this};
@@ -1083,8 +1085,8 @@ class DimExpression {
 
   // Overload that permits arguments to be specified as braced lists.
   template <DimensionIndex Rank>
-  IntervalSliceOpExpr<const Index (&)[Rank], const Index (&)[Rank],
-                      const Index (&)[Rank]>
+  IntervalSliceOpExprImpl<const Index (&)[Rank], const Index (&)[Rank],
+                          const Index (&)[Rank]>
   SizedInterval(const Index (&start)[Rank], const Index (&size)[Rank],
                 const Index (&strides)[Rank]) const {
     return {{IntervalForm::sized, false, start, size, strides}, *this};
@@ -1092,14 +1094,14 @@ class DimExpression {
 
   /// Equivalent to `ClosedInterval(start, stop, strides).TranslateTo(0)`.
   template <typename Start, typename Stop, typename Strides = Index>
-  IntervalSliceOpExpr<Start, Stop, Strides> TranslateClosedInterval(
+  IntervalSliceOpExprImpl<Start, Stop, Strides> TranslateClosedInterval(
       const Start& start, const Stop& stop, const Strides& strides = 1) const {
     return {{IntervalForm::closed, true, start, stop, strides}, *this};
   }
 
   // Overload that permits arguments to be specified as braced lists.
   template <typename Stop, typename Strides = Index, DimensionIndex Rank>
-  IntervalSliceOpExpr<const Index (&)[Rank], Stop, Strides>
+  IntervalSliceOpExprImpl<const Index (&)[Rank], Stop, Strides>
   TranslateClosedInterval(const Index (&start)[Rank], const Stop& stop,
                           const Strides& strides = 1) const {
     return {{IntervalForm::closed, true, start, stop, strides}, *this};
@@ -1107,7 +1109,7 @@ class DimExpression {
 
   // Overload that permits arguments to be specified as braced lists.
   template <typename Start, typename Strides = Index, DimensionIndex Rank>
-  IntervalSliceOpExpr<Start, const Index (&)[Rank], Strides>
+  IntervalSliceOpExprImpl<Start, const Index (&)[Rank], Strides>
   TranslateClosedInterval(const Start& start, const Index (&stop)[Rank],
                           const Strides& strides = 1) const {
     return {{IntervalForm::closed, true, start, stop, strides}, *this};
@@ -1115,7 +1117,7 @@ class DimExpression {
 
   // Overload that permits arguments to be specified as braced lists.
   template <typename Strides = Index, DimensionIndex Rank>
-  IntervalSliceOpExpr<const Index (&)[Rank], const Index (&)[Rank], Strides>
+  IntervalSliceOpExprImpl<const Index (&)[Rank], const Index (&)[Rank], Strides>
   TranslateClosedInterval(const Index (&start)[Rank], const Index (&stop)[Rank],
                           const Strides& strides = 1) const {
     return {{IntervalForm::closed, true, start, stop, strides}, *this};
@@ -1123,7 +1125,7 @@ class DimExpression {
 
   // Overload that permits arguments to be specified as braced lists.
   template <typename Start, typename Stop, DimensionIndex Rank>
-  IntervalSliceOpExpr<Start, Stop, const Index (&)[Rank]>
+  IntervalSliceOpExprImpl<Start, Stop, const Index (&)[Rank]>
   TranslateClosedInterval(const Start& start, const Stop& stop,
                           const Index (&strides)[Rank]) const {
     return {{IntervalForm::closed, true, start, stop, strides}, *this};
@@ -1131,7 +1133,7 @@ class DimExpression {
 
   // Overload that permits arguments to be specified as braced lists.
   template <typename Stop, DimensionIndex Rank>
-  IntervalSliceOpExpr<const Index (&)[Rank], Stop, const Index (&)[Rank]>
+  IntervalSliceOpExprImpl<const Index (&)[Rank], Stop, const Index (&)[Rank]>
   TranslateClosedInterval(const Index (&start)[Rank], const Stop& stop,
                           const Index (&strides)[Rank]) const {
     return {{IntervalForm::closed, true, start, stop, strides}, *this};
@@ -1139,7 +1141,7 @@ class DimExpression {
 
   // Overload that permits arguments to be specified as braced lists.
   template <typename Start, DimensionIndex Rank>
-  IntervalSliceOpExpr<Start, const Index (&)[Rank], const Index (&)[Rank]>
+  IntervalSliceOpExprImpl<Start, const Index (&)[Rank], const Index (&)[Rank]>
   TranslateClosedInterval(const Start& start, const Index (&stop)[Rank],
                           const Index (&strides)[Rank]) const {
     return {{IntervalForm::closed, true, start, stop, strides}, *this};
@@ -1147,8 +1149,8 @@ class DimExpression {
 
   // Overload that permits arguments to be specified as braced lists.
   template <DimensionIndex Rank>
-  IntervalSliceOpExpr<const Index (&)[Rank], const Index (&)[Rank],
-                      const Index (&)[Rank]>
+  IntervalSliceOpExprImpl<const Index (&)[Rank], const Index (&)[Rank],
+                          const Index (&)[Rank]>
   TranslateClosedInterval(const Index (&start)[Rank], const Index (&stop)[Rank],
                           const Index (&strides)[Rank]) const {
     return {{IntervalForm::closed, true, start, stop, strides}, *this};
@@ -1156,14 +1158,14 @@ class DimExpression {
 
   /// Equivalent to `HalfOpenInterval(start, stop, strides).TranslateTo(0)`.
   template <typename Start, typename Stop, typename Strides = Index>
-  IntervalSliceOpExpr<Start, Stop, Strides> TranslateHalfOpenInterval(
+  IntervalSliceOpExprImpl<Start, Stop, Strides> TranslateHalfOpenInterval(
       const Start& start, const Stop& stop, const Strides& strides = 1) const {
     return {{IntervalForm::half_open, true, start, stop, strides}, *this};
   }
 
   // Overload that permits arguments to be specified as braced lists.
   template <typename Stop, typename Strides = Index, DimensionIndex Rank>
-  IntervalSliceOpExpr<const Index (&)[Rank], Stop, Strides>
+  IntervalSliceOpExprImpl<const Index (&)[Rank], Stop, Strides>
   TranslateHalfOpenInterval(const Index (&start)[Rank], const Stop& stop,
                             const Strides& strides = 1) const {
     return {{IntervalForm::half_open, true, start, stop, strides}, *this};
@@ -1171,7 +1173,7 @@ class DimExpression {
 
   // Overload that permits arguments to be specified as braced lists.
   template <typename Start, typename Strides = Index, DimensionIndex Rank>
-  IntervalSliceOpExpr<Start, const Index (&)[Rank], Strides>
+  IntervalSliceOpExprImpl<Start, const Index (&)[Rank], Strides>
   TranslateHalfOpenInterval(const Start& start, const Index (&stop)[Rank],
                             const Strides& strides = 1) const {
     return {{IntervalForm::half_open, true, start, stop, strides}, *this};
@@ -1179,7 +1181,7 @@ class DimExpression {
 
   // Overload that permits arguments to be specified as braced lists.
   template <typename Strides = Index, DimensionIndex Rank>
-  IntervalSliceOpExpr<const Index (&)[Rank], const Index (&)[Rank], Strides>
+  IntervalSliceOpExprImpl<const Index (&)[Rank], const Index (&)[Rank], Strides>
   TranslateHalfOpenInterval(const Index (&start)[Rank],
                             const Index (&stop)[Rank],
                             const Strides& strides = 1) const {
@@ -1188,7 +1190,7 @@ class DimExpression {
 
   // Overload that permits arguments to be specified as braced lists.
   template <typename Start, typename Stop, DimensionIndex Rank>
-  IntervalSliceOpExpr<Start, Stop, const Index (&)[Rank]>
+  IntervalSliceOpExprImpl<Start, Stop, const Index (&)[Rank]>
   TranslateHalfOpenInterval(const Start& start, const Stop& stop,
                             const Index (&strides)[Rank]) const {
     return {{IntervalForm::half_open, true, start, stop, strides}, *this};
@@ -1196,7 +1198,7 @@ class DimExpression {
 
   // Overload that permits arguments to be specified as braced lists.
   template <typename Stop, DimensionIndex Rank>
-  IntervalSliceOpExpr<const Index (&)[Rank], Stop, const Index (&)[Rank]>
+  IntervalSliceOpExprImpl<const Index (&)[Rank], Stop, const Index (&)[Rank]>
   TranslateHalfOpenInterval(const Index (&start)[Rank], const Stop& stop,
                             const Index (&strides)[Rank]) const {
     return {{IntervalForm::half_open, true, start, stop, strides}, *this};
@@ -1204,7 +1206,7 @@ class DimExpression {
 
   // Overload that permits arguments to be specified as braced lists.
   template <typename Start, DimensionIndex Rank>
-  IntervalSliceOpExpr<Start, const Index (&)[Rank], const Index (&)[Rank]>
+  IntervalSliceOpExprImpl<Start, const Index (&)[Rank], const Index (&)[Rank]>
   TranslateHalfOpenInterval(const Start& start, const Index (&stop)[Rank],
                             const Index (&strides)[Rank]) const {
     return {{IntervalForm::half_open, true, start, stop, strides}, *this};
@@ -1212,8 +1214,8 @@ class DimExpression {
 
   // Overload that permits arguments to be specified as braced lists.
   template <DimensionIndex Rank>
-  IntervalSliceOpExpr<const Index (&)[Rank], const Index (&)[Rank],
-                      const Index (&)[Rank]>
+  IntervalSliceOpExprImpl<const Index (&)[Rank], const Index (&)[Rank],
+                          const Index (&)[Rank]>
   TranslateHalfOpenInterval(const Index (&start)[Rank],
                             const Index (&stop)[Rank],
                             const Index (&strides)[Rank]) const {
@@ -1222,14 +1224,14 @@ class DimExpression {
 
   /// Equivalent to `SizedInterval(start, size, strides).TranslateTo(0)`.
   template <typename Start, typename Size, typename Strides = Index>
-  IntervalSliceOpExpr<Start, Size, Strides> TranslateSizedInterval(
+  IntervalSliceOpExprImpl<Start, Size, Strides> TranslateSizedInterval(
       const Start& start, const Size& size, const Strides& strides = 1) const {
     return {{IntervalForm::sized, true, start, size, strides}, *this};
   }
 
   // Overload that permits arguments to be specified as braced lists.
   template <typename Size, typename Strides = Index, DimensionIndex Rank>
-  IntervalSliceOpExpr<const Index (&)[Rank], Size, Strides>
+  IntervalSliceOpExprImpl<const Index (&)[Rank], Size, Strides>
   TranslateSizedInterval(const Index (&start)[Rank], const Size& size,
                          const Strides& strides = 1) const {
     return {{IntervalForm::sized, true, start, size, strides}, *this};
@@ -1237,7 +1239,7 @@ class DimExpression {
 
   // Overload that permits arguments to be specified as braced lists.
   template <typename Start, typename Strides = Index, DimensionIndex Rank>
-  IntervalSliceOpExpr<Start, const Index (&)[Rank], Strides>
+  IntervalSliceOpExprImpl<Start, const Index (&)[Rank], Strides>
   TranslateSizedInterval(const Start& start, const Index (&size)[Rank],
                          const Strides& strides = 1) const {
     return {{IntervalForm::sized, true, start, size, strides}, *this};
@@ -1245,7 +1247,7 @@ class DimExpression {
 
   // Overload that permits arguments to be specified as braced lists.
   template <typename Strides = Index, DimensionIndex Rank>
-  IntervalSliceOpExpr<const Index (&)[Rank], const Index (&)[Rank], Strides>
+  IntervalSliceOpExprImpl<const Index (&)[Rank], const Index (&)[Rank], Strides>
   TranslateSizedInterval(const Index (&start)[Rank], const Index (&size)[Rank],
                          const Strides& strides = 1) const {
     return {{IntervalForm::sized, true, start, size, strides}, *this};
@@ -1253,7 +1255,7 @@ class DimExpression {
 
   // Overload that permits arguments to be specified as braced lists.
   template <typename Start, typename Size, DimensionIndex Rank>
-  IntervalSliceOpExpr<Start, Size, const Index (&)[Rank]>
+  IntervalSliceOpExprImpl<Start, Size, const Index (&)[Rank]>
   TranslateSizedInterval(const Start& start, const Size& size,
                          const Index (&strides)[Rank]) const {
     return {{IntervalForm::sized, true, start, size, strides}, *this};
@@ -1261,7 +1263,7 @@ class DimExpression {
 
   // Overload that permits arguments to be specified as braced lists.
   template <typename Size, DimensionIndex Rank>
-  IntervalSliceOpExpr<const Index (&)[Rank], Size, const Index (&)[Rank]>
+  IntervalSliceOpExprImpl<const Index (&)[Rank], Size, const Index (&)[Rank]>
   TranslateSizedInterval(const Index (&start)[Rank], const Size& size,
                          const Index (&strides)[Rank]) const {
     return {{IntervalForm::sized, true, start, size, strides}, *this};
@@ -1269,7 +1271,7 @@ class DimExpression {
 
   // Overload that permits arguments to be specified as braced lists.
   template <typename Start, DimensionIndex Rank>
-  IntervalSliceOpExpr<Start, const Index (&)[Rank], const Index (&)[Rank]>
+  IntervalSliceOpExprImpl<Start, const Index (&)[Rank], const Index (&)[Rank]>
   TranslateSizedInterval(const Start& start, const Index (&size)[Rank],
                          const Index (&strides)[Rank]) const {
     return {{IntervalForm::sized, true, start, size, strides}, *this};
@@ -1277,8 +1279,8 @@ class DimExpression {
 
   // Overload that permits arguments to be specified as braced lists.
   template <DimensionIndex Rank>
-  IntervalSliceOpExpr<const Index (&)[Rank], const Index (&)[Rank],
-                      const Index (&)[Rank]>
+  IntervalSliceOpExprImpl<const Index (&)[Rank], const Index (&)[Rank],
+                          const Index (&)[Rank]>
   TranslateSizedInterval(const Index (&start)[Rank], const Index (&size)[Rank],
                          const Index (&strides)[Rank]) const {
     return {{IntervalForm::sized, true, start, size, strides}, *this};
@@ -1368,11 +1370,11 @@ class DimExpression {
   ///     detected. \error `absl::StatusCode::kInvalidArgument` if integer
   ///     overflow occurs when computing the resultant transform.
   template <typename... IndexArray>
-  IndexArraySliceOpExpr<IndexArray...> IndexArraySlice(
+  IndexArraySliceOpExprImpl<IndexArray...> IndexArraySlice(
       const IndexArray&... index_arrays) const {
     return {{index_arrays...}, *this};
   }
-  DynamicIndexArraySliceOpExpr IndexArraySlice(
+  DynamicIndexArraySliceOpExprImpl IndexArraySlice(
       span<const SharedArrayView<const Index>> index_arrays) const {
     return {{index_arrays}, *this};
   }
@@ -1480,7 +1482,7 @@ class DimExpression {
   /// \error `absl::StatusCode::kInvalidArgument` if integer overflow occurs
   ///     when computing the resultant transform.
   template <typename IndexVectorArray>
-  IndexVectorArraySliceOpExpr<IndexVectorArray> IndexVectorArraySlice(
+  IndexVectorArraySliceOpExprImpl<IndexVectorArray> IndexVectorArraySlice(
       const IndexVectorArray& index_vector_array,
       DimensionIndex vector_dimension = -1) const {
     return {{index_vector_array, vector_dimension}, *this};
@@ -1563,11 +1565,11 @@ class DimExpression {
   ///     detected. \error `absl::StatusCode::kInvalidArgument` if integer
   ///     overflow occurs when computing the resultant transform.
   template <typename... IndexArray>
-  IndexArrayOuterSliceOpExpr<IndexArray...> OuterIndexArraySlice(
+  IndexArrayOuterSliceOpExprImpl<IndexArray...> OuterIndexArraySlice(
       const IndexArray&... index_arrays) const {
     return {{index_arrays...}, *this};
   }
-  DynamicIndexArrayOuterSliceOpExpr OuterIndexArraySlice(
+  DynamicIndexArrayOuterSliceOpExprImpl OuterIndexArraySlice(
       span<const SharedArrayView<const Index>> index_arrays) const {
     return {{index_arrays}, *this};
   }
@@ -1605,17 +1607,17 @@ class DimExpression {
   /// \error `absl::StatusCode::kInvalidArgument` if the extent of the `labels`
   ///     vector is equal to the number of selected dimensions.
   template <typename Labels>
-  LabelSpanOpExpr<Labels> Label(const Labels& labels) const {
+  LabelSpanOpExprImpl<Labels> Label(const Labels& labels) const {
     return {{labels}, *this};
   }
   template <typename... L>
-  LabelPackOpExpr<L...> Label(const L&... labels) const {
+  LabelPackOpExprImpl<L...> Label(const L&... labels) const {
     return {{{{labels...}}}, *this};
   }
 
   // Overload that permits the labels to specified as a braced list.
   template <DimensionIndex Rank>
-  LabelOpExpr<span<const std::string_view, Rank>, Rank> Label(
+  LabelOpExprImpl<span<const std::string_view, Rank>, Rank> Label(
       const std::string_view (&labels)[Rank]) const {
     return {{labels}, *this};
   }
@@ -1657,13 +1659,15 @@ class DimExpression {
   ///     index of the last selected dimension.
   /// \error `absl::StatusCode::kInvalidArgument` if `target` is outside the
   ///     valid range.
-  MoveToOpExpr MoveTo(DimensionIndex target) const { return {{target}, *this}; }
+  MoveToOpExprImpl MoveTo(DimensionIndex target) const {
+    return {{target}, *this};
+  }
 
   /// Equivalent to `MoveTo(0)`.
-  MoveToOpExpr MoveToFront() const { return {{0}, *this}; }
+  MoveToOpExprImpl MoveToFront() const { return {{0}, *this}; }
 
   /// Equivalent to `MoveTo(-1)`.
-  MoveToOpExpr MoveToBack() const { return {{-1}, *this}; }
+  MoveToOpExprImpl MoveToBack() const { return {{-1}, *this}; }
 
   /// Extracts the diagonal of the selected dimensions.
   ///
@@ -1710,7 +1714,7 @@ class DimExpression {
   ///     dimension as the first dimension.
   /// \remark `Diagonal()` with a single selected dimension is equivalent to
   ///     `MoveToFront().Label("")`.
-  DiagonalOpExpr Diagonal() const { return {{}, *this}; }
+  DiagonalOpExprImpl Diagonal() const { return {{}, *this}; }
 
   /// Adds new inert input dimensions that have no effect on the output indices.
   ///
@@ -1766,7 +1770,7 @@ class DimExpression {
   ///     `AllDims()` selection.
   template <int&... ExplicitArgumentBarrier,
             bool SfinaeIsFirst = sizeof...(Op) == 1>
-  std::enable_if_t<SfinaeIsFirst, AddNewOpExpr> AddNew() const {
+  std::enable_if_t<SfinaeIsFirst, AddNewOpExprImpl> AddNew() const {
     return {{}, *this};
   }
 
@@ -1809,7 +1813,7 @@ class DimExpression {
   /// \error `absl::StatusCode::kInvalidArgument` if the rank of the dimension
   ///     selection is not equal to the input rank.
   /// \id consecutive
-  TransposeOpExpr Transpose() const { return {{}, *this}; }
+  TransposeOpExprImpl Transpose() const { return {{}, *this}; }
 
   /// Transposes the input dimensions such that the selected dimensions have the
   /// specified indices.  Dimensions not in the selection retain their relative
@@ -1859,7 +1863,7 @@ class DimExpression {
   ///     range.
   /// \id target_dimensions
   template <typename TargetDimensions>
-  TransposeToOpExpr<TargetDimensions> Transpose(
+  TransposeToOpExprImpl<TargetDimensions> Transpose(
       const TargetDimensions& target_dimensions) const {
     return {{span(target_dimensions)}, *this};
   }
@@ -1867,7 +1871,7 @@ class DimExpression {
   // Overload that permits the target dimensions to be specified as a braced
   // list.
   template <DimensionIndex Rank>
-  TransposeToOpExpr<span<const DimensionIndex, Rank>> Transpose(
+  TransposeToOpExprImpl<span<const DimensionIndex, Rank>> Transpose(
       const DimensionIndex (&target_dimensions)[Rank]) const {
     return {{span(target_dimensions)}, *this};
   }
@@ -1897,8 +1901,8 @@ class DimExpression {
   ///
   /// \param lower If `true` (the default), mark the lower bounds as explicit.
   /// \param upper If `true` (the default), mark the upper bounds as explicit.
-  ChangeImplicitStateOpExpr MarkBoundsExplicit(bool lower = true,
-                                               bool upper = true) const {
+  ChangeImplicitStateOpExprImpl MarkBoundsExplicit(bool lower = true,
+                                                   bool upper = true) const {
     return {{/*.implicit=*/false, lower, upper}, *this};
   }
 
@@ -1931,8 +1935,8 @@ class DimExpression {
   ///
   /// \param lower If `true` (the default), mark the lower bounds as implicit.
   /// \param upper If `true` (the default), mark the upper bounds as implicit.
-  ChangeImplicitStateOpExpr UnsafeMarkBoundsImplicit(bool lower = true,
-                                                     bool upper = true) const {
+  ChangeImplicitStateOpExprImpl UnsafeMarkBoundsImplicit(
+      bool lower = true, bool upper = true) const {
     return {{/*.implicit=*/true, lower, upper}, *this};
   }
 
@@ -1989,13 +1993,13 @@ class DimExpression {
   ///     vector is not equal to the number of selected dimensions.
   /// \error `absl::StatusCode::kInvalidArgument` if a stride value is `0`.
   template <typename Strides>
-  StrideOpExpr<Strides> Stride(const Strides& strides) const {
+  StrideOpExprImpl<Strides> Stride(const Strides& strides) const {
     return {{strides}, *this};
   }
 
   // Overload that permits the strides vector to be specified as a braced list.
   template <DimensionIndex Rank>
-  StrideOpExpr<const Index (&)[Rank]> Stride(
+  StrideOpExprImpl<const Index (&)[Rank]> Stride(
       const Index (&strides)[Rank]) const {
     return {{span(strides)}, *this};
   }
@@ -2006,13 +2010,13 @@ class DimExpression {
   // DimExpression to an index transform with the specified `InputRank`,
   // `OutputRank`.
   template <DimensionIndex InputRank, DimensionIndex OutputRank>
-  using NewTransformType =
+  using NewTransformTypeImpl =
       DimExpressionHelper::NewTransformType<InputRank, OutputRank, Op...>;
 
   // Type alias for the new domain type that results from applying this
   // DimExpression to an index domain with the specified `Rank`.
   template <DimensionIndex Rank>
-  using NewDomainType = DimExpressionHelper::NewDomainType<Rank, Op...>;
+  using NewDomainTypeImpl = DimExpressionHelper::NewDomainType<Rank, Op...>;
 
   /// Applies this DimExpression to the specified index transform.
   ///
@@ -2032,14 +2036,14 @@ class DimExpression {
   // https://developercommunity.visualstudio.com/t/constexpr-evaluation-sometimes-seems-to/10307697
   auto
 #else
-  Result<NewTransformType<InputRank, OutputRank>>
+  Result<NewTransformTypeImpl<InputRank, OutputRank>>
 #endif
   operator()(IndexTransform<InputRank, OutputRank, CKind> transform,
              DimensionIndexBuffer* selection_output =
                  &internal::GetLValue(DimensionIndexBuffer())) const {
     // NONITPICK: internal
     // NONITPICK: internal::GetLValue
-    using R = Result<NewTransformType<InputRank, OutputRank>>;
+    using R = Result<NewTransformTypeImpl<InputRank, OutputRank>>;
     TENSORSTORE_ASSIGN_OR_RETURN(
         auto result,
         DimExpressionHelper::Apply(*this, std::move(transform),
@@ -2064,21 +2068,21 @@ class DimExpression {
   // https://developercommunity.visualstudio.com/t/constexpr-evaluation-sometimes-seems-to/10307697
   auto
 #else
-  Result<NewDomainType<Rank>>
+  Result<NewDomainTypeImpl<Rank>>
 #endif
   operator()(IndexDomain<Rank, CKind> domain,
              DimensionIndexBuffer* selection_output =
                  &internal::GetLValue(DimensionIndexBuffer())) const {
     // NONITPICK: internal
     // NONITPICK: internal::GetLValue
-    using R = Result<NewDomainType<Rank>>;
+    using R = Result<NewDomainTypeImpl<Rank>>;
     TENSORSTORE_ASSIGN_OR_RETURN(
         auto result,
         DimExpressionHelper::Apply(*this, Access::transform(std::move(domain)),
                                    selection_output, /*domain_only=*/true),
         R(_));
-    return R(
-        Access::Make<NewDomainType<Rank>>(Access::rep_ptr(std::move(result))));
+    return R(Access::Make<NewDomainTypeImpl<Rank>>(
+        Access::rep_ptr(std::move(result))));
   }
 
   /// Applies this DimExpression to an object with an associated index space
@@ -2096,9 +2100,9 @@ class DimExpression {
 
   template <DimensionIndex InputRank, DimensionIndex OutputRank,
             ContainerKind CKind>
-  friend Result<NewTransformType<InputRank, OutputRank>> ApplyIndexTransform(
-      const DimExpression& expr,
-      IndexTransform<InputRank, OutputRank, CKind> transform) {
+  friend Result<NewTransformTypeImpl<InputRank, OutputRank>>
+  ApplyIndexTransform(const DimExpression& expr,
+                      IndexTransform<InputRank, OutputRank, CKind> transform) {
     return expr(std::move(transform));
   }
 
diff --git a/tensorstore/index_space/dimension_identifier.h b/tensorstore/index_space/dimension_identifier.h
index 7f07afba..d13ee84f 100644
--- a/tensorstore/index_space/dimension_identifier.h
+++ b/tensorstore/index_space/dimension_identifier.h
@@ -262,7 +262,7 @@ absl::Status NormalizeDynamicDimSpec(const DynamicDimSpec& spec,
 
 /// Equivalent to calling ``NormalizeDynamicDimSpec(spec, labels, result)`` for
 /// each ``spec`` in `specs`.
-//
+///
 /// \relates DynamicDimSpec
 absl::Status NormalizeDynamicDimSpecs(span<const DynamicDimSpec> specs,
                                       span<const std::string> labels,
diff --git a/tensorstore/index_space/index_domain.h b/tensorstore/index_space/index_domain.h
index 432b0f7a..a6e7d684 100644
--- a/tensorstore/index_space/index_domain.h
+++ b/tensorstore/index_space/index_domain.h
@@ -309,9 +309,10 @@ class IndexDomain {
   /// If `!valid()`, returns an invalid view.
   ///
   /// \param permutation Permutation of ``0, ..., rank()-1``, where
-  ///     `permutation[i]` specifies the dimension of the existing domain that
-  ///     corresponds to dimension `i` of the new domain.
+  ///     ``permutation[i]`` specifies the dimension of the existing domain that
+  ///     corresponds to dimension ``i`` of the new domain.
   /// \dchecks `permutation` is a valid permutation.
+  /// \id permutation
   IndexDomain<Rank> Transpose(
       span<const DimensionIndex, Rank> permutation) const& {
     return Access::Make<IndexDomain<Rank, container>>(
@@ -479,6 +480,8 @@ class IndexDomain {
   Ptr rep_{};
 };
 
+namespace internal_index_space {
+
 template <typename Shape, typename ShapeSpan = internal::ConstSpanType<Shape>,
           DimensionIndex Rank = ShapeSpan::extent>
 using IdentityTransformFromShapeType =
@@ -491,7 +494,9 @@ using IdentityTransformFromLabelsType = std::enable_if_t<
     internal::IsStringLike<typename LabelsSpan::value_type>,
     IndexTransform<LabelsSpan::extent, LabelsSpan::extent, container>>;
 
-explicit IndexDomain(DimensionIndex)->IndexDomain<>;
+}  // namespace internal_index_space
+
+explicit IndexDomain(DimensionIndex) -> IndexDomain<>;
 
 template <DimensionIndex Rank>
 explicit IndexDomain(std::integral_constant<DimensionIndex, Rank>)
@@ -506,17 +511,19 @@ explicit IndexDomain(const std::string_view (&labels)[Rank])
 
 template <typename Shape>
 explicit IndexDomain(const Shape& shape)
-    -> IndexDomain<IdentityTransformFromShapeType<Shape>::static_input_rank>;
+    -> IndexDomain<internal_index_space::IdentityTransformFromShapeType<
+        Shape>::static_input_rank>;
 
 template <typename Labels>
 explicit IndexDomain(const Labels& labels)
-    -> IndexDomain<IdentityTransformFromLabelsType<Labels>::static_input_rank>;
+    -> IndexDomain<internal_index_space::IdentityTransformFromLabelsType<
+        Labels>::static_input_rank>;
 
 template <typename BoxType>
 explicit IndexDomain(const BoxType& box)
     -> IndexDomain<std::enable_if_t<IsBoxLike<BoxType>, BoxType>::static_rank>;
 
-explicit IndexDomain()->IndexDomain<>;
+explicit IndexDomain() -> IndexDomain<>;
 
 /// Specializes the HasBoxDomain metafunction for IndexTransform.
 ///
diff --git a/tensorstore/index_space/index_transform.h b/tensorstore/index_space/index_transform.h
index 7bb1409d..46d16521 100644
--- a/tensorstore/index_space/index_transform.h
+++ b/tensorstore/index_space/index_transform.h
@@ -399,9 +399,10 @@ class IndexTransform {
   /// If `!valid()`, returns an invalid view.
   ///
   /// \param permutation Permutation of ``0, ..., input_rank()-1``, where
-  ///     `permutation[i]` specifies the dimension of the existing transform
-  ///     that corresponds to input dimension `i` of the new transform.
+  ///     ``permutation[i]`` specifies the dimension of the existing transform
+  ///     that corresponds to input dimension ``i`` of the new transform.
   /// \dchecks `permutation` is a valid permutation.
+  /// \id permutation
   IndexTransform<InputRank, OutputRank> Transpose(
       span<const DimensionIndex, InputRank> permutation) const& {
     return Access::Make<IndexTransform<InputRank, OutputRank, container>>(
@@ -434,9 +435,10 @@ class IndexTransform {
   /// If `!valid()`, returns an invalid view.
   ///
   /// \param permutation Permutation of ``0, ..., output_rank()-1``, where
-  ///     `permutation[i]` specifies the dimension of the existing transform
-  ///     that corresponds to output dimension `i` of the new transform.
+  ///     ``permutation[i]`` specifies the dimension of the existing transform
+  ///     that corresponds to output dimension ``i`` of the new transform.
   /// \dchecks `permutation` is a valid permutation.
+  /// \id permutation
   IndexTransform<InputRank, OutputRank> TransposeOutput(
       span<const DimensionIndex, OutputRank> permutation) const& {
     return Access::Make<IndexTransform<InputRank, OutputRank, container>>(
@@ -679,10 +681,10 @@ inline IndexTransform<Rank, Rank> IdentityTransform(
       internal::StringLikeSpan(span(labels))));
 }
 template <typename Labels>
-inline IdentityTransformFromLabelsType<Labels> IdentityTransform(
-    const Labels& labels) {
+inline internal_index_space::IdentityTransformFromLabelsType<Labels>
+IdentityTransform(const Labels& labels) {
   return internal_index_space::TransformAccess::Make<
-      IdentityTransformFromLabelsType<Labels>>(
+      internal_index_space::IdentityTransformFromLabelsType<Labels>>(
       internal_index_space::MakeIdentityTransform(
           internal::StringLikeSpan(span(labels))));
 }
@@ -745,10 +747,10 @@ IdentityTransformLike(const Array& array) {
 /// \membergroup Identity transform
 /// \id shape
 template <typename Shape>
-inline IdentityTransformFromShapeType<Shape> IdentityTransform(
-    const Shape& shape) {
+inline internal_index_space::IdentityTransformFromShapeType<Shape>
+IdentityTransform(const Shape& shape) {
   return internal_index_space::TransformAccess::Make<
-      IdentityTransformFromShapeType<Shape>>(
+      internal_index_space::IdentityTransformFromShapeType<Shape>>(
       internal_index_space::MakeIdentityTransform(shape));
 }
 template <DimensionIndex Rank>
diff --git a/tensorstore/index_space/index_vector_or_scalar.h b/tensorstore/index_space/index_vector_or_scalar.h
index e00f7393..6f524654 100644
--- a/tensorstore/index_space/index_vector_or_scalar.h
+++ b/tensorstore/index_space/index_vector_or_scalar.h
@@ -48,7 +48,7 @@ namespace tensorstore {
 /// `DimExpression`.
 ///
 /// \relates DimExpression
-template <typename T, typename = std::true_type>
+template <typename T, typename Sfinae = std::true_type>
 struct IsIndexVectorOrScalar {
   /// Indicates whether `T` satisfies the concept.
   static constexpr bool value = false;
diff --git a/tensorstore/index_space/transformed_array.h b/tensorstore/index_space/transformed_array.h
index 8d72d20d..38ca5eec 100644
--- a/tensorstore/index_space/transformed_array.h
+++ b/tensorstore/index_space/transformed_array.h
@@ -101,11 +101,12 @@ template <typename T>
 constexpr inline bool IsTransformedArrayLike =
     IsArray<T> || IsTransformedArray<T>;
 
-/// Bool-valued metafunction that evaluates to `true` if `T` satisfies
-/// `IsTransformedArrayLike` and `IsShared`
+/// Bool-valued metafunction that evaluates to `true` if
+/// `IsTransformedArrayLike<ArrayLike>` and the associated element tag of the
+/// array satisfies `IsShared`.
 ///
 /// \relates TransformedArray
-template <typename ArrayLike, typename = std::true_type>
+template <typename ArrayLike, typename Sfinae = std::true_type>
 constexpr inline bool IsSharedArrayLike = false;
 
 template <typename ArrayLike>
diff --git a/tensorstore/kvstore/generation.h b/tensorstore/kvstore/generation.h
index 14dd0701..5a8dccbf 100644
--- a/tensorstore/kvstore/generation.h
+++ b/tensorstore/kvstore/generation.h
@@ -285,8 +285,9 @@ struct StorageGeneration {
   /// `StorageGeneration::Unknown()` value, i.e. an empty string.
   ///
   /// This usually indicates an unspecified generation; in
-  /// `kvstore::ReadOptions::if_equal` and `kvstore::ReadOptions::if_not_equal`
-  /// conditions, it indicates that the condition does not apply.
+  /// `kvstore::ReadGenerationConditions::if_equal` and
+  /// `kvstore::ReadGenerationConditions::if_not_equal`, it indicates
+  /// that the condition does not apply.
   static bool IsUnknown(const StorageGeneration& generation) {
     return generation.value.empty();
   }
@@ -305,10 +306,12 @@ struct StorageGeneration {
   /// Returns `true` if `generation` is equal to the special `NoValue()`
   /// generation.
   ///
-  /// While all kvstore drivers support `StorageGeneration::NoValue()` in
-  /// `kvstore::ReadOptions::if_equal` and `kvstore::ReadOptions::if_not_equal`
-  /// conditions, some kvstore drivers may return a different generation for
-  /// missing values.
+  /// .. warning::
+  ///
+  ///    While all kvstore drivers support `StorageGeneration::NoValue()` in
+  ///    store::ReadGenerationConditions::if_equal` and
+  ///    `kvstore::ReadGenerationConditions::if_not_equal`, some kvstore drivers
+  ///    may return a different generation for missing values.
   static bool IsNoValue(const StorageGeneration& generation) {
     return generation.value.size() == 1 &&
            generation.value[0] == (kNoValue | kBaseGeneration);
diff --git a/tensorstore/kvstore/operations.h b/tensorstore/kvstore/operations.h
index ee696929..1e9454ec 100644
--- a/tensorstore/kvstore/operations.h
+++ b/tensorstore/kvstore/operations.h
@@ -44,7 +44,7 @@ namespace kvstore {
 
 /// Specifies constraints on the generation for read operations.
 ///
-/// \relates KvStore
+/// \relates Read
 struct ReadGenerationConditions {
   /// The read is aborted if the generation associated with the stored key
   /// matches `if_not_equal`.  The special values of
@@ -98,9 +98,10 @@ struct ReadGenerationConditions {
 
 /// Read options for non-transactional reads.
 ///
-/// See also `TransactionalReadOptions`.
+/// See also:
+///   - `TransactionalReadOptions`.
 ///
-/// \relates KvStore
+/// \relates Read
 struct ReadOptions {
   /// Specifies conditions for the read.
   ReadGenerationConditions generation_conditions;
@@ -120,6 +121,9 @@ struct ReadOptions {
   Batch batch{no_batch};
 };
 
+/// Conditions on the existing generation for transactional read operations.
+///
+/// \relates Read
 struct TransactionalReadGenerationConditions {
   /// The read is aborted if the generation associated with the stored ``key``
   /// matches `if_not_equal`.  The special values of
@@ -130,7 +134,8 @@ struct TransactionalReadGenerationConditions {
 
 /// Read options for transactional reads.
 ///
-/// See also `ReadOptions`
+/// See also:
+///   - `ReadOptions`
 ///
 /// \relates KvStore
 struct TransactionalReadOptions {
@@ -149,6 +154,9 @@ struct TransactionalReadOptions {
   Batch batch{no_batch};
 };
 
+/// Conditions on the existing generation for write operations.
+///
+/// \relates Write
 struct WriteGenerationConditions {
   // Note: While it would be nice to use default member initializers to be
   // more explicit about what the default values are, doing so would trigger
@@ -179,7 +187,7 @@ struct WriteGenerationConditions {
 
 /// Options for `Write`.
 ///
-/// \relates KvStore
+/// \relates Write
 struct WriteOptions {
   /// Specifies conditions for the write.
   WriteGenerationConditions generation_conditions;
@@ -187,7 +195,7 @@ struct WriteOptions {
 
 /// Options for `ListFuture`.
 ///
-/// \relates KvStore
+/// \relates ListFuture
 struct ListOptions {
   /// Only keys in this range are emitted.
   KeyRange range;
@@ -199,7 +207,9 @@ struct ListOptions {
   absl::Time staleness_bound = absl::InfiniteFuture();
 };
 
-/// Return value for List operations
+/// Information for a single key returned from a `ListFuture` operation.
+///
+/// \relates ListFuture
 struct ListEntry {
   Key key;
 
@@ -227,9 +237,9 @@ void PrintTo(const std::vector<ListEntry>& v, ::std::ostream* os);
 using ListReceiver = AnyFlowReceiver<absl::Status, ListEntry>;
 using ListSender = AnyFlowSender<absl::Status, ListEntry>;
 
-/// Options for `CopyRange`.
+/// Options for `ExperimentalCopyRange`.
 ///
-/// \relates KvStore
+/// \relates ExperimentalCopyRange
 struct CopyRangeOptions {
   /// Only keys in this range are copied.
   KeyRange source_range;
diff --git a/tensorstore/kvstore/spec.h b/tensorstore/kvstore/spec.h
index 0cac5c06..5275b400 100644
--- a/tensorstore/kvstore/spec.h
+++ b/tensorstore/kvstore/spec.h
@@ -37,9 +37,16 @@ namespace tensorstore {
 namespace kvstore {
 
 /// Options for mutating `Spec` objects that are handled directly by drivers.
+///
+/// \relates Spec
 struct DriverSpecOptions {
   bool minimal_spec = false;
 
+  /// Indicates which option types are supported.
+  ///
+  /// Supported types include:
+  ///
+  /// - `MinimalSpec`
   template <typename T>
   constexpr static bool IsOption = false;
 
@@ -68,6 +75,7 @@ struct SpecConvertOptions : public DriverSpecOptions {
   ///
   /// Supported types include:
   ///
+  /// - `MinimalSpec`
   /// - `Context`
   /// - `ContextBindingMode`
   template <typename T>
diff --git a/tensorstore/open_mode.h b/tensorstore/open_mode.h
index 9b48e14c..6b3b126a 100644
--- a/tensorstore/open_mode.h
+++ b/tensorstore/open_mode.h
@@ -151,7 +151,7 @@ constexpr inline bool operator!(ReadWriteMode a) {
 }
 
 /// Returns the complement of a mode.
-////
+///
 /// \relates ReadWriteMode
 /// \id ReadWriteMode
 constexpr inline ReadWriteMode operator~(ReadWriteMode a) {
diff --git a/tensorstore/open_options.h b/tensorstore/open_options.h
index 42533d2b..3f3c31c5 100644
--- a/tensorstore/open_options.h
+++ b/tensorstore/open_options.h
@@ -38,7 +38,7 @@ struct SpecOptions : public Schema {
   bool minimal_spec = false;
   kvstore::Spec kvstore;
 
-  /// Excludes `Schema`, `MinimalSpec`, and `kvstore::Spec`.
+  // Excludes `Schema`, `MinimalSpec`, and `kvstore::Spec`.
   template <typename T>
   constexpr static inline bool IsCommonOption = false;
 
diff --git a/tensorstore/read_write_options.h b/tensorstore/read_write_options.h
index 3df3aaaa..5f461e63 100644
--- a/tensorstore/read_write_options.h
+++ b/tensorstore/read_write_options.h
@@ -118,6 +118,8 @@ constexpr inline bool ReadIntoNewArrayOptions::IsOption<Batch::View> = true;
 
 /// Specifies restrictions on how references to the source array/source
 /// TensorStore may be used by write operations.
+///
+/// \relates TensorStore
 enum SourceDataReferenceRestriction {
   /// References to the source data must be released as soon as possible, which
   /// may result in additional copies.
diff --git a/tensorstore/static_cast.h b/tensorstore/static_cast.h
index 8affd62e..0f2357ef 100644
--- a/tensorstore/static_cast.h
+++ b/tensorstore/static_cast.h
@@ -61,7 +61,12 @@ namespace tensorstore {
 /// that returns ``Result<T>``.
 ///
 /// \ingroup compile-time-constraints
-enum class CastChecking { checked = 0, unchecked = 1 };
+enum class CastChecking {
+  /// Indicates that the cast is checked at runtime and returns a ``Result<T>``.
+  checked = 0,
+  /// Indicates that the cast is unchecked and returns a bare value ``T``.
+  unchecked = 1
+};
 
 /// Tag type used as the first parameter of some constructors to request an
 /// unchecked conversion (e.g. from dynamic rank to a compile-time rank).
diff --git a/tensorstore/strided_layout.h b/tensorstore/strided_layout.h
index 691ab831..79387679 100644
--- a/tensorstore/strided_layout.h
+++ b/tensorstore/strided_layout.h
@@ -397,7 +397,7 @@ class StridedLayout
   using Selector =
       internal_strided_layout::LayoutStorageSelector<Rank, OriginKind, CKind>;
   using Storage = typename Selector::Storage;
-  using Access = typename Selector::Access;
+  using AccessImpl = typename Selector::Access;
 
  public:
   /// Origin kind of the layout.
@@ -419,13 +419,13 @@ class StridedLayout
   using RankType = StaticOrDynamicRank<RankConstraint::FromInlineRank(Rank)>;
 
   /// Conditionally const-qualified element type of `shape` vector.
-  using MaybeConstIndex = typename Access::MaybeConstIndex;
+  using MaybeConstIndex = typename AccessImpl::MaybeConstIndex;
 
   /// Conditionally const-qualified element type of `origin` vector.
-  using MaybeConstOriginIndex = typename Access::MaybeConstOriginIndex;
+  using MaybeConstOriginIndex = typename AccessImpl::MaybeConstOriginIndex;
 
   /// Returns the number of dimensions in the layout.
-  RankType rank() const { return Access::GetExtent(*this); }
+  RankType rank() const { return AccessImpl::GetExtent(*this); }
 
   /// Constructs a default layout of rank equal to `static_rank` (if
   /// `static_rank >= 0`) or rank `0` (if `static_rank == dynamic_rank`).
@@ -436,7 +436,7 @@ class StridedLayout
   StridedLayout() noexcept {
     if (container_kind == view) {
       const Index* zero_vec = GetConstantVector<Index, 0>(RankType{}).data();
-      Access::Assign(this, RankType{}, zero_vec, zero_vec);
+      AccessImpl::Assign(this, RankType{}, zero_vec, zero_vec);
     }
   }
 
@@ -463,17 +463,17 @@ class StridedLayout
           shape,
       tensorstore::span<const Index, RankConstraint::FromInlineRank(Rank)>
           byte_strides) {
-    // This check is redundant with the check done by Access::Assign, but
-    // provides a better assertion error message.
+    // This check is redundant with the check done by AccessImpl::Assign,
+    // but provides a better assertion error message.
     assert(shape.size() == byte_strides.size());
-    Access::Assign(this, GetStaticOrDynamicExtent(shape), shape.data(),
-                   byte_strides.data());
+    AccessImpl::Assign(this, GetStaticOrDynamicExtent(shape), shape.data(),
+                       byte_strides.data());
   }
   template <size_t N, typename = std::enable_if_t<
                           RankConstraint::Implies(N, static_rank)>>
   explicit StridedLayout(const Index (&shape)[N],
                          const Index (&byte_strides)[N]) {
-    Access::Assign(this, StaticRank<N>{}, shape, byte_strides);
+    AccessImpl::Assign(this, StaticRank<N>{}, shape, byte_strides);
   }
 
   /// Constructs from the specified `origin`, `shape` and `byte_strides`.
@@ -493,8 +493,8 @@ class StridedLayout
           byte_strides) {
     assert(origin.size() == shape.size());
     assert(origin.size() == byte_strides.size());
-    Access::Assign(this, GetStaticOrDynamicExtent(origin), origin.data(),
-                   shape.data(), byte_strides.data());
+    AccessImpl::Assign(this, GetStaticOrDynamicExtent(origin), origin.data(),
+                       shape.data(), byte_strides.data());
   }
   template <
       size_t N, ArrayOriginKind SfinaeOKind = OriginKind,
@@ -502,7 +502,7 @@ class StridedLayout
                                   RankConstraint::Implies(N, static_rank)>>
   explicit StridedLayout(const Index (&origin)[N], const Index (&shape)[N],
                          const Index (&byte_strides)[N]) {
-    Access::Assign(this, StaticRank<N>{}, origin, shape, byte_strides);
+    AccessImpl::Assign(this, StaticRank<N>{}, origin, shape, byte_strides);
   }
 
   /// Constructs from the specified `domain` and `byte_strides`.
@@ -520,8 +520,8 @@ class StridedLayout
       tensorstore::span<const Index, RankConstraint::FromInlineRank(Rank)>
           byte_strides) {
     assert(domain.rank() == byte_strides.size());
-    Access::Assign(this, domain.rank(), domain.origin().data(),
-                   domain.shape().data(), byte_strides.data());
+    AccessImpl::Assign(this, domain.rank(), domain.origin().data(),
+                       domain.shape().data(), byte_strides.data());
   }
 
   /// Constructs from a layout with a compatible `static_rank` and
@@ -537,7 +537,7 @@ class StridedLayout
                                    static_rank) &&
            IsArrayOriginKindConvertible(O, OriginKind))>>
   explicit StridedLayout(const StridedLayout<R, O, C>& source) {
-    Access::AssignFrom(this, source);
+    AccessImpl::AssignFrom(this, source);
   }
 
   // Overload of above constructor that handles the implicit conversion case of
@@ -549,7 +549,7 @@ class StridedLayout
                                          static_rank) &&
                  (R == 0 || IsArrayOriginKindConvertible(O, OriginKind)))>>
   StridedLayout(const StridedLayout<R, O, C>& source) {
-    Access::AssignFrom(this, source);
+    AccessImpl::AssignFrom(this, source);
   }
 
   /// Unchecked conversion.
@@ -562,7 +562,7 @@ class StridedLayout
                  (R == 0 || IsArrayOriginKindConvertible(O, OriginKind)))>>
   explicit StridedLayout(unchecked_t, const StridedLayout<R, O, C>& source) {
     assert(RankConstraint::EqualOrUnspecified(source.rank(), static_rank));
-    Access::AssignFrom(this, source);
+    AccessImpl::AssignFrom(this, source);
   }
   explicit StridedLayout(unchecked_t, StridedLayout&& source)
       : StridedLayout(std::move(source)) {}
@@ -578,13 +578,13 @@ class StridedLayout
   /// \id rank, components
   explicit StridedLayout(RankType rank, const Index* shape,
                          const Index* byte_strides) {
-    Access::Assign(this, rank, shape, byte_strides);
+    AccessImpl::Assign(this, rank, shape, byte_strides);
   }
   template <ArrayOriginKind OKind = array_origin_kind,
             typename = std::enable_if_t<OKind == offset_origin>>
   explicit StridedLayout(RankType rank, const Index* origin, const Index* shape,
                          const Index* byte_strides) {
-    Access::Assign(this, rank, origin, shape, byte_strides);
+    AccessImpl::Assign(this, rank, origin, shape, byte_strides);
   }
 
   /// Constructs a contiguous layout with the specified domain and element
@@ -629,7 +629,7 @@ class StridedLayout
                     (R == 0 || IsArrayOriginKindConvertible(O, OriginKind))),
                    StridedLayout&>
   operator=(const StridedLayout<R, O, C>& other) {
-    Access::AssignFrom(this, other);
+    AccessImpl::AssignFrom(this, other);
     return *this;
   }
 
@@ -640,7 +640,7 @@ class StridedLayout
   /// \membergroup Assignment
   template <int&... ExplicitArgumentBarrier, ContainerKind SfinaeC = CKind>
   std::enable_if_t<SfinaeC == container> set_rank(RankType rank) {
-    Access::Resize(this, rank);
+    AccessImpl::Resize(this, rank);
   }
 
   /// Returns the origin vector of size `rank()`.
@@ -655,7 +655,7 @@ class StridedLayout
   }
   tensorstore::span<MaybeConstOriginIndex, RankConstraint::FromInlineRank(Rank)>
   origin() {
-    return Access::origin(this);
+    return AccessImpl::origin(this);
   }
 
   /// Returns the byte strides vector of size `rank()`.
@@ -669,7 +669,7 @@ class StridedLayout
   }
   tensorstore::span<MaybeConstIndex, RankConstraint::FromInlineRank(Rank)>
   byte_strides() {
-    return Access::byte_strides(this);
+    return AccessImpl::byte_strides(this);
   }
 
   /// Returns the shape vector of size `rank()`.
@@ -683,7 +683,7 @@ class StridedLayout
   }
   tensorstore::span<MaybeConstIndex, RankConstraint::FromInlineRank(Rank)>
   shape() {
-    return Access::shape(this);
+    return AccessImpl::shape(this);
   }
 
   /// Returns the byte offset of the origin.
@@ -992,6 +992,9 @@ Index GetByteExtent(StridedLayoutView<> layout, Index element_size);
 
 /// Returns smallest number of contiguous bytes into which the specified layout
 /// fits.
+///
+/// \relates StridedLayout
+/// \id strided_layout
 template <DimensionIndex Rank, ArrayOriginKind OriginKind, ContainerKind CKind>
 Index GetByteExtent(const StridedLayout<Rank, OriginKind, CKind>& layout,
                     Index element_size) {
diff --git a/tensorstore/tensorstore.h b/tensorstore/tensorstore.h
index ddc7ebc1..b9661bf7 100644
--- a/tensorstore/tensorstore.h
+++ b/tensorstore/tensorstore.h
@@ -431,6 +431,7 @@ using RebindMode =
 /// Casts `source` to have a static `ReadWriteMode` of `TargetMode`.
 ///
 /// \ingroup compile-time-constraints
+/// \id compile_time
 template <ReadWriteMode TargetMode,
           CastChecking Checking = CastChecking::checked, typename SourceRef>
 StaticCastResultType<RebindMode<SourceRef, TargetMode>, SourceRef, Checking>
@@ -444,6 +445,7 @@ ModeCast(SourceRef&& source) {
 /// If `new_mode == ReadWriteMode::dynamic`, the existing mode is unchanged.
 ///
 /// \relates TensorStore
+/// \id runtime
 template <typename Element, DimensionIndex Rank, ReadWriteMode ExistingMode>
 Result<TensorStore<Element, Rank>> ModeCast(
     TensorStore<Element, Rank, ExistingMode> store, ReadWriteMode new_mode) {
@@ -622,6 +624,8 @@ Resize(
 /// satisfied.
 ///
 /// Used to specify the return type of `tensorstore::Read`.
+///
+/// \relates Read[TensorStore, Array]
 template <typename Source, typename Dest>
 constexpr inline bool CanReadTensorstoreToArray =
     (internal::IsTensorStoreThatSupportsMode<Source, ReadWriteMode::read> &&
@@ -638,7 +642,7 @@ constexpr inline bool CanReadTensorstoreToArray =
 /// may be left in a partially-written state.
 ///
 /// Options compatible with `ReadOptions` are specified in any order after
-/// `store`.  The meaning of each option is determined by its type.
+/// `target`.  The meaning of each option is determined by its type.
 ///
 /// Supported option types are:
 ///
@@ -701,7 +705,7 @@ Read(SourceTensorstore&& source, TargetArray&& target, Option&&... option) {
 /// Copies from a `source` `TensorStore` to a newly-allocated target `Array`.
 ///
 /// Options compatible with `ReadIntoNewArrayOptions` are specified in any order
-/// after `store`.  The meaning of each option is determined by its type.
+/// after `source`.  The meaning of each option is determined by its type.
 ///
 /// Supported option types are:
 ///
@@ -736,6 +740,8 @@ std::enable_if_t<
     Future<SharedArray<typename UnwrapResultType<SourceTensorstore>::Element,
                        UnwrapResultType<SourceTensorstore>::static_rank,
                        OriginKind>>>
+// NONITPICK: UnwrapResultType<SourceTensorstore>::Element
+// NONITPICK: UnwrapResultType<SourceTensorstore>::static_rank
 Read(SourceTensorstore&& source, ReadIntoNewArrayOptions options) {
   using Store = UnwrapResultType<SourceTensorstore>;
   return MapResult(
@@ -770,6 +776,8 @@ Read(SourceTensorstore&& source, Option&&... option) {
 /// satisfied.
 ///
 /// Used to specify the return type of `tensorstore::Write`.
+///
+/// \relates Write[Array, TensorStore]
 template <typename Source, typename Dest>
 constexpr inline bool CanWriteArrayToTensorStore =
     (internal::IsTensorStoreThatSupportsMode<Dest, ReadWriteMode::write> &&
@@ -788,7 +796,7 @@ constexpr inline bool CanWriteArrayToTensorStore =
 /// partially-written state.
 ///
 /// Options compatible with `WriteOptions` are specified in any order after
-/// `store`.  The meaning of each option is determined by its type.
+/// `target`.  The meaning of each option is determined by its type.
 ///
 /// Supported option types are:
 ///
@@ -849,6 +857,8 @@ Write(SourceArray&& source, Target&& target, Option&&... option) {
 /// satisfied.
 ///
 /// Used to specify the return type of `tensorstore::Copy`.
+///
+/// \relates Copy[TensorStore, TensorStore]
 template <typename Source, typename Dest>
 constexpr inline bool CanCopyTensorStoreToTensorStore =
     (internal::IsTensorStoreThatSupportsMode<Source, ReadWriteMode::read> &&
@@ -865,7 +875,7 @@ constexpr inline bool CanCopyTensorStoreToTensorStore =
 /// partially-written state.
 ///
 /// Options compatible with `CopyOptions` are specified in any order after
-/// `store`.  The meaning of each option is determined by its type.
+/// `target`.  The meaning of each option is determined by its type.
 ///
 /// Supported option types are:
 ///
diff --git a/tensorstore/util/bfloat16.h b/tensorstore/util/bfloat16.h
index f59cfbc6..8acf7304 100644
--- a/tensorstore/util/bfloat16.h
+++ b/tensorstore/util/bfloat16.h
@@ -139,12 +139,12 @@ class BFloat16 {
   /**/
 
 #define TENSORSTORE_INTERNAL_BFLOAT16_ARITHMETIC_ASSIGN_OP(OP)           \
-  friend BFloat16& operator OP##=(BFloat16& a, BFloat16 b) {             \
+  friend BFloat16& operator OP##=(BFloat16 & a, BFloat16 b) {            \
     return a = BFloat16(static_cast<float>(a) OP static_cast<float>(b)); \
   }                                                                      \
   template <typename T>                                                  \
   friend std::enable_if_t<std::numeric_limits<T>::is_integer, BFloat16&> \
-  operator OP##=(BFloat16& a, T b) {                                     \
+  operator OP##=(BFloat16 & a, T b) {                                    \
     return a = BFloat16(static_cast<float>(a) OP b);                     \
   }                                                                      \
   /**/
@@ -311,6 +311,7 @@ inline bool isfinite(BFloat16 x) {
 ///
 /// \membergroup Basic operations
 /// \relates BFloat16
+/// \id bfloat16
 inline BFloat16 abs(BFloat16 x) {
   x.rep_ &= 0x7fff;
   return x;
@@ -320,6 +321,7 @@ inline BFloat16 abs(BFloat16 x) {
 ///
 /// \membergroup Exponential functions
 /// \relates BFloat16
+/// \id bfloat16
 inline BFloat16 exp(BFloat16 x) {
   return BFloat16(std::exp(static_cast<float>(x)));
 }
@@ -328,6 +330,7 @@ inline BFloat16 exp(BFloat16 x) {
 ///
 /// \membergroup Exponential functions
 /// \relates BFloat16
+/// \id bfloat16
 inline BFloat16 exp2(BFloat16 x) {
   return BFloat16(std::exp2(static_cast<float>(x)));
 }
@@ -336,6 +339,7 @@ inline BFloat16 exp2(BFloat16 x) {
 ///
 /// \membergroup Exponential functions
 /// \relates BFloat16
+/// \id bfloat16
 inline BFloat16 expm1(BFloat16 x) {
   return BFloat16(std::expm1(static_cast<float>(x)));
 }
@@ -344,6 +348,7 @@ inline BFloat16 expm1(BFloat16 x) {
 ///
 /// \membergroup Exponential functions
 /// \relates BFloat16
+/// \id bfloat16
 inline BFloat16 log(BFloat16 x) {
   return BFloat16(std::log(static_cast<float>(x)));
 }
@@ -353,6 +358,7 @@ inline BFloat16 log(BFloat16 x) {
 ///
 /// \membergroup Exponential functions
 /// \relates BFloat16
+/// \id bfloat16
 inline BFloat16 log1p(BFloat16 x) {
   return BFloat16(std::log1p(static_cast<float>(x)));
 }
@@ -361,6 +367,7 @@ inline BFloat16 log1p(BFloat16 x) {
 ///
 /// \membergroup Exponential functions
 /// \relates BFloat16
+/// \id bfloat16
 inline BFloat16 log10(BFloat16 x) {
   return BFloat16(std::log10(static_cast<float>(x)));
 }
@@ -369,6 +376,7 @@ inline BFloat16 log10(BFloat16 x) {
 ///
 /// \membergroup Exponential functions
 /// \relates BFloat16
+/// \id bfloat16
 inline BFloat16 log2(BFloat16 x) {
   return BFloat16(std::log2(static_cast<float>(x)));
 }
@@ -377,6 +385,7 @@ inline BFloat16 log2(BFloat16 x) {
 ///
 /// \membergroup Power functions
 /// \relates BFloat16
+/// \id bfloat16
 inline BFloat16 sqrt(BFloat16 x) {
   return BFloat16(std::sqrt(static_cast<float>(x)));
 }
@@ -385,6 +394,7 @@ inline BFloat16 sqrt(BFloat16 x) {
 ///
 /// \membergroup Power functions
 /// \relates BFloat16
+/// \id bfloat16
 inline BFloat16 pow(BFloat16 x, BFloat16 y) {
   return BFloat16(std::pow(static_cast<float>(x), static_cast<float>(y)));
 }
@@ -393,6 +403,7 @@ inline BFloat16 pow(BFloat16 x, BFloat16 y) {
 ///
 /// \membergroup Trigonometric functions
 /// \relates BFloat16
+/// \id bfloat16
 inline BFloat16 sin(BFloat16 x) {
   return BFloat16(std::sin(static_cast<float>(x)));
 }
@@ -401,6 +412,7 @@ inline BFloat16 sin(BFloat16 x) {
 ///
 /// \membergroup Trigonometric functions
 /// \relates BFloat16
+/// \id bfloat16
 inline BFloat16 cos(BFloat16 x) {
   return BFloat16(std::cos(static_cast<float>(x)));
 }
@@ -409,6 +421,7 @@ inline BFloat16 cos(BFloat16 x) {
 ///
 /// \membergroup Trigonometric functions
 /// \relates BFloat16
+/// \id bfloat16
 inline BFloat16 tan(BFloat16 x) {
   return BFloat16(std::tan(static_cast<float>(x)));
 }
@@ -417,6 +430,7 @@ inline BFloat16 tan(BFloat16 x) {
 ///
 /// \membergroup Trigonometric functions
 /// \relates BFloat16
+/// \id bfloat16
 inline BFloat16 asin(BFloat16 x) {
   return BFloat16(std::asin(static_cast<float>(x)));
 }
@@ -425,6 +439,7 @@ inline BFloat16 asin(BFloat16 x) {
 ///
 /// \membergroup Trigonometric functions
 /// \relates BFloat16
+/// \id bfloat16
 inline BFloat16 acos(BFloat16 x) {
   return BFloat16(std::acos(static_cast<float>(x)));
 }
@@ -433,6 +448,7 @@ inline BFloat16 acos(BFloat16 x) {
 ///
 /// \membergroup Trigonometric functions
 /// \relates BFloat16
+/// \id bfloat16
 inline BFloat16 atan(BFloat16 x) {
   return BFloat16(std::atan(static_cast<float>(x)));
 }
@@ -441,6 +457,7 @@ inline BFloat16 atan(BFloat16 x) {
 ///
 /// \membergroup Hyperbolic functions
 /// \relates BFloat16
+/// \id bfloat16
 inline BFloat16 sinh(BFloat16 x) {
   return BFloat16(std::sinh(static_cast<float>(x)));
 }
@@ -449,6 +466,7 @@ inline BFloat16 sinh(BFloat16 x) {
 ///
 /// \membergroup Hyperbolic functions
 /// \relates BFloat16
+/// \id bfloat16
 inline BFloat16 cosh(BFloat16 x) {
   return BFloat16(std::cosh(static_cast<float>(x)));
 }
@@ -457,6 +475,7 @@ inline BFloat16 cosh(BFloat16 x) {
 ///
 /// \membergroup Hyperbolic functions
 /// \relates BFloat16
+/// \id bfloat16
 inline BFloat16 tanh(BFloat16 x) {
   return BFloat16(std::tanh(static_cast<float>(x)));
 }
@@ -465,6 +484,7 @@ inline BFloat16 tanh(BFloat16 x) {
 ///
 /// \membergroup Hyperbolic functions
 /// \relates BFloat16
+/// \id bfloat16
 inline BFloat16 asinh(BFloat16 x) {
   return BFloat16(std::asinh(static_cast<float>(x)));
 }
@@ -473,6 +493,7 @@ inline BFloat16 asinh(BFloat16 x) {
 ///
 /// \membergroup Hyperbolic functions
 /// \relates BFloat16
+/// \id bfloat16
 inline BFloat16 acosh(BFloat16 x) {
   return BFloat16(std::acosh(static_cast<float>(x)));
 }
@@ -481,6 +502,7 @@ inline BFloat16 acosh(BFloat16 x) {
 ///
 /// \membergroup Hyperbolic functions
 /// \relates BFloat16
+/// \id bfloat16
 inline BFloat16 atanh(BFloat16 x) {
   return BFloat16(std::atanh(static_cast<float>(x)));
 }
@@ -489,6 +511,7 @@ inline BFloat16 atanh(BFloat16 x) {
 ///
 /// \membergroup Rounding functions
 /// \relates BFloat16
+/// \id bfloat16
 inline BFloat16 floor(BFloat16 x) {
   return BFloat16(std::floor(static_cast<float>(x)));
 }
@@ -497,6 +520,7 @@ inline BFloat16 floor(BFloat16 x) {
 ///
 /// \membergroup Rounding functions
 /// \relates BFloat16
+/// \id bfloat16
 inline BFloat16 trunc(BFloat16 x) {
   return BFloat16(std::trunc(static_cast<float>(x)));
 }
@@ -505,6 +529,7 @@ inline BFloat16 trunc(BFloat16 x) {
 ///
 /// \membergroup Rounding functions
 /// \relates BFloat16
+/// \id bfloat16
 inline BFloat16 rint(BFloat16 x) {
   return BFloat16(std::rint(static_cast<float>(x)));
 }
@@ -513,6 +538,7 @@ inline BFloat16 rint(BFloat16 x) {
 ///
 /// \membergroup Rounding functions
 /// \relates BFloat16
+/// \id bfloat16
 inline BFloat16 ceil(BFloat16 x) {
   return BFloat16(std::ceil(static_cast<float>(x)));
 }
@@ -521,6 +547,7 @@ inline BFloat16 ceil(BFloat16 x) {
 ///
 /// \membergroup Basic operations
 /// \relates BFloat16
+/// \id bfloat16
 inline BFloat16 fmod(BFloat16 x, BFloat16 y) {
   return BFloat16(std::fmod(static_cast<float>(x), static_cast<float>(y)));
 }
@@ -529,6 +556,7 @@ inline BFloat16 fmod(BFloat16 x, BFloat16 y) {
 ///
 /// \membergroup Basic operations
 /// \relates BFloat16
+/// \id bfloat16
 inline BFloat16 fmin(BFloat16 a, BFloat16 b) {
   return BFloat16(std::fmin(static_cast<float>(a), static_cast<float>(b)));
 }
@@ -537,6 +565,7 @@ inline BFloat16 fmin(BFloat16 a, BFloat16 b) {
 ///
 /// \membergroup Basic operations
 /// \relates BFloat16
+/// \id bfloat16
 inline BFloat16 fmax(BFloat16 a, BFloat16 b) {
   return BFloat16(std::fmax(static_cast<float>(a), static_cast<float>(b)));
 }
@@ -545,6 +574,7 @@ inline BFloat16 fmax(BFloat16 a, BFloat16 b) {
 ///
 /// \membergroup Floating-point manipulation functions
 /// \relates BFloat16
+/// \id bfloat16
 inline BFloat16 nextafter(BFloat16 from, BFloat16 to) {
   const uint16_t from_as_int = absl::bit_cast<uint16_t>(from),
                  to_as_int = absl::bit_cast<uint16_t>(to);
diff --git a/tensorstore/util/element_pointer.h b/tensorstore/util/element_pointer.h
index d5b70f88..5c53f8e7 100644
--- a/tensorstore/util/element_pointer.h
+++ b/tensorstore/util/element_pointer.h
@@ -258,7 +258,7 @@ constexpr inline bool IsElementPointer<ElementPointer<PointerType>> = true;
 /// \ingroup array
 template <typename ElementTagType>
 class ElementPointer {
-  using Traits = ElementTagTraits<ElementTagType>;
+  using TraitsImpl = ElementTagTraits<ElementTagType>;
 
  public:
   static_assert(IsElementTag<ElementTagType>,
@@ -269,7 +269,7 @@ class ElementPointer {
 
   /// Underlying data pointer type, either `Element*` or
   /// `std::shared_ptr<Element>`.
-  using Pointer = typename Traits::Pointer;
+  using Pointer = typename TraitsImpl::Pointer;
 
   /// Underlying element type.
   using element_type = typename std::pointer_traits<Pointer>::
@@ -281,7 +281,8 @@ class ElementPointer {
 
   // For compatibility with `std::pointer_traits`.
   template <typename OtherElement>
-  using rebind = ElementPointer<typename Traits::template rebind<OtherElement>>;
+  using rebind =
+      ElementPointer<typename TraitsImpl::template rebind<OtherElement>>;
 
   /// Initializes to a null pointer.
   ///
diff --git a/tensorstore/util/extents.h b/tensorstore/util/extents.h
index b944a56e..6c3290ae 100644
--- a/tensorstore/util/extents.h
+++ b/tensorstore/util/extents.h
@@ -60,7 +60,7 @@ T ProductOfExtents(tensorstore::span<T, Extent> s) {
 /// `Index` and a static `span::extent` compatible with `Rank`.
 ///
 /// \ingroup index vectors
-template <DimensionIndex Rank, typename Indices, typename = void>
+template <DimensionIndex Rank, typename Indices, typename Sfinae = void>
 constexpr inline bool IsCompatibleFullIndexVector = false;
 
 template <DimensionIndex Rank, typename Indices>
@@ -76,7 +76,7 @@ constexpr inline bool IsCompatibleFullIndexVector<
 /// `Index` and a static `span::extent` implicitly compatible with `Rank`.
 ///
 /// \ingroup index vectors
-template <DimensionIndex Rank, typename Indices, typename = void>
+template <DimensionIndex Rank, typename Indices, typename Sfinae = void>
 constexpr inline bool IsImplicitlyCompatibleFullIndexVector = false;
 
 template <DimensionIndex Rank, typename Indices>
@@ -91,7 +91,7 @@ constexpr inline bool IsImplicitlyCompatibleFullIndexVector<
 /// `Index` and a static `span::extent <= Rank`.
 ///
 /// \ingroup index vectors
-template <DimensionIndex Rank, typename Indices, typename = void>
+template <DimensionIndex Rank, typename Indices, typename Sfinae = void>
 constexpr inline bool IsCompatiblePartialIndexVector = false;
 
 template <DimensionIndex Rank, typename Indices>
@@ -115,9 +115,9 @@ constexpr inline bool IsCompatibleFullIndexPack =
 /// Bool-valued metafunction that evaluates to `true` if `Indices` is
 /// `span`-compatible with a `span::value_type` convertible without narrowing to
 /// `Index`.
-//
+///
 /// \ingroup index vectors
-template <typename Indices, typename = void>
+template <typename Indices, typename Sfinae = void>
 constexpr inline bool IsIndexConvertibleVector = false;
 
 template <typename Indices>
@@ -130,7 +130,7 @@ constexpr inline bool IsIndexConvertibleVector<
 /// `span`-compatible with a `span::value_type` of `Index`.
 ///
 /// \ingroup index vectors
-template <typename Indices, typename = Index>
+template <typename Indices, typename Sfinae = Index>
 constexpr inline bool IsIndexVector = false;
 
 template <typename Indices>
@@ -141,7 +141,7 @@ constexpr inline bool IsIndexVector<
 /// `span`-compatible with a `span::element_type` of `Index`.
 ///
 /// \ingroup index vectors
-template <typename Indices, typename = Index>
+template <typename Indices, typename Sfinae = Index>
 constexpr inline bool IsMutableIndexVector = false;
 
 template <typename Indices>
diff --git a/tensorstore/util/float8.h b/tensorstore/util/float8.h
index fe5a34ce..9dbfa671 100644
--- a/tensorstore/util/float8.h
+++ b/tensorstore/util/float8.h
@@ -1329,6 +1329,12 @@ TENSORSTORE_INTERNAL_FPCLASSIFY(Float8e5m2fnuz);
 }  // namespace float8_internal
 
 // Exported types.
+
+/// Storage-only 8-bit floating-point data types.
+///
+/// See https://github.com/jax-ml/ml_dtypes for details.
+///
+/// \ingroup Data types
 using Float8e4m3fn = float8_internal::Float8e4m3fn;
 using Float8e4m3fnuz = float8_internal::Float8e4m3fnuz;
 using Float8e4m3b11fnuz = float8_internal::Float8e4m3b11fnuz;
diff --git a/tensorstore/util/future.h b/tensorstore/util/future.h
index c4f0082f..f6e85913 100644
--- a/tensorstore/util/future.h
+++ b/tensorstore/util/future.h
@@ -1362,7 +1362,7 @@ MapFuture(Executor&& executor, Callback&& callback,
 ///     `callback(future.result().value()...)` when all of the `future` objects
 ///     become ready with non-error results.
 /// \param future The `Future` objects to link.
-/// \dchecks `(future.!null() && ...)`
+/// \dchecks `(!future.null() && ...)`
 /// \returns A ``Future<UnwrapFutureType<std::remove_cvref_t<U>>>``, where
 ///     ``U`` is the return type of the specified `callback` function.
 /// \relates Future
diff --git a/tensorstore/util/int4.h b/tensorstore/util/int4.h
index d52b6992..5fa9b8a3 100644
--- a/tensorstore/util/int4.h
+++ b/tensorstore/util/int4.h
@@ -106,12 +106,12 @@ class Int4Padded {
   /**/
 
 #define TENSORSTORE_INTERNAL_INT4_PADDED_ARITHMETIC_ASSIGN_OP(OP)          \
-  friend Int4Padded& operator OP##=(Int4Padded& a, Int4Padded b) {         \
+  friend Int4Padded& operator OP##=(Int4Padded & a, Int4Padded b) {        \
     return a = Int4Padded(a.rep_ OP b.rep_);                               \
   }                                                                        \
   template <typename T>                                                    \
   friend std::enable_if_t<std::numeric_limits<T>::is_integer, Int4Padded&> \
-  operator OP##=(Int4Padded& a, T b) {                                     \
+  operator OP##=(Int4Padded & a, T b) {                                    \
     return a = Int4Padded(a.rep_ OP b);                                    \
   }                                                                        \
   /**/
@@ -340,6 +340,7 @@ class Int4Padded {
 ///
 /// \membergroup Basic operations
 /// \relates BFloat16
+/// \id int4padded
 inline Int4Padded abs(Int4Padded x) {
   x.rep_ = internal::SignedTrunc4(::std::abs(x.rep_));
   return x;
@@ -349,6 +350,7 @@ inline Int4Padded abs(Int4Padded x) {
 ///
 /// \membergroup Power functions
 /// \relates Int4Padded
+/// \id int4padded
 inline Int4Padded pow(Int4Padded x, Int4Padded y) {
   return Int4Padded(std::pow(static_cast<int8_t>(x), static_cast<int8_t>(y)));
 }
diff --git a/tensorstore/util/option.h b/tensorstore/util/option.h
index c336adb6..07586e0e 100644
--- a/tensorstore/util/option.h
+++ b/tensorstore/util/option.h
@@ -27,6 +27,7 @@ namespace tensorstore {
 ///
 /// \ingroup utilities
 template <typename Options, typename... Option>
+// NONITPICK: Options::IsOption<std::remove_cvref_t<Option>>
 constexpr inline bool IsCompatibleOptionSequence =
     ((!std::is_same_v<Options, absl::remove_cvref_t<Option>> &&
       Options::template IsOption<absl::remove_cvref_t<Option>>) &&
diff --git a/tensorstore/util/small_bit_set.h b/tensorstore/util/small_bit_set.h
index 83ef00fb..17b1816e 100644
--- a/tensorstore/util/small_bit_set.h
+++ b/tensorstore/util/small_bit_set.h
@@ -301,7 +301,7 @@ class BitIterator {
   ptrdiff_t offset_;
 };
 
-namespace bitset_impl {
+namespace internal_bitset {
 
 // View type for exposing SmallBitSet iterators.
 template <typename Iterator, size_t N>
@@ -376,7 +376,7 @@ class IndexView {
   Uint bits_;
 };
 
-}  // namespace bitset_impl
+}  // namespace internal_bitset
 
 /// Bit set that fits in a single unsigned integer.
 ///
@@ -419,10 +419,12 @@ class SmallBitSet {
   }
 
   /// Constructs the set containing bits at the specified indices.
-  /// Can be invoked with a braced list, e.g.
-  ///   `SmallBitSet<8>::FromIndices({1, 10})`.
   ///
-  /// \dchecks  `values[i] >= 0 && values[i] < N`
+  /// This can be invoked with a braced list, e.g.
+  ///
+  ///     SmallBitSet<8>::FromIndices({1, 10})
+  ///
+  /// \dchecks  ``positions[i] >= 0 && positions[i] < N`` for all ``i``
   /// \membergroup Constructors
   template <size_t NumBits, typename = std::enable_if_t<(NumBits <= N)>>
   static constexpr SmallBitSet FromIndices(const int (&positions)[NumBits]) {
@@ -442,10 +444,11 @@ class SmallBitSet {
   }
 
   /// Constructs from an array of `bool` values.
-  /// Can be invoked with a braced list, e.g.
-  ///   `SmallBitSet<8>::FromBools({0, 1, 1, 0})`.
   ///
-  /// \dchecks Size of `range` is not greater than `N`
+  /// This can be invoked with a braced list, e.g.
+  ///
+  ///     SmallBitSet<8>::FromBools({0, 1, 1, 0})
+  ///
   /// \membergroup constructors
   template <size_t NumBits, typename = std::enable_if_t<(NumBits <= N)>>
   static constexpr SmallBitSet FromBools(const bool (&bits)[NumBits]) {
@@ -489,20 +492,20 @@ class SmallBitSet {
   }
 
   /// Mutable view of SmallBitSet bits.
-  using BoolsView = bitset_impl::BoolsView<BitIterator<Uint>, N>;
+  using BoolsView = internal_bitset::BoolsView<BitIterator<Uint>, N>;
   constexpr BoolsView bools_view() TENSORSTORE_ATTRIBUTE_LIFETIME_BOUND {
     return BoolsView(BitIterator<Uint>(&bits_, 0));
   }
 
   /// Immutable view of SmallBitSet bits.
-  using ConstBoolsView = bitset_impl::BoolsView<BitIterator<const Uint>, N>;
+  using ConstBoolsView = internal_bitset::BoolsView<BitIterator<const Uint>, N>;
   constexpr ConstBoolsView bools_view() const
       TENSORSTORE_ATTRIBUTE_LIFETIME_BOUND {
     return ConstBoolsView(BitIterator<const Uint>(&bits_, 0));
   }
 
   /// Immutable view of SmallBitSet indices.
-  using IndexView = bitset_impl::IndexView<Uint>;
+  using IndexView = internal_bitset::IndexView<Uint>;
   constexpr IndexView index_view() const { return IndexView(bits_); }
 
   /// Returns the static size, `N`.
diff --git a/tensorstore/util/span.h b/tensorstore/util/span.h
index d60ee17e..0dc2136c 100644
--- a/tensorstore/util/span.h
+++ b/tensorstore/util/span.h
@@ -62,9 +62,9 @@ constexpr inline bool IsArrayOrSpan<span<T, Extent>> = true;
 template <typename T, typename Container,
           typename Pointer = decltype(std::declval<Container>().data()),
           typename Size = decltype(std::declval<Container>().size())>
-using EnableIfCompatibleContainer = std::enable_if_t<
+constexpr inline bool IsCompatibleContainer =
     !IsArrayOrSpan<std::remove_cv_t<Container>> &&
-    std::is_convertible_v<std::remove_pointer_t<Pointer> (*)[], T (*)[]>>;
+    std::is_convertible_v<std::remove_pointer_t<Pointer> (*)[], T (*)[]>;
 
 template <typename Container,
           typename Pointer = decltype(std::declval<Container>().data()),
@@ -245,12 +245,13 @@ class span {
   ///
   /// \id container
   template <typename Container,
-            typename = internal_span::EnableIfCompatibleContainer<T, Container>>
+            typename = std::enable_if_t<
+                internal_span::IsCompatibleContainer<T, Container>>>
   constexpr span(Container& cont TENSORSTORE_ATTRIBUTE_LIFETIME_BOUND)
       : span(cont.data(), cont.size()) {}
-  template <
-      typename Container,
-      typename = internal_span::EnableIfCompatibleContainer<T, const Container>>
+  template <typename Container,
+            typename = std::enable_if_t<
+                internal_span::IsCompatibleContainer<T, const Container>>>
   constexpr span(const Container& cont TENSORSTORE_ATTRIBUTE_LIFETIME_BOUND)
       : span(cont.data(), cont.size()) {}
 
diff --git a/tensorstore/util/status.h b/tensorstore/util/status.h
index fbdcad24..1257ee31 100644
--- a/tensorstore/util/status.h
+++ b/tensorstore/util/status.h
@@ -34,8 +34,8 @@ namespace internal {
 /// Add the SourceLocation to the Status.
 void MaybeAddSourceLocationImpl(absl::Status& status, SourceLocation loc);
 
-/// Returns a copy of `source` with `prefix_message` appended, possibly changing
-/// the status code and adding a source location.
+// Returns a copy of `source` with `prefix_message` appended, possibly changing
+// the status code and adding a source location.
 absl::Status MaybeAnnotateStatusImpl(absl::Status source,
                                      std::string_view prefix_message,
                                      std::optional<absl::StatusCode> new_code,
@@ -84,7 +84,7 @@ inline absl::Status InvokeForStatus(F&& f, Args&&... args) {
 
 }  // namespace internal
 
-/// Add a source location to the status.
+// Add a source location to the status.
 inline void MaybeAddSourceLocation(
     absl::Status& status,
     SourceLocation loc = tensorstore::SourceLocation::current()) {
@@ -93,10 +93,10 @@ inline void MaybeAddSourceLocation(
   internal::MaybeAddSourceLocationImpl(status, loc);
 }
 
-/// Adds value to status usiung `status.SetPayload`.
-/// Iterates through payloads like `prefix` and `prefix[N]`, and if value
-/// is not found, adds to the status payload, returning prefix.
-/// If the payload already exists, returns std::nullopt.
+// Adds value to status usiung `status.SetPayload`.
+// Iterates through payloads like `prefix` and `prefix[N]`, and if value
+// is not found, adds to the status payload, returning prefix.
+// If the payload already exists, returns std::nullopt.
 std::optional<std::string> AddStatusPayload(absl::Status& status,
                                             std::string_view prefix,
                                             absl::Cord value);
@@ -111,7 +111,6 @@ inline absl::Status MaybeAnnotateStatus(
   return internal::MaybeAnnotateStatusImpl(std::move(source), message,
                                            std::nullopt, loc);
 }
-
 inline absl::Status MaybeAnnotateStatus(
     absl::Status source, std::string_view message, absl::StatusCode new_code,
     SourceLocation loc = tensorstore::SourceLocation::current()) {