Support ~Copyable elements, more standard protocol conformances

Author: florianpircher

Sources/LightTableDelta/Delta.swift

@@ -18,16 +18,11 @@
 //
 
 /// A type representing a source element, a target element, or both a source and a target element.
-public enum Delta<Element> {
+public enum Delta<Element>: ~Copyable where Element: ~Copyable {
 	/// The type of the elements.
 	public typealias Element = Element
 	public typealias Side = DeltaSide
 
-	enum CodingKeys: String, CodingKey {
-		case source = "A"
-		case target = "B"
-	}
-	
 	/// A source element.
 	///
 	/// Conceptually, this is a value that was deleted and thus no target element is available.
@@ -41,25 +36,21 @@ public enum Delta<Element> {
 	/// Conceptually, this is a value that was modified and both the source and the target element are available.
 	/// The source and target elements can be different or equal.
 	case modified(source: Element, target: Element)
-	
-	/// Returns a modified delta where both the source and target share the same element.
-	@inlinable @inline(__always)
-	public static func equal(_ element: Element) -> Self {
-		.modified(source: element, target: element)
-	}
-	
+}
+
+public extension Delta where Element: ~Copyable {
 	/// Creates a modified delta from a source and a target element.
 	@inlinable @inline(__always)
-	public init(source: Element, target: Element) {
-		self = .modified(source: source, target: target)
+	init(source: consuming Element, target: consuming Element) {
+		self = .transition(source: source, target: target)
 	}
 
 	/// Creates a delta from a source and a target element.
 	///
 	/// If the source element is `nil`, the delta is `.added(target:)`.
 	/// Otherwise, the delta is `.modified(source:target:)`.
 	@inlinable
-	public init(source: Element?, target: Element) {
+	init(source: consuming Element?, target: consuming Element) {
 		if let source {
 			self = .modified(source: source, target: target)
 		}
@@ -73,7 +64,7 @@ public enum Delta<Element> {
 	/// If the target element is `nil`, the delta is `.deleted(source:)`.
 	/// Otherwise, the delta is `.modified(source:target:)`.
 	@inlinable
-	public init(source: Element, target: Element?) {
+	init(source: consuming Element, target: consuming Element?) {
 		if let target {
 			self = .modified(source: source, target: target)
 		}
@@ -89,9 +80,10 @@ public enum Delta<Element> {
 	/// If the target element is `nil`, the delta is `.deleted(source:)`.
 	/// Otherwise, the delta is `.modified(source:target:)`.
 	@inlinable
-	public init?(source: Element?, target: Element?) {
-		if let source, let target {
-			self = .modified(source: source, target: target)
+	init?(source: consuming Element?, target: consuming Element?) {
+		if source != nil && target != nil {
+			// `if let source, let target` does not work with non-copyable types here
+			self = .modified(source: source!, target: target!)
 		}
 		else if let source {
 			self = .deleted(source: source)
@@ -103,33 +95,15 @@ public enum Delta<Element> {
 			return nil
 		}
 	}
-	
-	/// The source element, if the delta value is not of type `.added`.
-	@inlinable @inline(__always)
-	public var source: Element? {
-		switch self {
-		case .deleted(let source): source
-		case .added(_): nil
-		case .modified(let source, _): source
-		}
-	}
-	
-	/// The target element, if the delta value is not of type `.deleted`.
-	@inlinable @inline(__always)
-	public var target: Element? {
-		switch self {
-		case .deleted(_): nil
-		case .added(let target): target
-		case .modified(_, let target): target
-		}
-	}
-	
+}
+
+public extension Delta where Element: ~Copyable {
 	/// Returns a delta containing the results of mapping the given closure over the delta’s elements.
 	@inlinable
-	public func map<T, E>(
-		_ transform: (Element) throws(E) -> T
+	consuming func map<T: ~Copyable, E>(
+		_ transform: (consuming Element) throws(E) -> T
 	) throws(E) -> Delta<T> {
-		switch self {
+		switch consume self {
 		case .deleted(let source):
 			.deleted(source: try transform(source))
 		case .added(let target):
@@ -141,10 +115,10 @@ public enum Delta<Element> {
 
 	/// Returns a delta containing the results of mapping the given closure over the delta’s elements, or `nil`, if the closure returns `nil` for any element.
 	@inlinable
-	public func flatMap<T, E>(
-		_ transform: (Element) throws(E) -> T?
+	consuming func compactMap<T: ~Copyable, E>(
+		_ transform: (consuming Element) throws(E) -> T?
 	) throws(E) -> Delta<T>? {
-		switch self {
+		switch consume self {
 		case .deleted(let source):
 			guard let source = try transform(source) else {
 				return nil
@@ -157,20 +131,85 @@ public enum Delta<Element> {
 			return .added(target: target)
 		case .modified(let source, let target):
 			guard let source = try transform(source),
-				  let target = try transform(target) else {
+			      let target = try transform(target) else {
 				return nil
 			}
 			return .modified(source: source, target: target)
 		}
 	}
 
+	/// Returns a reduced view of the delta, favoring the given side.
+	///
+	/// If an element is available on the favored side, it is returned.
+	/// Otherwise, the element on the other side is returned.
+	@inlinable
+	consuming func unified(favoring side: Side) -> Element {
+		switch side {
+		case .source:
+			switch consume self {
+			case .deleted(let source): source
+			case .added(let target): target
+			case .modified(let source, _): source
+			}
+		case .target:
+			switch consume self {
+			case .deleted(let source): source
+			case .added(let target): target
+			case .modified(_, let target): target
+			}
+		}
+	}
+	
+	/// Returns the combined value of the source and target element, if modified, otherwise returns the source or target value.
+	@inlinable
+	consuming func reduce<E>(
+		combine: (consuming Element, consuming Element) throws(E) -> Element
+	) throws(E) -> Element {
+		switch consume self {
+		case .deleted(let source):
+			source
+		case .added(let target):
+			target
+		case .modified(let source, let target):
+			try combine(source, target)
+		}
+	}
+}
+
+extension Delta: Copyable where Element: Copyable {
+	/// Returns a modified delta where both the source and target share the same element.
+	@inlinable @inline(__always)
+	public static func equal(_ element: Element) -> Self {
+		.modified(source: element, target: element)
+	}
+	
+	/// The source element, if the delta value is not of type `.added`.
+	@inlinable @inline(__always)
+	public var source: Element? {
+		switch self {
+		case .deleted(let source): source
+		case .added(_): nil
+		case .modified(let source, _): source
+		}
+	}
+	
+	/// The target element, if the delta value is not of type `.deleted`.
+	@inlinable @inline(__always)
+	public var target: Element? {
+		switch self {
+		case .deleted(_): nil
+		case .added(let target): target
+		case .modified(_, let target): target
+		}
+	}
+	
 	/// Returns a delta containing the results of mapping the given closure over the delta’s elements.
 	///
 	/// In the `.modified` case, `transform` is applied concurrently to both sides.
 	@available(macOS 10.15, iOS 13, tvOS 13, visionOS 1, watchOS 6, *)
 	@inlinable
 	public func asyncMap<T>(
-		_ transform: @Sendable (Element) async -> T
+		_ transform: @Sendable (consuming Element) async -> T
 	) async -> Delta<T> where Element: Sendable {
 		switch self {
 		case .deleted(let source):
@@ -190,7 +229,7 @@ public enum Delta<Element> {
 	@available(macOS 10.15, iOS 13, tvOS 13, visionOS 1, watchOS 6, *)
 	@inlinable
 	public func asyncMap<T>(
-		_ transform: @Sendable (Element) async throws -> T
+		_ transform: @Sendable (consuming Element) async throws -> T
 	) async throws -> Delta<T> where Element: Sendable {
 		switch self {
 		case .deleted(let source):
@@ -203,41 +242,17 @@ public enum Delta<Element> {
 			return try await .modified(source: transformedSource, target: transformedTarget)
 		}
 	}
-	
-	/// Returns a reduced view of the delta, favoring the given side.
-	///
-	/// If an element is available on the favored side, it is returned.
-	/// Otherwise, the element on the other side is returned.
-	@inlinable
-	public func unified(favoring side: Side) -> Element {
-		switch side {
-		case .source:
-			switch self {
-			case .deleted(let source): source
-			case .added(let target): target
-			case .modified(let source, _): source
-			}
-		case .target:
-			switch self {
-			case .deleted(let source): source
-			case .added(let target): target
-			case .modified(_, let target): target
-			}
-		}
-	}
-	
-	/// Returns the combined value of the source and target element, if modified, otherwise returns the source or target value.
-	@inlinable
-	public func reduce<E>(
-		combine: (Element, Element) throws(E) -> Element
-	) throws(E) -> Element {
+}
+
+extension Delta: CustomDebugStringConvertible {
+	public var debugDescription: String {
 		switch self {
 		case .deleted(let source):
-			source
+			"Delta.deleted(\(source))"
 		case .added(let target):
-			target
+			"Delta.added(\(target))"
 		case .modified(let source, let target):
-			try combine(source, target)
+			"Delta.modified(\(source), \(target))"
 		}
 	}
 }
@@ -246,6 +261,13 @@ extension Delta: Equatable where Element: Equatable {}
 
 extension Delta: Hashable where Element: Hashable {}
 
+public extension Delta where Element: ~Copyable {
+	enum CodingKeys: String, CodingKey {
+		case source = "A"
+		case target = "B"
+	}
+}
+
 extension Delta: Encodable where Element: Encodable {
 	public func encode(to encoder: any Encoder) throws {
 		switch self {

Sources/LightTableDelta/DeltaSide.swift

@@ -18,7 +18,7 @@
 //
 
 /// A description of the two sides of a delta value.
-public enum DeltaSide: Hashable, Sendable {
+public enum DeltaSide: Hashable, Sendable, BitwiseCopyable, CustomStringConvertible {
 	case source
 	case target
 
@@ -31,4 +31,11 @@ public enum DeltaSide: Hashable, Sendable {
 			.source
 		}
 	}
+	
+	public var description: String {
+		switch self {
+		case .source: "source"
+		case .target: "target"
+		}
+	}
 }