# SectionKit SKCSingleTypeSection: Building Type-Safe Single-Cell Collection Sections

> Learn about SKCSingleTypeSection in SectionKit its use for homogeneous content lists with identical cell subclasses and data models. Build type-safe collection views.

- Repository: [神奇/sectionkit](https://github.com/linhay/sectionkit)
- Tags: deep-dive
- Published: 2026-03-06

---

**`SKCSingleTypeSection` is a generic, single-cell-type section implementation in SectionKit designed for homogeneous content lists where every row uses the same `UICollectionViewCell` subclass and shares a common data model.**

`SKCSingleTypeSection` eliminates boilerplate when building collection views with uniform rows. According to the [linhay/sectionkit](https://github.com/linhay/sectionkit) source code, this class provides a complete, type-safe infrastructure for data binding, diff-based reloads, and cell lifecycle management without requiring a custom `UICollectionViewDataSource`.

## What is SKCSingleTypeSection?

`SKCSingleTypeSection` is an `open class` that manages a section of collection view cells where every item is rendered by the same cell type. In [`SKCSingleTypeSection.swift`](https://github.com/linhay/sectionkit/blob/main/SKCSingleTypeSection.swift) lines 12-13, the class is declared with three generic constraints:

```swift
open class SKCSingleTypeSection<Cell: UICollectionViewCell & SKConfigurableView & SKLoadViewProtocol>

```

This declaration ties the section to a specific cell type that must conform to `SKConfigurableView` (providing a `Model` type and configuration method) and `SKLoadViewProtocol` (providing size calculation). The section uses `typealias Model = Cell.Model` to ensure type consistency between the data array and cell configuration.

### Architecture and Conformance

According to [`SKCSingleTypeSectionProtocol.swift`](https://github.com/linhay/sectionkit/blob/main/SKCSingleTypeSectionProtocol.swift) lines 11-14, the section conforms to **`SKCSingleTypeSectionProtocol`**, which inherits from:

- `SKCSectionProtocol` – Base section behavior
- `SKCViewDataSourcePrefetchingProtocol` – Cell prefetching support
- `SKSafeSizeProviderProtocol` – Safe area size handling

Internally, the class manages an array of `Model` objects, publishes changes via Combine, handles high-performance size caching through `highPerformance`/`highPerformanceID` properties, and supports flexible reload strategies via the `ReloadKind` enum defined in [`SKCSingleTypeSection.swift`](https://github.com/linhay/sectionkit/blob/main/SKCSingleTypeSection.swift) lines 35-39.

## When to Use SKCSingleTypeSection

Use this class when you need a **ready-made, type-safe section** for collections with homogeneous content. The primary use cases include:

- **Homogeneous lists** – Every row uses the same cell class (text lists, image grids, card collections)
- **Type-safe data binding** – You want compile-time guarantees that data models match cell expectations without manual casting
- **Advanced reload semantics** – You need automatic diff-based updates via `apply(models:)` or fine-grained reload control with `reloadKind` options like `.difference` or `.configAndDelete`
- **Built-in infrastructure** – You require prefetching, context menus, cell actions, and high-performance size caching without writing custom delegate methods

Avoid `SKCSingleTypeSection` when a section contains heterogeneous cell types; instead, implement a custom section conforming to `SKCSectionProtocol` directly.

## Implementing SKCSingleTypeSection

### Creating a Reusable Cell

First, define a cell that conforms to `SKConfigurableView` and `SKLoadViewProtocol`. In `Sources/SectionKit/SKConfigurable/`, these protocols require a `Model` struct, a `config(_:)` method, and a static size calculation method.

```swift
import UIKit
import SectionKit

final class TextCell: UICollectionViewCell, SKConfigurableView, SKLoadViewProtocol {
    struct Model {
        let text: String
    }
    
    private let label = UILabel()
    
    // MARK: - SKConfigurableView
    func config(_ model: Model) {
        label.text = model.text
    }
    
    // MARK: - SKLoadViewProtocol
    static func preferredSize(limit: CGSize, model: Model) -> CGSize {
        return CGSize(width: limit.width, height: 44)
    }
}

```

The `SKConfigurableView` protocol ensures the cell can be configured with its associated `Model` type, while `SKLoadViewProtocol` enables the section to calculate cell sizes before instantiation.

### Initializing the Section

Initialize the section with an array of models. The `init(_ models:)` method referenced in [`SKCSingleTypeSection.swift`](https://github.com/linhay/sectionkit/blob/main/SKCSingleTypeSection.swift) lines 51-53 accepts the initial data array:

```swift
let items = [
    TextCell.Model(text: "First Item"),
    TextCell.Model(text: "Second Item"),
    TextCell.Model(text: "Third Item")
]

let textSection = SKCSingleTypeSection<TextCell>(items)

```

You can customize cell appearance and handle interactions using the section's modifier methods:

```swift
// Apply conditional styling
textSection.if({ true }) { section in
    section.cellStyles.append { context in
        context.view.backgroundColor = .systemBackground
    }
}

// Handle cell selection
textSection.onCellAction(.selected) { context in
    print("Selected: \(context.model.text)")
}

```

### Wiring to SKCManager

`SKCManager` orchestrates the collection view. Assign your section to the manager's `sections` array and call `reloadData()`:

```swift
let layout = UICollectionViewFlowLayout()
let collectionView = UICollectionView(frame: .zero, collectionViewLayout: layout)
let manager = SKCManager(collectionView: collectionView)

manager.sections = [textSection]
manager.reloadData()

```

`SKCManager` (defined in [`SKCManager.swift`](https://github.com/linhay/sectionkit/blob/main/SKCManager.swift) lines 62-85) forwards all data source and delegate calls to each section conforming to `SKCAnySectionProtocol`.

### Advanced Diff-Based Reloads

For efficient updates, use the `apply(models:)` method with a custom equivalence closure. The implementation in [`SKCSingleTypeSection.swift`](https://github.com/linhay/sectionkit/blob/main/SKCSingleTypeSection.swift) uses the `reloadKind` property to determine the update strategy:

```swift
// Configure diff-based reloading
textSection.reloadKind = .difference { $0.text == $1.text }

// Apply new data with automatic insert/delete/move calculations
let newItems = [
    TextCell.Model(text: "First Item"),
    TextCell.Model(text: "Fourth Item")  // Changed from "Third Item"
]
textSection.apply(newItems)

```

The `ReloadKind` enum supports strategies ranging from full reloads to configuration-only updates, implemented in the private `reload(models:by:)` method (lines 44-62).

## Key Source Files and Components

Understanding the file structure helps when debugging or extending functionality:

- **[`SKCSingleTypeSection.swift`](https://github.com/linhay/sectionkit/blob/main/SKCSingleTypeSection.swift)** – Core implementation containing the generic class declaration (lines 12-13), initialization (lines 51-53), `apply(models:)` (lines 59-67), and `config(models:)` (lines 71-75)
- **[`SKCSingleTypeSectionProtocol.swift`](https://github.com/linhay/sectionkit/blob/main/SKCSingleTypeSectionProtocol.swift)** – Defines the protocol requirements and associated types tying cells to sections (lines 11-18)
- **`Plugin+SKCSingleTypeSection.swift`** – Bridges the section to the UI layer and collection view
- **`Sources/SectionKit/SKConfigurable/`** – Contains `SKConfigurableView` and `SKLoadViewProtocol` required by compatible cells

## Summary

- **`SKCSingleTypeSection`** is a generic, open class in SectionKit for managing collection view sections with uniform cell types
- It requires cells to conform to `SKConfigurableView` and `SKLoadViewProtocol` for type-safe data binding and size calculation
- Use it for homogeneous content to gain automatic diffing, prefetching, context menus, and high-performance size caching without custom data sources
- Key methods include `init(_ models:)`, `apply(models:)` for diff updates, and `onCellAction(_:)` for event handling
- The class supports flexible reload strategies via the `ReloadKind` enum including difference-based updates

## Frequently Asked Questions

### What protocols must a cell implement to work with SKCSingleTypeSection?

A cell must conform to **`SKConfigurableView`** and **`SKLoadViewProtocol`**. `SKConfigurableView` requires an associated `Model` type and a `config(_:)` method for data binding, while `SKLoadViewProtocol` requires `preferredSize(limit:model:)` for size calculation. These protocols are defined in the `Sources/SectionKit/SKConfigurable/` directory.

### How does SKCSingleTypeSection handle cell size calculation?

The section delegates size calculation to the cell's static method defined in `SKLoadViewProtocol`. It also provides **high-performance caching** through `highPerformance` and `highPerformanceID` properties, which cache calculated sizes to avoid expensive recomputation during scrolling.

### Can I use SKCSingleTypeSection with multiple cell types in one section?

No. `SKCSingleTypeSection` is strictly designed for **single-type sections** where every row uses the same cell class. For heterogeneous sections with multiple cell types, implement a custom section conforming to `SKCSectionProtocol` directly.

### What is the difference between `apply(models:)` and `config(models:)`?

**`apply(models:)`** performs a diff-aware reload using the section's `reloadKind` strategy (such as `.difference`), calculating minimal insertions, deletions, and moves. **`config(models:)`** simply replaces the internal model array and reloads the section without diffing, as implemented in [`SKCSingleTypeSection.swift`](https://github.com/linhay/sectionkit/blob/main/SKCSingleTypeSection.swift) lines 71-75.