perf(polymorphic): drop the intermediate Result array in release builds

Address CodeRabbit feedback on #29: the lossy element helper built a
full [Result] array and callers built a second array via compactMap,
doubling transient storage in release builds where per-element results
are unobservable.

Return a LossyPolymorphicElements value instead, which carries the
element array always and the per-element results only in DEBUG builds,
so release decodes a lossy array with a single collection allocation.
Behavior is unchanged in both configurations.

Includes house-style formatting (trailing commas, redundant self) that
the format hook applied to the touched files.

Claude-Session: https://claude.ai/code/session_017kn3Hf2khxiFy1TqimTGx9

Author: ElonPark

Sources/KarrotCodableKit/PolymorphicCodable/Extensions/UnkeyedDecodingContainer+LossyPolymorphicElements.swift

@@ -8,28 +8,49 @@
 
 import Foundation
 
+/// The outcome of a lossy polymorphic array pass. Per-element results are retained only in
+/// DEBUG builds, so release builds allocate a single element array and no `Result` storage.
+struct LossyPolymorphicElements<Element> {
+  let elements: [Element]
+  #if DEBUG
+  let results: [Result<Element, Error>]
+  #endif
+}
+
 extension UnkeyedDecodingContainer {
-  /// Decodes every element with the polymorphic `strategy`, capturing each element's result
-  /// instead of throwing, so lossy array wrappers can keep valid elements and record failures.
-  mutating func decodeLossyPolymorphicElementResults<Strategy: PolymorphicCodableStrategy>(
+  /// Decodes every element with the polymorphic `strategy`, skipping elements that fail to
+  /// decode instead of throwing, so lossy array wrappers can keep the valid elements.
+  /// In DEBUG builds each element's `Result` is also captured for resilient decoding outcomes.
+  mutating func decodeLossyPolymorphicElements<Strategy: PolymorphicCodableStrategy>(
     of strategy: Strategy.Type
-  ) throws -> [Result<Strategy.ExpectedType, Error>] {
+  ) throws -> LossyPolymorphicElements<Strategy.ExpectedType> {
+    var elements = [Strategy.ExpectedType]()
+    #if DEBUG
     var results = [Result<Strategy.ExpectedType, Error>]()
+    #endif
 
     while !isAtEnd {
       // Decoding through the element's super decoder always advances the container,
       // even when the element fails to decode.
       let elementDecoder = try superDecoder()
       do {
-        try results.append(.success(PolymorphicValue<Strategy>(from: elementDecoder).wrappedValue))
+        let value = try PolymorphicValue<Strategy>(from: elementDecoder).wrappedValue
+        elements.append(value)
+        #if DEBUG
+        results.append(.success(value))
+        #endif
       } catch {
         #if DEBUG
         elementDecoder.reportError(error)
-        #endif
         results.append(.failure(error))
+        #endif
       }
     }
 
-    return results
+    #if DEBUG
+    return LossyPolymorphicElements(elements: elements, results: results)
+    #else
+    return LossyPolymorphicElements(elements: elements)
+    #endif
   }
 }

Sources/KarrotCodableKit/PolymorphicCodable/OptionalPolymorphicLossyArrayValue.swift

@@ -66,7 +66,7 @@ public struct OptionalPolymorphicLossyArrayValue<PolymorphicType: PolymorphicCod
   init(
     wrappedValue: [PolymorphicType.ExpectedType]?,
     outcome: ResilientDecodingOutcome,
-    results: [Result<PolymorphicType.ExpectedType, Error>] = []
+    results: [Result<PolymorphicType.ExpectedType, Error>] = [],
   ) {
     self.wrappedValue = wrappedValue
     self.outcome = outcome
@@ -97,18 +97,21 @@ extension OptionalPolymorphicLossyArrayValue: Decodable {
 
     do {
       var container = try decoder.unkeyedContainer()
-      let results = try container.decodeLossyPolymorphicElementResults(of: PolymorphicType.self)
-      let elements = results.compactMap(\.success)
+      let decoded = try container.decodeLossyPolymorphicElements(of: PolymorphicType.self)
 
       #if DEBUG
-      if results.contains(where: \.isFailure) {
-        let error = ResilientDecodingOutcome.ArrayDecodingError(results: results)
-        self.init(wrappedValue: elements, outcome: .recoveredFrom(error, wasReported: false), results: results)
+      if decoded.results.contains(where: \.isFailure) {
+        let error = ResilientDecodingOutcome.ArrayDecodingError(results: decoded.results)
+        self.init(
+          wrappedValue: decoded.elements,
+          outcome: .recoveredFrom(error, wasReported: false),
+          results: decoded.results,
+        )
       } else {
-        self.init(wrappedValue: elements, outcome: .decodedSuccessfully, results: results)
+        self.init(wrappedValue: decoded.elements, outcome: .decodedSuccessfully, results: decoded.results)
       }
       #else
-      self.init(wrappedValue: elements, outcome: .decodedSuccessfully)
+      self.init(wrappedValue: decoded.elements, outcome: .decodedSuccessfully)
       #endif
     } catch {
       // Same policy as `PolymorphicLossyArrayValue`: an invalid array-level value recovers to `[]`.

Sources/KarrotCodableKit/PolymorphicCodable/PolymorphicLossyArrayValue.swift

@@ -60,17 +60,17 @@ public struct PolymorphicLossyArrayValue<PolymorphicType: PolymorphicCodableStra
 
   public init(wrappedValue: [PolymorphicType.ExpectedType]) {
     self.wrappedValue = wrappedValue
-    self.outcome = .decodedSuccessfully
+    outcome = .decodedSuccessfully
     #if DEBUG
-    self.results = []
+    results = []
     #endif
   }
 
   #if DEBUG
   init(
     wrappedValue: [PolymorphicType.ExpectedType],
     outcome: ResilientDecodingOutcome,
-    results: [Result<PolymorphicType.ExpectedType, Error>] = []
+    results: [Result<PolymorphicType.ExpectedType, Error>] = [],
   ) {
     self.wrappedValue = wrappedValue
     self.outcome = outcome
@@ -98,7 +98,7 @@ extension PolymorphicLossyArrayValue: Decodable {
       #if DEBUG
       let context = DecodingError.Context(
         codingPath: decoder.codingPath,
-        debugDescription: "Value was nil but property is non-optional"
+        debugDescription: "Value was nil but property is non-optional",
       )
       let error = DecodingError.valueNotFound([PolymorphicType.ExpectedType].self, context)
       decoder.reportError(error)
@@ -111,18 +111,21 @@ extension PolymorphicLossyArrayValue: Decodable {
 
     do {
       var container = try decoder.unkeyedContainer()
-      let results = try container.decodeLossyPolymorphicElementResults(of: PolymorphicType.self)
-      let elements = results.compactMap(\.success)
+      let decoded = try container.decodeLossyPolymorphicElements(of: PolymorphicType.self)
 
       #if DEBUG
-      if results.contains(where: \.isFailure) {
-        let error = ResilientDecodingOutcome.ArrayDecodingError(results: results)
-        self.init(wrappedValue: elements, outcome: .recoveredFrom(error, wasReported: false), results: results)
+      if decoded.results.contains(where: \.isFailure) {
+        let error = ResilientDecodingOutcome.ArrayDecodingError(results: decoded.results)
+        self.init(
+          wrappedValue: decoded.elements,
+          outcome: .recoveredFrom(error, wasReported: false),
+          results: decoded.results,
+        )
       } else {
-        self.init(wrappedValue: elements, outcome: .decodedSuccessfully, results: results)
+        self.init(wrappedValue: decoded.elements, outcome: .decodedSuccessfully, results: decoded.results)
       }
       #else
-      self.init(wrappedValue: elements)
+      self.init(wrappedValue: decoded.elements)
       #endif
     } catch {
       // An invalid array-level value (e.g., not an array) recovers to an empty array.