global: traversable

crates/brk_computer/src/blks.rs

@@ -4,7 +4,7 @@ use brk_error::Result;
 use brk_indexer::Indexer;
 use brk_parser::Parser;
 use brk_structs::{BlkPosition, Height, TxIndex, Version};
-use brk_vecs::IVecs;
+use brk_traversable::Traversable;
 use vecdb::{
     AnyIterableVec, AnyStoredVec, AnyVec, CompressedVec, Database, Exit, GenericStoredVec,
     PAGE_SIZE, VecIterator,
@@ -12,7 +12,7 @@ use vecdb::{
 
 use super::{Indexes, indexes};
 
-#[derive(Clone, IVecs)]
+#[derive(Clone, Traversable)]
 pub struct Vecs {
     db: Database,
 
@@ -42,8 +42,11 @@ impl Vecs {
             db,
         };
 
-        this.db
-            .retain_regions(this.iter().flat_map(|v| v.region_names()).collect())?;
+        this.db.retain_regions(
+            this.iter_any_collectable()
+                .flat_map(|v| v.region_names())
+                .collect(),
+        )?;
 
         Ok(this)
     }

crates/brk_computer/src/chain.rs

@@ -9,7 +9,7 @@ use brk_structs::{
     SemesterIndex, StoredBool, StoredF32, StoredF64, StoredU32, StoredU64, Timestamp, TxIndex,
     TxVersion, Version, WeekIndex, Weight, YearIndex,
 };
-use brk_vecs::IVecs;
+use brk_traversable::Traversable;
 use vecdb::{
     AnyCloneableIterableVec, AnyIterableVec, Database, EagerVec, Exit, LazyVecFrom1, LazyVecFrom2,
     LazyVecFrom3, PAGE_SIZE, StoredIndex, VecIterator,
@@ -33,7 +33,7 @@ const TARGET_BLOCKS_PER_YEAR: u64 = 2 * TARGET_BLOCKS_PER_SEMESTER;
 const TARGET_BLOCKS_PER_DECADE: u64 = 10 * TARGET_BLOCKS_PER_YEAR;
 const ONE_TERA_HASH: f64 = 1_000_000_000_000.0;
 
-#[derive(Clone, IVecs, Allocative)]
+#[derive(Clone, Traversable, Allocative)]
 pub struct Vecs {
     db: Database,
 
@@ -1152,8 +1152,11 @@ impl Vecs {
             db,
         };
 
-        this.db
-            .retain_regions(this.iter().flat_map(|v| v.region_names()).collect())?;
+        this.db.retain_regions(
+            this.iter_any_collectable()
+                .flat_map(|v| v.region_names())
+                .collect(),
+        )?;
 
         Ok(this)
     }

crates/brk_computer/src/cointime.rs

@@ -2,7 +2,7 @@ use std::path::Path;
 
 use brk_error::Result;
 use brk_structs::{Bitcoin, CheckedSub, Dollars, StoredF32, StoredF64, Version};
-use brk_vecs::IVecs;
+use brk_traversable::Traversable;
 use vecdb::{Database, Exit, PAGE_SIZE, VecIterator};
 
 use crate::grouped::ComputedVecsFromDateIndex;
@@ -16,7 +16,7 @@ use super::{
     indexes, price, stateful,
 };
 
-#[derive(Clone, IVecs)]
+#[derive(Clone, Traversable)]
 pub struct Vecs {
     db: Database,
 
@@ -278,8 +278,11 @@ impl Vecs {
             db,
         };
 
-        this.db
-            .retain_regions(this.iter().flat_map(|v| v.region_names()).collect())?;
+        this.db.retain_regions(
+            this.iter_any_collectable()
+                .flat_map(|v| v.region_names())
+                .collect(),
+        )?;
 
         Ok(this)
     }

crates/brk_computer/src/constants.rs

@@ -2,7 +2,7 @@ use std::path::Path;
 
 use brk_error::Result;
 use brk_structs::{StoredF32, StoredI16, StoredU16, Version};
-use brk_vecs::IVecs;
+use brk_traversable::Traversable;
 use vecdb::{AnyVec, Database, Exit};
 
 use crate::grouped::Source;
@@ -13,7 +13,7 @@ use super::{
     indexes,
 };
 
-#[derive(Clone, IVecs)]
+#[derive(Clone, Traversable)]
 pub struct Vecs {
     db: Database,
 
@@ -160,8 +160,11 @@ impl Vecs {
             db,
         };
 
-        this.db
-            .retain_regions(this.iter().flat_map(|v| v.region_names()).collect())?;
+        this.db.retain_regions(
+            this.iter_any_collectable()
+                .flat_map(|v| v.region_names())
+                .collect(),
+        )?;
 
         Ok(this)
     }

crates/brk_computer/src/fetched.rs

@@ -4,7 +4,7 @@ use brk_error::Result;
 use brk_fetcher::Fetcher;
 use brk_indexer::Indexer;
 use brk_structs::{DateIndex, Height, OHLCCents, Version};
-use brk_vecs::IVecs;
+use brk_traversable::Traversable;
 use vecdb::{
     AnyIterableVec, AnyStoredVec, AnyVec, Database, Exit, GenericStoredVec, RawVec, StoredIndex,
     VecIterator,
@@ -12,7 +12,7 @@ use vecdb::{
 
 use super::{Indexes, indexes};
 
-#[derive(Clone, IVecs)]
+#[derive(Clone, Traversable)]
 pub struct Vecs {
     db: Database,
     fetcher: Fetcher,
@@ -42,8 +42,11 @@ impl Vecs {
             db,
         };
 
-        this.db
-            .retain_regions(this.iter().flat_map(|v| v.region_names()).collect())?;
+        this.db.retain_regions(
+            this.iter_any_collectable()
+                .flat_map(|v| v.region_names())
+                .collect(),
+        )?;
 
         Ok(this)
     }

crates/brk_computer/src/grouped/builder_eager.rs

@@ -1,17 +1,17 @@
 use allocative::Allocative;
 use brk_error::{Error, Result};
 use brk_structs::{CheckedSub, StoredU64, Version};
-use brk_vecs::IVecs;
+use brk_traversable::Traversable;
 use vecdb::{
-    AnyCollectableVec, AnyIterableVec, AnyStoredVec, AnyVec, Database, EagerVec, Exit, Format,
-    GenericStoredVec, StoredIndex, StoredRaw,
+    AnyIterableVec, AnyStoredVec, AnyVec, Database, EagerVec, Exit, Format, GenericStoredVec,
+    StoredIndex, StoredRaw,
 };
 
 use crate::utils::get_percentile;
 
 use super::ComputedType;
 
-#[derive(Clone, Debug, IVecs, Allocative)]
+#[derive(Clone, Debug, Traversable, Allocative)]
 pub struct EagerVecsBuilder<I, T>
 where
     I: StoredIndex,
@@ -541,7 +541,9 @@ where
     }
 
     pub fn starting_index(&self, max_from: I) -> I {
-        max_from.min(I::from(self.iter().map(|v| v.len()).min().unwrap()))
+        max_from.min(I::from(
+            self.iter_any_collectable().map(|v| v.len()).min().unwrap(),
+        ))
     }
 
     pub fn unwrap_first(&self) -> &EagerVec<I, T> {

crates/brk_computer/src/grouped/builder_lazy.rs

@@ -1,9 +1,8 @@
 use allocative::Allocative;
 use brk_structs::Version;
-use brk_vecs::IVecs;
+use brk_traversable::Traversable;
 use vecdb::{
-    AnyBoxedIterableVec, AnyCloneableIterableVec, AnyCollectableVec, FromCoarserIndex,
-    LazyVecFrom2, StoredIndex,
+    AnyBoxedIterableVec, AnyCloneableIterableVec, FromCoarserIndex, LazyVecFrom2, StoredIndex,
 };
 
 use crate::grouped::{EagerVecsBuilder, VecBuilderOptions};
@@ -11,7 +10,7 @@ use crate::grouped::{EagerVecsBuilder, VecBuilderOptions};
 use super::ComputedType;
 
 #[allow(clippy::type_complexity)]
-#[derive(Clone, IVecs, Allocative)]
+#[derive(Clone, Traversable, Allocative)]
 pub struct LazyVecsBuilder<I, T, S1I, S2T>
 where
     I: StoredIndex,
@@ -218,7 +217,9 @@ where
     }
 
     pub fn starting_index(&self, max_from: I) -> I {
-        max_from.min(I::from(self.iter().map(|v| v.len()).min().unwrap()))
+        max_from.min(I::from(
+            self.iter_any_collectable().map(|v| v.len()).min().unwrap(),
+        ))
     }
 
     pub fn unwrap_first(&self) -> &LazyVecFrom2<I, T, S1I, T, I, S2T> {

crates/brk_computer/src/grouped/from_dateindex.rs

@@ -4,14 +4,14 @@ use brk_error::Result;
 use brk_structs::{
     DateIndex, DecadeIndex, MonthIndex, QuarterIndex, SemesterIndex, Version, WeekIndex, YearIndex,
 };
-use brk_vecs::IVecs;
+use brk_traversable::Traversable;
 use vecdb::{AnyCloneableIterableVec, AnyIterableVec, Database, EagerVec, Exit};
 
 use crate::{Indexes, grouped::LazyVecsBuilder, indexes};
 
 use super::{ComputedType, EagerVecsBuilder, Source, VecBuilderOptions};
 
-#[derive(Clone, IVecs, Allocative)]
+#[derive(Clone, Traversable, Allocative)]
 pub struct ComputedVecsFromDateIndex<T>
 where
     T: ComputedType + PartialOrd,

crates/brk_computer/src/grouped/from_height.rs

@@ -5,7 +5,7 @@ use brk_structs::{
     DateIndex, DecadeIndex, DifficultyEpoch, Height, MonthIndex, QuarterIndex, SemesterIndex,
     Version, WeekIndex, YearIndex,
 };
-use brk_vecs::IVecs;
+use brk_traversable::Traversable;
 use vecdb::{AnyCloneableIterableVec, AnyIterableVec, Database, EagerVec, Exit};
 
 use crate::{
@@ -16,7 +16,7 @@ use crate::{
 
 use super::{ComputedType, EagerVecsBuilder, VecBuilderOptions};
 
-#[derive(Clone, IVecs, Allocative)]
+#[derive(Clone, Traversable, Allocative)]
 pub struct ComputedVecsFromHeight<T>
 where
     T: ComputedType + PartialOrd,

crates/brk_computer/src/grouped/from_height_strict.rs

@@ -1,14 +1,14 @@
 use brk_error::Result;
 
 use brk_structs::{DifficultyEpoch, Height, Version};
-use brk_vecs::IVecs;
+use brk_traversable::Traversable;
 use vecdb::{Database, EagerVec, Exit};
 
 use crate::{Indexes, indexes};
 
 use super::{ComputedType, EagerVecsBuilder, VecBuilderOptions};
 
-#[derive(Clone, IVecs)]
+#[derive(Clone, Traversable)]
 pub struct ComputedVecsFromHeightStrict<T>
 where
     T: ComputedType + PartialOrd,

crates/brk_computer/src/grouped/from_txindex.rs

@@ -5,7 +5,7 @@ use brk_structs::{
     Bitcoin, DateIndex, DecadeIndex, DifficultyEpoch, Dollars, Height, MonthIndex, QuarterIndex,
     Sats, SemesterIndex, TxIndex, Version, WeekIndex, YearIndex,
 };
-use brk_vecs::IVecs;
+use brk_traversable::Traversable;
 use vecdb::{
     AnyCloneableIterableVec, AnyVec, CollectableVec, Database, EagerVec, Exit, GenericStoredVec,
     StoredIndex, VecIterator,
@@ -19,7 +19,7 @@ use crate::{
 
 use super::{ComputedType, EagerVecsBuilder, VecBuilderOptions};
 
-#[derive(Clone, IVecs, Allocative)]
+#[derive(Clone, Traversable, Allocative)]
 pub struct ComputedVecsFromTxindex<T>
 where
     T: ComputedType + PartialOrd,

crates/brk_computer/src/grouped/ratio_from_dateindex.rs

@@ -1,6 +1,6 @@
 use brk_error::Result;
 use brk_structs::{Date, DateIndex, Dollars, StoredF32, Version};
-use brk_vecs::IVecs;
+use brk_traversable::Traversable;
 use vecdb::{
     AnyIterableVec, AnyStoredVec, AnyVec, CollectableVec, Database, EagerVec, Exit,
     GenericStoredVec, StoredIndex, VecIterator,
@@ -17,7 +17,7 @@ use crate::{
 
 use super::{ComputedVecsFromDateIndex, VecBuilderOptions};
 
-#[derive(Clone, IVecs)]
+#[derive(Clone, Traversable)]
 pub struct ComputedRatioVecsFromDateIndex {
     pub price: Option<ComputedVecsFromDateIndex<Dollars>>,
 

crates/brk_computer/src/grouped/sd_from_dateindex.rs

@@ -1,6 +1,6 @@
 use brk_error::Result;
 use brk_structs::{CheckedSub, Date, DateIndex, Dollars, StoredF32, Version};
-use brk_vecs::IVecs;
+use brk_traversable::Traversable;
 use vecdb::{
     AnyIterableVec, AnyStoredVec, AnyVec, BoxedVecIterator, CollectableVec, Database, EagerVec,
     Exit, GenericStoredVec, StoredIndex,
@@ -10,7 +10,7 @@ use crate::{Indexes, grouped::source::Source, indexes};
 
 use super::{ComputedVecsFromDateIndex, VecBuilderOptions};
 
-#[derive(Clone, IVecs)]
+#[derive(Clone, Traversable)]
 pub struct ComputedStandardDeviationVecsFromDateIndex {
     days: usize,
 

crates/brk_computer/src/grouped/value_from_dateindex.rs

@@ -1,6 +1,6 @@
 use brk_error::Result;
 use brk_structs::{Bitcoin, DateIndex, Dollars, Sats, Version};
-use brk_vecs::IVecs;
+use brk_traversable::Traversable;
 use vecdb::{CollectableVec, Database, EagerVec, Exit, StoredVec};
 
 use crate::{
@@ -12,7 +12,7 @@ use crate::{
 
 use super::{Source, VecBuilderOptions};
 
-#[derive(Clone, IVecs)]
+#[derive(Clone, Traversable)]
 pub struct ComputedValueVecsFromDateIndex {
     pub sats: ComputedVecsFromDateIndex<Sats>,
     pub bitcoin: ComputedVecsFromDateIndex<Bitcoin>,

crates/brk_computer/src/grouped/value_from_height.rs

@@ -1,7 +1,7 @@
 use allocative::Allocative;
 use brk_error::Result;
 use brk_structs::{Bitcoin, Dollars, Height, Sats, Version};
-use brk_vecs::IVecs;
+use brk_traversable::Traversable;
 use vecdb::{CollectableVec, Database, EagerVec, Exit, StoredVec};
 
 use crate::{
@@ -13,7 +13,7 @@ use crate::{
 
 use super::{ComputedVecsFromHeight, VecBuilderOptions};
 
-#[derive(Clone, IVecs, Allocative)]
+#[derive(Clone, Traversable, Allocative)]
 pub struct ComputedValueVecsFromHeight {
     pub sats: ComputedVecsFromHeight<Sats>,
     pub bitcoin: ComputedVecsFromHeight<Bitcoin>,

crates/brk_computer/src/grouped/value_from_txindex.rs

@@ -2,7 +2,7 @@ use allocative::Allocative;
 use brk_error::Result;
 use brk_indexer::Indexer;
 use brk_structs::{Bitcoin, Close, Dollars, Height, Sats, TxIndex, Version};
-use brk_vecs::IVecs;
+use brk_traversable::Traversable;
 use vecdb::{
     AnyCloneableIterableVec, CollectableVec, Database, Exit, LazyVecFrom1, LazyVecFrom3,
     StoredIndex, StoredVec,
@@ -12,7 +12,7 @@ use crate::{Indexes, grouped::Source, indexes, price};
 
 use super::{ComputedVecsFromTxindex, VecBuilderOptions};
 
-#[derive(Clone, IVecs, Allocative)]
+#[derive(Clone, Traversable, Allocative)]
 pub struct ComputedValueVecsFromTxindex {
     pub sats: ComputedVecsFromTxindex<Sats>,
     pub bitcoin_txindex: LazyVecFrom1<TxIndex, Bitcoin, TxIndex, Sats>,

crates/brk_computer/src/grouped/value_height.rs

@@ -1,6 +1,6 @@
 use brk_error::Result;
 use brk_structs::{Bitcoin, Dollars, Height, Sats, Version};
-use brk_vecs::IVecs;
+use brk_traversable::Traversable;
 use vecdb::{CollectableVec, Database, EagerVec, Exit, Format, StoredVec};
 
 use crate::{
@@ -10,7 +10,7 @@ use crate::{
     traits::{ComputeFromBitcoin, ComputeFromSats},
 };
 
-#[derive(Clone, IVecs)]
+#[derive(Clone, Traversable)]
 pub struct ComputedHeightValueVecs {
     pub sats: Option<EagerVec<Height, Sats>>,
     pub bitcoin: EagerVec<Height, Bitcoin>,

crates/brk_computer/src/indexes.rs

@@ -10,15 +10,15 @@ use brk_structs::{
     P2WPKHBytes, P2WSHAddressIndex, P2WSHBytes, QuarterIndex, Sats, SemesterIndex, StoredU64,
     Timestamp, TxIndex, Txid, UnknownOutputIndex, Version, WeekIndex, YearIndex,
 };
-use brk_vecs::IVecs;
+use brk_traversable::Traversable;
 use vecdb::{
-    AnyCloneableIterableVec, AnyCollectableVec, Database, EagerVec, Exit, LazyVecFrom1,
-    LazyVecFrom2, PAGE_SIZE, StoredIndex, VecIterator,
+    AnyCloneableIterableVec, Database, EagerVec, Exit, LazyVecFrom1, LazyVecFrom2, PAGE_SIZE,
+    StoredIndex, VecIterator,
 };
 
 const VERSION: Version = Version::ZERO;
 
-#[derive(Clone, IVecs)]
+#[derive(Clone, Traversable)]
 pub struct Vecs {
     db: Database,
 
@@ -475,8 +475,11 @@ impl Vecs {
             db,
         };
 
-        this.db
-            .retain_regions(this.iter().flat_map(|v| v.region_names()).collect())?;
+        this.db.retain_regions(
+            this.iter_any_collectable()
+                .flat_map(|v| v.region_names())
+                .collect(),
+        )?;
 
         Ok(this)
     }

crates/brk_computer/src/lib.rs

@@ -7,7 +7,7 @@ use brk_fetcher::Fetcher;
 use brk_indexer::Indexer;
 use brk_parser::Parser;
 use brk_structs::Version;
-use brk_vecs::IVecs;
+use brk_traversable::Traversable;
 use log::info;
 use vecdb::{Exit, Format};
 
@@ -32,7 +32,7 @@ pub use pools::*;
 pub use states::PriceToAmount;
 use states::*;
 
-#[derive(Clone, IVecs)]
+#[derive(Clone, Traversable)]
 pub struct Computer {
     pub chain: chain::Vecs,
     pub cointime: cointime::Vecs,

crates/brk_computer/src/market.rs

@@ -2,7 +2,7 @@ use std::{path::Path, thread};
 
 use brk_error::Result;
 use brk_structs::{Date, DateIndex, Dollars, Height, Sats, StoredF32, StoredU16, Version};
-use brk_vecs::IVecs;
+use brk_traversable::Traversable;
 use vecdb::{Database, EagerVec, Exit, PAGE_SIZE, StoredIndex, VecIterator};
 
 use crate::{
@@ -17,7 +17,7 @@ use super::{
     indexes,
 };
 
-#[derive(Clone, IVecs)]
+#[derive(Clone, Traversable)]
 pub struct Vecs {
     db: Database,
 
@@ -1516,8 +1516,11 @@ impl Vecs {
             db,
         };
 
-        this.db
-            .retain_regions(this.iter().flat_map(|v| v.region_names()).collect())?;
+        this.db.retain_regions(
+            this.iter_any_collectable()
+                .flat_map(|v| v.region_names())
+                .collect(),
+        )?;
 
         Ok(this)
     }

crates/brk_computer/src/pools/mod.rs

@@ -5,7 +5,7 @@ use brk_error::Result;
 use brk_indexer::Indexer;
 use brk_store::AnyStore;
 use brk_structs::{AddressBytes, Height, OutputIndex, OutputType, PoolId, Pools, pools};
-use brk_vecs::IVecs;
+use brk_traversable::Traversable;
 use rayon::prelude::*;
 use vecdb::{
     AnyIterableVec, AnyStoredVec, AnyVec, Database, Exit, GenericStoredVec, PAGE_SIZE, RawVec,
@@ -20,13 +20,13 @@ use crate::{
     price,
 };
 
-#[derive(Clone, IVecs, Allocative)]
+#[derive(Clone, Traversable, Allocative)]
 pub struct Vecs {
     db: Database,
     pools: &'static Pools,
-    height_to_pool: RawVec<Height, PoolId>,
 
-    vecs: BTreeMap<PoolId, vecs::Vecs>,
+    pub height_to_pool: RawVec<Height, PoolId>,
+    pub vecs: BTreeMap<PoolId, vecs::Vecs>,
 }
 
 impl Vecs {
@@ -62,8 +62,11 @@ impl Vecs {
             db,
         };
 
-        this.db
-            .retain_regions(this.iter().flat_map(|v| v.region_names()).collect())?;
+        this.db.retain_regions(
+            this.iter_any_collectable()
+                .flat_map(|v| v.region_names())
+                .collect(),
+        )?;
 
         Ok(this)
     }

crates/brk_computer/src/pools/vecs.rs

@@ -1,7 +1,7 @@
 use allocative::Allocative;
 use brk_error::Result;
 use brk_structs::{Height, PoolId, Pools, Sats, StoredF32, StoredU16, StoredU32};
-use brk_vecs::IVecs;
+use brk_traversable::Traversable;
 use vecdb::{AnyIterableVec, Database, Exit, StoredIndex, VecIterator, Version};
 
 use crate::{
@@ -14,23 +14,23 @@ use crate::{
     price,
 };
 
-#[derive(Clone, IVecs, Allocative)]
+#[derive(Clone, Traversable, Allocative)]
 pub struct Vecs {
     id: PoolId,
 
-    indexes_to_blocks_mined: ComputedVecsFromHeight<StoredU32>,
-    indexes_to_1w_blocks_mined: ComputedVecsFromDateIndex<StoredU32>,
-    indexes_to_1m_blocks_mined: ComputedVecsFromDateIndex<StoredU32>,
-    indexes_to_1y_blocks_mined: ComputedVecsFromDateIndex<StoredU32>,
-    indexes_to_subsidy: ComputedValueVecsFromHeight,
-    indexes_to_fee: ComputedValueVecsFromHeight,
-    indexes_to_coinbase: ComputedValueVecsFromHeight,
-    indexes_to_dominance: ComputedVecsFromDateIndex<StoredF32>,
-    indexes_to_1d_dominance: ComputedVecsFromDateIndex<StoredF32>,
-    indexes_to_1w_dominance: ComputedVecsFromDateIndex<StoredF32>,
-    indexes_to_1m_dominance: ComputedVecsFromDateIndex<StoredF32>,
-    indexes_to_1y_dominance: ComputedVecsFromDateIndex<StoredF32>,
-    indexes_to_days_since_block: ComputedVecsFromDateIndex<StoredU16>,
+    pub indexes_to_blocks_mined: ComputedVecsFromHeight<StoredU32>,
+    pub indexes_to_1w_blocks_mined: ComputedVecsFromDateIndex<StoredU32>,
+    pub indexes_to_1m_blocks_mined: ComputedVecsFromDateIndex<StoredU32>,
+    pub indexes_to_1y_blocks_mined: ComputedVecsFromDateIndex<StoredU32>,
+    pub indexes_to_subsidy: ComputedValueVecsFromHeight,
+    pub indexes_to_fee: ComputedValueVecsFromHeight,
+    pub indexes_to_coinbase: ComputedValueVecsFromHeight,
+    pub indexes_to_dominance: ComputedVecsFromDateIndex<StoredF32>,
+    pub indexes_to_1d_dominance: ComputedVecsFromDateIndex<StoredF32>,
+    pub indexes_to_1w_dominance: ComputedVecsFromDateIndex<StoredF32>,
+    pub indexes_to_1m_dominance: ComputedVecsFromDateIndex<StoredF32>,
+    pub indexes_to_1y_dominance: ComputedVecsFromDateIndex<StoredF32>,
+    pub indexes_to_days_since_block: ComputedVecsFromDateIndex<StoredU16>,
 }
 
 impl Vecs {

crates/brk_computer/src/price.rs

@@ -5,7 +5,7 @@ use brk_structs::{
     Cents, Close, DateIndex, DecadeIndex, DifficultyEpoch, Dollars, Height, High, Low, MonthIndex,
     OHLCDollars, OHLCSats, Open, QuarterIndex, Sats, SemesterIndex, Version, WeekIndex, YearIndex,
 };
-use brk_vecs::IVecs;
+use brk_traversable::Traversable;
 use vecdb::{
     AnyIterableVec, AnyStoredVec, AnyVec, Database, EagerVec, Exit, GenericStoredVec, PAGE_SIZE,
     RawVec,
@@ -19,7 +19,7 @@ use super::{
     indexes,
 };
 
-#[derive(Clone, IVecs)]
+#[derive(Clone, Traversable)]
 pub struct Vecs {
     db: Database,
 
@@ -326,8 +326,11 @@ impl Vecs {
             db,
         };
 
-        this.db
-            .retain_regions(this.iter().flat_map(|v| v.region_names()).collect())?;
+        this.db.retain_regions(
+            this.iter_any_collectable()
+                .flat_map(|v| v.region_names())
+                .collect(),
+        )?;
 
         Ok(this)
     }

crates/brk_computer/src/stateful/address_cohort.rs

@@ -2,7 +2,7 @@ use std::path::Path;
 
 use brk_error::Result;
 use brk_structs::{Bitcoin, DateIndex, Dollars, Height, StoredU64, Version};
-use brk_vecs::IVecs;
+use brk_traversable::Traversable;
 use vecdb::{
     AnyIterableVec, AnyStoredVec, AnyVec, Database, EagerVec, Exit, Format, GenericStoredVec,
     VecIterator,
@@ -21,7 +21,7 @@ use crate::{
 
 const VERSION: Version = Version::ZERO;
 
-#[derive(Clone, IVecs)]
+#[derive(Clone, Traversable)]
 pub struct Vecs {
     starting_height: Option<Height>,
 

crates/brk_computer/src/stateful/address_cohorts.rs

@@ -3,9 +3,9 @@ use std::path::Path;
 use brk_error::Result;
 use brk_structs::{
     AddressGroups, Bitcoin, ByAmountRange, ByGreatEqualAmount, ByLowerThanAmount, DateIndex,
-    Dollars, GroupFilter, Height, Version,
+    Dollars, Filtered, Height, Version,
 };
-use brk_vecs::IVecs;
+use brk_traversable::Traversable;
 use derive_deref::{Deref, DerefMut};
 use vecdb::{AnyIterableVec, Database, Exit, Format};
 
@@ -19,8 +19,8 @@ use crate::{
 
 const VERSION: Version = Version::new(0);
 
-#[derive(Clone, Deref, DerefMut, IVecs)]
-pub struct Vecs(AddressGroups<(GroupFilter, address_cohort::Vecs)>);
+#[derive(Clone, Deref, DerefMut, Traversable)]
+pub struct Vecs(AddressGroups<Filtered<address_cohort::Vecs>>);
 
 impl Vecs {
     pub fn forced_import(
@@ -465,13 +465,13 @@ impl Vecs {
             self.0
                 .ge_amount
                 .iter_mut()
-                .map(|(filter, vecs)| {
+                .map(|Filtered(filter, vecs)| {
                     (
                         vecs,
                         by_size_range
                             .iter()
-                            .filter(|(other, _)| filter.includes(other))
-                            .map(|(_, v)| v)
+                            .filter(|other| other.includes(filter))
+                            .map(Filtered::t)
                             .collect::<Vec<_>>(),
                     )
                 })
@@ -479,13 +479,13 @@ impl Vecs {
             self.0
                 .lt_amount
                 .iter_mut()
-                .map(|(filter, vecs)| {
+                .map(|Filtered(filter, vecs)| {
                     (
                         vecs,
                         by_size_range
                             .iter()
-                            .filter(|(other, _)| filter.includes(other))
-                            .map(|(_, v)| v)
+                            .filter(|other| other.includes(filter))
+                            .map(Filtered::t)
                             .collect::<Vec<_>>(),
                     )
                 })
@@ -506,8 +506,8 @@ impl Vecs {
         exit: &Exit,
     ) -> Result<()> {
         self.iter_mut()
-            .into_iter()
-            .try_for_each(|(_, v)| v.compute_rest_part1(indexes, price, starting_indexes, exit))
+            .map(Filtered::mut_t)
+            .try_for_each(|v| v.compute_rest_part1(indexes, price, starting_indexes, exit))
     }
 
     #[allow(clippy::too_many_arguments)]
@@ -524,7 +524,7 @@ impl Vecs {
         dateindex_to_realized_cap: Option<&impl AnyIterableVec<DateIndex, Dollars>>,
         exit: &Exit,
     ) -> Result<()> {
-        self.0.iter_mut().try_for_each(|(_, v)| {
+        self.0.iter_mut().map(Filtered::mut_t).try_for_each(|v| {
             v.compute_rest_part2(
                 indexes,
                 price,
@@ -542,7 +542,7 @@ impl Vecs {
 
     pub fn safe_flush_stateful_vecs(&mut self, height: Height, exit: &Exit) -> Result<()> {
         self.iter_separate_mut()
-            .into_iter()
-            .try_for_each(|(_, v)| v.safe_flush_stateful_vecs(height, exit))
+            .map(Filtered::mut_t)
+            .try_for_each(|v| v.safe_flush_stateful_vecs(height, exit))
     }
 }

crates/brk_computer/src/stateful/addresstype/height_to_addresscount.rs

@@ -1,12 +1,12 @@
 use brk_error::Result;
 use brk_structs::{ByAddressType, Height, StoredU64};
-use brk_vecs::IVecs;
+use brk_traversable::Traversable;
 use derive_deref::{Deref, DerefMut};
 use vecdb::{EagerVec, Exit, GenericStoredVec};
 
 use super::AddressTypeToAddressCount;
 
-#[derive(Debug, Clone, Deref, DerefMut, IVecs)]
+#[derive(Debug, Clone, Deref, DerefMut, Traversable)]
 pub struct AddressTypeToHeightToAddressCount(ByAddressType<EagerVec<Height, StoredU64>>);
 
 impl From<ByAddressType<EagerVec<Height, StoredU64>>> for AddressTypeToHeightToAddressCount {

crates/brk_computer/src/stateful/addresstype/indexes_to_addresscount.rs

@@ -1,6 +1,6 @@
 use brk_error::Result;
 use brk_structs::{ByAddressType, StoredU64};
-use brk_vecs::IVecs;
+use brk_traversable::Traversable;
 use derive_deref::{Deref, DerefMut};
 use vecdb::Exit;
 
@@ -8,7 +8,7 @@ use crate::{Indexes, grouped::ComputedVecsFromHeight, indexes};
 
 use super::AddressTypeToHeightToAddressCount;
 
-#[derive(Clone, Deref, DerefMut, IVecs)]
+#[derive(Clone, Deref, DerefMut, Traversable)]
 pub struct AddressTypeToIndexesToAddressCount(ByAddressType<ComputedVecsFromHeight<StoredU64>>);
 
 impl From<ByAddressType<ComputedVecsFromHeight<StoredU64>>> for AddressTypeToIndexesToAddressCount {

crates/brk_computer/src/stateful/common.rs

@@ -2,7 +2,7 @@ use brk_error::{Error, Result};
 use brk_structs::{
     Bitcoin, DateIndex, Dollars, Height, Sats, StoredF32, StoredF64, StoredU64, Version,
 };
-use brk_vecs::IVecs;
+use brk_traversable::Traversable;
 use vecdb::{
     AnyCloneableIterableVec, AnyIterableVec, AnyStoredVec, AnyVec, Database, EagerVec, Exit,
     Format, GenericStoredVec, VecIterator,
@@ -18,7 +18,7 @@ use crate::{
     states::CohortState,
 };
 
-#[derive(Clone, IVecs)]
+#[derive(Clone, Traversable)]
 pub struct Vecs {
     // Cumulative
     pub height_to_realized_cap: Option<EagerVec<Height, Dollars>>,

crates/brk_computer/src/stateful/mod.rs

@@ -10,12 +10,12 @@ use brk_error::Result;
 use brk_indexer::Indexer;
 use brk_structs::{
     AnyAddressDataIndexEnum, AnyAddressIndex, ByAddressType, ByAnyAddress, CheckedSub, DateIndex,
-    Dollars, EmptyAddressData, EmptyAddressIndex, Height, InputIndex, LoadedAddressData,
+    Dollars, EmptyAddressData, EmptyAddressIndex, Filtered, Height, InputIndex, LoadedAddressData,
     LoadedAddressIndex, OutputIndex, OutputType, P2AAddressIndex, P2PK33AddressIndex,
     P2PK65AddressIndex, P2PKHAddressIndex, P2SHAddressIndex, P2TRAddressIndex, P2WPKHAddressIndex,
     P2WSHAddressIndex, Sats, StoredU64, Timestamp, TypeIndex, Version,
 };
-use brk_vecs::IVecs;
+use brk_traversable::Traversable;
 use log::info;
 use rayon::prelude::*;
 use vecdb::{
@@ -50,7 +50,7 @@ use withaddressdatasource::*;
 
 const VERSION: Version = Version::new(21);
 
-#[derive(Clone, IVecs)]
+#[derive(Clone, Traversable)]
 pub struct Vecs {
     db: Database,
 
@@ -493,8 +493,11 @@ impl Vecs {
             db,
         };
 
-        this.db
-            .retain_regions(this.iter().flat_map(|v| v.region_names()).collect())?;
+        this.db.retain_regions(
+            this.iter_any_collectable()
+                .flat_map(|v| v.region_names())
+                .collect(),
+        )?;
 
         Ok(this)
     }
@@ -601,10 +604,10 @@ impl Vecs {
 
         separate_utxo_vecs
             .par_iter_mut()
-            .try_for_each(|(_, v)| v.validate_computed_versions(base_version))?;
+            .try_for_each(|Filtered(_, v)| v.validate_computed_versions(base_version))?;
         separate_address_vecs
             .par_iter_mut()
-            .try_for_each(|(_, v)| v.validate_computed_versions(base_version))?;
+            .try_for_each(|Filtered(_, v)| v.validate_computed_versions(base_version))?;
         self.height_to_unspendable_supply
             .validate_computed_version_or_reset(
                 base_version + self.height_to_unspendable_supply.inner_version(),
@@ -617,13 +620,13 @@ impl Vecs {
         let mut chain_state_starting_height = Height::from(self.chain_state.len());
         let stateful_starting_height = match separate_utxo_vecs
             .par_iter_mut()
-            .map(|(_, v)| Height::from(v.min_height_vecs_len()))
+            .map(|Filtered(_, v)| Height::from(v.min_height_vecs_len()))
             .min()
             .unwrap_or_default()
             .min(
                 separate_address_vecs
                     .par_iter_mut()
-                    .map(|(_, v)| Height::from(v.min_height_vecs_len()))
+                    .map(|Filtered(_, v)| Height::from(v.min_height_vecs_len()))
                     .min()
                     .unwrap_or_default(),
             )
@@ -707,7 +710,7 @@ impl Vecs {
             let starting_height = if starting_height.is_not_zero()
                 && separate_utxo_vecs
                     .iter_mut()
-                    .map(|(_, v)| v.import_state(starting_height).unwrap_or_default())
+                    .map(|Filtered(_, v)| v.import_state(starting_height).unwrap_or_default())
                     .all(|h| h == starting_height)
             {
                 starting_height
@@ -719,7 +722,7 @@ impl Vecs {
             let starting_height = if starting_height.is_not_zero()
                 && separate_address_vecs
                     .iter_mut()
-                    .map(|(_, v)| v.import_state(starting_height).unwrap_or_default())
+                    .map(|Filtered(_, v)| v.import_state(starting_height).unwrap_or_default())
                     .all(|h| h == starting_height)
             {
                 starting_height
@@ -767,14 +770,16 @@ impl Vecs {
                 self.loadedaddressindex_to_loadedaddressdata.reset()?;
                 self.emptyaddressindex_to_emptyaddressdata.reset()?;
 
-                separate_utxo_vecs.par_iter_mut().try_for_each(|(_, v)| {
-                    v.reset_state_starting_height();
-                    v.state.as_mut().unwrap().reset_price_to_amount_if_needed()
-                })?;
+                separate_utxo_vecs
+                    .par_iter_mut()
+                    .try_for_each(|Filtered(_, v)| {
+                        v.reset_state_starting_height();
+                        v.state.as_mut().unwrap().reset_price_to_amount_if_needed()
+                    })?;
 
                 separate_address_vecs
                     .par_iter_mut()
-                    .try_for_each(|(_, v)| {
+                    .try_for_each(|Filtered(_, v)| {
                         v.reset_state_starting_height();
                         v.state.as_mut().unwrap().reset_price_to_amount_if_needed()
                     })?;
@@ -877,11 +882,11 @@ impl Vecs {
 
                     self.utxo_cohorts
                         .iter_separate_mut()
-                        .for_each(|(_, v)| v.state.as_mut().unwrap().reset_single_iteration_values());
+                        .for_each(|Filtered(_, v)| v.state.as_mut().unwrap().reset_single_iteration_values());
 
                     self.address_cohorts
                         .iter_separate_mut()
-                        .for_each(|(_, v)| v.state.as_mut().unwrap().reset_single_iteration_values());
+                        .for_each(|Filtered(_, v)| v.state.as_mut().unwrap().reset_single_iteration_values());
 
                     let timestamp = height_to_timestamp_fixed_iter.unwrap_get_inner(height);
                     let price = height_to_price_close_iter
@@ -1249,11 +1254,11 @@ impl Vecs {
                     let dateindex = is_date_last_height.then_some(dateindex);
 
                     self.utxo_cohorts.iter_separate_mut().par_bridge()
-                        .map(|(_, v)| v as &mut dyn DynCohortVecs)
+                        .map(|Filtered(_, v)| v as &mut dyn DynCohortVecs)
                         .chain(
                             self.address_cohorts.iter_separate_mut()
                                 .par_bridge()
-                                .map(|(_, v)| v as &mut dyn DynCohortVecs),
+                                .map(|Filtered(_, v)| v as &mut dyn DynCohortVecs),
                         )
                         .try_for_each(|v| {
                             v.forced_pushed_at(height, exit)?;
@@ -1642,11 +1647,11 @@ impl Vecs {
         self.utxo_cohorts
             .iter_separate_mut()
             .par_bridge()
-            .try_for_each(|(_, v)| v.safe_flush_stateful_vecs(height, exit))?;
+            .try_for_each(|Filtered(_, v)| v.safe_flush_stateful_vecs(height, exit))?;
         self.address_cohorts
             .iter_separate_mut()
             .par_bridge()
-            .try_for_each(|(_, v)| v.safe_flush_stateful_vecs(height, exit))?;
+            .try_for_each(|Filtered(_, v)| v.safe_flush_stateful_vecs(height, exit))?;
         self.height_to_unspendable_supply.safe_flush(exit)?;
         self.height_to_opreturn_supply.safe_flush(exit)?;
         self.addresstype_to_height_to_addr_count

crates/brk_computer/src/stateful/utxo_cohort.rs

@@ -2,7 +2,7 @@ use std::{ops::Deref, path::Path};
 
 use brk_error::Result;
 use brk_structs::{Bitcoin, DateIndex, Dollars, Height, Version};
-use brk_vecs::IVecs;
+use brk_traversable::Traversable;
 use vecdb::{AnyIterableVec, Database, Exit, Format};
 
 use crate::{
@@ -13,14 +13,14 @@ use crate::{
     },
 };
 
-#[derive(Clone, IVecs)]
+#[derive(Clone, Traversable)]
 pub struct Vecs {
     state_starting_height: Option<Height>,
 
     #[vecs(skip)]
     pub state: Option<UTXOCohortState>,
 
-    inner: common::Vecs,
+    pub inner: common::Vecs,
 }
 
 impl Vecs {

crates/brk_computer/src/stateful/utxo_cohorts.rs

@@ -3,10 +3,10 @@ use std::{collections::BTreeMap, ops::ControlFlow, path::Path};
 use brk_error::Result;
 use brk_structs::{
     Bitcoin, ByAgeRange, ByAmountRange, ByEpoch, ByGreatEqualAmount, ByLowerThanAmount, ByMaxAge,
-    ByMinAge, BySpendableType, ByTerm, CheckedSub, DateIndex, Dollars, GroupFilter, HalvingEpoch,
-    Height, Timestamp, UTXOGroups, Version,
+    ByMinAge, BySpendableType, ByTerm, CheckedSub, DateIndex, Dollars, Filter, Filtered,
+    HalvingEpoch, Height, Timestamp, UTXOGroups, Version,
 };
-use brk_vecs::IVecs;
+use brk_traversable::Traversable;
 use derive_deref::{Deref, DerefMut};
 use vecdb::{AnyIterableVec, Database, Exit, Format, StoredIndex};
 
@@ -20,8 +20,8 @@ use super::{r#trait::CohortVecs, utxo_cohort};
 
 const VERSION: Version = Version::new(0);
 
-#[derive(Clone, Deref, DerefMut, IVecs)]
-pub struct Vecs(UTXOGroups<(GroupFilter, utxo_cohort::Vecs)>);
+#[derive(Clone, Deref, DerefMut, Traversable)]
+pub struct Vecs(UTXOGroups<Filtered<utxo_cohort::Vecs>>);
 
 impl Vecs {
     pub fn forced_import(
@@ -1459,7 +1459,7 @@ impl Vecs {
         let mut vecs = self
             .age_range
             .iter_mut()
-            .map(|(filter, v)| (filter, &mut v.state))
+            .map(|Filtered(filter, v)| (filter, &mut v.state))
             .collect::<Vec<_>>();
 
         let _ = chain_state
@@ -1531,14 +1531,14 @@ impl Vecs {
 
             time_based_vecs
                 .iter_mut()
-                .filter(|(filter, _)| match filter {
-                    GroupFilter::GreaterOrEqual(from) => *from <= days_old,
-                    GroupFilter::LowerThan(to) => *to > days_old,
-                    GroupFilter::Range(range) => range.contains(&days_old),
-                    GroupFilter::Epoch(epoch) => *epoch == HalvingEpoch::from(height),
+                .filter(|Filtered(filter, _)| match filter {
+                    Filter::GreaterOrEqual(from) => *from <= days_old,
+                    Filter::LowerThan(to) => *to > days_old,
+                    Filter::Range(range) => range.contains(&days_old),
+                    Filter::Epoch(epoch) => *epoch == HalvingEpoch::from(height),
                     _ => unreachable!(),
                 })
-                .for_each(|(_, vecs)| {
+                .for_each(|Filtered(_, vecs)| {
                     vecs.state.as_mut().unwrap().send(
                         &sent.spendable_supply,
                         current_price,
@@ -1604,9 +1604,9 @@ impl Vecs {
             v.state.as_mut().unwrap().receive(&supply_state, price);
         });
 
-        self._type.iter_mut().for_each(|(filter, vecs)| {
+        self._type.iter_mut().for_each(|Filtered(filter, vecs)| {
             let output_type = match filter {
-                GroupFilter::Type(output_type) => *output_type,
+                Filter::Type(output_type) => *output_type,
                 _ => unreachable!(),
             };
             vecs.state
@@ -1639,56 +1639,56 @@ impl Vecs {
 
         [(
             &mut self.0.all.1,
-            by_date_range.iter().map(|(_, v)| v).collect::<Vec<_>>(),
+            by_date_range.iter().map(Filtered::t).collect::<Vec<_>>(),
         )]
         .into_iter()
-        .chain(self.0.min_age.iter_mut().map(|(filter, vecs)| {
+        .chain(self.0.min_age.iter_mut().map(|Filtered(filter, vecs)| {
             (
                 vecs,
                 by_date_range
                     .iter()
-                    .filter(|(other, _)| filter.includes(other))
-                    .map(|(_, v)| v)
+                    .filter(|other| other.includes(filter))
+                    .map(Filtered::t)
                     .collect::<Vec<_>>(),
             )
         }))
-        .chain(self.0.max_age.iter_mut().map(|(filter, vecs)| {
+        .chain(self.0.max_age.iter_mut().map(|Filtered(filter, vecs)| {
             (
                 vecs,
                 by_date_range
                     .iter()
-                    .filter(|(other, _)| filter.includes(other))
-                    .map(|(_, v)| v)
+                    .filter(|other| other.includes(filter))
+                    .map(Filtered::t)
                     .collect::<Vec<_>>(),
             )
         }))
-        .chain(self.0.term.iter_mut().map(|(filter, vecs)| {
+        .chain(self.0.term.iter_mut().map(|Filtered(filter, vecs)| {
             (
                 vecs,
                 by_date_range
                     .iter()
-                    .filter(|(other, _)| filter.includes(other))
-                    .map(|(_, v)| v)
+                    .filter(|other| other.includes(filter))
+                    .map(Filtered::t)
                     .collect::<Vec<_>>(),
             )
         }))
-        .chain(self.0.ge_amount.iter_mut().map(|(filter, vecs)| {
+        .chain(self.0.ge_amount.iter_mut().map(|Filtered(filter, vecs)| {
             (
                 vecs,
                 by_size_range
                     .iter()
-                    .filter(|(other, _)| filter.includes(other))
-                    .map(|(_, v)| v)
+                    .filter(|other| other.includes(filter))
+                    .map(Filtered::t)
                     .collect::<Vec<_>>(),
             )
         }))
-        .chain(self.0.lt_amount.iter_mut().map(|(filter, vecs)| {
+        .chain(self.0.lt_amount.iter_mut().map(|Filtered(filter, vecs)| {
             (
                 vecs,
                 by_size_range
                     .iter()
-                    .filter(|(other, _)| filter.includes(other))
-                    .map(|(_, v)| v)
+                    .filter(|other| other.includes(filter))
+                    .map(Filtered::t)
                     .collect::<Vec<_>>(),
             )
         }))
@@ -1705,8 +1705,8 @@ impl Vecs {
         exit: &Exit,
     ) -> Result<()> {
         self.iter_mut()
-            .into_iter()
-            .try_for_each(|(_, v)| v.compute_rest_part1(indexes, price, starting_indexes, exit))
+            .map(Filtered::mut_t)
+            .try_for_each(|v| v.compute_rest_part1(indexes, price, starting_indexes, exit))
     }
 
     #[allow(clippy::too_many_arguments)]
@@ -1723,7 +1723,7 @@ impl Vecs {
         dateindex_to_realized_cap: Option<&impl AnyIterableVec<DateIndex, Dollars>>,
         exit: &Exit,
     ) -> Result<()> {
-        self.iter_mut().into_iter().try_for_each(|(_, v)| {
+        self.iter_mut().map(Filtered::mut_t).try_for_each(|v| {
             v.compute_rest_part2(
                 indexes,
                 price,
@@ -1741,6 +1741,7 @@ impl Vecs {
 
     pub fn safe_flush_stateful_vecs(&mut self, height: Height, exit: &Exit) -> Result<()> {
         self.iter_separate_mut()
-            .try_for_each(|(_, v)| v.safe_flush_stateful_vecs(height, exit))
+            .map(Filtered::mut_t)
+            .try_for_each(|v| v.safe_flush_stateful_vecs(height, exit))
     }
 }