From 5b76e9052623aca0b9e31868f03f5ba55b46a6e9 Mon Sep 17 00:00:00 2001
From: =?UTF-8?q?Tiago=20Guimar=C3=A3es?= <tilacog@gmail.com>
Date: Tue, 16 Jun 2026 16:24:28 -0300
Subject: [PATCH] Simplify SettledOrders IntoIterator type

The previous IntoIterator::IntoIter alias spelled out
std::iter::Map<std::iter::Zip<...>, fn(...)> and required a non-capturing
closure coerced to a function pointer so the type stayed nameable.

Replace it with a tiny SettledOrdersIter struct that holds the two
slice iterators and implements Iterator directly. Behavior is
unchanged for all call sites.
---
 programs/settlement/src/settle.rs | 37 ++++++++++++++++++++-----------
 1 file changed, 24 insertions(+), 13 deletions(-)

diff --git a/programs/settlement/src/settle.rs b/programs/settlement/src/settle.rs
index 0cbb47c..6d65615 100644
--- a/programs/settlement/src/settle.rs
+++ b/programs/settlement/src/settle.rs
@@ -34,21 +34,32 @@ struct SettledOrders<'a> {
 
 impl<'a> IntoIterator for SettledOrders<'a> {
     type Item = SettledOrder<'a>;
-    type IntoIter = std::iter::Map<
-        std::iter::Zip<std::slice::Iter<'a, [AccountView; 2]>, std::slice::Iter<'a, u8>>,
-        fn((&'a [AccountView; 2], &'a u8)) -> SettledOrder<'a>,
-    >;
+    type IntoIter = SettledOrdersIter<'a>;
 
     fn into_iter(self) -> Self::IntoIter {
-        // A non-capturing closure coerced to a function pointer so the iterator
-        // type stays nameable in `IntoIter` above.
-        let pair_to_order: fn((&'a [AccountView; 2], &'a u8)) -> SettledOrder<'a> =
-            |([order_pda, sell_token_account], &bump)| SettledOrder {
-                order_pda,
-                sell_token_account,
-                bump,
-            };
-        self.accounts.iter().zip(self.bumps).map(pair_to_order)
+        SettledOrdersIter {
+            accounts: self.accounts.iter(),
+            bumps: self.bumps.iter(),
+        }
+    }
+}
+
+struct SettledOrdersIter<'a> {
+    accounts: std::slice::Iter<'a, [AccountView; 2]>,
+    bumps: std::slice::Iter<'a, u8>,
+}
+
+impl<'a> Iterator for SettledOrdersIter<'a> {
+    type Item = SettledOrder<'a>;
+
+    fn next(&mut self) -> Option<Self::Item> {
+        let [order_pda, sell_token_account] = self.accounts.next()?;
+        let &bump = self.bumps.next()?;
+        Some(SettledOrder {
+            order_pda,
+            sell_token_account,
+            bump,
+        })
     }
 }