     
     #if os(iOS)
     // The record comparator
-    fileprivate var compareItems: ((Item<Record>, Item<Record>) -> Bool)?
+    fileprivate var identicalItems: ItemComparator<Record>?
     
     // The record comparator builder. It helps us supporting types that adopt
     // MutablePersistable: we just have to wait for a database connection, in
     // performFetch(), to get primary key information and generate a primary
     // key comparator.
-    private let compareItemsFactory: (Database) -> (Item<Record>, Item<Record>) -> Bool
+    private let identicalItemsFactory: (Database) -> ItemComparator<Record>
     #endif
     
     /// The request

        // Should controller become strong at any point before callbacks are
        // called, such unowned reference would have an opportunity to crash.
        return { [weak controller] observer in
            // Observer invalidated?
            guard observer.isValid else { return }
            
            // Controller alive?
            guard let request = controller?.request, let databaseWriter = controller?.databaseWriter else { return }
            
            // Fetch items.

                    // Look for a matching insertion
                    for (index, otherChange) in changes.enumerated() {
                        guard case .insertion(let newItem, let newIndexPath) = otherChange else { continue }
                        guard identicalItems(oldItem, newItem) else { continue }
                        let rowChanges = changedValues(from: oldItem.row, to: newItem.row)
                        if oldIndexPath == newIndexPath {
                            return (TableViewChange.update(item: newItem, indexPath: oldIndexPath, changes: rowChanges), index)
