group imports

ran:
cargo +nightly fmt

with:
imports_granularity = "crate" in .rustformat.toml

Author: cowlicks

benches/pipe.rs

@@ -1,14 +1,14 @@
 use async_std::task;
 use criterion::{criterion_group, criterion_main, Criterion, Throughput};
-use futures::io::{AsyncRead, AsyncWrite};
-use futures::stream::StreamExt;
-use hypercore_protocol::{schema::*, Duplex};
-use hypercore_protocol::{Channel, Event, Message, Protocol, ProtocolBuilder};
+use futures::{
+    io::{AsyncRead, AsyncWrite},
+    stream::StreamExt,
+};
+use hypercore_protocol::{schema::*, Channel, Duplex, Event, Message, Protocol, ProtocolBuilder};
 use log::*;
 use pretty_bytes::converter::convert as pretty_bytes;
 use sluice::pipe::pipe;
-use std::io::Result;
-use std::time::Instant;
+use std::{io::Result, time::Instant};
 
 const COUNT: u64 = 1000;
 const SIZE: u64 = 100;

benches/throughput.rs

@@ -1,11 +1,14 @@
-use async_std::net::{Shutdown, TcpListener, TcpStream};
-use async_std::task;
+use async_std::{
+    net::{Shutdown, TcpListener, TcpStream},
+    task,
+};
 use criterion::{criterion_group, criterion_main, Criterion, Throughput};
-use futures::future::Either;
-use futures::io::{AsyncRead, AsyncWrite};
-use futures::stream::{FuturesUnordered, StreamExt};
-use hypercore_protocol::schema::*;
-use hypercore_protocol::{Channel, Event, Message, ProtocolBuilder};
+use futures::{
+    future::Either,
+    io::{AsyncRead, AsyncWrite},
+    stream::{FuturesUnordered, StreamExt},
+};
+use hypercore_protocol::{schema::*, Channel, Event, Message, ProtocolBuilder};
 use log::*;
 use std::time::Instant;
 

examples/replication.rs

@@ -1,22 +1,19 @@
 use anyhow::Result;
-use async_std::net::{TcpListener, TcpStream};
-use async_std::prelude::*;
-use async_std::sync::{Arc, Mutex};
-use async_std::task;
+use async_std::{
+    net::{TcpListener, TcpStream},
+    prelude::*,
+    sync::{Arc, Mutex},
+    task,
+};
 use futures_lite::stream::StreamExt;
 use hypercore::{
     Hypercore, HypercoreBuilder, PartialKeypair, RequestBlock, RequestUpgrade, Storage,
     VerifyingKey,
 };
-use std::collections::HashMap;
-use std::convert::TryInto;
-use std::env;
-use std::fmt::Debug;
-use std::sync::OnceLock;
+use std::{collections::HashMap, convert::TryInto, env, fmt::Debug, sync::OnceLock};
 use tracing::{error, info};
 
-use hypercore_protocol::schema::*;
-use hypercore_protocol::{discovery_key, Channel, Event, Message, ProtocolBuilder};
+use hypercore_protocol::{discovery_key, schema::*, Channel, Event, Message, ProtocolBuilder};
 
 fn main() {
     log();

src/builder.rs

@@ -1,5 +1,4 @@
-use crate::Protocol;
-use crate::{duplex::Duplex, protocol::Options};
+use crate::{duplex::Duplex, protocol::Options, Protocol};
 use futures_lite::io::{AsyncRead, AsyncWrite};
 
 /// Build a Protocol instance with options.

src/channels.rs

@@ -1,18 +1,23 @@
-use crate::message::ChannelMessage;
-use crate::schema::*;
-use crate::util::{map_channel_err, pretty_hash};
-use crate::Message;
-use crate::{discovery_key, DiscoveryKey, Key};
+use crate::{
+    discovery_key,
+    message::ChannelMessage,
+    schema::*,
+    util::{map_channel_err, pretty_hash},
+    DiscoveryKey, Key, Message,
+};
 use async_channel::{Receiver, Sender, TrySendError};
-use futures_lite::ready;
-use futures_lite::stream::Stream;
-use std::collections::HashMap;
-use std::fmt;
-use std::io::{Error, ErrorKind, Result};
-use std::pin::Pin;
-use std::sync::atomic::{AtomicBool, Ordering};
-use std::sync::Arc;
-use std::task::Poll;
+use futures_lite::{ready, stream::Stream};
+use std::{
+    collections::HashMap,
+    fmt,
+    io::{Error, ErrorKind, Result},
+    pin::Pin,
+    sync::{
+        atomic::{AtomicBool, Ordering},
+        Arc,
+    },
+    task::Poll,
+};
 use tracing::instrument;
 
 /// A protocol channel.

src/crypto/cipher.rs

@@ -5,8 +5,7 @@ use blake2::{
 };
 use crypto_secretstream::{Header, Key, PullStream, PushStream, Tag};
 use rand::rngs::OsRng;
-use std::convert::TryInto;
-use std::io;
+use std::{convert::TryInto, io};
 
 const STREAM_ID_LENGTH: usize = 32;
 const KEY_LENGTH: usize = 32;

src/crypto/handshake.rs

@@ -3,8 +3,10 @@ use blake2::{
     digest::{typenum::U32, FixedOutput, Update},
     Blake2bMac,
 };
-use snow::resolvers::{DefaultResolver, FallbackResolver};
-use snow::{Builder, Error as SnowError, HandshakeState};
+use snow::{
+    resolvers::{DefaultResolver, FallbackResolver},
+    Builder, Error as SnowError, HandshakeState,
+};
 use std::io::{Error, ErrorKind, Result};
 use tracing::instrument;
 

src/duplex.rs

@@ -1,7 +1,9 @@
 use futures_lite::{AsyncRead, AsyncWrite};
-use std::io;
-use std::pin::Pin;
-use std::task::{Context, Poll};
+use std::{
+    io,
+    pin::Pin,
+    task::{Context, Poll},
+};
 
 #[derive(Clone, Debug, PartialEq)]
 /// Duplex IO stream from reader and writer halves.

src/message.rs

@@ -4,8 +4,7 @@ use compact_encoding::{
     VecEncodable,
 };
 use pretty_hash::fmt as pretty_fmt;
-use std::fmt;
-use std::io;
+use std::{fmt, io};
 use tracing::{debug, instrument, trace, warn};
 
 const OPEN_MESSAGE_PREFIX: [u8; 2] = [0, 1];

src/protocol.rs

@@ -1,25 +1,31 @@
 use async_channel::{Receiver, Sender};
-use futures_lite::io::{AsyncRead, AsyncWrite};
-use futures_lite::stream::Stream;
+use futures_lite::{
+    io::{AsyncRead, AsyncWrite},
+    stream::Stream,
+};
 use futures_timer::Delay;
-use std::collections::VecDeque;
-use std::convert::TryInto;
-use std::fmt;
-use std::io::{self, Error, ErrorKind, Result};
-use std::pin::Pin;
-use std::task::{Context, Poll};
-use std::time::Duration;
+use std::{
+    collections::VecDeque,
+    convert::TryInto,
+    fmt,
+    io::{self, Error, ErrorKind, Result},
+    pin::Pin,
+    task::{Context, Poll},
+    time::Duration,
+};
 use tracing::{debug, error, instrument, warn};
 
-use crate::channels::{Channel, ChannelMap};
-use crate::constants::{DEFAULT_KEEPALIVE, PROTOCOL_NAME};
-use crate::crypto::HandshakeResult;
-use crate::message::{ChannelMessage, Message};
-use crate::mqueue::{MessageIo, MqueueEvent};
-use crate::noise::EncryptionInfo;
-use crate::util::{map_channel_err, pretty_hash};
 use crate::{
-    encrypted_framed_message_channel, schema::*, Encrypted, Uint24LELengthPrefixedFraming,
+    channels::{Channel, ChannelMap},
+    constants::{DEFAULT_KEEPALIVE, PROTOCOL_NAME},
+    crypto::HandshakeResult,
+    encrypted_framed_message_channel,
+    message::{ChannelMessage, Message},
+    mqueue::{MessageIo, MqueueEvent},
+    noise::EncryptionInfo,
+    schema::*,
+    util::{map_channel_err, pretty_hash},
+    Encrypted, Uint24LELengthPrefixedFraming,
 };
 
 macro_rules! return_error {