diff --git a/substrate/client/api/src/in_mem.rs b/substrate/client/api/src/in_mem.rs
index 9cea1883bdcdc17bf29158d3c7a1639c547ca464..99efdd3bf1d22bef5c6c982c89c78488b4c6670d 100644
--- a/substrate/client/api/src/in_mem.rs
+++ b/substrate/client/api/src/in_mem.rs
@@ -516,7 +516,7 @@ where
) -> sp_blockchain::Result<Block::Hash> {
check_genesis_storage(&storage)?;
- let child_delta = storage.children_default.iter().map(|(_storage_key, child_content)| {
+ let child_delta = storage.children_default.values().map(|child_content| {
(
&child_content.child_info,
child_content.data.iter().map(|(k, v)| (k.as_ref(), Some(v.as_ref()))),
diff --git a/substrate/client/consensus/slots/src/lib.rs b/substrate/client/consensus/slots/src/lib.rs
index 6225bbbda17450ad3ad6147d288e2f48ff9a3419..90bfef6c1609cd432e147499016d94d0312837f6 100644
--- a/substrate/client/consensus/slots/src/lib.rs
+++ b/substrate/client/consensus/slots/src/lib.rs
@@ -1118,7 +1118,7 @@ mod test {
// But lets assert all distances, which we expect to grow linearly until `max_interval + 1`
let expected_intervals: Vec<_> =
- (0..497).map(|i| (i / 2).max(1).min(expected_distance)).collect();
+ (0..497).map(|i| (i / 2).clamp(1, expected_distance)).collect();
assert_eq!(intervals, expected_intervals);
}
diff --git a/substrate/client/db/src/bench.rs b/substrate/client/db/src/bench.rs
index b1f4e3b6c0af5448cbdc889d369342cac5323f5f..13d91fff0b555f23bb993fd579b3b644414211c2 100644
--- a/substrate/client/db/src/bench.rs
+++ b/substrate/client/db/src/bench.rs
@@ -116,7 +116,7 @@ impl<B: BlockT> BenchmarkingState<B> {
state.add_whitelist_to_tracker();
state.reopen()?;
- let child_delta = genesis.children_default.iter().map(|(_storage_key, child_content)| {
+ let child_delta = genesis.children_default.values().map(|child_content| {
(
&child_content.child_info,
child_content.data.iter().map(|(k, v)| (k.as_ref(), Some(v.as_ref()))),
diff --git a/substrate/client/db/src/lib.rs b/substrate/client/db/src/lib.rs
index ae777ad154f6d8c5bf6532cbef840f73bdead93e..1a80c16c4e59de07a0c0edc97bd5799afe4ad9ff 100644
--- a/substrate/client/db/src/lib.rs
+++ b/substrate/client/db/src/lib.rs
@@ -798,7 +798,7 @@ impl<Block: BlockT> BlockImportOperation<Block> {
return Err(sp_blockchain::Error::InvalidState)
}
- let child_delta = storage.children_default.iter().map(|(_storage_key, child_content)| {
+ let child_delta = storage.children_default.values().map(|child_content| {
(
&child_content.child_info,
child_content.data.iter().map(|(k, v)| (&k[..], Some(&v[..]))),
diff --git a/substrate/client/network/sync/src/lib.rs b/substrate/client/network/sync/src/lib.rs
index 64d9d4d668eb348ce78bba1cfa8fcb3086fe55e3..e9c2b24b2ba9530ee9e3b3247c01a02c9489a46f 100644
--- a/substrate/client/network/sync/src/lib.rs
+++ b/substrate/client/network/sync/src/lib.rs
@@ -1444,8 +1444,7 @@ where
if let SyncMode::LightState { skip_proofs, .. } = &self.mode {
if self.state_sync.is_none() && !self.peers.is_empty() && self.queue_blocks.is_empty() {
// Finalized a recent block.
- let mut heads: Vec<_> =
- self.peers.iter().map(|(_, peer)| peer.best_number).collect();
+ let mut heads: Vec<_> = self.peers.values().map(|peer| peer.best_number).collect();
heads.sort();
let median = heads[heads.len() / 2];
if number + STATE_SYNC_FINALITY_THRESHOLD.saturated_into() >= median {
diff --git a/substrate/client/state-db/src/pruning.rs b/substrate/client/state-db/src/pruning.rs
index 2c2311091049504710686b903d999e1ed79e28f3..50a46def59541b2bc8d732a5b7f9b356e173a545 100644
--- a/substrate/client/state-db/src/pruning.rs
+++ b/substrate/client/state-db/src/pruning.rs
@@ -117,7 +117,7 @@ impl<BlockHash: Hash, Key: Hash, D: MetaDb> DeathRowQueue<BlockHash, Key, D> {
window_size: u32,
) -> Result<DeathRowQueue<BlockHash, Key, D>, Error<D::Error>> {
// limit the cache capacity from 1 to `DEFAULT_MAX_BLOCK_CONSTRAINT`
- let cache_capacity = window_size.max(1).min(DEFAULT_MAX_BLOCK_CONSTRAINT) as usize;
+ let cache_capacity = window_size.clamp(1, DEFAULT_MAX_BLOCK_CONSTRAINT) as usize;
let mut cache = VecDeque::with_capacity(cache_capacity);
trace!(target: "state-db", "Reading pruning journal for the database-backed queue. Pending #{}", base);
// Load block from db
diff --git a/substrate/client/transaction-pool/src/graph/pool.rs b/substrate/client/transaction-pool/src/graph/pool.rs
index 9afceffe8dddfd7acc6439cbac5a7bf9dd7d19fc..d311e0d0c8f2f229fcbec1014253f4df2501f3ed 100644
--- a/substrate/client/transaction-pool/src/graph/pool.rs
+++ b/substrate/client/transaction-pool/src/graph/pool.rs
@@ -168,7 +168,7 @@ impl<B: ChainApi> Pool<B> {
) -> Result<Vec<Result<ExtrinsicHash<B>, B::Error>>, B::Error> {
let xts = xts.into_iter().map(|xt| (source, xt));
let validated_transactions = self.verify(at, xts, CheckBannedBeforeVerify::Yes).await?;
- Ok(self.validated_pool.submit(validated_transactions.into_iter().map(|(_, tx)| tx)))
+ Ok(self.validated_pool.submit(validated_transactions.into_values()))
}
/// Resubmit the given extrinsics to the pool.
@@ -182,7 +182,7 @@ impl<B: ChainApi> Pool<B> {
) -> Result<Vec<Result<ExtrinsicHash<B>, B::Error>>, B::Error> {
let xts = xts.into_iter().map(|xt| (source, xt));
let validated_transactions = self.verify(at, xts, CheckBannedBeforeVerify::No).await?;
- Ok(self.validated_pool.submit(validated_transactions.into_iter().map(|(_, tx)| tx)))
+ Ok(self.validated_pool.submit(validated_transactions.into_values()))
}
/// Imports one unverified extrinsic to the pool
@@ -349,7 +349,7 @@ impl<B: ChainApi> Pool<B> {
at,
known_imported_hashes,
pruned_hashes,
- reverified_transactions.into_iter().map(|(_, xt)| xt).collect(),
+ reverified_transactions.into_values().collect(),
)
}
diff --git a/substrate/frame/transaction-payment/src/lib.rs b/substrate/frame/transaction-payment/src/lib.rs
index ce85bf93a90a7839d4a937573076c504bd39b8f3..5027db41ec098f98dc48510b54b0b98a4a69d1cd 100644
--- a/substrate/frame/transaction-payment/src/lib.rs
+++ b/substrate/frame/transaction-payment/src/lib.rs
@@ -228,11 +228,11 @@ where
if positive {
let excess = first_term.saturating_add(second_term).saturating_mul(previous);
- previous.saturating_add(excess).max(min_multiplier).min(max_multiplier)
+ previous.saturating_add(excess).clamp(min_multiplier, max_multiplier)
} else {
// Defensive-only: first_term > second_term. Safe subtraction.
let negative = first_term.saturating_sub(second_term).saturating_mul(previous);
- previous.saturating_sub(negative).max(min_multiplier).min(max_multiplier)
+ previous.saturating_sub(negative).clamp(min_multiplier, max_multiplier)
}
}
}
@@ -713,8 +713,8 @@ where
let max_block_weight = max_block_weight.ref_time();
let info_weight = info.weight.ref_time();
- let bounded_weight = info_weight.max(1).min(max_block_weight);
- let bounded_length = (len as u64).max(1).min(max_block_length);
+ let bounded_weight = info_weight.clamp(1, max_block_weight);
+ let bounded_length = (len as u64).clamp(1, max_block_length);
let max_tx_per_block_weight = max_block_weight / bounded_weight;
let max_tx_per_block_length = max_block_length / bounded_length;
diff --git a/substrate/primitives/runtime/src/generic/era.rs b/substrate/primitives/runtime/src/generic/era.rs
index 2ca50b12b2e1f95f91f03876e8db613d4b701b49..b26545fb8404e373c5947a672ee34bf69e003201 100644
--- a/substrate/primitives/runtime/src/generic/era.rs
+++ b/substrate/primitives/runtime/src/generic/era.rs
@@ -63,7 +63,7 @@ impl Era {
/// does not exceed `BlockHashCount` parameter passed to `system` module, since that
/// prunes old blocks and renders transactions immediately invalid.
pub fn mortal(period: u64, current: u64) -> Self {
- let period = period.checked_next_power_of_two().unwrap_or(1 << 16).max(4).min(1 << 16);
+ let period = period.checked_next_power_of_two().unwrap_or(1 << 16).clamp(4, 1 << 16);
let phase = current % period;
let quantize_factor = (period >> 12).max(1);
let quantized_phase = phase / quantize_factor * quantize_factor;
@@ -105,7 +105,7 @@ impl Encode for Era {
Self::Immortal => output.push_byte(0),
Self::Mortal(period, phase) => {
let quantize_factor = (*period as u64 >> 12).max(1);
- let encoded = (period.trailing_zeros() - 1).max(1).min(15) as u16 |
+ let encoded = (period.trailing_zeros() - 1).clamp(1, 15) as u16 |
((phase / quantize_factor) << 4) as u16;
encoded.encode_to(output);
},
diff --git a/substrate/primitives/runtime/src/offchain/storage_lock.rs b/substrate/primitives/runtime/src/offchain/storage_lock.rs
index 4ea9030745296edc4df46d3f17b04ba67746bb89..47325743bd2f3a7d2bb50b79d40fd6242982b3b6 100644
--- a/substrate/primitives/runtime/src/offchain/storage_lock.rs
+++ b/substrate/primitives/runtime/src/offchain/storage_lock.rs
@@ -77,8 +77,8 @@ const STORAGE_LOCK_DEFAULT_EXPIRY_DURATION: Duration = Duration::from_millis(20_
const STORAGE_LOCK_DEFAULT_EXPIRY_BLOCKS: u32 = 4;
/// Time between checks if the lock is still being held in milliseconds.
-const STORAGE_LOCK_PER_CHECK_ITERATION_SNOOZE_MIN: Duration = Duration::from_millis(100);
-const STORAGE_LOCK_PER_CHECK_ITERATION_SNOOZE_MAX: Duration = Duration::from_millis(10);
+const STORAGE_LOCK_PER_CHECK_ITERATION_SNOOZE_MIN: Duration = Duration::from_millis(10);
+const STORAGE_LOCK_PER_CHECK_ITERATION_SNOOZE_MAX: Duration = Duration::from_millis(100);
/// Lockable item for use with a persisted storage lock.
///
@@ -137,10 +137,9 @@ impl Lockable for Time {
let remainder: Duration = now.diff(deadline);
// do not snooze the full duration, but instead snooze max 100ms
// it might get unlocked in another thread
- use core::cmp::{max, min};
- let snooze = max(
- min(remainder, STORAGE_LOCK_PER_CHECK_ITERATION_SNOOZE_MAX),
+ let snooze = remainder.clamp(
STORAGE_LOCK_PER_CHECK_ITERATION_SNOOZE_MIN,
+ STORAGE_LOCK_PER_CHECK_ITERATION_SNOOZE_MAX,
);
sp_io::offchain::sleep_until(now.add(snooze));
}
@@ -239,10 +238,9 @@ impl<B: BlockNumberProvider> Lockable for BlockAndTime<B> {
fn snooze(deadline: &Self::Deadline) {
let now = offchain::timestamp();
let remainder: Duration = now.diff(&(deadline.timestamp));
- use core::cmp::{max, min};
- let snooze = max(
- min(remainder, STORAGE_LOCK_PER_CHECK_ITERATION_SNOOZE_MAX),
+ let snooze = remainder.clamp(
STORAGE_LOCK_PER_CHECK_ITERATION_SNOOZE_MIN,
+ STORAGE_LOCK_PER_CHECK_ITERATION_SNOOZE_MAX,
);
sp_io::offchain::sleep_until(now.add(snooze));
}
diff --git a/substrate/primitives/state-machine/src/in_memory_backend.rs b/substrate/primitives/state-machine/src/in_memory_backend.rs
index e205e83e855721d6d367e15e5e13deec233907f2..06714fb41405a7548f686bc2ac523f9352825aea 100644
--- a/substrate/primitives/state-machine/src/in_memory_backend.rs
+++ b/substrate/primitives/state-machine/src/in_memory_backend.rs
@@ -157,8 +157,8 @@ where
fn from((inners, state_version): (Storage, StateVersion)) -> Self {
let mut inner: HashMap<Option<ChildInfo>, BTreeMap<StorageKey, StorageValue>> = inners
.children_default
- .into_iter()
- .map(|(_k, c)| (Some(c.child_info), c.data))
+ .into_values()
+ .map(|c| (Some(c.child_info), c.data))
.collect();
inner.insert(None, inners.top);
(inner, state_version).into()
diff --git a/substrate/primitives/state-machine/src/overlayed_changes/mod.rs b/substrate/primitives/state-machine/src/overlayed_changes/mod.rs
index ef5c02d2ec1fa2788406eec302182a4bacb59641..9eb26d52f79f8f9b7d4634d9e6c579b4265f18a6 100644
--- a/substrate/primitives/state-machine/src/overlayed_changes/mod.rs
+++ b/substrate/primitives/state-machine/src/overlayed_changes/mod.rs
@@ -474,7 +474,7 @@ impl OverlayedChanges {
pub fn children(
&self,
) -> impl Iterator<Item = (impl Iterator<Item = (&StorageKey, &OverlayedValue)>, &ChildInfo)> {
- self.children.iter().map(|(_, v)| (v.0.changes(), &v.1))
+ self.children.values().map(|v| (v.0.changes(), &v.1))
}
/// Get an iterator over all top changes as been by the current transaction.
diff --git a/substrate/primitives/trie/src/recorder.rs b/substrate/primitives/trie/src/recorder.rs
index 5599ad1c369049a797574276db14a1cccb34d529..6fbf698592a310e4d30b7e103cae79b04f2d5e90 100644
--- a/substrate/primitives/trie/src/recorder.rs
+++ b/substrate/primitives/trie/src/recorder.rs
@@ -109,7 +109,7 @@ impl<H: Hasher> Recorder<H> {
/// Returns the [`StorageProof`].
pub fn to_storage_proof(&self) -> StorageProof {
let recorder = self.inner.lock();
- StorageProof::new(recorder.accessed_nodes.iter().map(|(_, v)| v.clone()))
+ StorageProof::new(recorder.accessed_nodes.values().cloned())
}
/// Returns the estimated encoded size of the proof.
diff --git a/substrate/test-utils/runtime/client/src/lib.rs b/substrate/test-utils/runtime/client/src/lib.rs
index fe0fef3516671d62ace0daf6beb6d3099dd09df8..99d4e1163e27246022ecae4ff95f45f92e77a24a 100644
--- a/substrate/test-utils/runtime/client/src/lib.rs
+++ b/substrate/test-utils/runtime/client/src/lib.rs
@@ -134,7 +134,7 @@ impl substrate_test_client::GenesisInit for GenesisParameters {
.insert(sp_core::storage::well_known_keys::CODE.to_vec(), code.clone());
}
- let child_roots = storage.children_default.iter().map(|(_sk, child_content)| {
+ let child_roots = storage.children_default.values().map(|child_content| {
let state_root =
<<<runtime::Block as BlockT>::Header as HeaderT>::Hashing as HashT>::trie_root(
child_content.data.clone().into_iter().collect(),
diff --git a/substrate/utils/frame/benchmarking-cli/src/pallet/command.rs b/substrate/utils/frame/benchmarking-cli/src/pallet/command.rs
index daf4aa74e13941dec0041f92e0af2f1e02c8dfef..6e413bdf7e2c5a42ac93baca60db1a0d16360247 100644
--- a/substrate/utils/frame/benchmarking-cli/src/pallet/command.rs
+++ b/substrate/utils/frame/benchmarking-cli/src/pallet/command.rs
@@ -268,9 +268,8 @@ impl PalletCmd {
for s in 0..self.steps {
// This is the value we will be testing for component `name`
- let component_value = ((lowest as f32 + step_size * s as f32) as u32)
- .min(highest)
- .max(lowest);
+ let component_value =
+ ((lowest as f32 + step_size * s as f32) as u32).clamp(lowest, highest);
// Select the max value for all the other components.
let c: Vec<(BenchmarkParameter, u32)> = components