Support the predicate expressions CoreData can represent

Sources/CoreDataModel/FunctionEvaluation.swift

@@ -71,6 +71,8 @@ internal extension FetchRequest.Predicate.Expression {
             return true
         case .attribute, .relationship, .keyPath:
             return false
+        case let .arithmetic(arithmetic):
+            return arithmetic.left.containsFunction || arithmetic.right.containsFunction
         }
     }
 }

Sources/CoreDataModel/NSPredicate.swift

@@ -127,6 +127,7 @@ internal extension FetchRequest.Predicate.Expression {
         case let .attribute(value): return NSExpression(forConstantValue: value.toFoundation())
         case let .relationship(value): return NSExpression(forConstantValue: value.toFoundation())
         case let .function(value): return NSExpression(forFunction: value.name, arguments: value.arguments.map { $0.toFoundation() })
+        case let .arithmetic(value): return NSExpression(forFunction: value.function.rawValue, arguments: [value.left.toFoundation(), value.right.toFoundation()])
         }
     }
 }

Sources/CoreModel/FetchRequestEvaluation.swift

@@ -13,6 +13,9 @@ public extension FetchRequest {
     /// Filters by entity and predicate, sorts by the sort descriptors
     /// (with a stable identifier tiebreaker), then applies the fetch offset and limit.
     ///
+    /// Objects of other entities may be included; they're filtered out of the results but
+    /// remain available for key paths that traverse a relationship (e.g. `events.name`).
+    ///
     /// - Parameters:
     ///   - objects: The objects to evaluate the fetch request against.
     ///   - functions: Custom functions (keyed by name) that `.function` expressions can invoke.
@@ -23,7 +26,8 @@ public extension FetchRequest {
     ) -> [ModelData] {
         var results = objects.filter { $0.entity == entity }
         if let predicate {
-            results = results.filter { predicate.evaluate(with: $0, functions: functions) }
+            let index = objects.index()
+            results = results.filter { predicate.evaluate(with: $0, functions: functions, objects: index) }
         }
         results = results.sorted(by: sortDescriptors, functions: functions)
         if fetchOffset > 0 {
@@ -47,7 +51,20 @@ public extension Array where Element == ModelData {
         by predicate: FetchRequest.Predicate,
         functions: [String: DatabaseFunction] = [:]
     ) -> [ModelData] {
-        filter { predicate.evaluate(with: $0, functions: functions) }
+        let index = self.index()
+        return filter { predicate.evaluate(with: $0, functions: functions, objects: index) }
+    }
+
+    /// Index these objects by identifier, for resolving key paths that traverse a relationship.
+    ///
+    /// - Note: Built by hand rather than with `Dictionary.init(_:uniquingKeysWith:)`,
+    ///   which relies on dynamic casting and is unavailable under Embedded Swift.
+    internal func index() -> [ObjectID: ModelData] {
+        var index = [ObjectID: ModelData](minimumCapacity: count)
+        for object in self where index[object.id] == nil {
+            index[object.id] = object
+        }
+        return index
     }
 
     /// Sort in memory by the given descriptors, resolving function terms with the

Sources/CoreModel/InMemoryStorage.swift

@@ -66,7 +66,12 @@ internal final class InMemoryStorage {
             try validate(fetchRequest.entity)
             let values = (state.objects[fetchRequest.entity].map { Array($0.values) } ?? [])
                 .map { normalized(entity: fetchRequest.entity, $0, objects: state.objects) }
-            return fetchRequest.evaluate(values, functions: state.functions)
+            // objects of other entities are filtered out of the results, but let key paths
+            // that traverse a relationship (e.g. `events.name`) resolve their related objects
+            let related = state.objects
+                .filter { $0.key != fetchRequest.entity }
+                .flatMap { $0.value.values }
+            return fetchRequest.evaluate(values + related, functions: state.functions)
         }
     }
 

Sources/CoreModel/Predicate/ArithmeticExpression.swift

@@ -0,0 +1,90 @@
+//
+//  ArithmeticExpression.swift
+//  CoreModel
+//
+//  Created by Alsey Coleman Miller on 8/16/26.
+//  Copyright © 2026 PureSwift. All rights reserved.
+//
+
+public extension FetchRequest.Predicate {
+
+    /// An arithmetic operation on two expressions (e.g. `age + 1`).
+    struct ArithmeticExpression: Equatable, Hashable, Sendable {
+
+        /// The arithmetic function to apply.
+        public var function: Function
+
+        /// The left operand.
+        public var left: Expression
+
+        /// The right operand.
+        public var right: Expression
+
+        public init(function: Function, left: Expression, right: Expression) {
+            self.function = function
+            self.left = left
+            self.right = right
+        }
+    }
+}
+
+// MARK: - Supporting Types
+
+public extension FetchRequest.Predicate.ArithmeticExpression {
+
+    /// Arithmetic function.
+    ///
+    /// Raw values match the corresponding `NSExpression` function names,
+    /// with operands passed in `(left, right)` order.
+    enum Function: String, Sendable, CaseIterable {
+
+        /// Addition (`left + right`).
+        case add        = "add:to:"
+
+        /// Subtraction (`left - right`).
+        case subtract   = "from:subtract:"
+
+        /// Multiplication (`left * right`).
+        case multiply   = "multiply:by:"
+
+        /// Division (`left / right`).
+        ///
+        /// Integer operands divide truncating, the way Swift's `/` and
+        /// `NSExpression`'s `divide:by:` both do; floating-point operands
+        /// produce a floating-point value.
+        case divide     = "divide:by:"
+
+        /// Remainder (`left % right`), integers only.
+        case modulus    = "modulus:by:"
+    }
+}
+
+public extension FetchRequest.Predicate.ArithmeticExpression.Function {
+
+    /// The operator symbol (e.g. `+`).
+    var symbol: String {
+        switch self {
+        case .add:      return "+"
+        case .subtract: return "-"
+        case .multiply: return "*"
+        case .divide:   return "/"
+        case .modulus:  return "%"
+        }
+    }
+}
+
+// MARK: - CustomStringConvertible
+
+extension FetchRequest.Predicate.ArithmeticExpression: CustomStringConvertible {
+
+    public var description: String {
+        "(" + left.description + " " + function.symbol + " " + right.description + ")"
+    }
+}
+
+// MARK: - Codable
+
+#if !hasFeature(Embedded)
+extension FetchRequest.Predicate.ArithmeticExpression: Codable {}
+extension FetchRequest.Predicate.ArithmeticExpression.Function: Codable {}
+#endif