diff --git a/examples/parse.rs b/examples/parse.rs
index f4c07a798..a7651f86c 100644
--- a/examples/parse.rs
+++ b/examples/parse.rs
@@ -19,7 +19,8 @@ extern crate miniscript;
 
 use std::str::FromStr;
 
-use miniscript::{descriptor::DescriptorType, Descriptor, DescriptorTrait};
+use miniscript::descriptor::DescriptorType;
+use miniscript::{Descriptor, DescriptorTrait};
 
 fn main() {
     let my_descriptor = miniscript::Descriptor::<bitcoin::PublicKey>::from_str(
diff --git a/rustfmt.toml b/rustfmt.toml
index f61bac29a..f3bff64fa 100644
--- a/rustfmt.toml
+++ b/rustfmt.toml
@@ -27,7 +27,7 @@ fn_single_line = false
 where_single_line = false
 imports_indent = "Block"
 imports_layout = "Mixed"
-imports_granularity = "Preserve"
+imports_granularity = "Module"     # Default "Preserve"
 group_imports = "StdExternalCrate" # Default "Preserve"
 reorder_imports = true
 reorder_modules = true
diff --git a/src/descriptor/bare.rs b/src/descriptor/bare.rs
index d05b5ddfe..aca61be78 100644
--- a/src/descriptor/bare.rs
+++ b/src/descriptor/bare.rs
@@ -18,9 +18,11 @@
 //! Also includes pk, and pkh descriptors
 //!
 
-use std::{fmt, str::FromStr};
+use std::fmt;
+use std::str::FromStr;
 
-use bitcoin::{self, blockdata::script, Script};
+use bitcoin::blockdata::script;
+use bitcoin::{self, Script};
 use expression::{self, FromTree};
 use miniscript::context::ScriptContext;
 use policy::{semantic, Liftable};
@@ -30,10 +32,8 @@ use {
     TranslatePk,
 };
 
-use super::{
-    checksum::{desc_checksum, verify_checksum},
-    DescriptorTrait,
-};
+use super::checksum::{desc_checksum, verify_checksum};
+use super::DescriptorTrait;
 
 /// Create a Bare Descriptor. That is descriptor that is
 /// not wrapped in sh or wsh. This covers the Pk descriptor
diff --git a/src/descriptor/key.rs b/src/descriptor/key.rs
index 926165a3d..0e152af55 100644
--- a/src/descriptor/key.rs
+++ b/src/descriptor/key.rs
@@ -1,14 +1,11 @@
-use std::{error, fmt, str::FromStr};
-
-use bitcoin::{
-    self,
-    hashes::Hash,
-    hashes::{hex::FromHex, HashEngine},
-    secp256k1,
-    secp256k1::{Secp256k1, Signing},
-    util::bip32,
-    XOnlyPublicKey, XpubIdentifier,
-};
+use std::str::FromStr;
+use std::{error, fmt};
+
+use bitcoin::hashes::hex::FromHex;
+use bitcoin::hashes::{Hash, HashEngine};
+use bitcoin::secp256k1::{Secp256k1, Signing};
+use bitcoin::util::bip32;
+use bitcoin::{self, secp256k1, XOnlyPublicKey, XpubIdentifier};
 use {MiniscriptKey, ToPublicKey};
 
 /// Single public key without any origin or range information
diff --git a/src/descriptor/mod.rs b/src/descriptor/mod.rs
index 24019e411..afa269d28 100644
--- a/src/descriptor/mod.rs
+++ b/src/descriptor/mod.rs
@@ -23,20 +23,17 @@
 //! these with BIP32 paths, pay-to-contract instructions, etc.
 //!
 
-use std::{collections::HashMap, sync::Arc};
-use std::{
-    fmt,
-    str::{self, FromStr},
-};
+use std::collections::HashMap;
+use std::fmt;
+use std::str::{self, FromStr};
+use std::sync::Arc;
 
 use bitcoin::blockdata::witness::Witness;
 use bitcoin::{self, secp256k1, Script};
-use expression;
-use miniscript;
 use miniscript::{Legacy, Miniscript, Segwitv0};
 use {
-    BareCtx, Error, ForEach, ForEachKey, MiniscriptKey, Satisfier, ToPublicKey, TranslatePk,
-    TranslatePk2,
+    expression, miniscript, BareCtx, Error, ForEach, ForEachKey, MiniscriptKey, Satisfier,
+    ToPublicKey, TranslatePk, TranslatePk2,
 };
 
 use self::checksum::verify_checksum;
@@ -839,10 +836,9 @@ mod tests {
     use descriptor::{
         DescriptorPublicKey, DescriptorSecretKey, DescriptorSinglePub, DescriptorXKey,
     };
-    use hex_script;
     #[cfg(feature = "compiler")]
     use policy;
-    use {Descriptor, DummyKey, Error, Miniscript, Satisfier, TranslatePk2};
+    use {hex_script, Descriptor, DummyKey, Error, Miniscript, Satisfier, TranslatePk2};
 
     use super::checksum::desc_checksum;
     use super::tr::Tr;
diff --git a/src/descriptor/pretaproot.rs b/src/descriptor/pretaproot.rs
index 3140583df..2f1c21842 100644
--- a/src/descriptor/pretaproot.rs
+++ b/src/descriptor/pretaproot.rs
@@ -1,12 +1,11 @@
-use std::{
-    fmt,
-    str::{self, FromStr},
-};
+use std::fmt;
+use std::str::{self, FromStr};
 
 use bitcoin::{self, Script};
 use {expression, DescriptorTrait, Error, MiniscriptKey, Satisfier, ToPublicKey};
 
-use super::{checksum::verify_checksum, Bare, Pkh, Sh, Wpkh, Wsh};
+use super::checksum::verify_checksum;
+use super::{Bare, Pkh, Sh, Wpkh, Wsh};
 
 /// Script descriptor
 #[derive(Clone, PartialEq, Eq, PartialOrd, Ord, Hash)]
@@ -240,10 +239,8 @@ serde_string_impl_pk!(PreTaprootDescriptor, "a pre-taproot script descriptor");
 // Have the trait in a separate module to avoid conflicts
 pub(crate) mod traits {
     use bitcoin::Script;
-    use {
-        descriptor::{Pkh, Sh, Wpkh, Wsh},
-        DescriptorTrait, MiniscriptKey, ToPublicKey,
-    };
+    use descriptor::{Pkh, Sh, Wpkh, Wsh};
+    use {DescriptorTrait, MiniscriptKey, ToPublicKey};
 
     use super::PreTaprootDescriptor;
 
diff --git a/src/descriptor/segwitv0.rs b/src/descriptor/segwitv0.rs
index d1e4af883..6d77b2ffa 100644
--- a/src/descriptor/segwitv0.rs
+++ b/src/descriptor/segwitv0.rs
@@ -16,7 +16,8 @@
 //! Implementation of Segwit Descriptors. Contains the implementation
 //! of wsh, wpkh and sortedmulti inside wsh.
 
-use std::{fmt, str::FromStr};
+use std::fmt;
+use std::str::FromStr;
 
 use bitcoin::{self, Script};
 use expression::{self, FromTree};
@@ -28,10 +29,8 @@ use {
     TranslatePk,
 };
 
-use super::{
-    checksum::{desc_checksum, verify_checksum},
-    DescriptorTrait, SortedMultiVec,
-};
+use super::checksum::{desc_checksum, verify_checksum};
+use super::{DescriptorTrait, SortedMultiVec};
 /// A Segwitv0 wsh descriptor
 #[derive(Clone, Ord, PartialOrd, Eq, PartialEq, Hash)]
 pub struct Wsh<Pk: MiniscriptKey> {
diff --git a/src/descriptor/sh.rs b/src/descriptor/sh.rs
index d04bbed78..767fe6c1a 100644
--- a/src/descriptor/sh.rs
+++ b/src/descriptor/sh.rs
@@ -18,23 +18,22 @@
 //! sh(miniscript), and sh(wpkh)
 //!
 
-use std::{fmt, str::FromStr};
+use std::fmt;
+use std::str::FromStr;
 
-use bitcoin::{self, blockdata::script, Script};
+use bitcoin::blockdata::script;
+use bitcoin::{self, Script};
 use expression::{self, FromTree};
 use miniscript::context::ScriptContext;
 use policy::{semantic, Liftable};
-use push_opcode_size;
 use util::{varint_len, witness_to_scriptsig};
 use {
-    Error, ForEach, ForEachKey, Legacy, Miniscript, MiniscriptKey, Satisfier, Segwitv0,
-    ToPublicKey, TranslatePk,
+    push_opcode_size, Error, ForEach, ForEachKey, Legacy, Miniscript, MiniscriptKey, Satisfier,
+    Segwitv0, ToPublicKey, TranslatePk,
 };
 
-use super::{
-    checksum::{desc_checksum, verify_checksum},
-    DescriptorTrait, SortedMultiVec, Wpkh, Wsh,
-};
+use super::checksum::{desc_checksum, verify_checksum};
+use super::{DescriptorTrait, SortedMultiVec, Wpkh, Wsh};
 
 /// A Legacy p2sh Descriptor
 #[derive(Clone, Ord, PartialOrd, Eq, PartialEq, Hash)]
diff --git a/src/descriptor/sortedmulti.rs b/src/descriptor/sortedmulti.rs
index 475ef3307..f3d039636 100644
--- a/src/descriptor/sortedmulti.rs
+++ b/src/descriptor/sortedmulti.rs
@@ -16,16 +16,18 @@
 //! Implementation of sorted multi primitive for descriptors
 //!
 
-use std::{fmt, marker::PhantomData, str::FromStr};
+use std::fmt;
+use std::marker::PhantomData;
+use std::str::FromStr;
 
 use bitcoin::blockdata::script;
-use expression;
-use miniscript::{
-    self, context::ScriptContext, decode::Terminal, limits::MAX_PUBKEYS_PER_MULTISIG,
+use miniscript::context::ScriptContext;
+use miniscript::decode::Terminal;
+use miniscript::limits::MAX_PUBKEYS_PER_MULTISIG;
+use {
+    errstr, expression, miniscript, policy, script_num_size, Error, ForEach, ForEachKey,
+    Miniscript, MiniscriptKey, Satisfier, ToPublicKey,
 };
-use policy;
-use script_num_size;
-use {errstr, Error, ForEach, ForEachKey, Miniscript, MiniscriptKey, Satisfier, ToPublicKey};
 
 /// Contents of a "sortedmulti" descriptor
 #[derive(Clone, PartialEq, Eq, PartialOrd, Ord, Hash)]
diff --git a/src/descriptor/tr.rs b/src/descriptor/tr.rs
index 8e9504c27..5d870b343 100644
--- a/src/descriptor/tr.rs
+++ b/src/descriptor/tr.rs
@@ -1,9 +1,9 @@
 // Tapscript
 
 use std::cmp::{self, max};
-use std::hash;
+use std::str::FromStr;
 use std::sync::{Arc, Mutex};
-use std::{fmt, str::FromStr};
+use std::{fmt, hash};
 
 use bitcoin::blockdata::opcodes;
 use bitcoin::util::taproot::{
@@ -11,15 +11,15 @@ use bitcoin::util::taproot::{
     TAPROOT_CONTROL_MAX_NODE_COUNT, TAPROOT_CONTROL_NODE_SIZE,
 };
 use bitcoin::{self, secp256k1, Script};
-use errstr;
 use expression::{self, FromTree};
 use miniscript::Miniscript;
 use policy::semantic::Policy;
 use policy::Liftable;
 use util::{varint_len, witness_size};
-use Tap;
-use {DescriptorTrait, ForEach, ForEachKey, Satisfier, ToPublicKey, TranslatePk};
-use {Error, MiniscriptKey};
+use {
+    errstr, DescriptorTrait, Error, ForEach, ForEachKey, MiniscriptKey, Satisfier, Tap,
+    ToPublicKey, TranslatePk,
+};
 
 use super::checksum::{desc_checksum, verify_checksum};
 
diff --git a/src/expression.rs b/src/expression.rs
index 596cfce02..a079533cf 100644
--- a/src/expression.rs
+++ b/src/expression.rs
@@ -17,9 +17,7 @@
 
 use std::str::FromStr;
 
-use errstr;
-use Error;
-use MAX_RECURSION_DEPTH;
+use {errstr, Error, MAX_RECURSION_DEPTH};
 
 #[derive(Debug)]
 /// A token of the form `x(...)` or `x`
diff --git a/src/interpreter/error.rs b/src/interpreter/error.rs
index 32bebf52c..45318f620 100644
--- a/src/interpreter/error.rs
+++ b/src/interpreter/error.rs
@@ -14,7 +14,8 @@
 
 use std::{error, fmt};
 
-use bitcoin::hashes::{hash160, hex::ToHex};
+use bitcoin::hashes::hash160;
+use bitcoin::hashes::hex::ToHex;
 use bitcoin::util::taproot;
 use bitcoin::{self, secp256k1};
 
diff --git a/src/interpreter/inner.rs b/src/interpreter/inner.rs
index f95aca0fa..dd566f7dd 100644
--- a/src/interpreter/inner.rs
+++ b/src/interpreter/inner.rs
@@ -12,13 +12,11 @@
 // If not, see <http://creativecommons.org/publicdomain/zero/1.0/>.
 //
 
-use bitcoin;
 use bitcoin::blockdata::witness::Witness;
 use bitcoin::hashes::{hash160, sha256, Hash};
 use bitcoin::util::taproot::{ControlBlock, TAPROOT_ANNEX_PREFIX};
 use miniscript::context::{NoChecks, ScriptContext};
-use {BareCtx, Legacy, Segwitv0, Tap};
-use {Miniscript, MiniscriptKey};
+use {bitcoin, BareCtx, Legacy, Miniscript, MiniscriptKey, Segwitv0, Tap};
 
 use super::{stack, BitcoinKey, Error, Stack, TypedHash160};
 
diff --git a/src/interpreter/mod.rs b/src/interpreter/mod.rs
index 2577a041b..0e2314f62 100644
--- a/src/interpreter/mod.rs
+++ b/src/interpreter/mod.rs
@@ -29,9 +29,7 @@ use bitcoin::util::{sighash, taproot};
 use bitcoin::{self, secp256k1, TxOut};
 use miniscript::context::NoChecks;
 use miniscript::ScriptContext;
-use Miniscript;
-use Terminal;
-use {Descriptor, ToPublicKey};
+use {Descriptor, Miniscript, Terminal, ToPublicKey};
 
 mod error;
 mod inner;
@@ -1030,13 +1028,10 @@ fn verify_sersig<'txin>(
 #[cfg(test)]
 mod tests {
 
-    use bitcoin;
     use bitcoin::hashes::{hash160, ripemd160, sha256, sha256d, Hash};
     use bitcoin::secp256k1::{self, Secp256k1};
     use miniscript::context::NoChecks;
-    use Miniscript;
-    use MiniscriptKey;
-    use ToPublicKey;
+    use {bitcoin, Miniscript, MiniscriptKey, ToPublicKey};
 
     use super::inner::ToNoChecks;
     use super::*;
diff --git a/src/lib.rs b/src/lib.rs
index aac9c6750..8d36b5677 100644
--- a/src/lib.rs
+++ b/src/lib.rs
@@ -121,7 +121,8 @@ use std::{error, fmt, hash, str};
 
 use bitcoin::blockdata::{opcodes, script};
 use bitcoin::hashes::{hash160, sha256, Hash};
-pub use descriptor::pretaproot::{traits::PreTaprootDescriptorTrait, PreTaprootDescriptor};
+pub use descriptor::pretaproot::traits::PreTaprootDescriptorTrait;
+pub use descriptor::pretaproot::PreTaprootDescriptor;
 pub use descriptor::{Descriptor, DescriptorPublicKey, DescriptorTrait};
 pub use interpreter::Interpreter;
 pub use miniscript::context::{BareCtx, Legacy, ScriptContext, Segwitv0, Tap};
diff --git a/src/miniscript/analyzable.rs b/src/miniscript/analyzable.rs
index 6487c100a..25202ae39 100644
--- a/src/miniscript/analyzable.rs
+++ b/src/miniscript/analyzable.rs
@@ -20,9 +20,8 @@
 use std::collections::HashSet;
 use std::fmt;
 
-use error;
 use miniscript::iter::PkPkh;
-use {Miniscript, MiniscriptKey, ScriptContext};
+use {error, Miniscript, MiniscriptKey, ScriptContext};
 /// Possible reasons Miniscript guarantees can fail
 /// We currently mark Miniscript as Non-Analyzable if
 /// 1. It is unsafe(does not require a digital signature to spend it)
diff --git a/src/miniscript/astelem.rs b/src/miniscript/astelem.rs
index 21c5d7f86..11971e1d1 100644
--- a/src/miniscript/astelem.rs
+++ b/src/miniscript/astelem.rs
@@ -26,14 +26,14 @@ use std::{fmt, str};
 use bitcoin::blockdata::{opcodes, script};
 use bitcoin::hashes::hex::FromHex;
 use bitcoin::hashes::{hash160, ripemd160, sha256, sha256d, Hash};
-use errstr;
-use expression;
 use miniscript::context::SigType;
 use miniscript::types::{self, Property};
 use miniscript::ScriptContext;
-use script_num_size;
 use util::MsKeyBuilder;
-use {Error, ForEach, ForEachKey, Miniscript, MiniscriptKey, Terminal, ToPublicKey, TranslatePk};
+use {
+    errstr, expression, script_num_size, Error, ForEach, ForEachKey, Miniscript, MiniscriptKey,
+    Terminal, ToPublicKey, TranslatePk,
+};
 
 impl<Pk: MiniscriptKey, Ctx: ScriptContext> Terminal<Pk, Ctx> {
     /// Internal helper function for displaying wrapper types; returns
diff --git a/src/miniscript/context.rs b/src/miniscript/context.rs
index 7602ee092..b4798fa92 100644
--- a/src/miniscript/context.rs
+++ b/src/miniscript/context.rs
@@ -14,7 +14,6 @@
 
 use std::{fmt, hash};
 
-use bitcoin;
 use bitcoin::blockdata::constants::MAX_BLOCK_WEIGHT;
 use miniscript::limits::{
     MAX_OPS_PER_SCRIPT, MAX_PUBKEYS_PER_MULTISIG, MAX_SCRIPTSIG_SIZE, MAX_SCRIPT_ELEMENT_SIZE,
@@ -23,8 +22,7 @@ use miniscript::limits::{
 };
 use miniscript::types;
 use util::witness_to_scriptsig;
-use Error;
-use {Miniscript, MiniscriptKey, Terminal};
+use {bitcoin, Error, Miniscript, MiniscriptKey, Terminal};
 
 use super::decode::ParseableKey;
 
diff --git a/src/miniscript/decode.rs b/src/miniscript/decode.rs
index d42591db7..500788000 100644
--- a/src/miniscript/decode.rs
+++ b/src/miniscript/decode.rs
@@ -26,13 +26,9 @@ use bitcoin::hashes::{hash160, ripemd160, sha256, sha256d, Hash};
 use miniscript::lex::{Token as Tk, TokenIter};
 use miniscript::limits::MAX_PUBKEYS_PER_MULTISIG;
 use miniscript::types::extra_props::ExtData;
-use miniscript::types::Property;
-use miniscript::types::Type;
+use miniscript::types::{Property, Type};
 use miniscript::ScriptContext;
-use Error;
-use MiniscriptKey;
-use ToPublicKey;
-use {bitcoin, Miniscript};
+use {bitcoin, Error, Miniscript, MiniscriptKey, ToPublicKey};
 
 fn return_none<T>(_: usize) -> Option<T> {
     None
diff --git a/src/miniscript/mod.rs b/src/miniscript/mod.rs
index 4e569f5f6..165a71aaa 100644
--- a/src/miniscript/mod.rs
+++ b/src/miniscript/mod.rs
@@ -49,8 +49,7 @@ pub use miniscript::context::ScriptContext;
 use miniscript::decode::Terminal;
 use miniscript::types::extra_props::ExtData;
 use miniscript::types::Type;
-use MiniscriptKey;
-use {expression, Error, ForEach, ForEachKey, ToPublicKey, TranslatePk};
+use {expression, Error, ForEach, ForEachKey, MiniscriptKey, ToPublicKey, TranslatePk};
 
 use self::lex::{lex, TokenIter};
 use self::types::Property;
@@ -473,16 +472,15 @@ mod tests {
     use bitcoin::secp256k1::XOnlyPublicKey;
     use bitcoin::util::taproot::TapLeafHash;
     use bitcoin::{self, secp256k1};
-    use hex_script;
     use miniscript::types::{self, ExtData, Property, Type};
     use miniscript::Terminal;
     use policy::Liftable;
-    use TranslatePk2;
-    use {DummyKey, DummyKeyHash, MiniscriptKey, TranslatePk, TranslatePk1};
-    use {Satisfier, ToPublicKey};
+    use {
+        hex_script, DummyKey, DummyKeyHash, MiniscriptKey, Satisfier, ToPublicKey, TranslatePk,
+        TranslatePk1, TranslatePk2,
+    };
 
-    use super::{Miniscript, ScriptContext};
-    use super::{Segwitv0, Tap};
+    use super::{Miniscript, ScriptContext, Segwitv0, Tap};
 
     type Segwitv0Script = Miniscript<bitcoin::PublicKey, Segwitv0>;
     type Tapscript = Miniscript<bitcoin::secp256k1::XOnlyPublicKey, Tap>;
diff --git a/src/miniscript/ms_tests.rs b/src/miniscript/ms_tests.rs
index f706768f3..4bdd874f0 100644
--- a/src/miniscript/ms_tests.rs
+++ b/src/miniscript/ms_tests.rs
@@ -20,7 +20,8 @@
 mod tests {
     use std::fmt;
 
-    use {miniscript::types, Miniscript, Segwitv0};
+    use miniscript::types;
+    use {Miniscript, Segwitv0};
 
     struct TestType(types::Type);
 
diff --git a/src/miniscript/satisfy.rs b/src/miniscript/satisfy.rs
index 323490e50..a53968fc7 100644
--- a/src/miniscript/satisfy.rs
+++ b/src/miniscript/satisfy.rs
@@ -22,7 +22,6 @@ use std::collections::{BTreeMap, HashMap};
 use std::sync::Arc;
 use std::{cmp, i64, mem};
 
-use bitcoin;
 use bitcoin::hashes::{hash160, ripemd160, sha256, sha256d};
 use bitcoin::secp256k1::XOnlyPublicKey;
 use bitcoin::util::taproot::{ControlBlock, LeafVersion, TapLeafHash};
@@ -30,10 +29,7 @@ use miniscript::limits::{
     HEIGHT_TIME_THRESHOLD, SEQUENCE_LOCKTIME_DISABLE_FLAG, SEQUENCE_LOCKTIME_TYPE_FLAG,
 };
 use util::witness_size;
-use Miniscript;
-use ScriptContext;
-use Terminal;
-use {MiniscriptKey, ToPublicKey};
+use {bitcoin, Miniscript, MiniscriptKey, ScriptContext, Terminal, ToPublicKey};
 
 /// Type alias for 32 byte Preimage.
 pub type Preimage32 = [u8; 32];
diff --git a/src/miniscript/types/extra_props.rs b/src/miniscript/types/extra_props.rs
index d28f46024..f4ddea460 100644
--- a/src/miniscript/types/extra_props.rs
+++ b/src/miniscript/types/extra_props.rs
@@ -7,9 +7,7 @@ use std::iter::once;
 use miniscript::limits::{
     HEIGHT_TIME_THRESHOLD, SEQUENCE_LOCKTIME_DISABLE_FLAG, SEQUENCE_LOCKTIME_TYPE_FLAG,
 };
-use script_num_size;
-use MiniscriptKey;
-use Terminal;
+use {script_num_size, MiniscriptKey, Terminal};
 
 use super::{Error, ErrorKind, Property, ScriptContext};
 
diff --git a/src/miniscript/types/mod.rs b/src/miniscript/types/mod.rs
index eef2f2771..53e4aa9c4 100644
--- a/src/miniscript/types/mod.rs
+++ b/src/miniscript/types/mod.rs
@@ -22,13 +22,13 @@ pub mod malleability;
 
 use std::{error, fmt};
 
-use MiniscriptKey;
-use Terminal;
+use {MiniscriptKey, Terminal};
 
 pub use self::correctness::{Base, Correctness, Input};
 pub use self::extra_props::ExtData;
 pub use self::malleability::{Dissat, Malleability};
-use super::{limits::SEQUENCE_LOCKTIME_DISABLE_FLAG, ScriptContext};
+use super::limits::SEQUENCE_LOCKTIME_DISABLE_FLAG;
+use super::ScriptContext;
 
 /// None-returning function to help type inference when we need a
 /// closure that simply returns `None`
diff --git a/src/policy/compiler.rs b/src/policy/compiler.rs
index 8d511a6e2..67b6fb92a 100644
--- a/src/policy/compiler.rs
+++ b/src/policy/compiler.rs
@@ -20,17 +20,15 @@
 use std::collections::vec_deque::VecDeque;
 use std::collections::BTreeMap;
 use std::convert::From;
-use std::hash;
 use std::marker::PhantomData;
 use std::sync::Arc;
-use std::{cmp, error, f64, fmt, mem};
+use std::{cmp, error, f64, fmt, hash, mem};
 
 use miniscript::limits::MAX_PUBKEYS_PER_MULTISIG;
 use miniscript::types::{self, ErrorKind, ExtData, Property, Type};
 use miniscript::ScriptContext;
 use policy::Concrete;
-use {policy, Terminal};
-use {Miniscript, MiniscriptKey};
+use {policy, Miniscript, MiniscriptKey, Terminal};
 
 type PolicyCache<Pk, Ctx> =
     BTreeMap<(Concrete<Pk>, OrdF64, Option<OrdF64>), BTreeMap<CompilationKey, AstElemExt<Pk, Ctx>>>;
diff --git a/src/policy/concrete.rs b/src/policy/concrete.rs
index a189b39f4..b38176fc7 100644
--- a/src/policy/concrete.rs
+++ b/src/policy/concrete.rs
@@ -20,7 +20,6 @@ use std::{error, fmt, str};
 
 use bitcoin::hashes::hex::FromHex;
 use bitcoin::hashes::{hash160, ripemd160, sha256, sha256d};
-use errstr;
 use expression::{self, FromTree};
 use miniscript::limits::{HEIGHT_TIME_THRESHOLD, SEQUENCE_LOCKTIME_TYPE_FLAG};
 use miniscript::types::extra_props::TimeLockInfo;
@@ -32,7 +31,7 @@ use policy::compiler;
 use policy::compiler::CompilerError;
 #[cfg(feature = "compiler")]
 use Miniscript;
-use {Error, ForEach, ForEachKey, MiniscriptKey};
+use {errstr, Error, ForEach, ForEachKey, MiniscriptKey};
 
 use super::ENTAILMENT_MAX_TERMINALS;
 /// Concrete policy which corresponds directly to a Miniscript structure,
diff --git a/src/policy/mod.rs b/src/policy/mod.rs
index 3a1ccea94..aff3b379d 100644
--- a/src/policy/mod.rs
+++ b/src/policy/mod.rs
@@ -30,9 +30,7 @@ pub mod semantic;
 
 use descriptor::Descriptor;
 use miniscript::{Miniscript, ScriptContext};
-use Error;
-use MiniscriptKey;
-use Terminal;
+use {Error, MiniscriptKey, Terminal};
 
 pub use self::concrete::Policy as Concrete;
 /// Semantic policies are "abstract" policies elsewhere; but we
@@ -230,13 +228,11 @@ impl<Pk: MiniscriptKey> Liftable<Pk> for Concrete<Pk> {
 mod tests {
     use std::str::FromStr;
 
-    use bitcoin;
-    use DummyKey;
+    use {bitcoin, DummyKey};
 
-    use super::{
-        super::miniscript::{context::Segwitv0, Miniscript},
-        Concrete, Liftable, Semantic,
-    };
+    use super::super::miniscript::context::Segwitv0;
+    use super::super::miniscript::Miniscript;
+    use super::{Concrete, Liftable, Semantic};
 
     type ConcretePol = Concrete<DummyKey>;
     type SemanticPol = Semantic<DummyKey>;
diff --git a/src/policy/semantic.rs b/src/policy/semantic.rs
index 28e0edb95..9ae9d37b7 100644
--- a/src/policy/semantic.rs
+++ b/src/policy/semantic.rs
@@ -19,9 +19,7 @@ use std::{fmt, str};
 
 use bitcoin::hashes::hex::FromHex;
 use bitcoin::hashes::{hash160, ripemd160, sha256, sha256d};
-use errstr;
-use Error;
-use {expression, ForEach, ForEachKey, MiniscriptKey};
+use {errstr, expression, Error, ForEach, ForEachKey, MiniscriptKey};
 
 use super::concrete::PolicyError;
 use super::ENTAILMENT_MAX_TERMINALS;
diff --git a/src/psbt/finalizer.rs b/src/psbt/finalizer.rs
index 609c8e819..95c10738f 100644
--- a/src/psbt/finalizer.rs
+++ b/src/psbt/finalizer.rs
@@ -28,15 +28,10 @@ use bitcoin::util::sighash::Prevouts;
 use bitcoin::util::taproot::LeafVersion;
 use bitcoin::{self, PublicKey, Script, TxOut};
 use descriptor::DescriptorTrait;
-use interpreter;
 use util::witness_size;
-use Descriptor;
-use Miniscript;
-use Satisfier;
-use {BareCtx, Legacy, Segwitv0, Tap};
+use {interpreter, BareCtx, Descriptor, Legacy, Miniscript, Satisfier, Segwitv0, Tap};
 
-use super::{sanity_check, Psbt};
-use super::{Error, InputError, PsbtInputSatisfier};
+use super::{sanity_check, Error, InputError, Psbt, PsbtInputSatisfier};
 
 // Satisfy the taproot descriptor. It is not possible to infer the complete
 // descriptor from psbt because the information about all the scripts might not
diff --git a/src/psbt/mod.rs b/src/psbt/mod.rs
index 994b1ae21..9147d9aed 100644
--- a/src/psbt/mod.rs
+++ b/src/psbt/mod.rs
@@ -28,15 +28,13 @@ use bitcoin::secp256k1::{self, Secp256k1};
 use bitcoin::util::psbt::PartiallySignedTransaction as Psbt;
 use bitcoin::util::sighash::SighashCache;
 use bitcoin::util::taproot::{self, ControlBlock, LeafVersion, TapLeafHash};
-use bitcoin::{self, SchnorrSighashType};
-use bitcoin::{EcdsaSighashType, Script};
-use descriptor;
-use interpreter;
+use bitcoin::{self, EcdsaSighashType, SchnorrSighashType, Script};
 use miniscript::limits::SEQUENCE_LOCKTIME_DISABLE_FLAG;
 use miniscript::satisfy::{After, Older};
-use Preimage32;
-use Satisfier;
-use {Descriptor, DescriptorPublicKey, DescriptorTrait, MiniscriptKey, ToPublicKey};
+use {
+    descriptor, interpreter, Descriptor, DescriptorPublicKey, DescriptorTrait, MiniscriptKey,
+    Preimage32, Satisfier, ToPublicKey,
+};
 
 mod finalizer;
 
diff --git a/src/util.rs b/src/util.rs
index ab957ccde..8d3fcf979 100644
--- a/src/util.rs
+++ b/src/util.rs
@@ -1,8 +1,7 @@
-use bitcoin;
 use bitcoin::blockdata::script;
 use bitcoin::Script;
 use miniscript::context;
-use {ScriptContext, ToPublicKey};
+use {bitcoin, ScriptContext, ToPublicKey};
 pub(crate) fn varint_len(n: usize) -> usize {
     bitcoin::VarInt(n as u64).len()
 }