     internal let representation: ReductionsIndexRepresentation<Base.Index, Base.Element>
 
     @inlinable
+    internal init(
+      _ representation: ReductionsIndexRepresentation<Base.Index, Base.Element>
+    ) {
+      self.representation = representation
+    }
+
+    @inlinable
     public static func < (lhs: Self, rhs: Self) -> Bool {
       lhs.representation < rhs.representation
     }
-
-    @usableFromInline
-    internal static func base(index: Base.Index, result: Base.Element) -> Self {
-      Self(representation: .base(index: index, result: result))
-    }
-
-    @usableFromInline
-    internal static var start: Self { Self(representation: .start) }
-
-    @usableFromInline
-    internal static var end: Self { Self(representation: .end) }
   }
 
   @inlinable
   public var startIndex: Index {
     guard base.startIndex != base.endIndex else { return endIndex }
-    return .start
-  }
-
-  @inlinable
-  public var endIndex: Index { .end }
+    return Index(.start)
+  }
+
+  @inlinable
+  public var endIndex: Index { Index(.end) }
 
   @inlinable
   public subscript(position: Index) -> Base.Element {

  @usableFromInline
  internal let transform: (Base.Element, Base.Element) -> Base.Element

  @usableFromInline
  internal init(
    base: Base,
    transform: @escaping (Base.Element, Base.Element) -> Base.Element

    func index(after i: Base.Index, previous: Base.Element) -> Index {
      let index = base.index(after: i)
      guard index != base.endIndex else { return endIndex }
      return Index(.base(index: index, result: transform(previous, base[index])))
    }
    switch i.representation {
    case .start:
