You are viewing a plain text version of this content. The canonical link for it is here.
Posted to commits@opendal.apache.org by xu...@apache.org on 2025/05/26 06:29:51 UTC

(opendal) branch polish-docs created (now a6217ac82)

This is an automated email from the ASF dual-hosted git repository.

xuanwo pushed a change to branch polish-docs
in repository https://gitbox.apache.org/repos/asf/opendal.git


      at a6217ac82 docs: Remove deprecated APIs and polish docs for public APIs

This branch includes the following new commits:

     new 24d9512ba Save work
     new a6217ac82 docs: Remove deprecated APIs and polish docs for public APIs

The 2 revisions listed above as "new" are entirely new to this
repository and will be described in separate emails.  The revisions
listed as "add" were already present in the repository and have only
been added to this reference.



(opendal) 01/02: Save work

Posted by xu...@apache.org.
This is an automated email from the ASF dual-hosted git repository.

xuanwo pushed a commit to branch polish-docs
in repository https://gitbox.apache.org/repos/asf/opendal.git

commit 24d9512ba1d397acddbdd5c804312f74f58b7762
Author: Xuanwo <gi...@xuanwo.io>
AuthorDate: Fri May 23 23:16:33 2025 +0800

    Save work
    
    Signed-off-by: Xuanwo <gi...@xuanwo.io>
---
 core/benches/types/buffer.rs                  |  3 +-
 core/benches/types/tasks.rs                   |  2 +-
 core/src/blocking/operator.rs                 |  2 +-
 core/src/blocking/read/reader.rs              |  5 +-
 core/src/layers/capability_check.rs           | 10 ++-
 core/src/layers/complete.rs                   | 10 +--
 core/src/layers/correctness_check.rs          |  8 ++-
 core/src/layers/mime_guess.rs                 |  3 +-
 core/src/layers/otelmetrics.rs                |  3 +-
 core/src/layers/retry.rs                      |  3 +-
 core/src/layers/tracing.rs                    | 21 ++++--
 core/src/layers/type_eraser.rs                |  5 +-
 core/src/lib.rs                               | 33 ++++++++--
 core/src/raw/adapters/kv/backend.rs           |  3 +-
 core/src/raw/chrono_util.rs                   |  2 +-
 core/src/raw/futures_util.rs                  | 11 ++--
 core/src/raw/http_util/client.rs              |  2 +-
 core/src/raw/http_util/mod.rs                 |  1 -
 core/src/raw/http_util/uri.rs                 |  3 +-
 core/src/raw/layer.rs                         |  4 +-
 core/src/raw/oio/delete/api.rs                |  7 +-
 core/src/raw/oio/delete/batch_delete.rs       |  5 +-
 core/src/raw/oio/delete/one_shot_delete.rs    |  3 +-
 core/src/raw/oio/list/page_list.rs            |  5 +-
 core/src/raw/ops.rs                           |  8 ++-
 core/src/raw/tests/utils.rs                   |  1 -
 core/src/services/aliyun_drive/core.rs        |  3 +-
 core/src/services/aliyun_drive/delete.rs      |  9 ++-
 core/src/services/alluxio/core.rs             |  7 +-
 core/src/services/alluxio/delete.rs           |  3 +-
 core/src/services/azblob/delete.rs            |  6 +-
 core/src/services/azdls/core.rs               | 15 +++--
 core/src/services/azdls/delete.rs             |  6 +-
 core/src/services/azdls/writer.rs             |  3 +-
 core/src/services/azfile/core.rs              |  9 +--
 core/src/services/azfile/delete.rs            |  6 +-
 core/src/services/b2/delete.rs                |  6 +-
 core/src/services/compfs/core.rs              |  5 +-
 core/src/services/compfs/delete.rs            |  3 +-
 core/src/services/compfs/reader.rs            |  4 +-
 core/src/services/cos/backend.rs              |  4 +-
 core/src/services/cos/delete.rs               |  6 +-
 core/src/services/cos/writer.rs               |  4 +-
 core/src/services/dashmap/backend.rs          |  3 +-
 core/src/services/dbfs/delete.rs              |  6 +-
 core/src/services/dropbox/delete.rs           |  6 +-
 core/src/services/fs/core.rs                  |  1 +
 core/src/services/fs/delete.rs                |  3 +-
 core/src/services/ftp/backend.rs              |  2 +-
 core/src/services/ftp/core.rs                 | 16 +++--
 core/src/services/ftp/delete.rs               | 10 +--
 core/src/services/gcs/core.rs                 |  7 +-
 core/src/services/gcs/delete.rs               |  6 +-
 core/src/services/gdrive/builder.rs           |  3 +-
 core/src/services/gdrive/delete.rs            |  6 +-
 core/src/services/ghac/backend.rs             |  9 +--
 core/src/services/ghac/core.rs                | 21 ++++--
 core/src/services/ghac/error.rs               |  5 +-
 core/src/services/ghac/writer.rs              |  5 +-
 core/src/services/github/core.rs              |  7 +-
 core/src/services/github/delete.rs            |  3 +-
 core/src/services/gridfs/core.rs              | 26 +++++---
 core/src/services/hdfs/delete.rs              |  5 +-
 core/src/services/hdfs_native/backend.rs      | 14 ++--
 core/src/services/hdfs_native/delete.rs       |  3 +-
 core/src/services/hdfs_native/lister.rs       |  3 +-
 core/src/services/hdfs_native/writer.rs       |  3 +-
 core/src/services/huggingface/core.rs         |  5 +-
 core/src/services/ipmfs/delete.rs             |  6 +-
 core/src/services/koofr/delete.rs             |  6 +-
 core/src/services/lakefs/core.rs              | 12 ++--
 core/src/services/lakefs/delete.rs            |  6 +-
 core/src/services/monoiofs/core.rs            |  3 +-
 core/src/services/monoiofs/delete.rs          |  3 +-
 core/src/services/nebula_graph/backend.rs     | 11 ++--
 core/src/services/obs/backend.rs              |  3 +-
 core/src/services/obs/delete.rs               |  6 +-
 core/src/services/obs/writer.rs               |  4 +-
 core/src/services/onedrive/builder.rs         |  1 -
 core/src/services/onedrive/core.rs            |  1 -
 core/src/services/onedrive/delete.rs          |  6 +-
 core/src/services/onedrive/lister.rs          |  4 +-
 core/src/services/onedrive/writer.rs          |  3 +-
 core/src/services/opfs/backend.rs             |  4 +-
 core/src/services/opfs/core.rs                | 20 +++---
 core/src/services/oss/backend.rs              |  4 +-
 core/src/services/oss/delete.rs               | 10 +--
 core/src/services/oss/writer.rs               |  4 +-
 core/src/services/pcloud/core.rs              |  7 +-
 core/src/services/pcloud/delete.rs            | 11 ++--
 core/src/services/redis/backend.rs            | 12 ++--
 core/src/services/redis/core.rs               | 11 ++--
 core/src/services/s3/backend.rs               |  9 ++-
 core/src/services/s3/core.rs                  |  7 +-
 core/src/services/s3/delete.rs                | 11 ++--
 core/src/services/s3/lister.rs                |  5 +-
 core/src/services/s3/writer.rs                |  8 ++-
 core/src/services/seafile/delete.rs           |  3 +-
 core/src/services/sftp/delete.rs              |  6 +-
 core/src/services/swift/core.rs               |  5 +-
 core/src/services/swift/delete.rs             |  6 +-
 core/src/services/upyun/core.rs               |  7 +-
 core/src/services/upyun/delete.rs             |  6 +-
 core/src/services/vercel_artifacts/builder.rs |  3 +-
 core/src/services/vercel_blob/core.rs         |  7 +-
 core/src/services/webdav/core.rs              | 11 ++--
 core/src/services/webdav/delete.rs            |  6 +-
 core/src/services/webhdfs/backend.rs          |  3 +-
 core/src/services/webhdfs/delete.rs           |  6 +-
 core/src/services/yandex_disk/core.rs         |  7 +-
 core/src/services/yandex_disk/delete.rs       |  6 +-
 core/src/types/buffer.rs                      | 12 +++-
 core/src/types/context/read.rs                |  4 +-
 core/src/types/delete/deleter.rs              | 14 ++--
 core/src/types/delete/futures_delete_sink.rs  | 12 ++--
 core/src/types/error.rs                       |  8 ++-
 core/src/types/operator/operator.rs           | 94 ++++++++++++++-------------
 core/src/types/operator/operator_futures.rs   | 47 +++++++++-----
 core/src/types/options.rs                     |  3 +-
 core/src/types/read/reader.rs                 | 10 +--
 core/src/types/write/writer.rs                |  6 +-
 core/tests/behavior/async_delete.rs           |  6 +-
 core/tests/behavior/async_read.rs             |  3 +-
 core/tests/behavior/async_stat.rs             |  3 +-
 124 files changed, 590 insertions(+), 352 deletions(-)

diff --git a/core/benches/types/buffer.rs b/core/benches/types/buffer.rs
index 63cf682d9..686c83ee3 100644
--- a/core/benches/types/buffer.rs
+++ b/core/benches/types/buffer.rs
@@ -17,7 +17,8 @@
 
 use bytes::Buf;
 use bytes::Bytes;
-use divan::{black_box, Bencher};
+use divan::black_box;
+use divan::Bencher;
 use opendal::Buffer;
 
 mod chunk {
diff --git a/core/benches/types/tasks.rs b/core/benches/types/tasks.rs
index abb7093c0..fbedf0d1b 100644
--- a/core/benches/types/tasks.rs
+++ b/core/benches/types/tasks.rs
@@ -15,12 +15,12 @@
 // specific language governing permissions and limitations
 // under the License.
 
+use std::sync::LazyLock;
 use std::time::Duration;
 
 use divan::Bencher;
 use opendal::raw::ConcurrentTasks;
 use opendal::Executor;
-use std::sync::LazyLock;
 
 pub static TOKIO: LazyLock<tokio::runtime::Runtime> =
     LazyLock::new(|| tokio::runtime::Runtime::new().expect("build tokio runtime"));
diff --git a/core/src/blocking/operator.rs b/core/src/blocking/operator.rs
index ef5c3202d..74b4c36d0 100644
--- a/core/src/blocking/operator.rs
+++ b/core/src/blocking/operator.rs
@@ -361,11 +361,11 @@ impl Operator {
     ///
     /// ```no_run
     /// # use opendal::Result;
-    /// use opendal::blocking;
     /// # use opendal::blocking::Operator;
     /// # use futures::StreamExt;
     /// # use futures::SinkExt;
     /// use bytes::Bytes;
+    /// use opendal::blocking;
     ///
     /// # fn test(op: blocking::Operator) -> Result<()> {
     /// op.write("path/to/file", vec![0; 4096])?;
diff --git a/core/src/blocking/read/reader.rs b/core/src/blocking/read/reader.rs
index e4f5942c9..1e04d1f54 100644
--- a/core/src/blocking/read/reader.rs
+++ b/core/src/blocking/read/reader.rs
@@ -19,12 +19,11 @@ use std::ops::RangeBounds;
 
 use bytes::BufMut;
 
-use crate::Reader as AsyncReader;
-use crate::*;
-
 use super::BufferIterator;
 use super::StdBytesIterator;
 use super::StdReader;
+use crate::Reader as AsyncReader;
+use crate::*;
 
 /// BlockingReader is designed to read data from given path in an blocking
 /// manner.
diff --git a/core/src/layers/capability_check.rs b/core/src/layers/capability_check.rs
index 6d5c3c9a6..1a8f534ee 100644
--- a/core/src/layers/capability_check.rs
+++ b/core/src/layers/capability_check.rs
@@ -15,10 +15,12 @@
 // specific language governing permissions and limitations
 // under the License.
 
+use std::fmt::Debug;
+use std::fmt::Formatter;
+use std::sync::Arc;
+
 use crate::layers::correctness_check::new_unsupported_error;
 use crate::raw::*;
-use std::fmt::{Debug, Formatter};
-use std::sync::Arc;
 
 /// Add an extra capability check layer for every operation
 ///
@@ -141,7 +143,9 @@ impl<A: Access> LayeredAccess for CapabilityAccessor<A> {
 #[cfg(test)]
 mod tests {
     use super::*;
-    use crate::{Capability, ErrorKind, Operator};
+    use crate::Capability;
+    use crate::ErrorKind;
+    use crate::Operator;
 
     #[derive(Debug)]
     struct MockService {
diff --git a/core/src/layers/complete.rs b/core/src/layers/complete.rs
index c2756146d..830db569d 100644
--- a/core/src/layers/complete.rs
+++ b/core/src/layers/complete.rs
@@ -15,15 +15,16 @@
 // specific language governing permissions and limitations
 // under the License.
 
-use crate::raw::oio::FlatLister;
-use crate::raw::oio::PrefixLister;
-use crate::raw::*;
-use crate::*;
 use std::cmp::Ordering;
 use std::fmt::Debug;
 use std::fmt::Formatter;
 use std::sync::Arc;
 
+use crate::raw::oio::FlatLister;
+use crate::raw::oio::PrefixLister;
+use crate::raw::*;
+use crate::*;
+
 /// Complete underlying services features so that users can use them in
 /// the same way.
 ///
@@ -51,7 +52,6 @@ use std::sync::Arc;
 ///
 /// - If support `list_with_recursive`, return directly.
 /// - if not, wrap with [`FlatLister`].
-///
 pub struct CompleteLayer;
 
 impl<A: Access> Layer<A> for CompleteLayer {
diff --git a/core/src/layers/correctness_check.rs b/core/src/layers/correctness_check.rs
index 47e8a0716..c0ba97b49 100644
--- a/core/src/layers/correctness_check.rs
+++ b/core/src/layers/correctness_check.rs
@@ -15,7 +15,8 @@
 // specific language governing permissions and limitations
 // under the License.
 
-use std::fmt::{Debug, Formatter};
+use std::fmt::Debug;
+use std::fmt::Formatter;
 use std::future::Future;
 use std::sync::Arc;
 
@@ -252,7 +253,10 @@ impl<T: oio::Delete> oio::Delete for CheckWrapper<T> {
 mod tests {
     use super::*;
     use crate::raw::oio;
-    use crate::{Capability, EntryMode, Metadata, Operator};
+    use crate::Capability;
+    use crate::EntryMode;
+    use crate::Metadata;
+    use crate::Operator;
 
     #[derive(Debug)]
     struct MockService {
diff --git a/core/src/layers/mime_guess.rs b/core/src/layers/mime_guess.rs
index 10f5762d5..021e302b9 100644
--- a/core/src/layers/mime_guess.rs
+++ b/core/src/layers/mime_guess.rs
@@ -142,11 +142,12 @@ impl<A: Access> LayeredAccess for MimeGuessAccessor<A> {
 
 #[cfg(test)]
 mod tests {
+    use futures::TryStreamExt;
+
     use super::*;
     use crate::services::Memory;
     use crate::Metadata;
     use crate::Operator;
-    use futures::TryStreamExt;
 
     const DATA: &str = "<html>test</html>";
     const CUSTOM: &str = "text/custom";
diff --git a/core/src/layers/otelmetrics.rs b/core/src/layers/otelmetrics.rs
index 3f3ca4121..95c416faa 100644
--- a/core/src/layers/otelmetrics.rs
+++ b/core/src/layers/otelmetrics.rs
@@ -161,8 +161,7 @@ impl OtelMetricsLayerBuilder {
     /// # async fn main() -> Result<()> {
     /// let meter = opentelemetry::global::meter("opendal");
     /// let op = Operator::new(services::Memory::default())?
-    ///     .layer(OtelMetricsLayer::builder()
-    ///     .register(&meter))
+    ///     .layer(OtelMetricsLayer::builder().register(&meter))
     ///     .finish();
     ///
     /// Ok(())
diff --git a/core/src/layers/retry.rs b/core/src/layers/retry.rs
index fd64c4079..19471f732 100644
--- a/core/src/layers/retry.rs
+++ b/core/src/layers/retry.rs
@@ -606,7 +606,8 @@ mod tests {
     use std::sync::Mutex;
 
     use bytes::Bytes;
-    use futures::{stream, TryStreamExt};
+    use futures::stream;
+    use futures::TryStreamExt;
     use tracing_subscriber::filter::LevelFilter;
 
     use super::*;
diff --git a/core/src/layers/tracing.rs b/core/src/layers/tracing.rs
index a432a1ab4..38a39865a 100644
--- a/core/src/layers/tracing.rs
+++ b/core/src/layers/tracing.rs
@@ -17,11 +17,14 @@
 
 use std::fmt::Debug;
 use std::pin::Pin;
-use std::task::{Context, Poll};
+use std::task::Context;
+use std::task::Poll;
 
 use futures::Stream;
 use futures::StreamExt;
-use tracing::{span, Level, Span};
+use tracing::span;
+use tracing::Level;
+use tracing::Span;
 
 use crate::raw::*;
 use crate::*;
@@ -62,10 +65,16 @@ use crate::*;
 /// # fn main() -> Result<()> {
 /// use opentelemetry::trace::TracerProvider;
 /// let tracer_provider = opentelemetry_sdk::trace::SdkTracerProvider::builder()
-///     .with_simple_exporter(opentelemetry_otlp::SpanExporter::builder().with_tonic().build()?)
-///     .with_resource(Resource::builder().with_attributes(vec![
-///         KeyValue::new("service.name", "opendal_example"),
-///     ]).build())
+///     .with_simple_exporter(
+///         opentelemetry_otlp::SpanExporter::builder()
+///             .with_tonic()
+///             .build()?,
+///     )
+///     .with_resource(
+///         Resource::builder()
+///             .with_attributes(vec![KeyValue::new("service.name", "opendal_example")])
+///             .build(),
+///     )
 ///     .build();
 /// let tracer = tracer_provider.tracer("opendal_tracer");
 /// let opentelemetry = tracing_opentelemetry::layer().with_tracer(tracer);
diff --git a/core/src/layers/type_eraser.rs b/core/src/layers/type_eraser.rs
index 4fe7547ff..bb019d14f 100644
--- a/core/src/layers/type_eraser.rs
+++ b/core/src/layers/type_eraser.rs
@@ -15,11 +15,12 @@
 // specific language governing permissions and limitations
 // under the License.
 
-use crate::raw::*;
-use crate::*;
 use std::fmt::Debug;
 use std::fmt::Formatter;
 
+use crate::raw::*;
+use crate::*;
+
 /// TypeEraseLayer will erase the types on internal accessor.
 ///
 /// For example, we will erase `Self::Reader` to `oio::Reader` (`Box<dyn oio::Read>`).
diff --git a/core/src/lib.rs b/core/src/lib.rs
index e3901e2a5..ecb2a5910 100644
--- a/core/src/lib.rs
+++ b/core/src/lib.rs
@@ -90,15 +90,20 @@
 //! The final step is to use the operator. OpenDAL supports both async [`Operator`]
 //! and blocking [`blocking::Operator`]. Please pick the one that fits your use case.
 //!
-//! Every Operator API follows the same pattern, take `read` as an example:
+//! Every Operator API follows a consistent pattern. For example, consider the `read` operation:
 //!
-//! - `read`: Execute a read operation.
-//! - `read_with`: Execute a read operation with additional options, like `range` and `if_match`.
-//! - `reader`: Create a reader for streaming data, enabling flexible access.
-//! - `reader_with`: Create a reader with advanced options.
+//! - [`Operator::read_with`]: Executes a read operation with additional options using the builder pattern.
+//! - [`Operator::read_options`]: Executes a read operation with extra options provided via a [`options::ReadOptions`] struct.
+//! - [`Operator::reader`]: Creates a reader for streaming data, allowing for flexible access.
+//! - [`Operator::reader_with`]: Creates a reader with advanced options using the builder pattern.
+//! - [`Operator::reader_options`]: Creates a reader with extra options provided via a [`options::ReadOptions`] struct.
+//!
+//! The [`Reader`] created by [`Operator`] supports custom read control methods and can be converted
+//! into `futures::AsyncRead` for broader ecosystem compatibility.
 //!
 //! ```no_run
 //! use opendal::layers::LoggingLayer;
+//! use opendal::options;
 //! use opendal::services;
 //! use opendal::Operator;
 //! use opendal::Result;
@@ -118,8 +123,22 @@
 //!     let meta = op.stat("hello.txt").await?;
 //!     let length = meta.content_length();
 //!
-//!     // Read data from `hello.txt` with range `0..1024`.
-//!     let bs = op.read_with("hello.txt").range(0..1024).await?;
+//!     // Read data from `hello.txt` with options.
+//!     let bs = op
+//!         .read_with("hello.txt")
+//!         .range(0..8 * 1024 * 1024)
+//!         .chunk(1024 * 1024)
+//!         .concurrent(4)
+//!         .await?;
+//!
+//!     // The same to:
+//!     let bs = op
+//!         .read_options("hello.txt", options::ReadOptions {
+//!             range: (0..8 * 1024 * 1024).into(),
+//!             chunk: Some(1024 * 1024),
+//!             concurrent: 4,
+//!         })
+//!         .await?;
 //!
 //!     Ok(())
 //! }
diff --git a/core/src/raw/adapters/kv/backend.rs b/core/src/raw/adapters/kv/backend.rs
index 3f5380ac6..05bb716b1 100644
--- a/core/src/raw/adapters/kv/backend.rs
+++ b/core/src/raw/adapters/kv/backend.rs
@@ -17,7 +17,8 @@
 
 use std::sync::Arc;
 
-use super::{Adapter, Scan};
+use super::Adapter;
+use super::Scan;
 use crate::raw::oio::HierarchyLister;
 use crate::raw::oio::QueueBuf;
 use crate::raw::*;
diff --git a/core/src/raw/chrono_util.rs b/core/src/raw/chrono_util.rs
index 2899be619..4d34ee950 100644
--- a/core/src/raw/chrono_util.rs
+++ b/core/src/raw/chrono_util.rs
@@ -42,8 +42,8 @@ pub fn parse_datetime_from_rfc2822(s: &str) -> Result<DateTime<Utc>> {
 ///
 /// ```
 /// use chrono::Datelike;
-/// use opendal::Error;
 /// use opendal::raw::parse_datetime_from_rfc3339;
+/// use opendal::Error;
 ///
 /// let date_time = parse_datetime_from_rfc3339("2014-11-28T21:00:09+09:00")?;
 /// assert_eq!(date_time.date_naive().day(), 28);
diff --git a/core/src/raw/futures_util.rs b/core/src/raw/futures_util.rs
index 63d5715ca..44deab8d9 100644
--- a/core/src/raw/futures_util.rs
+++ b/core/src/raw/futures_util.rs
@@ -15,11 +15,10 @@
 // specific language governing permissions and limitations
 // under the License.
 
-use std::{
-    collections::VecDeque,
-    sync::atomic::Ordering,
-    sync::{atomic::AtomicUsize, Arc},
-};
+use std::collections::VecDeque;
+use std::sync::atomic::AtomicUsize;
+use std::sync::atomic::Ordering;
+use std::sync::Arc;
 
 use futures::FutureExt;
 
@@ -309,11 +308,11 @@ impl<I: Send + 'static, O: Send + 'static> ConcurrentTasks<I, O> {
 mod tests {
     use std::time::Duration;
 
+    use pretty_assertions::assert_eq;
     use rand::Rng;
     use tokio::time::sleep;
 
     use super::*;
-    use pretty_assertions::assert_eq;
 
     #[tokio::test]
     async fn test_concurrent_tasks() {
diff --git a/core/src/raw/http_util/client.rs b/core/src/raw/http_util/client.rs
index 43dfaa19a..4faa37b48 100644
--- a/core/src/raw/http_util/client.rs
+++ b/core/src/raw/http_util/client.rs
@@ -24,6 +24,7 @@ use std::ops::Deref;
 use std::pin::Pin;
 use std::str::FromStr;
 use std::sync::Arc;
+use std::sync::LazyLock;
 use std::task::Context;
 use std::task::Poll;
 
@@ -35,7 +36,6 @@ use http::Response;
 use http_body::Frame;
 use http_body::SizeHint;
 use raw::oio::Read;
-use std::sync::LazyLock;
 
 use super::parse_content_encoding;
 use super::parse_content_length;
diff --git a/core/src/raw/http_util/mod.rs b/core/src/raw/http_util/mod.rs
index 01264f7f4..8a20443d5 100644
--- a/core/src/raw/http_util/mod.rs
+++ b/core/src/raw/http_util/mod.rs
@@ -26,7 +26,6 @@ mod client;
 pub use client::HttpClient;
 pub use client::HttpFetch;
 pub use client::HttpFetcher;
-
 /// temporary client used by several features
 #[allow(unused_imports)]
 pub(crate) use client::GLOBAL_REQWEST_CLIENT;
diff --git a/core/src/raw/http_util/uri.rs b/core/src/raw/http_util/uri.rs
index b74de6677..5dd076382 100644
--- a/core/src/raw/http_util/uri.rs
+++ b/core/src/raw/http_util/uri.rs
@@ -15,12 +15,13 @@
 // specific language governing permissions and limitations
 // under the License.
 
-use crate::*;
 use percent_encoding::percent_decode_str;
 use percent_encoding::utf8_percent_encode;
 use percent_encoding::AsciiSet;
 use percent_encoding::NON_ALPHANUMERIC;
 
+use crate::*;
+
 /// Parse http uri invalid error in to opendal::Error.
 pub fn new_http_uri_invalid_error(err: http::uri::InvalidUri) -> Error {
     Error::new(ErrorKind::Unexpected, "parse http uri").set_source(err)
diff --git a/core/src/raw/layer.rs b/core/src/raw/layer.rs
index 87d99f81e..86151c4e0 100644
--- a/core/src/raw/layer.rs
+++ b/core/src/raw/layer.rs
@@ -78,8 +78,8 @@ use crate::*;
 ///     }
 ///
 ///     async fn delete(&self) -> Result<(RpDelete, Self::Deleter)> {
-///        self.inner.delete().await
-///        }
+///         self.inner.delete().await
+///     }
 /// }
 ///
 /// /// The public struct that exposed to users.
diff --git a/core/src/raw/oio/delete/api.rs b/core/src/raw/oio/delete/api.rs
index bf605334f..ea5d4c5de 100644
--- a/core/src/raw/oio/delete/api.rs
+++ b/core/src/raw/oio/delete/api.rs
@@ -15,11 +15,14 @@
 // specific language governing permissions and limitations
 // under the License.
 
-use crate::raw::{BoxedFuture, MaybeSend, OpDelete};
-use crate::*;
 use std::future::Future;
 use std::ops::DerefMut;
 
+use crate::raw::BoxedFuture;
+use crate::raw::MaybeSend;
+use crate::raw::OpDelete;
+use crate::*;
+
 /// Deleter is a type erased [`Delete`]
 pub type Deleter = Box<dyn DeleteDyn>;
 
diff --git a/core/src/raw/oio/delete/batch_delete.rs b/core/src/raw/oio/delete/batch_delete.rs
index 0c5583bdf..d244a22ad 100644
--- a/core/src/raw/oio/delete/batch_delete.rs
+++ b/core/src/raw/oio/delete/batch_delete.rs
@@ -15,11 +15,12 @@
 // specific language governing permissions and limitations
 // under the License.
 
-use crate::raw::*;
-use crate::*;
 use std::collections::HashSet;
 use std::future::Future;
 
+use crate::raw::*;
+use crate::*;
+
 /// BatchDelete is used to implement [`oio::Delete`] based on batch delete operation.
 ///
 /// OneShotDeleter will perform delete operation while calling `flush`.
diff --git a/core/src/raw/oio/delete/one_shot_delete.rs b/core/src/raw/oio/delete/one_shot_delete.rs
index c769d274d..1df00547a 100644
--- a/core/src/raw/oio/delete/one_shot_delete.rs
+++ b/core/src/raw/oio/delete/one_shot_delete.rs
@@ -15,9 +15,10 @@
 // specific language governing permissions and limitations
 // under the License.
 
+use std::future::Future;
+
 use crate::raw::*;
 use crate::*;
-use std::future::Future;
 
 /// OneShotDelete is used to implement [`oio::Delete`] based on one shot operation.
 ///
diff --git a/core/src/raw/oio/list/page_list.rs b/core/src/raw/oio/list/page_list.rs
index 897a54f49..2e146e33c 100644
--- a/core/src/raw/oio/list/page_list.rs
+++ b/core/src/raw/oio/list/page_list.rs
@@ -15,11 +15,12 @@
 // specific language governing permissions and limitations
 // under the License.
 
-use crate::raw::*;
-use crate::*;
 use std::collections::VecDeque;
 use std::future::Future;
 
+use crate::raw::*;
+use crate::*;
+
 /// PageList is used to implement [`oio::List`] based on API supporting pagination. By implementing
 /// PageList, services don't need to care about the details of page list.
 ///
diff --git a/core/src/raw/ops.rs b/core/src/raw/ops.rs
index c02785543..fc95611bc 100644
--- a/core/src/raw/ops.rs
+++ b/core/src/raw/ops.rs
@@ -19,11 +19,15 @@
 //!
 //! By using ops, users can add more context for operation.
 
-use crate::{options, raw::*};
-use chrono::{DateTime, Utc};
 use std::collections::HashMap;
 use std::time::Duration;
 
+use chrono::DateTime;
+use chrono::Utc;
+
+use crate::options;
+use crate::raw::*;
+
 /// Args for `create` operation.
 ///
 /// The path must be normalized.
diff --git a/core/src/raw/tests/utils.rs b/core/src/raw/tests/utils.rs
index 81f21dc51..f7706af84 100644
--- a/core/src/raw/tests/utils.rs
+++ b/core/src/raw/tests/utils.rs
@@ -18,7 +18,6 @@
 use std::collections::HashMap;
 use std::env;
 use std::str::FromStr;
-
 use std::sync::LazyLock;
 
 use crate::*;
diff --git a/core/src/services/aliyun_drive/core.rs b/core/src/services/aliyun_drive/core.rs
index 95401689d..67df76de7 100644
--- a/core/src/services/aliyun_drive/core.rs
+++ b/core/src/services/aliyun_drive/core.rs
@@ -22,8 +22,9 @@ use bytes::Buf;
 use chrono::Utc;
 use http::header::HeaderValue;
 use http::header::{self};
+use http::Method;
 use http::Request;
-use http::{Method, Response};
+use http::Response;
 use serde::Deserialize;
 use serde::Serialize;
 use tokio::sync::Mutex;
diff --git a/core/src/services/aliyun_drive/delete.rs b/core/src/services/aliyun_drive/delete.rs
index 0eb9c8be2..50936bab2 100644
--- a/core/src/services/aliyun_drive/delete.rs
+++ b/core/src/services/aliyun_drive/delete.rs
@@ -15,11 +15,14 @@
 // specific language governing permissions and limitations
 // under the License.
 
-use super::core::{AliyunDriveCore, AliyunDriveFile};
+use std::sync::Arc;
+
+use bytes::Buf;
+
+use super::core::AliyunDriveCore;
+use super::core::AliyunDriveFile;
 use crate::raw::*;
 use crate::*;
-use bytes::Buf;
-use std::sync::Arc;
 
 pub struct AliyunDriveDeleter {
     core: Arc<AliyunDriveCore>,
diff --git a/core/src/services/alluxio/core.rs b/core/src/services/alluxio/core.rs
index 20535db54..8f9dbbaa7 100644
--- a/core/src/services/alluxio/core.rs
+++ b/core/src/services/alluxio/core.rs
@@ -15,15 +15,16 @@
 // specific language governing permissions and limitations
 // under the License.
 
+use std::fmt::Debug;
+use std::fmt::Formatter;
+use std::sync::Arc;
+
 use bytes::Buf;
 use http::Request;
 use http::Response;
 use http::StatusCode;
 use serde::Deserialize;
 use serde::Serialize;
-use std::fmt::Debug;
-use std::fmt::Formatter;
-use std::sync::Arc;
 
 use super::error::parse_error;
 use crate::raw::*;
diff --git a/core/src/services/alluxio/delete.rs b/core/src/services/alluxio/delete.rs
index 21837cb92..6ff6ccd4b 100644
--- a/core/src/services/alluxio/delete.rs
+++ b/core/src/services/alluxio/delete.rs
@@ -15,10 +15,11 @@
 // specific language governing permissions and limitations
 // under the License.
 
+use std::sync::Arc;
+
 use super::core::*;
 use crate::raw::*;
 use crate::*;
-use std::sync::Arc;
 
 pub struct AlluxioDeleter {
     core: Arc<AlluxioCore>,
diff --git a/core/src/services/azblob/delete.rs b/core/src/services/azblob/delete.rs
index 1cc8750ad..4ecca5a4e 100644
--- a/core/src/services/azblob/delete.rs
+++ b/core/src/services/azblob/delete.rs
@@ -15,13 +15,15 @@
 // specific language governing permissions and limitations
 // under the License.
 
+use std::sync::Arc;
+
+use http::StatusCode;
+
 use super::core::*;
 use super::error::parse_error;
 use crate::raw::oio::BatchDeleteResult;
 use crate::raw::*;
 use crate::*;
-use http::StatusCode;
-use std::sync::Arc;
 
 pub struct AzblobDeleter {
     core: Arc<AzblobCore>,
diff --git a/core/src/services/azdls/core.rs b/core/src/services/azdls/core.rs
index c5f1e5f6e..f13a64b2d 100644
--- a/core/src/services/azdls/core.rs
+++ b/core/src/services/azdls/core.rs
@@ -15,9 +15,15 @@
 // specific language governing permissions and limitations
 // under the License.
 
+use std::fmt;
+use std::fmt::Debug;
+use std::fmt::Formatter;
+use std::sync::Arc;
+
+use http::header::CONTENT_DISPOSITION;
 use http::header::CONTENT_LENGTH;
 use http::header::CONTENT_TYPE;
-use http::header::{CONTENT_DISPOSITION, IF_NONE_MATCH};
+use http::header::IF_NONE_MATCH;
 use http::HeaderName;
 use http::HeaderValue;
 use http::Request;
@@ -26,16 +32,11 @@ use http::StatusCode;
 use reqsign::AzureStorageCredential;
 use reqsign::AzureStorageLoader;
 use reqsign::AzureStorageSigner;
-use std::fmt;
-use std::fmt::Debug;
-use std::fmt::Formatter;
-use std::sync::Arc;
 
+use super::error::parse_error;
 use crate::raw::*;
 use crate::*;
 
-use super::error::parse_error;
-
 const X_MS_RENAME_SOURCE: &str = "x-ms-rename-source";
 const X_MS_VERSION: &str = "x-ms-version";
 pub const DIRECTORY: &str = "directory";
diff --git a/core/src/services/azdls/delete.rs b/core/src/services/azdls/delete.rs
index 3fe7a557c..583b61d64 100644
--- a/core/src/services/azdls/delete.rs
+++ b/core/src/services/azdls/delete.rs
@@ -15,12 +15,14 @@
 // specific language governing permissions and limitations
 // under the License.
 
+use std::sync::Arc;
+
+use http::StatusCode;
+
 use super::core::*;
 use super::error::parse_error;
 use crate::raw::*;
 use crate::*;
-use http::StatusCode;
-use std::sync::Arc;
 
 pub struct AzdlsDeleter {
     core: Arc<AzdlsCore>,
diff --git a/core/src/services/azdls/writer.rs b/core/src/services/azdls/writer.rs
index 63f19647a..45f68e2fd 100644
--- a/core/src/services/azdls/writer.rs
+++ b/core/src/services/azdls/writer.rs
@@ -19,7 +19,8 @@ use std::sync::Arc;
 
 use http::StatusCode;
 
-use super::core::{AzdlsCore, FILE};
+use super::core::AzdlsCore;
+use super::core::FILE;
 use super::error::parse_error;
 use crate::raw::*;
 use crate::*;
diff --git a/core/src/services/azfile/core.rs b/core/src/services/azfile/core.rs
index 5c5a09c71..fac7d2c0c 100644
--- a/core/src/services/azfile/core.rs
+++ b/core/src/services/azfile/core.rs
@@ -15,6 +15,11 @@
 // specific language governing permissions and limitations
 // under the License.
 
+use std::collections::VecDeque;
+use std::fmt::Debug;
+use std::fmt::Formatter;
+use std::sync::Arc;
+
 use http::header::CONTENT_DISPOSITION;
 use http::header::CONTENT_LENGTH;
 use http::header::CONTENT_TYPE;
@@ -27,10 +32,6 @@ use http::StatusCode;
 use reqsign::AzureStorageCredential;
 use reqsign::AzureStorageLoader;
 use reqsign::AzureStorageSigner;
-use std::collections::VecDeque;
-use std::fmt::Debug;
-use std::fmt::Formatter;
-use std::sync::Arc;
 
 use super::error::parse_error;
 use crate::raw::*;
diff --git a/core/src/services/azfile/delete.rs b/core/src/services/azfile/delete.rs
index 562b7d2da..eb881e9dd 100644
--- a/core/src/services/azfile/delete.rs
+++ b/core/src/services/azfile/delete.rs
@@ -15,12 +15,14 @@
 // specific language governing permissions and limitations
 // under the License.
 
+use std::sync::Arc;
+
+use http::StatusCode;
+
 use super::core::*;
 use super::error::parse_error;
 use crate::raw::*;
 use crate::*;
-use http::StatusCode;
-use std::sync::Arc;
 
 pub struct AzfileDeleter {
     core: Arc<AzfileCore>,
diff --git a/core/src/services/b2/delete.rs b/core/src/services/b2/delete.rs
index a6db1b422..79d33d9e7 100644
--- a/core/src/services/b2/delete.rs
+++ b/core/src/services/b2/delete.rs
@@ -15,12 +15,14 @@
 // specific language governing permissions and limitations
 // under the License.
 
+use std::sync::Arc;
+
+use http::StatusCode;
+
 use super::core::*;
 use super::error::parse_error;
 use crate::raw::*;
 use crate::*;
-use http::StatusCode;
-use std::sync::Arc;
 
 pub struct B2Deleter {
     core: Arc<B2Core>,
diff --git a/core/src/services/compfs/core.rs b/core/src/services/compfs/core.rs
index fa91149d9..f76c29ee3 100644
--- a/core/src/services/compfs/core.rs
+++ b/core/src/services/compfs/core.rs
@@ -15,12 +15,13 @@
 // specific language governing permissions and limitations
 // under the License.
 
-use compio::buf::IoBuf;
-use compio::dispatcher::Dispatcher;
 use std::future::Future;
 use std::path::PathBuf;
 use std::sync::Arc;
 
+use compio::buf::IoBuf;
+use compio::dispatcher::Dispatcher;
+
 use crate::raw::*;
 use crate::*;
 
diff --git a/core/src/services/compfs/delete.rs b/core/src/services/compfs/delete.rs
index 9ff01d2ed..bef19a529 100644
--- a/core/src/services/compfs/delete.rs
+++ b/core/src/services/compfs/delete.rs
@@ -15,10 +15,11 @@
 // specific language governing permissions and limitations
 // under the License.
 
+use std::sync::Arc;
+
 use super::core::*;
 use crate::raw::*;
 use crate::*;
-use std::sync::Arc;
 
 pub struct CompfsDeleter {
     core: Arc<CompfsCore>,
diff --git a/core/src/services/compfs/reader.rs b/core/src/services/compfs/reader.rs
index 7a7c2432b..bc6149f15 100644
--- a/core/src/services/compfs/reader.rs
+++ b/core/src/services/compfs/reader.rs
@@ -17,7 +17,9 @@
 
 use std::sync::Arc;
 
-use compio::buf::{buf_try, IntoInner, IoBuf};
+use compio::buf::buf_try;
+use compio::buf::IntoInner;
+use compio::buf::IoBuf;
 use compio::io::AsyncReadAt;
 
 use super::core::CompfsCore;
diff --git a/core/src/services/cos/backend.rs b/core/src/services/cos/backend.rs
index 5a1f21f5f..260a0b98c 100644
--- a/core/src/services/cos/backend.rs
+++ b/core/src/services/cos/backend.rs
@@ -29,7 +29,9 @@ use reqsign::TencentCosSigner;
 use super::core::*;
 use super::delete::CosDeleter;
 use super::error::parse_error;
-use super::lister::{CosLister, CosListers, CosObjectVersionsLister};
+use super::lister::CosLister;
+use super::lister::CosListers;
+use super::lister::CosObjectVersionsLister;
 use super::writer::CosWriter;
 use super::writer::CosWriters;
 use crate::raw::oio::PageLister;
diff --git a/core/src/services/cos/delete.rs b/core/src/services/cos/delete.rs
index bd29f8521..640efe941 100644
--- a/core/src/services/cos/delete.rs
+++ b/core/src/services/cos/delete.rs
@@ -15,12 +15,14 @@
 // specific language governing permissions and limitations
 // under the License.
 
+use std::sync::Arc;
+
+use http::StatusCode;
+
 use super::core::*;
 use super::error::parse_error;
 use crate::raw::*;
 use crate::*;
-use http::StatusCode;
-use std::sync::Arc;
 
 pub struct CosDeleter {
     core: Arc<CosCore>,
diff --git a/core/src/services/cos/writer.rs b/core/src/services/cos/writer.rs
index d28c1d620..ddafe7cdc 100644
--- a/core/src/services/cos/writer.rs
+++ b/core/src/services/cos/writer.rs
@@ -18,7 +18,9 @@
 use std::sync::Arc;
 
 use bytes::Buf;
-use http::{HeaderMap, HeaderValue, StatusCode};
+use http::HeaderMap;
+use http::HeaderValue;
+use http::StatusCode;
 
 use super::core::*;
 use super::error::parse_error;
diff --git a/core/src/services/dashmap/backend.rs b/core/src/services/dashmap/backend.rs
index 7f56126e9..64cc0716e 100644
--- a/core/src/services/dashmap/backend.rs
+++ b/core/src/services/dashmap/backend.rs
@@ -15,10 +15,11 @@
 // specific language governing permissions and limitations
 // under the License.
 
-use dashmap::DashMap;
 use std::fmt::Debug;
 use std::fmt::Formatter;
 
+use dashmap::DashMap;
+
 use crate::raw::adapters::typed_kv;
 use crate::raw::Access;
 use crate::services::DashmapConfig;
diff --git a/core/src/services/dbfs/delete.rs b/core/src/services/dbfs/delete.rs
index 089ec756d..2d41a1e9b 100644
--- a/core/src/services/dbfs/delete.rs
+++ b/core/src/services/dbfs/delete.rs
@@ -15,12 +15,14 @@
 // specific language governing permissions and limitations
 // under the License.
 
+use std::sync::Arc;
+
+use http::StatusCode;
+
 use super::core::*;
 use super::error::parse_error;
 use crate::raw::*;
 use crate::*;
-use http::StatusCode;
-use std::sync::Arc;
 
 pub struct DbfsDeleter {
     core: Arc<DbfsCore>,
diff --git a/core/src/services/dropbox/delete.rs b/core/src/services/dropbox/delete.rs
index a084a7675..ca1d9e9ad 100644
--- a/core/src/services/dropbox/delete.rs
+++ b/core/src/services/dropbox/delete.rs
@@ -15,12 +15,14 @@
 // specific language governing permissions and limitations
 // under the License.
 
+use std::sync::Arc;
+
+use http::StatusCode;
+
 use super::core::*;
 use super::error::parse_error;
 use crate::raw::*;
 use crate::*;
-use http::StatusCode;
-use std::sync::Arc;
 
 pub struct DropboxDeleter {
     core: Arc<DropboxCore>,
diff --git a/core/src/services/fs/core.rs b/core/src/services/fs/core.rs
index 574f16d10..20a85e233 100644
--- a/core/src/services/fs/core.rs
+++ b/core/src/services/fs/core.rs
@@ -18,6 +18,7 @@
 use std::path::Path;
 use std::path::PathBuf;
 use std::sync::Arc;
+
 use uuid::Uuid;
 
 use crate::raw::*;
diff --git a/core/src/services/fs/delete.rs b/core/src/services/fs/delete.rs
index 2a541c9f8..f14e6d13e 100644
--- a/core/src/services/fs/delete.rs
+++ b/core/src/services/fs/delete.rs
@@ -15,10 +15,11 @@
 // specific language governing permissions and limitations
 // under the License.
 
+use std::sync::Arc;
+
 use super::core::*;
 use crate::raw::*;
 use crate::*;
-use std::sync::Arc;
 
 pub struct FsDeleter {
     core: Arc<FsCore>,
diff --git a/core/src/services/ftp/backend.rs b/core/src/services/ftp/backend.rs
index 558eab27a..9509b2d83 100644
--- a/core/src/services/ftp/backend.rs
+++ b/core/src/services/ftp/backend.rs
@@ -21,7 +21,6 @@ use std::str;
 use std::str::FromStr;
 use std::sync::Arc;
 
-use super::core::FtpCore;
 use http::Uri;
 use log::debug;
 use services::ftp::core::Manager;
@@ -32,6 +31,7 @@ use suppaftp::Status;
 use tokio::sync::OnceCell;
 use uuid::Uuid;
 
+use super::core::FtpCore;
 use super::delete::FtpDeleter;
 use super::err::parse_error;
 use super::lister::FtpLister;
diff --git a/core/src/services/ftp/core.rs b/core/src/services/ftp/core.rs
index 14c219b24..3f9b42cb0 100644
--- a/core/src/services/ftp/core.rs
+++ b/core/src/services/ftp/core.rs
@@ -15,22 +15,26 @@
 // specific language governing permissions and limitations
 // under the License.
 
-use super::err::parse_error;
-use crate::raw::AccessorInfo;
-use crate::*;
+use std::sync::Arc;
+
 use bb8::Pool;
 use bb8::PooledConnection;
 use bb8::RunError;
 use futures_rustls::TlsConnector;
 use raw::Operation;
-use std::sync::Arc;
 use suppaftp::rustls::ClientConfig;
 use suppaftp::types::FileType;
+use suppaftp::AsyncRustlsConnector;
+use suppaftp::AsyncRustlsFtpStream;
+use suppaftp::FtpError;
+use suppaftp::ImplAsyncFtpStream;
 use suppaftp::Status;
-use suppaftp::{AsyncRustlsConnector, AsyncRustlsFtpStream};
-use suppaftp::{FtpError, ImplAsyncFtpStream};
 use tokio::sync::OnceCell;
 
+use super::err::parse_error;
+use crate::raw::AccessorInfo;
+use crate::*;
+
 pub struct FtpCore {
     pub info: Arc<AccessorInfo>,
     pub manager: Manager,
diff --git a/core/src/services/ftp/delete.rs b/core/src/services/ftp/delete.rs
index 3da37722b..0b5d72e58 100644
--- a/core/src/services/ftp/delete.rs
+++ b/core/src/services/ftp/delete.rs
@@ -15,15 +15,17 @@
 // specific language governing permissions and limitations
 // under the License.
 
-use super::core::FtpCore;
-use super::err::parse_error;
-use crate::raw::*;
-use crate::*;
 use std::sync::Arc;
+
 use suppaftp::types::Response;
 use suppaftp::FtpError;
 use suppaftp::Status;
 
+use super::core::FtpCore;
+use super::err::parse_error;
+use crate::raw::*;
+use crate::*;
+
 pub struct FtpDeleter {
     core: Arc<FtpCore>,
 }
diff --git a/core/src/services/gcs/core.rs b/core/src/services/gcs/core.rs
index 094c32cb9..df666671c 100644
--- a/core/src/services/gcs/core.rs
+++ b/core/src/services/gcs/core.rs
@@ -20,11 +20,14 @@ use std::fmt::Debug;
 use std::fmt::Formatter;
 use std::fmt::Write;
 use std::sync::Arc;
+use std::sync::LazyLock;
 use std::time::Duration;
 
 use backon::ExponentialBuilder;
 use backon::Retryable;
-use bytes::{Buf, Bytes};
+use bytes::Buf;
+use bytes::Bytes;
+use constants::*;
 use http::header::CONTENT_ENCODING;
 use http::header::CONTENT_LENGTH;
 use http::header::CONTENT_TYPE;
@@ -42,12 +45,10 @@ use reqsign::GoogleToken;
 use reqsign::GoogleTokenLoader;
 use serde::Deserialize;
 use serde::Serialize;
-use std::sync::LazyLock;
 
 use super::uri::percent_encode_path;
 use crate::raw::*;
 use crate::*;
-use constants::*;
 
 pub mod constants {
     pub const X_GOOG_ACL: &str = "x-goog-acl";
diff --git a/core/src/services/gcs/delete.rs b/core/src/services/gcs/delete.rs
index 241b6152e..803c86dc3 100644
--- a/core/src/services/gcs/delete.rs
+++ b/core/src/services/gcs/delete.rs
@@ -15,13 +15,15 @@
 // specific language governing permissions and limitations
 // under the License.
 
+use std::sync::Arc;
+
+use http::StatusCode;
+
 use super::core::*;
 use super::error::parse_error;
 use crate::raw::oio::BatchDeleteResult;
 use crate::raw::*;
 use crate::*;
-use http::StatusCode;
-use std::sync::Arc;
 
 pub struct GcsDeleter {
     core: Arc<GcsCore>,
diff --git a/core/src/services/gdrive/builder.rs b/core/src/services/gdrive/builder.rs
index 81949d70f..d267ea399 100644
--- a/core/src/services/gdrive/builder.rs
+++ b/core/src/services/gdrive/builder.rs
@@ -28,10 +28,11 @@ use super::backend::GdriveBackend;
 use super::core::GdriveCore;
 use super::core::GdrivePathQuery;
 use super::core::GdriveSigner;
+use crate::raw::normalize_root;
 use crate::raw::Access;
+use crate::raw::AccessorInfo;
 use crate::raw::HttpClient;
 use crate::raw::PathCacher;
-use crate::raw::{normalize_root, AccessorInfo};
 use crate::services::GdriveConfig;
 use crate::Scheme;
 use crate::*;
diff --git a/core/src/services/gdrive/delete.rs b/core/src/services/gdrive/delete.rs
index 129387458..253702502 100644
--- a/core/src/services/gdrive/delete.rs
+++ b/core/src/services/gdrive/delete.rs
@@ -15,12 +15,14 @@
 // specific language governing permissions and limitations
 // under the License.
 
+use std::sync::Arc;
+
+use http::StatusCode;
+
 use super::core::*;
 use super::error::parse_error;
 use crate::raw::*;
 use crate::*;
-use http::StatusCode;
-use std::sync::Arc;
 
 pub struct GdriveDeleter {
     core: Arc<GdriveCore>,
diff --git a/core/src/services/ghac/backend.rs b/core/src/services/ghac/backend.rs
index fca6fbe2c..0864ee3e5 100644
--- a/core/src/services/ghac/backend.rs
+++ b/core/src/services/ghac/backend.rs
@@ -18,6 +18,11 @@
 use std::env;
 use std::sync::Arc;
 
+use http::Response;
+use http::StatusCode;
+use log::debug;
+use sha2::Digest;
+
 use super::core::*;
 use super::error::parse_error;
 use super::writer::GhacWriter;
@@ -25,10 +30,6 @@ use crate::raw::*;
 use crate::services::ghac::core::GhacCore;
 use crate::services::GhacConfig;
 use crate::*;
-use http::Response;
-use http::StatusCode;
-use log::debug;
-use sha2::Digest;
 
 fn value_or_env(
     explicit_value: Option<String>,
diff --git a/core/src/services/ghac/core.rs b/core/src/services/ghac/core.rs
index 76ef860be..84ddebcce 100644
--- a/core/src/services/ghac/core.rs
+++ b/core/src/services/ghac/core.rs
@@ -16,16 +16,27 @@
 // under the License.
 
 use std::env;
-use std::fmt::{Debug, Formatter};
+use std::fmt::Debug;
+use std::fmt::Formatter;
 use std::str::FromStr;
 use std::sync::Arc;
 
 use ::ghac::v1 as ghac_types;
-use bytes::{Buf, Bytes};
-use http::header::{self, ACCEPT, AUTHORIZATION, CONTENT_LENGTH, CONTENT_RANGE, CONTENT_TYPE};
-use http::{Request, Response, StatusCode, Uri};
+use bytes::Buf;
+use bytes::Bytes;
+use http::header::ACCEPT;
+use http::header::AUTHORIZATION;
+use http::header::CONTENT_LENGTH;
+use http::header::CONTENT_RANGE;
+use http::header::CONTENT_TYPE;
+use http::header::{self};
+use http::Request;
+use http::Response;
+use http::StatusCode;
+use http::Uri;
 use prost::Message;
-use serde::{Deserialize, Serialize};
+use serde::Deserialize;
+use serde::Serialize;
 
 use super::error::parse_error;
 use crate::raw::*;
diff --git a/core/src/services/ghac/error.rs b/core/src/services/ghac/error.rs
index bc5ce64c0..7efafe1f6 100644
--- a/core/src/services/ghac/error.rs
+++ b/core/src/services/ghac/error.rs
@@ -15,11 +15,12 @@
 // specific language governing permissions and limitations
 // under the License.
 
-use crate::raw::*;
-use crate::*;
 use http::Response;
 use http::StatusCode;
 
+use crate::raw::*;
+use crate::*;
+
 /// Parse error response into Error.
 pub(super) fn parse_error(resp: Response<Buffer>) -> Error {
     let (parts, body) = resp.into_parts();
diff --git a/core/src/services/ghac/writer.rs b/core/src/services/ghac/writer.rs
index bdecf823d..6252552a0 100644
--- a/core/src/services/ghac/writer.rs
+++ b/core/src/services/ghac/writer.rs
@@ -15,14 +15,15 @@
 // specific language governing permissions and limitations
 // under the License.
 
+use std::str::FromStr;
+use std::sync::Arc;
+
 use super::core::*;
 use super::error::parse_error;
 use crate::raw::*;
 use crate::services::core::AzblobCore;
 use crate::services::writer::AzblobWriter;
 use crate::*;
-use std::str::FromStr;
-use std::sync::Arc;
 
 pub type GhacWriter = TwoWays<GhacWriterV1, GhacWriterV2>;
 
diff --git a/core/src/services/github/core.rs b/core/src/services/github/core.rs
index a76d94199..94f096dcb 100644
--- a/core/src/services/github/core.rs
+++ b/core/src/services/github/core.rs
@@ -15,6 +15,10 @@
 // specific language governing permissions and limitations
 // under the License.
 
+use std::fmt::Debug;
+use std::fmt::Formatter;
+use std::sync::Arc;
+
 use base64::Engine;
 use bytes::Buf;
 use bytes::Bytes;
@@ -25,9 +29,6 @@ use http::Response;
 use http::StatusCode;
 use serde::Deserialize;
 use serde::Serialize;
-use std::fmt::Debug;
-use std::fmt::Formatter;
-use std::sync::Arc;
 
 use super::error::parse_error;
 use crate::raw::*;
diff --git a/core/src/services/github/delete.rs b/core/src/services/github/delete.rs
index 8f246d7e6..2e73750a8 100644
--- a/core/src/services/github/delete.rs
+++ b/core/src/services/github/delete.rs
@@ -15,10 +15,11 @@
 // specific language governing permissions and limitations
 // under the License.
 
+use std::sync::Arc;
+
 use super::core::*;
 use crate::raw::*;
 use crate::*;
-use std::sync::Arc;
 
 pub struct GithubDeleter {
     core: Arc<GithubCore>,
diff --git a/core/src/services/gridfs/core.rs b/core/src/services/gridfs/core.rs
index 67b81ddee..78b7ceb7b 100644
--- a/core/src/services/gridfs/core.rs
+++ b/core/src/services/gridfs/core.rs
@@ -15,20 +15,26 @@
 // specific language governing permissions and limitations
 // under the License.
 
-use crate::{
-    raw::{adapters::kv, new_std_io_error},
-    Buffer, Capability, Error, ErrorKind, Result, Scheme,
-};
+use std::fmt::Debug;
+use std::fmt::Formatter;
+
 use futures::AsyncReadExt;
 use futures::AsyncWriteExt;
-use mongodb::{
-    bson::doc,
-    gridfs::GridFsBucket,
-    options::{ClientOptions, GridFsBucketOptions},
-};
-use std::fmt::{Debug, Formatter};
+use mongodb::bson::doc;
+use mongodb::gridfs::GridFsBucket;
+use mongodb::options::ClientOptions;
+use mongodb::options::GridFsBucketOptions;
 use tokio::sync::OnceCell;
 
+use crate::raw::adapters::kv;
+use crate::raw::new_std_io_error;
+use crate::Buffer;
+use crate::Capability;
+use crate::Error;
+use crate::ErrorKind;
+use crate::Result;
+use crate::Scheme;
+
 #[derive(Clone)]
 pub struct GridFsCore {
     pub connection_string: String,
diff --git a/core/src/services/hdfs/delete.rs b/core/src/services/hdfs/delete.rs
index ae129d268..a95478771 100644
--- a/core/src/services/hdfs/delete.rs
+++ b/core/src/services/hdfs/delete.rs
@@ -15,11 +15,12 @@
 // specific language governing permissions and limitations
 // under the License.
 
+use std::io;
+use std::sync::Arc;
+
 use super::backend::HdfsBackend;
 use crate::raw::*;
 use crate::*;
-use std::io;
-use std::sync::Arc;
 
 pub struct HdfsDeleter {
     core: Arc<HdfsBackend>,
diff --git a/core/src/services/hdfs_native/backend.rs b/core/src/services/hdfs_native/backend.rs
index b585373e7..c221655b6 100644
--- a/core/src/services/hdfs_native/backend.rs
+++ b/core/src/services/hdfs_native/backend.rs
@@ -15,6 +15,14 @@
 // specific language governing permissions and limitations
 // under the License.
 
+use std::fmt::Debug;
+use std::fmt::Formatter;
+use std::sync::Arc;
+
+use hdfs_native::HdfsError;
+use hdfs_native::WriteOptions;
+use log::debug;
+
 use super::delete::HdfsNativeDeleter;
 use super::error::parse_hdfs_error;
 use super::lister::HdfsNativeLister;
@@ -23,12 +31,6 @@ use super::writer::HdfsNativeWriter;
 use crate::raw::*;
 use crate::services::HdfsNativeConfig;
 use crate::*;
-use hdfs_native::HdfsError;
-use hdfs_native::WriteOptions;
-use log::debug;
-use std::fmt::Debug;
-use std::fmt::Formatter;
-use std::sync::Arc;
 
 /// [Hadoop Distributed File System (HDFS™)](https://hadoop.apache.org/) support.
 /// Using [Native Rust HDFS client](https://github.com/Kimahriman/hdfs-native).
diff --git a/core/src/services/hdfs_native/delete.rs b/core/src/services/hdfs_native/delete.rs
index 7b438dac3..84888b0e8 100644
--- a/core/src/services/hdfs_native/delete.rs
+++ b/core/src/services/hdfs_native/delete.rs
@@ -15,11 +15,12 @@
 // specific language governing permissions and limitations
 // under the License.
 
+use std::sync::Arc;
+
 use super::backend::HdfsNativeBackend;
 use super::error::parse_hdfs_error;
 use crate::raw::*;
 use crate::*;
-use std::sync::Arc;
 
 pub struct HdfsNativeDeleter {
     core: Arc<HdfsNativeBackend>,
diff --git a/core/src/services/hdfs_native/lister.rs b/core/src/services/hdfs_native/lister.rs
index bcdb783b8..04187f873 100644
--- a/core/src/services/hdfs_native/lister.rs
+++ b/core/src/services/hdfs_native/lister.rs
@@ -15,6 +15,8 @@
 // specific language governing permissions and limitations
 // under the License.
 
+use hdfs_native::client::ListStatusIterator;
+
 use crate::raw::build_rel_path;
 use crate::raw::oio;
 use crate::raw::parse_datetime_from_from_timestamp_millis;
@@ -22,7 +24,6 @@ use crate::services::hdfs_native::error::parse_hdfs_error;
 use crate::EntryMode;
 use crate::Metadata;
 use crate::Result;
-use hdfs_native::client::ListStatusIterator;
 
 pub struct HdfsNativeLister {
     root: String,
diff --git a/core/src/services/hdfs_native/writer.rs b/core/src/services/hdfs_native/writer.rs
index 800f2dc81..5033a83fe 100644
--- a/core/src/services/hdfs_native/writer.rs
+++ b/core/src/services/hdfs_native/writer.rs
@@ -15,10 +15,11 @@
 // specific language governing permissions and limitations
 // under the License.
 
+use hdfs_native::file::FileWriter;
+
 use crate::raw::*;
 use crate::services::hdfs_native::error::parse_hdfs_error;
 use crate::*;
-use hdfs_native::file::FileWriter;
 pub struct HdfsNativeWriter {
     f: FileWriter,
     size: u64,
diff --git a/core/src/services/huggingface/core.rs b/core/src/services/huggingface/core.rs
index 8190e0130..d8ba86cfc 100644
--- a/core/src/services/huggingface/core.rs
+++ b/core/src/services/huggingface/core.rs
@@ -15,13 +15,14 @@
 // specific language governing permissions and limitations
 // under the License.
 
+use std::fmt::Debug;
+use std::sync::Arc;
+
 use bytes::Bytes;
 use http::header;
 use http::Request;
 use http::Response;
 use serde::Deserialize;
-use std::fmt::Debug;
-use std::sync::Arc;
 
 use super::backend::RepoType;
 use crate::raw::*;
diff --git a/core/src/services/ipmfs/delete.rs b/core/src/services/ipmfs/delete.rs
index ddf74f280..dc1f45c27 100644
--- a/core/src/services/ipmfs/delete.rs
+++ b/core/src/services/ipmfs/delete.rs
@@ -15,12 +15,14 @@
 // specific language governing permissions and limitations
 // under the License.
 
+use std::sync::Arc;
+
+use http::StatusCode;
+
 use super::core::IpmfsCore;
 use super::error::parse_error;
 use crate::raw::*;
 use crate::*;
-use http::StatusCode;
-use std::sync::Arc;
 
 pub struct IpmfsDeleter {
     core: Arc<IpmfsCore>,
diff --git a/core/src/services/koofr/delete.rs b/core/src/services/koofr/delete.rs
index a91bf879d..7b6b9c38b 100644
--- a/core/src/services/koofr/delete.rs
+++ b/core/src/services/koofr/delete.rs
@@ -15,12 +15,14 @@
 // specific language governing permissions and limitations
 // under the License.
 
+use std::sync::Arc;
+
+use http::StatusCode;
+
 use super::core::*;
 use super::error::parse_error;
 use crate::raw::*;
 use crate::*;
-use http::StatusCode;
-use std::sync::Arc;
 
 pub struct KoofrDeleter {
     core: Arc<KoofrCore>,
diff --git a/core/src/services/lakefs/core.rs b/core/src/services/lakefs/core.rs
index 3e3e190b5..789d9b134 100644
--- a/core/src/services/lakefs/core.rs
+++ b/core/src/services/lakefs/core.rs
@@ -15,15 +15,17 @@
 // specific language governing permissions and limitations
 // under the License.
 
-use crate::raw::*;
-use crate::*;
+use std::collections::HashMap;
+use std::fmt::Debug;
+use std::sync::Arc;
+
 use http::header;
 use http::Request;
 use http::Response;
 use serde::Deserialize;
-use std::collections::HashMap;
-use std::fmt::Debug;
-use std::sync::Arc;
+
+use crate::raw::*;
+use crate::*;
 
 pub struct LakefsCore {
     pub info: Arc<AccessorInfo>,
diff --git a/core/src/services/lakefs/delete.rs b/core/src/services/lakefs/delete.rs
index 29f16964f..a75820919 100644
--- a/core/src/services/lakefs/delete.rs
+++ b/core/src/services/lakefs/delete.rs
@@ -15,12 +15,14 @@
 // specific language governing permissions and limitations
 // under the License.
 
+use std::sync::Arc;
+
+use http::StatusCode;
+
 use super::core::*;
 use super::error::parse_error;
 use crate::raw::*;
 use crate::*;
-use http::StatusCode;
-use std::sync::Arc;
 
 pub struct LakefsDeleter {
     core: Arc<LakefsCore>,
diff --git a/core/src/services/monoiofs/core.rs b/core/src/services/monoiofs/core.rs
index b6a8adfa3..a6115f1f8 100644
--- a/core/src/services/monoiofs/core.rs
+++ b/core/src/services/monoiofs/core.rs
@@ -17,7 +17,8 @@
 
 use std::mem;
 use std::path::PathBuf;
-use std::sync::{Arc, Mutex};
+use std::sync::Arc;
+use std::sync::Mutex;
 use std::time::Duration;
 
 use flume::Receiver;
diff --git a/core/src/services/monoiofs/delete.rs b/core/src/services/monoiofs/delete.rs
index 69e43eeb9..b3811b7aa 100644
--- a/core/src/services/monoiofs/delete.rs
+++ b/core/src/services/monoiofs/delete.rs
@@ -15,10 +15,11 @@
 // specific language governing permissions and limitations
 // under the License.
 
+use std::sync::Arc;
+
 use super::core::MonoiofsCore;
 use crate::raw::*;
 use crate::*;
-use std::sync::Arc;
 
 pub struct MonoiofsDeleter {
     core: Arc<MonoiofsCore>,
diff --git a/core/src/services/nebula_graph/backend.rs b/core/src/services/nebula_graph/backend.rs
index 37275cf41..ce7893628 100644
--- a/core/src/services/nebula_graph/backend.rs
+++ b/core/src/services/nebula_graph/backend.rs
@@ -16,17 +16,18 @@
 // under the License.
 
 use std::fmt::Debug;
-
 #[cfg(feature = "tests")]
 use std::time::Duration;
 use std::vec;
 
 use base64::engine::general_purpose::STANDARD as BASE64;
 use base64::engine::Engine as _;
-use bb8::{PooledConnection, RunError};
-use rust_nebula::{
-    graph::GraphQuery, HostAddress, SingleConnSessionConf, SingleConnSessionManager,
-};
+use bb8::PooledConnection;
+use bb8::RunError;
+use rust_nebula::graph::GraphQuery;
+use rust_nebula::HostAddress;
+use rust_nebula::SingleConnSessionConf;
+use rust_nebula::SingleConnSessionManager;
 use snowflaked::sync::Generator;
 use tokio::sync::OnceCell;
 
diff --git a/core/src/services/obs/backend.rs b/core/src/services/obs/backend.rs
index 79b2ff6a7..63525b3a8 100644
--- a/core/src/services/obs/backend.rs
+++ b/core/src/services/obs/backend.rs
@@ -28,7 +28,8 @@ use reqsign::HuaweicloudObsConfig;
 use reqsign::HuaweicloudObsCredentialLoader;
 use reqsign::HuaweicloudObsSigner;
 
-use super::core::{constants, ObsCore};
+use super::core::constants;
+use super::core::ObsCore;
 use super::delete::ObsDeleter;
 use super::error::parse_error;
 use super::lister::ObsLister;
diff --git a/core/src/services/obs/delete.rs b/core/src/services/obs/delete.rs
index e592c00ac..034073a56 100644
--- a/core/src/services/obs/delete.rs
+++ b/core/src/services/obs/delete.rs
@@ -15,12 +15,14 @@
 // specific language governing permissions and limitations
 // under the License.
 
+use std::sync::Arc;
+
+use http::StatusCode;
+
 use super::core::*;
 use super::error::parse_error;
 use crate::raw::*;
 use crate::*;
-use http::StatusCode;
-use std::sync::Arc;
 
 pub struct ObsDeleter {
     core: Arc<ObsCore>,
diff --git a/core/src/services/obs/writer.rs b/core/src/services/obs/writer.rs
index a93113a3e..b26768f73 100644
--- a/core/src/services/obs/writer.rs
+++ b/core/src/services/obs/writer.rs
@@ -18,7 +18,9 @@
 use std::sync::Arc;
 
 use bytes::Buf;
-use http::{HeaderMap, HeaderValue, StatusCode};
+use http::HeaderMap;
+use http::HeaderValue;
+use http::StatusCode;
 
 use super::core::*;
 use super::error::parse_error;
diff --git a/core/src/services/onedrive/builder.rs b/core/src/services/onedrive/builder.rs
index 53a570a09..01255fa2e 100644
--- a/core/src/services/onedrive/builder.rs
+++ b/core/src/services/onedrive/builder.rs
@@ -24,7 +24,6 @@ use chrono::Utc;
 use log::debug;
 use services::onedrive::core::OneDriveCore;
 use services::onedrive::core::OneDriveSigner;
-
 use tokio::sync::Mutex;
 
 use super::backend::OnedriveBackend;
diff --git a/core/src/services/onedrive/core.rs b/core/src/services/onedrive/core.rs
index 8b10d213e..46af662a0 100644
--- a/core/src/services/onedrive/core.rs
+++ b/core/src/services/onedrive/core.rs
@@ -27,7 +27,6 @@ use chrono::Utc;
 use http::header;
 use http::Request;
 use http::Response;
-
 use http::StatusCode;
 use tokio::sync::Mutex;
 
diff --git a/core/src/services/onedrive/delete.rs b/core/src/services/onedrive/delete.rs
index b7ba786c0..68d38c21d 100644
--- a/core/src/services/onedrive/delete.rs
+++ b/core/src/services/onedrive/delete.rs
@@ -15,12 +15,14 @@
 // specific language governing permissions and limitations
 // under the License.
 
+use std::sync::Arc;
+
+use http::StatusCode;
+
 use super::core::OneDriveCore;
 use super::error::parse_error;
 use crate::raw::*;
 use crate::*;
-use http::StatusCode;
-use std::sync::Arc;
 
 /// Delete operation
 /// Documentation: https://learn.microsoft.com/en-us/onedrive/developer/rest-api/api/driveitem_delete?view=odsp-graph-online
diff --git a/core/src/services/onedrive/lister.rs b/core/src/services/onedrive/lister.rs
index a813bd353..93633270b 100644
--- a/core/src/services/onedrive/lister.rs
+++ b/core/src/services/onedrive/lister.rs
@@ -21,7 +21,9 @@ use bytes::Buf;
 
 use super::core::OneDriveCore;
 use super::error::parse_error;
-use super::graph_model::{GraphApiOneDriveListResponse, ItemType, GENERAL_SELECT_PARAM};
+use super::graph_model::GraphApiOneDriveListResponse;
+use super::graph_model::ItemType;
+use super::graph_model::GENERAL_SELECT_PARAM;
 use crate::raw::oio;
 use crate::raw::*;
 use crate::*;
diff --git a/core/src/services/onedrive/writer.rs b/core/src/services/onedrive/writer.rs
index 4ce8cb5bb..7c87a817d 100644
--- a/core/src/services/onedrive/writer.rs
+++ b/core/src/services/onedrive/writer.rs
@@ -23,7 +23,8 @@ use http::StatusCode;
 
 use super::core::OneDriveCore;
 use super::error::parse_error;
-use super::graph_model::{OneDriveItem, OneDriveUploadSessionCreationResponseBody};
+use super::graph_model::OneDriveItem;
+use super::graph_model::OneDriveUploadSessionCreationResponseBody;
 use crate::raw::*;
 use crate::*;
 
diff --git a/core/src/services/opfs/backend.rs b/core/src/services/opfs/backend.rs
index 0c30b0f48..0b232ef06 100644
--- a/core/src/services/opfs/backend.rs
+++ b/core/src/services/opfs/backend.rs
@@ -15,10 +15,12 @@
 // specific language governing permissions and limitations
 // under the License.
 
-use crate::raw::{Access, AccessorInfo};
 use std::fmt::Debug;
 use std::sync::Arc;
 
+use crate::raw::Access;
+use crate::raw::AccessorInfo;
+
 /// OPFS Service backend
 #[derive(Default, Debug, Clone)]
 pub struct OpfsBackend {}
diff --git a/core/src/services/opfs/core.rs b/core/src/services/opfs/core.rs
index 7efeb4424..870f4c38c 100644
--- a/core/src/services/opfs/core.rs
+++ b/core/src/services/opfs/core.rs
@@ -32,17 +32,21 @@
 // specific language governing permissions and limitations
 // under the License.
 
-use crate::{Error, ErrorKind, Result};
 use std::fmt::Debug;
 
-use web_sys::{
-    window, File, FileSystemDirectoryHandle, FileSystemFileHandle, FileSystemGetFileOptions,
-    FileSystemWritableFileStream,
-};
-
-use wasm_bindgen::{JsCast, JsValue};
-
+use wasm_bindgen::JsCast;
+use wasm_bindgen::JsValue;
 use wasm_bindgen_futures::JsFuture;
+use web_sys::window;
+use web_sys::File;
+use web_sys::FileSystemDirectoryHandle;
+use web_sys::FileSystemFileHandle;
+use web_sys::FileSystemGetFileOptions;
+use web_sys::FileSystemWritableFileStream;
+
+use crate::Error;
+use crate::ErrorKind;
+use crate::Result;
 
 fn parse_js_error(msg: JsValue) -> Error {
     Error::new(
diff --git a/core/src/services/oss/backend.rs b/core/src/services/oss/backend.rs
index 151b59e12..4ecaf247e 100644
--- a/core/src/services/oss/backend.rs
+++ b/core/src/services/oss/backend.rs
@@ -30,7 +30,9 @@ use reqsign::AliyunOssSigner;
 use super::core::*;
 use super::delete::OssDeleter;
 use super::error::parse_error;
-use super::lister::{OssLister, OssListers, OssObjectVersionsLister};
+use super::lister::OssLister;
+use super::lister::OssListers;
+use super::lister::OssObjectVersionsLister;
 use super::writer::OssWriter;
 use super::writer::OssWriters;
 use crate::raw::*;
diff --git a/core/src/services/oss/delete.rs b/core/src/services/oss/delete.rs
index f12e0eee1..f5b930746 100644
--- a/core/src/services/oss/delete.rs
+++ b/core/src/services/oss/delete.rs
@@ -15,15 +15,17 @@
 // specific language governing permissions and limitations
 // under the License.
 
+use std::collections::HashSet;
+use std::sync::Arc;
+
+use bytes::Buf;
+use http::StatusCode;
+
 use super::core::*;
 use super::error::parse_error;
 use crate::raw::oio::BatchDeleteResult;
 use crate::raw::*;
 use crate::*;
-use bytes::Buf;
-use http::StatusCode;
-use std::collections::HashSet;
-use std::sync::Arc;
 
 pub struct OssDeleter {
     core: Arc<OssCore>,
diff --git a/core/src/services/oss/writer.rs b/core/src/services/oss/writer.rs
index 7ddb69ba4..13f5e6317 100644
--- a/core/src/services/oss/writer.rs
+++ b/core/src/services/oss/writer.rs
@@ -17,7 +17,9 @@
 
 use std::sync::Arc;
 
-use http::{HeaderMap, HeaderValue, StatusCode};
+use http::HeaderMap;
+use http::HeaderValue;
+use http::StatusCode;
 
 use super::core::*;
 use super::error::parse_error;
diff --git a/core/src/services/pcloud/core.rs b/core/src/services/pcloud/core.rs
index f428ceeb0..253301510 100644
--- a/core/src/services/pcloud/core.rs
+++ b/core/src/services/pcloud/core.rs
@@ -15,15 +15,16 @@
 // specific language governing permissions and limitations
 // under the License.
 
+use std::fmt::Debug;
+use std::fmt::Formatter;
+use std::sync::Arc;
+
 use bytes::Buf;
 use http::header;
 use http::Request;
 use http::Response;
 use http::StatusCode;
 use serde::Deserialize;
-use std::fmt::Debug;
-use std::fmt::Formatter;
-use std::sync::Arc;
 
 use super::error::parse_error;
 use super::error::PcloudError;
diff --git a/core/src/services/pcloud/delete.rs b/core/src/services/pcloud/delete.rs
index 5f0d240e0..059879d4c 100644
--- a/core/src/services/pcloud/delete.rs
+++ b/core/src/services/pcloud/delete.rs
@@ -15,13 +15,16 @@
 // specific language governing permissions and limitations
 // under the License.
 
+use std::sync::Arc;
+
+use bytes::Buf;
+use http::StatusCode;
+
 use super::core::*;
-use super::error::{parse_error, PcloudError};
+use super::error::parse_error;
+use super::error::PcloudError;
 use crate::raw::*;
 use crate::*;
-use bytes::Buf;
-use http::StatusCode;
-use std::sync::Arc;
 
 pub struct PcloudDeleter {
     core: Arc<PcloudCore>,
diff --git a/core/src/services/redis/backend.rs b/core/src/services/redis/backend.rs
index e745f4901..bedfeb186 100644
--- a/core/src/services/redis/backend.rs
+++ b/core/src/services/redis/backend.rs
@@ -15,20 +15,22 @@
 // specific language governing permissions and limitations
 // under the License.
 
+use std::fmt::Debug;
+use std::fmt::Formatter;
+use std::path::PathBuf;
+use std::time::Duration;
+
 use bb8::RunError;
 use bytes::Bytes;
 use http::Uri;
 use redis::cluster::ClusterClient;
 use redis::cluster::ClusterClientBuilder;
+use redis::AsyncCommands;
+use redis::Client;
 use redis::ConnectionAddr;
 use redis::ConnectionInfo;
 use redis::ProtocolVersion;
 use redis::RedisConnectionInfo;
-use redis::{AsyncCommands, Client};
-use std::fmt::Debug;
-use std::fmt::Formatter;
-use std::path::PathBuf;
-use std::time::Duration;
 use tokio::sync::OnceCell;
 
 use super::core::*;
diff --git a/core/src/services/redis/core.rs b/core/src/services/redis/core.rs
index f5eab5cc7..c4681e12e 100644
--- a/core/src/services/redis/core.rs
+++ b/core/src/services/redis/core.rs
@@ -15,17 +15,20 @@
 // specific language governing permissions and limitations
 // under the License.
 
-use crate::Error;
-use crate::ErrorKind;
-
 use redis::aio::ConnectionLike;
 use redis::aio::ConnectionManager;
 use redis::cluster::ClusterClient;
 use redis::cluster_async::ClusterConnection;
 use redis::AsyncCommands;
 use redis::Client;
+use redis::Cmd;
+use redis::Pipeline;
 use redis::RedisError;
-use redis::{Cmd, Pipeline, RedisFuture, Value};
+use redis::RedisFuture;
+use redis::Value;
+
+use crate::Error;
+use crate::ErrorKind;
 
 #[derive(Clone)]
 pub enum RedisConnection {
diff --git a/core/src/services/s3/backend.rs b/core/src/services/s3/backend.rs
index 72c735d75..eb7e4c163 100644
--- a/core/src/services/s3/backend.rs
+++ b/core/src/services/s3/backend.rs
@@ -22,10 +22,12 @@ use std::fmt::Write;
 use std::str::FromStr;
 use std::sync::atomic::AtomicBool;
 use std::sync::Arc;
+use std::sync::LazyLock;
 
 use base64::prelude::BASE64_STANDARD;
 use base64::Engine;
 use constants::X_AMZ_META_PREFIX;
+use constants::X_AMZ_VERSION_ID;
 use http::Response;
 use http::StatusCode;
 use log::debug;
@@ -38,19 +40,20 @@ use reqsign::AwsCredentialLoad;
 use reqsign::AwsDefaultLoader;
 use reqsign::AwsV4Signer;
 use reqwest::Url;
-use std::sync::LazyLock;
 
 use super::core::*;
 use super::delete::S3Deleter;
 use super::error::parse_error;
-use super::lister::{S3ListerV1, S3ListerV2, S3Listers, S3ObjectVersionsLister};
+use super::lister::S3ListerV1;
+use super::lister::S3ListerV2;
+use super::lister::S3Listers;
+use super::lister::S3ObjectVersionsLister;
 use super::writer::S3Writer;
 use super::writer::S3Writers;
 use crate::raw::oio::PageLister;
 use crate::raw::*;
 use crate::services::S3Config;
 use crate::*;
-use constants::X_AMZ_VERSION_ID;
 
 /// Allow constructing correct region endpoint if user gives a global endpoint.
 static ENDPOINT_TEMPLATES: LazyLock<HashMap<&'static str, &'static str>> = LazyLock::new(|| {
diff --git a/core/src/services/s3/core.rs b/core/src/services/s3/core.rs
index 032b66277..972f5375d 100644
--- a/core/src/services/s3/core.rs
+++ b/core/src/services/s3/core.rs
@@ -20,14 +20,16 @@ use std::fmt::Debug;
 use std::fmt::Display;
 use std::fmt::Formatter;
 use std::fmt::Write;
+use std::sync::atomic;
 use std::sync::atomic::AtomicBool;
-use std::sync::{atomic, Arc};
+use std::sync::Arc;
 use std::time::Duration;
 
 use base64::prelude::BASE64_STANDARD;
 use base64::Engine;
 use bytes::Bytes;
 use constants::X_AMZ_META_PREFIX;
+use http::header::HeaderName;
 use http::header::CACHE_CONTROL;
 use http::header::CONTENT_DISPOSITION;
 use http::header::CONTENT_ENCODING;
@@ -35,8 +37,9 @@ use http::header::CONTENT_LENGTH;
 use http::header::CONTENT_TYPE;
 use http::header::HOST;
 use http::header::IF_MATCH;
+use http::header::IF_MODIFIED_SINCE;
 use http::header::IF_NONE_MATCH;
-use http::header::{HeaderName, IF_MODIFIED_SINCE, IF_UNMODIFIED_SINCE};
+use http::header::IF_UNMODIFIED_SINCE;
 use http::HeaderValue;
 use http::Request;
 use http::Response;
diff --git a/core/src/services/s3/delete.rs b/core/src/services/s3/delete.rs
index c1ac1fb51..9d8ae601d 100644
--- a/core/src/services/s3/delete.rs
+++ b/core/src/services/s3/delete.rs
@@ -15,14 +15,17 @@
 // specific language governing permissions and limitations
 // under the License.
 
+use std::sync::Arc;
+
+use bytes::Buf;
+use http::StatusCode;
+
 use super::core::*;
-use super::error::{parse_error, parse_s3_error_code};
+use super::error::parse_error;
+use super::error::parse_s3_error_code;
 use crate::raw::oio::BatchDeleteResult;
 use crate::raw::*;
 use crate::*;
-use bytes::Buf;
-use http::StatusCode;
-use std::sync::Arc;
 
 pub struct S3Deleter {
     core: Arc<S3Core>,
diff --git a/core/src/services/s3/lister.rs b/core/src/services/s3/lister.rs
index b5d3703f4..96341da6b 100644
--- a/core/src/services/s3/lister.rs
+++ b/core/src/services/s3/lister.rs
@@ -17,6 +17,9 @@
 
 use std::sync::Arc;
 
+use bytes::Buf;
+use quick_xml::de;
+
 use super::core::*;
 use super::error::parse_error;
 use crate::raw::oio::PageContext;
@@ -25,8 +28,6 @@ use crate::EntryMode;
 use crate::Error;
 use crate::Metadata;
 use crate::Result;
-use bytes::Buf;
-use quick_xml::de;
 
 pub type S3Listers = ThreeWays<
     oio::PageLister<S3ListerV1>,
diff --git a/core/src/services/s3/writer.rs b/core/src/services/s3/writer.rs
index 300453083..fd5d1140c 100644
--- a/core/src/services/s3/writer.rs
+++ b/core/src/services/s3/writer.rs
@@ -17,15 +17,17 @@
 
 use std::sync::Arc;
 
+use bytes::Buf;
+use constants::X_AMZ_OBJECT_SIZE;
+use constants::X_AMZ_VERSION_ID;
+use http::StatusCode;
+
 use super::core::*;
 use super::error::from_s3_error;
 use super::error::parse_error;
 use super::error::S3Error;
 use crate::raw::*;
 use crate::*;
-use bytes::Buf;
-use constants::{X_AMZ_OBJECT_SIZE, X_AMZ_VERSION_ID};
-use http::StatusCode;
 
 pub type S3Writers = TwoWays<oio::MultipartWriter<S3Writer>, oio::AppendWriter<S3Writer>>;
 
diff --git a/core/src/services/seafile/delete.rs b/core/src/services/seafile/delete.rs
index 21d23cd01..bf5712a7e 100644
--- a/core/src/services/seafile/delete.rs
+++ b/core/src/services/seafile/delete.rs
@@ -15,10 +15,11 @@
 // specific language governing permissions and limitations
 // under the License.
 
+use std::sync::Arc;
+
 use super::core::*;
 use crate::raw::*;
 use crate::*;
-use std::sync::Arc;
 
 pub struct SeafileDeleter {
     core: Arc<SeafileCore>,
diff --git a/core/src/services/sftp/delete.rs b/core/src/services/sftp/delete.rs
index 64ff6686e..9376b1f4b 100644
--- a/core/src/services/sftp/delete.rs
+++ b/core/src/services/sftp/delete.rs
@@ -15,11 +15,13 @@
 // specific language governing permissions and limitations
 // under the License.
 
+use std::sync::Arc;
+
 use super::core::SftpCore;
-use super::error::{is_not_found, parse_sftp_error};
+use super::error::is_not_found;
+use super::error::parse_sftp_error;
 use crate::raw::*;
 use crate::*;
-use std::sync::Arc;
 
 pub struct SftpDeleter {
     core: Arc<SftpCore>,
diff --git a/core/src/services/swift/core.rs b/core/src/services/swift/core.rs
index 4c8c0e9ef..320d989a7 100644
--- a/core/src/services/swift/core.rs
+++ b/core/src/services/swift/core.rs
@@ -15,12 +15,13 @@
 // specific language governing permissions and limitations
 // under the License.
 
+use std::fmt::Debug;
+use std::sync::Arc;
+
 use http::header;
 use http::Request;
 use http::Response;
 use serde::Deserialize;
-use std::fmt::Debug;
-use std::sync::Arc;
 
 use crate::raw::*;
 use crate::*;
diff --git a/core/src/services/swift/delete.rs b/core/src/services/swift/delete.rs
index 1c5ce4f00..8f8cd3035 100644
--- a/core/src/services/swift/delete.rs
+++ b/core/src/services/swift/delete.rs
@@ -15,12 +15,14 @@
 // specific language governing permissions and limitations
 // under the License.
 
+use std::sync::Arc;
+
+use http::StatusCode;
+
 use super::core::*;
 use super::error::parse_error;
 use crate::raw::*;
 use crate::*;
-use http::StatusCode;
-use std::sync::Arc;
 
 pub struct SwfitDeleter {
     core: Arc<SwiftCore>,
diff --git a/core/src/services/upyun/core.rs b/core/src/services/upyun/core.rs
index 9f277ff3f..ff1815f9a 100644
--- a/core/src/services/upyun/core.rs
+++ b/core/src/services/upyun/core.rs
@@ -15,6 +15,10 @@
 // specific language governing permissions and limitations
 // under the License.
 
+use std::fmt::Debug;
+use std::fmt::Formatter;
+use std::sync::Arc;
+
 use base64::Engine;
 use hmac::Hmac;
 use hmac::Mac;
@@ -25,9 +29,6 @@ use http::Response;
 use md5::Digest;
 use serde::Deserialize;
 use sha1::Sha1;
-use std::fmt::Debug;
-use std::fmt::Formatter;
-use std::sync::Arc;
 
 use self::constants::*;
 use crate::raw::*;
diff --git a/core/src/services/upyun/delete.rs b/core/src/services/upyun/delete.rs
index ca7dc8950..a45927b63 100644
--- a/core/src/services/upyun/delete.rs
+++ b/core/src/services/upyun/delete.rs
@@ -15,12 +15,14 @@
 // specific language governing permissions and limitations
 // under the License.
 
+use std::sync::Arc;
+
+use http::StatusCode;
+
 use super::core::*;
 use super::error::parse_error;
 use crate::raw::*;
 use crate::*;
-use http::StatusCode;
-use std::sync::Arc;
 
 pub struct UpyunDeleter {
     core: Arc<UpyunCore>,
diff --git a/core/src/services/vercel_artifacts/builder.rs b/core/src/services/vercel_artifacts/builder.rs
index 88d675cbe..37de45d66 100644
--- a/core/src/services/vercel_artifacts/builder.rs
+++ b/core/src/services/vercel_artifacts/builder.rs
@@ -21,8 +21,9 @@ use std::sync::Arc;
 
 use super::backend::VercelArtifactsBackend;
 use super::core::VercelArtifactsCore;
+use crate::raw::Access;
+use crate::raw::AccessorInfo;
 use crate::raw::HttpClient;
-use crate::raw::{Access, AccessorInfo};
 use crate::services::VercelArtifactsConfig;
 use crate::Scheme;
 use crate::*;
diff --git a/core/src/services/vercel_blob/core.rs b/core/src/services/vercel_blob/core.rs
index 6435dbe74..3eb4b6eec 100644
--- a/core/src/services/vercel_blob/core.rs
+++ b/core/src/services/vercel_blob/core.rs
@@ -15,6 +15,10 @@
 // specific language governing permissions and limitations
 // under the License.
 
+use std::fmt::Debug;
+use std::fmt::Formatter;
+use std::sync::Arc;
+
 use bytes::Buf;
 use bytes::Bytes;
 use http::header;
@@ -25,9 +29,6 @@ use http::StatusCode;
 use serde::Deserialize;
 use serde::Serialize;
 use serde_json::json;
-use std::fmt::Debug;
-use std::fmt::Formatter;
-use std::sync::Arc;
 
 use self::constants::*;
 use super::error::parse_error;
diff --git a/core/src/services/webdav/core.rs b/core/src/services/webdav/core.rs
index b0e7b3c5d..fd673739c 100644
--- a/core/src/services/webdav/core.rs
+++ b/core/src/services/webdav/core.rs
@@ -15,17 +15,18 @@
 // specific language governing permissions and limitations
 // under the License.
 
+use std::collections::VecDeque;
+use std::fmt;
+use std::fmt::Debug;
+use std::fmt::Formatter;
+use std::sync::Arc;
+
 use bytes::Bytes;
 use http::header;
 use http::Request;
 use http::Response;
 use http::StatusCode;
 use serde::Deserialize;
-use std::collections::VecDeque;
-use std::fmt;
-use std::fmt::Debug;
-use std::fmt::Formatter;
-use std::sync::Arc;
 
 use super::error::parse_error;
 use crate::raw::*;
diff --git a/core/src/services/webdav/delete.rs b/core/src/services/webdav/delete.rs
index b6935507c..dd7ac0271 100644
--- a/core/src/services/webdav/delete.rs
+++ b/core/src/services/webdav/delete.rs
@@ -15,12 +15,14 @@
 // specific language governing permissions and limitations
 // under the License.
 
+use std::sync::Arc;
+
+use http::StatusCode;
+
 use super::core::*;
 use super::error::parse_error;
 use crate::raw::*;
 use crate::*;
-use http::StatusCode;
-use std::sync::Arc;
 
 pub struct WebdavDeleter {
     core: Arc<WebdavCore>,
diff --git a/core/src/services/webhdfs/backend.rs b/core/src/services/webhdfs/backend.rs
index 7dcc83979..0c604bf4c 100644
--- a/core/src/services/webhdfs/backend.rs
+++ b/core/src/services/webhdfs/backend.rs
@@ -15,11 +15,11 @@
 // specific language governing permissions and limitations
 // under the License.
 
+use core::fmt::Debug;
 use std::fmt::Formatter;
 use std::sync::Arc;
 
 use bytes::Buf;
-use core::fmt::Debug;
 use http::Response;
 use http::StatusCode;
 use log::debug;
@@ -100,7 +100,6 @@ impl WebhdfsBuilder {
 
     /// Set the username of this backend,
     /// used for authentication
-    ///
     pub fn user_name(mut self, user_name: &str) -> Self {
         if !user_name.is_empty() {
             self.config.user_name = Some(user_name.to_string());
diff --git a/core/src/services/webhdfs/delete.rs b/core/src/services/webhdfs/delete.rs
index 97ebe6de9..e066cbde6 100644
--- a/core/src/services/webhdfs/delete.rs
+++ b/core/src/services/webhdfs/delete.rs
@@ -15,12 +15,14 @@
 // specific language governing permissions and limitations
 // under the License.
 
+use std::sync::Arc;
+
+use http::StatusCode;
+
 use super::core::WebhdfsCore;
 use super::error::parse_error;
 use crate::raw::*;
 use crate::*;
-use http::StatusCode;
-use std::sync::Arc;
 
 pub struct WebhdfsDeleter {
     core: Arc<WebhdfsCore>,
diff --git a/core/src/services/yandex_disk/core.rs b/core/src/services/yandex_disk/core.rs
index 2322a0c39..d9b87ef2b 100644
--- a/core/src/services/yandex_disk/core.rs
+++ b/core/src/services/yandex_disk/core.rs
@@ -15,6 +15,10 @@
 // specific language governing permissions and limitations
 // under the License.
 
+use std::fmt::Debug;
+use std::fmt::Formatter;
+use std::sync::Arc;
+
 use bytes::Buf;
 use http::header;
 use http::request;
@@ -22,9 +26,6 @@ use http::Request;
 use http::Response;
 use http::StatusCode;
 use serde::Deserialize;
-use std::fmt::Debug;
-use std::fmt::Formatter;
-use std::sync::Arc;
 
 use super::error::parse_error;
 use crate::raw::*;
diff --git a/core/src/services/yandex_disk/delete.rs b/core/src/services/yandex_disk/delete.rs
index 01a95d6a5..ea1d0f5dd 100644
--- a/core/src/services/yandex_disk/delete.rs
+++ b/core/src/services/yandex_disk/delete.rs
@@ -15,12 +15,14 @@
 // specific language governing permissions and limitations
 // under the License.
 
+use std::sync::Arc;
+
+use http::StatusCode;
+
 use super::core::*;
 use super::error::parse_error;
 use crate::raw::*;
 use crate::*;
-use http::StatusCode;
-use std::sync::Arc;
 
 pub struct YandexDiskDeleter {
     core: Arc<YandexDiskCore>,
diff --git a/core/src/types/buffer.rs b/core/src/types/buffer.rs
index 97bd54bfa..6114ad9af 100644
--- a/core/src/types/buffer.rs
+++ b/core/src/types/buffer.rs
@@ -19,8 +19,12 @@ use std::collections::VecDeque;
 use std::convert::Infallible;
 use std::fmt::Debug;
 use std::fmt::Formatter;
+use std::io::BufRead;
 use std::io::IoSlice;
-use std::io::{self, BufRead, Read, Seek, SeekFrom};
+use std::io::Read;
+use std::io::Seek;
+use std::io::SeekFrom;
+use std::io::{self};
 use std::mem;
 use std::ops::Bound;
 use std::ops::RangeBounds;
@@ -687,9 +691,13 @@ impl BufRead for Buffer {
 
 #[cfg(test)]
 mod tests {
+    use std::io::BufRead;
+    use std::io::Read;
+    use std::io::Seek;
+    use std::io::SeekFrom;
+
     use pretty_assertions::assert_eq;
     use rand::prelude::*;
-    use std::io::{BufRead, Read, Seek, SeekFrom};
 
     use super::*;
 
diff --git a/core/src/types/context/read.rs b/core/src/types/context/read.rs
index 4abe6c138..4d79d83ca 100644
--- a/core/src/types/context/read.rs
+++ b/core/src/types/context/read.rs
@@ -15,7 +15,9 @@
 // specific language governing permissions and limitations
 // under the License.
 
-use std::ops::{Bound, Range, RangeBounds};
+use std::ops::Bound;
+use std::ops::Range;
+use std::ops::RangeBounds;
 use std::sync::Arc;
 
 use crate::raw::*;
diff --git a/core/src/types/delete/deleter.rs b/core/src/types/delete/deleter.rs
index 9b4b2c865..75ac9c526 100644
--- a/core/src/types/delete/deleter.rs
+++ b/core/src/types/delete/deleter.rs
@@ -15,11 +15,14 @@
 // specific language governing permissions and limitations
 // under the License.
 
+use std::pin::pin;
+
+use futures::Stream;
+use futures::StreamExt;
+
 use crate::raw::oio::DeleteDyn;
 use crate::raw::*;
 use crate::*;
-use futures::{Stream, StreamExt};
-use std::pin::pin;
 
 /// Deleter is designed to continuously remove content from storage.
 ///
@@ -48,9 +51,9 @@ use std::pin::pin;
 /// Delete multiple files via a stream:
 ///
 /// ```rust
+/// use futures::stream;
 /// use opendal::Operator;
 /// use opendal::Result;
-/// use futures::stream;
 ///
 /// async fn example(op: Operator) -> Result<()> {
 ///     let mut d = op.deleter().await?;
@@ -65,10 +68,11 @@ use std::pin::pin;
 /// Deleter can be used as a Sink for file deletion:
 ///
 /// ```rust
+/// use futures::stream;
+/// use futures::Sink;
+/// use futures::SinkExt;
 /// use opendal::Operator;
 /// use opendal::Result;
-/// use futures::{stream, Sink};
-/// use futures::SinkExt;
 ///
 /// async fn example(op: Operator) -> Result<()> {
 ///     let mut sink = op.deleter().await?.into_sink();
diff --git a/core/src/types/delete/futures_delete_sink.rs b/core/src/types/delete/futures_delete_sink.rs
index 458481b87..6896cab69 100644
--- a/core/src/types/delete/futures_delete_sink.rs
+++ b/core/src/types/delete/futures_delete_sink.rs
@@ -15,12 +15,16 @@
 // specific language governing permissions and limitations
 // under the License.
 
-use crate::raw::*;
-use crate::*;
-use futures::Sink;
 use std::marker::PhantomData;
 use std::pin::Pin;
-use std::task::{ready, Context, Poll};
+use std::task::ready;
+use std::task::Context;
+use std::task::Poll;
+
+use futures::Sink;
+
+use crate::raw::*;
+use crate::*;
 
 /// FuturesDeleteSink is a sink that generated by [`Deleter`]
 pub struct FuturesDeleteSink<T: IntoDeleteInput> {
diff --git a/core/src/types/error.rs b/core/src/types/error.rs
index 26af115e0..46bb35545 100644
--- a/core/src/types/error.rs
+++ b/core/src/types/error.rs
@@ -478,12 +478,14 @@ impl From<Error> for io::Error {
 
 #[cfg(test)]
 mod tests {
-    use super::*;
-    use anyhow::anyhow;
-    use pretty_assertions::assert_eq;
     use std::mem::size_of;
     use std::sync::LazyLock;
 
+    use anyhow::anyhow;
+    use pretty_assertions::assert_eq;
+
+    use super::*;
+
     static TEST_ERROR: LazyLock<Error> = LazyLock::new(|| Error {
         kind: ErrorKind::Unexpected,
         message: "something wrong happened".to_string(),
diff --git a/core/src/types/operator/operator.rs b/core/src/types/operator/operator.rs
index c024c0f27..af9d08fa3 100644
--- a/core/src/types/operator/operator.rs
+++ b/core/src/types/operator/operator.rs
@@ -91,27 +91,54 @@ use crate::*;
 ///
 /// Operator provides a consistent API pattern for data operations. For reading operations, it exposes:
 ///
-/// - [`Operator::read`]: Basic operation that reads entire content into memory
-/// - [`Operator::read_with`]: Enhanced read operation with additional options (range, if_match, if_none_match)
-/// - [`Operator::reader`]: Creates a lazy reader for on-demand data streaming
-/// - [`Operator::reader_with`]: Creates a configurable reader with conditional options (if_match, if_none_match)
+/// - [`Operator::read`]: Executes a read operation.
+/// - [`Operator::read_with`]: Executes a read operation with additional options using the builder pattern.
+/// - [`Operator::read_options`]: Executes a read operation with extra options provided via a [`options::ReadOptions`] struct.
+/// - [`Operator::reader`]: Creates a reader for streaming data, allowing for flexible access.
+/// - [`Operator::reader_with`]: Creates a reader with advanced options using the builder pattern.
+/// - [`Operator::reader_options`]: Creates a reader with extra options provided via a [`options::ReadOptions`] struct.
 ///
 /// The [`Reader`] created by [`Operator`] supports custom read control methods and can be converted
-/// into `futures::AsyncRead` for broader ecosystem compatibility.
+/// into [`futures::AsyncRead`] or [`futures::Stream`] for broader ecosystem compatibility.
 ///
-/// ```
-/// # use anyhow::Result;
-/// use opendal::layers::RetryLayer;
-/// use opendal::services::Memory;
+/// ```no_run
+/// use opendal::layers::LoggingLayer;
+/// use opendal::options;
+/// use opendal::services;
 /// use opendal::Operator;
-/// async fn test() -> Result<()> {
-///     let op: Operator = Operator::new(Memory::default())?.finish();
+/// use opendal::Result;
 ///
-///     // OpenDAL will retry failed operations now.
-///     let op = op.layer(RetryLayer::default());
+/// #[tokio::main]
+/// async fn main() -> Result<()> {
+///     // Pick a builder and configure it.
+///     let mut builder = services::S3::default().bucket("test");
+///
+///     // Init an operator
+///     let op = Operator::new(builder)?
+///         // Init with logging layer enabled.
+///         .layer(LoggingLayer::default())
+///         .finish();
+///
+///     // Fetch this file's metadata
+///     let meta = op.stat("hello.txt").await?;
+///     let length = meta.content_length();
+///
+///     // Read data from `hello.txt` with options.
+///     let bs = op
+///         .read_with("hello.txt")
+///         .range(0..8 * 1024 * 1024)
+///         .chunk(1024 * 1024)
+///         .concurrent(4)
+///         .await?;
 ///
-///     // Read all data into memory.
-///     let data = op.read("path/to/file").await?;
+///     // The same to:
+///     let bs = op
+///         .read_options("hello.txt", options::ReadOptions {
+///             range: (0..8 * 1024 * 1024).into(),
+///             chunk: Some(1024 * 1024),
+///             concurrent: 4,
+///         })
+///         .await?;
 ///
 ///     Ok(())
 /// }
@@ -139,33 +166,6 @@ impl Operator {
         self.accessor
     }
 
-    /// Get current operator's limit.
-    /// Limit is usually the maximum size of data that operator will handle in one operation.
-    #[deprecated(note = "limit is no-op for now", since = "0.52.0")]
-    pub fn limit(&self) -> usize {
-        0
-    }
-
-    /// Specify the batch limit.
-    ///
-    /// Default: 1000
-    #[deprecated(note = "limit is no-op for now", since = "0.52.0")]
-    pub fn with_limit(&self, _: usize) -> Self {
-        self.clone()
-    }
-
-    /// Get the default executor.
-    #[deprecated(note = "use Operator::executor instead", since = "0.53.0")]
-    pub fn default_executor(&self) -> Option<Executor> {
-        None
-    }
-
-    /// Specify the default executor.
-    #[deprecated(note = "use Operator::update_executor instead", since = "0.53.0")]
-    pub fn with_default_executor(&self, _: Executor) -> Self {
-        self.clone()
-    }
-
     /// Get information of underlying accessor.
     ///
     /// # Examples
@@ -723,7 +723,8 @@ impl Operator {
     /// use bytes::Bytes;
     ///
     /// # async fn test(op: Operator) -> Result<()> {
-    /// let _ = op.write_with("path/to/file", vec![0; 4096])
+    /// let _ = op
+    ///     .write_with("path/to/file", vec![0; 4096])
     ///     .if_not_exists(true)
     ///     .await?;
     /// # Ok(())
@@ -841,8 +842,9 @@ impl Operator {
     /// use bytes::Bytes;
     ///
     /// # async fn test(op: Operator) -> Result<()> {
-    /// let mut w = op.writer_with("path/to/file")
-    ///     .chunk(4*1024*1024)
+    /// let mut w = op
+    ///     .writer_with("path/to/file")
+    ///     .chunk(4 * 1024 * 1024)
     ///     .concurrent(8)
     ///     .await?;
     /// w.write(vec![0; 4096]).await?;
@@ -1053,7 +1055,7 @@ impl Operator {
     /// op.delete_with("path/to/file").version(version).await?;
     /// # Ok(())
     /// # }
-    ///```
+    /// ```
     ///
     /// # Examples
     ///
diff --git a/core/src/types/operator/operator_futures.rs b/core/src/types/operator/operator_futures.rs
index 17daa6553..056d6e7ab 100644
--- a/core/src/types/operator/operator_futures.rs
+++ b/core/src/types/operator/operator_futures.rs
@@ -19,13 +19,15 @@
 //!
 //! By using futures, users can add more options for operation.
 
-use chrono::{DateTime, Utc};
-use futures::Future;
 use std::collections::HashMap;
 use std::future::IntoFuture;
 use std::ops::RangeBounds;
 use std::time::Duration;
 
+use chrono::DateTime;
+use chrono::Utc;
+use futures::Future;
+
 use crate::raw::*;
 use crate::*;
 
@@ -373,9 +375,9 @@ impl<F: Future<Output = Result<Buffer>>> FutureRead<F> {
     ///
     /// ```
     /// # use opendal::Result;
-    /// use opendal::Operator;
     /// use chrono::DateTime;
     /// use chrono::Utc;
+    /// use opendal::Operator;
     /// # async fn test(op: Operator, time: DateTime<Utc>) -> Result<()> {
     /// let mut metadata = op.read_with("path/to/file").if_modified_since(time).await?;
     /// # Ok(())
@@ -395,11 +397,14 @@ impl<F: Future<Output = Result<Buffer>>> FutureRead<F> {
     ///
     /// ```
     /// # use opendal::Result;
-    /// use opendal::Operator;
     /// use chrono::DateTime;
     /// use chrono::Utc;
+    /// use opendal::Operator;
     /// # async fn test(op: Operator, time: DateTime<Utc>) -> Result<()> {
-    /// let mut metadata = op.read_with("path/to/file").if_unmodified_since(time).await?;
+    /// let mut metadata = op
+    ///     .read_with("path/to/file")
+    ///     .if_unmodified_since(time)
+    ///     .await?;
     /// # Ok(())
     /// # }
     /// ```
@@ -505,7 +510,7 @@ impl<F: Future<Output = Result<Reader>>> FutureReader<F> {
     /// let r = op
     ///     .reader_with("path/to/file")
     ///     .chunk(4 * 1024 * 1024)
-    ///     .gap(1024 * 1024)  // 1MiB gap
+    ///     .gap(1024 * 1024) // 1MiB gap
     ///     .await?;
     /// # Ok(())
     /// # }
@@ -564,11 +569,14 @@ impl<F: Future<Output = Result<Reader>>> FutureReader<F> {
     ///
     /// ```
     /// # use opendal::Result;
-    /// use opendal::Operator;
     /// use chrono::DateTime;
     /// use chrono::Utc;
+    /// use opendal::Operator;
     /// # async fn test(op: Operator, time: DateTime<Utc>) -> Result<()> {
-    /// let mut r = op.reader_with("path/to/file").if_modified_since(time).await?;
+    /// let mut r = op
+    ///     .reader_with("path/to/file")
+    ///     .if_modified_since(time)
+    ///     .await?;
     /// # Ok(())
     /// # }
     /// ```
@@ -586,11 +594,14 @@ impl<F: Future<Output = Result<Reader>>> FutureReader<F> {
     ///
     /// ```
     /// # use opendal::Result;
-    /// use opendal::Operator;
     /// use chrono::DateTime;
     /// use chrono::Utc;
+    /// use opendal::Operator;
     /// # async fn test(op: Operator, time: DateTime<Utc>) -> Result<()> {
-    /// let mut r = op.reader_with("path/to/file").if_unmodified_since(time).await?;
+    /// let mut r = op
+    ///     .reader_with("path/to/file")
+    ///     .if_unmodified_since(time)
+    ///     .await?;
     /// # Ok(())
     /// # }
     /// ```
@@ -620,7 +631,10 @@ impl<F: Future<Output = Result<Metadata>>> FutureWrite<F> {
     /// use bytes::Bytes;
     ///
     /// # async fn test(op: Operator) -> Result<()> {
-    /// let _ = op.write_with("path/to/file", vec![0; 4096]).append(true).await?;
+    /// let _ = op
+    ///     .write_with("path/to/file", vec![0; 4096])
+    ///     .append(true)
+    ///     .await?;
     /// # Ok(())
     /// # }
     /// ```
@@ -671,7 +685,11 @@ impl<F: Future<Output = Result<Metadata>>> FutureWrite<F> {
     ///
     /// # async fn test(op: Operator) -> Result<()> {
     /// // Enable concurrent writes with 8 parallel operations at 128B chunk.
-    /// let _ = op.write_with("path/to/file", vec![0; 4096]).chunk(128).concurrent(8).await?;
+    /// let _ = op
+    ///     .write_with("path/to/file", vec![0; 4096])
+    ///     .chunk(128)
+    ///     .concurrent(8)
+    ///     .await?;
     /// # Ok(())
     /// # }
     /// ```
@@ -1187,10 +1205,7 @@ impl<F: Future<Output = Result<Writer>>> FutureWriter<F> {
     /// use bytes::Bytes;
     ///
     /// # async fn test(op: Operator) -> Result<()> {
-    /// let mut w = op
-    ///     .writer_with("path/to/file")
-    ///     .if_not_exists(true)
-    ///     .await?;
+    /// let mut w = op.writer_with("path/to/file").if_not_exists(true).await?;
     /// w.write(vec![0; 4096]).await?;
     /// w.write(vec![1; 4096]).await?;
     /// w.close().await?;
diff --git a/core/src/types/options.rs b/core/src/types/options.rs
index cb7d51b14..c8d5e78b9 100644
--- a/core/src/types/options.rs
+++ b/core/src/types/options.rs
@@ -19,7 +19,8 @@
 
 use std::collections::HashMap;
 
-use chrono::{DateTime, Utc};
+use chrono::DateTime;
+use chrono::Utc;
 
 use crate::raw::BytesRange;
 
diff --git a/core/src/types/read/reader.rs b/core/src/types/read/reader.rs
index 04d53ce84..34e8cc67f 100644
--- a/core/src/types/read/reader.rs
+++ b/core/src/types/read/reader.rs
@@ -211,10 +211,11 @@ impl Reader {
     /// ```
     /// use std::io;
     ///
+    /// use bytes::Bytes;
     /// use futures::TryStreamExt;
-    /// use opendal::{Buffer, Operator};
+    /// use opendal::Buffer;
+    /// use opendal::Operator;
     /// use opendal::Result;
-    /// use bytes::Bytes;
     ///
     /// async fn test(op: Operator) -> io::Result<()> {
     ///     let mut s = op
@@ -239,10 +240,11 @@ impl Reader {
     ///
     /// ```
     /// use std::io;
-    /// use bytes::Bytes;
     ///
+    /// use bytes::Bytes;
     /// use futures::TryStreamExt;
-    /// use opendal::{Buffer, Operator};
+    /// use opendal::Buffer;
+    /// use opendal::Operator;
     /// use opendal::Result;
     ///
     /// async fn test(op: Operator) -> io::Result<()> {
diff --git a/core/src/types/write/writer.rs b/core/src/types/write/writer.rs
index 2aef6fdc2..b3a606973 100644
--- a/core/src/types/write/writer.rs
+++ b/core/src/types/write/writer.rs
@@ -195,7 +195,8 @@ impl Writer {
     ///
     /// use bytes::Bytes;
     /// use futures::SinkExt;
-    /// use opendal::{Buffer, Operator};
+    /// use opendal::Buffer;
+    /// use opendal::Operator;
     /// use opendal::Result;
     ///
     /// async fn test(op: Operator) -> io::Result<()> {
@@ -215,7 +216,8 @@ impl Writer {
     ///
     /// use bytes::Bytes;
     /// use futures::SinkExt;
-    /// use opendal::{Buffer, Operator};
+    /// use opendal::Buffer;
+    /// use opendal::Operator;
     /// use opendal::Result;
     ///
     /// async fn test(op: Operator) -> io::Result<()> {
diff --git a/core/tests/behavior/async_delete.rs b/core/tests/behavior/async_delete.rs
index c88ecd66e..c663c117f 100644
--- a/core/tests/behavior/async_delete.rs
+++ b/core/tests/behavior/async_delete.rs
@@ -15,11 +15,13 @@
 // specific language governing permissions and limitations
 // under the License.
 
-use crate::*;
 use anyhow::Result;
 use futures::TryStreamExt;
 use log::warn;
-use opendal::raw::{Access, OpDelete};
+use opendal::raw::Access;
+use opendal::raw::OpDelete;
+
+use crate::*;
 
 pub fn tests(op: &Operator, tests: &mut Vec<Trial>) {
     let cap = op.info().full_capability();
diff --git a/core/tests/behavior/async_read.rs b/core/tests/behavior/async_read.rs
index e3afeb534..e85143d4d 100644
--- a/core/tests/behavior/async_read.rs
+++ b/core/tests/behavior/async_read.rs
@@ -18,7 +18,6 @@
 use std::str::FromStr;
 use std::time::Duration;
 
-use crate::*;
 use futures::AsyncReadExt;
 use futures::TryStreamExt;
 use http::StatusCode;
@@ -28,6 +27,8 @@ use sha2::Digest;
 use sha2::Sha256;
 use tokio::time::sleep;
 
+use crate::*;
+
 pub fn tests(op: &Operator, tests: &mut Vec<Trial>) {
     let cap = op.info().full_capability();
 
diff --git a/core/tests/behavior/async_stat.rs b/core/tests/behavior/async_stat.rs
index ac9a8a551..37e3f5e12 100644
--- a/core/tests/behavior/async_stat.rs
+++ b/core/tests/behavior/async_stat.rs
@@ -18,13 +18,14 @@
 use std::str::FromStr;
 use std::time::Duration;
 
-use crate::*;
 use anyhow::Result;
 use http::StatusCode;
 use log::warn;
 use reqwest::Url;
 use tokio::time::sleep;
 
+use crate::*;
+
 pub fn tests(op: &Operator, tests: &mut Vec<Trial>) {
     let cap = op.info().full_capability();
 


(opendal) 02/02: docs: Remove deprecated APIs and polish docs for public APIs

Posted by xu...@apache.org.
This is an automated email from the ASF dual-hosted git repository.

xuanwo pushed a commit to branch polish-docs
in repository https://gitbox.apache.org/repos/asf/opendal.git

commit a6217ac8255877fc3bde700956a870c74550c817
Author: Xuanwo <gi...@xuanwo.io>
AuthorDate: Mon May 26 14:29:20 2025 +0800

    docs: Remove deprecated APIs and polish docs for public APIs
    
    Signed-off-by: Xuanwo <gi...@xuanwo.io>
---
 core/src/lib.rs                     |   4 +-
 core/src/raw/path.rs                |   1 +
 core/src/types/operator/operator.rs | 771 ++++++++++++++++--------------------
 3 files changed, 351 insertions(+), 425 deletions(-)

diff --git a/core/src/lib.rs b/core/src/lib.rs
index ecb2a5910..864dfb452 100644
--- a/core/src/lib.rs
+++ b/core/src/lib.rs
@@ -92,6 +92,7 @@
 //!
 //! Every Operator API follows a consistent pattern. For example, consider the `read` operation:
 //!
+//! - [`Operator::read`]: Executes a read operation.
 //! - [`Operator::read_with`]: Executes a read operation with additional options using the builder pattern.
 //! - [`Operator::read_options`]: Executes a read operation with extra options provided via a [`options::ReadOptions`] struct.
 //! - [`Operator::reader`]: Creates a reader for streaming data, allowing for flexible access.
@@ -99,7 +100,7 @@
 //! - [`Operator::reader_options`]: Creates a reader with extra options provided via a [`options::ReadOptions`] struct.
 //!
 //! The [`Reader`] created by [`Operator`] supports custom read control methods and can be converted
-//! into `futures::AsyncRead` for broader ecosystem compatibility.
+//! into [`futures::AsyncRead`] or [`futures::Stream`] for broader ecosystem compatibility.
 //!
 //! ```no_run
 //! use opendal::layers::LoggingLayer;
@@ -137,6 +138,7 @@
 //!             range: (0..8 * 1024 * 1024).into(),
 //!             chunk: Some(1024 * 1024),
 //!             concurrent: 4,
+//!             ..Default::default()
 //!         })
 //!         .await?;
 //!
diff --git a/core/src/raw/path.rs b/core/src/raw/path.rs
index 5790c7232..c49c94e3e 100644
--- a/core/src/raw/path.rs
+++ b/core/src/raw/path.rs
@@ -211,6 +211,7 @@ pub fn get_parent(path: &str) -> &str {
 }
 
 /// Validate given path is match with given EntryMode.
+#[inline]
 pub fn validate_path(path: &str, mode: EntryMode) -> bool {
     debug_assert!(!path.is_empty(), "input path should not be empty");
 
diff --git a/core/src/types/operator/operator.rs b/core/src/types/operator/operator.rs
index af9d08fa3..f87706431 100644
--- a/core/src/types/operator/operator.rs
+++ b/core/src/types/operator/operator.rs
@@ -137,6 +137,7 @@ use crate::*;
 ///             range: (0..8 * 1024 * 1024).into(),
 ///             chunk: Some(1024 * 1024),
 ///             concurrent: 4,
+///             ..Default::default()
 ///         })
 ///         .await?;
 ///
@@ -238,7 +239,7 @@ impl Operator {
     /// # }
     /// ```
     pub async fn check(&self) -> Result<()> {
-        let mut ds = self.lister("/").await?;
+        let mut ds = self.lister_with("/").limit(1).await?;
 
         match ds.next().await {
             Some(Err(e)) if e.kind() != ErrorKind::NotFound => Err(e),
@@ -246,14 +247,14 @@ impl Operator {
         }
     }
 
-    /// Get given path's metadata.
+    /// Retrieve the metadata for the specified path.
     ///
     /// # Notes
     ///
     /// ## Extra Options
     ///
-    /// [`Operator::stat`] is a wrapper of [`Operator::stat_with`] without any options. To use extra
-    /// options like `if_match` and `if_none_match`, please use [`Operator::stat_with`] instead.
+    /// [`Operator::stat`] is a wrapper around [`Operator::stat_with`] that uses no additional options.
+    /// To specify extra options such as `if_match` and `if_none_match`, please use [`Operator::stat_with`] instead.
     ///
     /// # Examples
     ///
@@ -278,7 +279,7 @@ impl Operator {
         self.stat_with(path).await
     }
 
-    /// Get given path's metadata with extra options.
+    /// Retrieve the metadata of the specified path with additional options.
     ///
     /// # Options
     ///
@@ -313,34 +314,6 @@ impl Operator {
     /// # Ok(())
     /// # }
     /// ```
-    ///
-    /// ---
-    ///
-    /// # Behavior
-    ///
-    /// ## Services that support `create_dir`
-    ///
-    /// `test` and `test/` may vary in some services such as S3. However, on a local file system,
-    /// they're identical. Therefore, the behavior of `stat("test")` and `stat("test/")` might differ
-    /// in certain edge cases. Always use `stat("test/")` when you need to access a directory if possible.
-    ///
-    /// Here are the behavior list:
-    ///
-    /// | Case                   | Path            | Result                                     |
-    /// |------------------------|-----------------|--------------------------------------------|
-    /// | stat existing dir      | `abc/`          | Metadata with dir mode                     |
-    /// | stat existing file     | `abc/def_file`  | Metadata with file mode                    |
-    /// | stat dir without `/`   | `abc/def_dir`   | Error `NotFound` or metadata with dir mode |
-    /// | stat file with `/`     | `abc/def_file/` | Error `NotFound`                           |
-    /// | stat not existing path | `xyz`           | Error `NotFound`                           |
-    ///
-    /// Refer to [RFC: List Prefix][crate::docs::rfcs::rfc_3243_list_prefix] for more details.
-    ///
-    /// ## Services that not support `create_dir`
-    ///
-    /// For services that not support `create_dir`, `stat("test/")` will return `NotFound` even
-    /// when `test/abc` exists since the service won't have the concept of dir. There is nothing
-    /// we can do about this.
     pub fn stat_with(&self, path: &str) -> FutureStat<impl Future<Output = Result<Metadata>>> {
         let path = normalize_path(path);
         OperatorFuture::new(
@@ -351,7 +324,44 @@ impl Operator {
         )
     }
 
-    /// Get given path's metadata with extra options.
+    /// Retrieve the metadata of the specified path with additional options.
+    ///
+    /// # Examples
+    ///
+    /// ## Get metadata while `ETag` matches
+    ///
+    /// `stat_with` will
+    ///
+    /// - return `Ok(metadata)` if `ETag` matches
+    /// - return `Err(error)` and `error.kind() == ErrorKind::ConditionNotMatch` if file exists but
+    ///   `ETag` mismatch
+    /// - return `Err(err)` if other errors occur, for example, `NotFound`.
+    ///
+    /// ```
+    /// # use anyhow::Result;
+    /// # use futures::io;
+    /// # use opendal::Operator;
+    /// use opendal::options;
+    /// use opendal::ErrorKind;
+    /// #
+    /// # async fn test(op: Operator) -> Result<()> {
+    /// let res = op
+    ///     .stat_options("test", options::StatOptions {
+    ///         if_match: Some("<etag>".to_string()),
+    ///         ..Default::default()
+    ///     })
+    ///     .await;
+    /// if let Err(e) = res {
+    ///     if e.kind() == ErrorKind::ConditionNotMatch {
+    ///         println!("file exists, but etag mismatch")
+    ///     }
+    ///     if e.kind() == ErrorKind::NotFound {
+    ///         println!("file not exist")
+    ///     }
+    /// }
+    /// # Ok(())
+    /// # }
+    /// ```
     pub async fn stat_options(&self, path: &str, opts: options::StatOptions) -> Result<Metadata> {
         let path = normalize_path(path);
         Self::stat_inner(self.accessor.clone(), path, opts).await
@@ -367,7 +377,7 @@ impl Operator {
         Ok(rp.into_metadata())
     }
 
-    /// Check if this path exists or not.
+    /// Check whether this path exists.
     ///
     /// # Example
     ///
@@ -386,52 +396,22 @@ impl Operator {
         let r = self.stat(path).await;
         match r {
             Ok(_) => Ok(true),
-            Err(err) => match err.kind() {
-                ErrorKind::NotFound => Ok(false),
-                _ => Err(err),
-            },
+            Err(err) if err.kind() == ErrorKind::NotFound => Ok(false),
+            Err(err) => Err(err),
         }
     }
 
-    /// Check if this path exists or not.
-    ///
-    /// # Example
-    ///
-    /// ```
-    /// use anyhow::Result;
-    /// use futures::io;
-    /// use opendal::Operator;
-    ///
-    /// async fn test(op: Operator) -> Result<()> {
-    ///     let _ = op.is_exist("test").await?;
-    ///
-    ///     Ok(())
-    /// }
-    /// ```
-    #[deprecated(note = "rename to `exists` for consistence with `std::fs::exists`")]
-    pub async fn is_exist(&self, path: &str) -> Result<bool> {
-        let r = self.stat(path).await;
-        match r {
-            Ok(_) => Ok(true),
-            Err(err) => match err.kind() {
-                ErrorKind::NotFound => Ok(false),
-                _ => Err(err),
-            },
-        }
-    }
-
-    /// Create a dir at given path.
+    /// Create a directory at the specified path.
     ///
     /// # Notes
     ///
-    /// To indicate that a path is a directory, it is compulsory to include
-    /// a trailing / in the path. Failure to do so may result in
-    /// `NotADirectory` error being returned by OpenDAL.
+    /// To specify that a path is a directory, you must include a trailing slash (/).
+    /// Omitting the trailing slash may cause OpenDAL to return a `NotADirectory` error.
     ///
     /// # Behavior
     ///
-    /// - Create on existing dir will succeed.
-    /// - Create dir is always recursive, works like `mkdir -p`
+    /// - Creating a directory that already exists will succeed.
+    /// - Directory creation is always recursive, functioning like `mkdir -p`.
     ///
     /// # Examples
     ///
@@ -461,19 +441,17 @@ impl Operator {
         Ok(())
     }
 
-    /// Read the whole path into a bytes.
+    /// Read the entire file into bytes from given path.
     ///
     /// # Notes
     ///
-    /// ## Extra Options
+    /// ## Additional Options
     ///
-    /// [`Operator::read`] is a wrapper of [`Operator::read_with`] without any options. To use
-    /// extra options like `range` and `if_match`, please use [`Operator::read_with`] instead.
+    /// [`Operator::read`] is a simplified method that does not support additional options. To access features like `range` and `if_match`, please use [`Operator::read_with`] or [`Operator::read_options`] instead.
     ///
     /// ## Streaming Read
     ///
-    /// This function will allocate a new bytes internally. For more precise memory control or
-    /// reading data lazily, please use [`Operator::reader`]
+    /// This function reads all content into memory at once. For more precise memory management or to read big file lazily, please use [`Operator::reader`].
     ///
     /// # Examples
     ///
@@ -487,20 +465,17 @@ impl Operator {
     /// # }
     /// ```
     pub async fn read(&self, path: &str) -> Result<Buffer> {
-        self.read_with(path).await
+        self.read_options(path, options::ReadOptions::default())
+            .await
     }
 
-    /// Read the whole path into a bytes with extra options.
-    ///
-    /// This function will allocate a new bytes internally. For more precise memory control or
-    /// reading data lazily, please use [`Operator::reader`]
+    /// Read the entire file into bytes from given path with additional options.
     ///
     /// # Notes
     ///
     /// ## Streaming Read
     ///
-    /// This function will allocate a new bytes internally. For more precise memory control or
-    /// reading data lazily, please use [`Operator::reader`]
+    /// This function reads all content into memory at once. For more precise memory management or to read big file lazily, please use [`Operator::reader`].
     ///
     /// # Options
     ///
@@ -508,14 +483,12 @@ impl Operator {
     ///
     /// # Examples
     ///
-    /// Read the whole path into a bytes.
+    /// Read the first 10 bytes of a file:
     ///
     /// ```
     /// # use opendal::Result;
     /// # use opendal::Operator;
-    /// # use futures::TryStreamExt;
     /// # async fn test(op: Operator) -> Result<()> {
-    /// let bs = op.read_with("path/to/file").await?;
     /// let bs = op.read_with("path/to/file").range(0..10).await?;
     /// # Ok(())
     /// # }
@@ -531,7 +504,32 @@ impl Operator {
         )
     }
 
-    /// Read the whole path into a bytes with extra options.
+    /// Read the entire file into bytes from given path with additional options.
+    ///
+    /// # Notes
+    ///
+    /// ## Streaming Read
+    ///
+    /// This function reads all content into memory at once. For more precise memory management or to read big file lazily, please use [`Operator::reader`].
+    ///
+    /// # Examples
+    ///
+    /// Read the first 10 bytes of a file:
+    ///
+    /// ```
+    /// # use opendal::Result;
+    /// # use opendal::Operator;
+    /// use opendal::options;
+    /// # async fn test(op: Operator) -> Result<()> {
+    /// let bs = op
+    ///     .read_options("path/to/file", options::ReadOptions {
+    ///         range: (0..10).into(),
+    ///         ..Default::default()
+    ///     })
+    ///     .await?;
+    /// # Ok(())
+    /// # }
+    /// ```
     pub async fn read_options(&self, path: &str, opts: options::ReadOptions) -> Result<Buffer> {
         let path = normalize_path(path);
         Self::read_inner(self.inner().clone(), path, opts).await
@@ -556,14 +554,13 @@ impl Operator {
         Ok(buf)
     }
 
-    /// Create a new reader which can read the whole path.
+    /// Create a new reader of given path.
     ///
     /// # Notes
     ///
     /// ## Extra Options
     ///
-    /// [`Operator::reader`] is a wrapper of [`Operator::reader_with`] without any options. To use
-    /// extra options like `concurrent`, please use [`Operator::reader_with`] instead.
+    /// [`Operator::reader`] is a simplified method without any options. To use additional options such as `concurrent` or `if_match`, please use [`Operator::reader_with`] or [`Operator::reader_options`] instead.
     ///
     /// # Examples
     ///
@@ -574,6 +571,8 @@ impl Operator {
     /// # use opendal::Scheme;
     /// # async fn test(op: Operator) -> Result<()> {
     /// let r = op.reader("path/to/file").await?;
+    /// // Read the first 10 bytes of the file
+    /// let data = r.read(0..10).await?;
     /// # Ok(())
     /// # }
     /// ```
@@ -581,14 +580,7 @@ impl Operator {
         self.reader_with(path).await
     }
 
-    /// Create a new reader with extra options
-    ///
-    /// # Notes
-    ///
-    /// ## Extra Options
-    ///
-    /// [`Operator::reader`] is a wrapper of [`Operator::reader_with`] without any options. To use
-    /// extra options like `version`, please use [`Operator::reader_with`] instead.
+    /// Create a new reader of given path with additional options.
     ///
     /// # Options
     ///
@@ -596,12 +588,16 @@ impl Operator {
     ///
     /// # Examples
     ///
+    /// Create a reader with a specific version ID:
+    ///
     /// ```
     /// # use opendal::Result;
     /// # use opendal::Operator;
     /// # use opendal::Scheme;
     /// # async fn test(op: Operator) -> Result<()> {
     /// let r = op.reader_with("path/to/file").version("version_id").await?;
+    /// // Read the first 10 bytes of the file
+    /// let data = r.read(0..10).await?;
     /// # Ok(())
     /// # }
     /// ```
@@ -616,7 +612,28 @@ impl Operator {
         )
     }
 
-    /// Create a new reader with extra options
+    /// Create a new reader of given path with additional options.
+    ///
+    /// # Examples
+    ///
+    /// Create a reader with a specific version ID:
+    ///
+    /// ```
+    /// # use opendal::Result;
+    /// # use opendal::Operator;
+    /// use opendal::options;
+    /// # async fn test(op: Operator) -> Result<()> {
+    /// let r = op
+    ///     .reader_options("path/to/file", options::ReadOptions {
+    ///         version: Some("version_id".to_string()),
+    ///         ..Default::default()
+    ///     })
+    ///     .await?;
+    /// // Read the first 10 bytes of the file
+    /// let data = r.read(0..10).await?;
+    /// # Ok(())
+    /// # }
+    /// ```
     pub async fn reader_options(&self, path: &str, opts: options::ReaderOptions) -> Result<Reader> {
         let path = normalize_path(path);
         Self::reader_inner(self.inner().clone(), path, opts).await
@@ -645,25 +662,27 @@ impl Operator {
         Ok(Reader::new(context))
     }
 
-    /// Write bytes into path.
+    /// Write all data to the specified path at once.
     ///
     /// # Notes
     ///
+    /// Visit [`performance::concurrent_write`][crate::docs::performance::concurrent_write] for more details on concurrent writes.
+    ///
     /// ## Extra Options
     ///
-    /// [`Operator::write`] is a simplified version of [`Operator::write_with`] without additional options.
-    /// For advanced features like `content_type` and `cache_control`, use [`Operator::write_with`] instead.
+    /// [`Operator::write`] is a simplified method that does not include additional options.
+    /// For advanced features such as `chunk` and `concurrent`, use [`Operator::write_with`] or [`Operator::write_options`] instead.
     ///
     /// ## Streaming Write
     ///
-    /// This method performs a single bulk write operation. For finer-grained memory control
-    /// or streaming data writes, use [`Operator::writer`] instead.
+    /// This method executes a single bulk write operation. For more precise memory management
+    /// or to write data in a streaming fashion, use [`Operator::writer`] instead.
     ///
     /// ## Multipart Uploads
     ///
-    /// OpenDAL provides multipart upload functionality through the [`Writer`] abstraction,
-    /// handling all upload details automatically. You can customize the upload behavior by
-    /// configuring `chunk` size and `concurrent` operations via [`Operator::writer_with`].
+    /// OpenDAL offers multipart upload capabilities through the [`Writer`] abstraction,
+    /// automatically managing all upload details for you. You can fine-tune the upload process
+    /// by adjusting the `chunk` size and the number of `concurrent` operations using [`Operator::writer_with`].
     ///
     /// # Examples
     ///
@@ -684,39 +703,31 @@ impl Operator {
         self.write_with(path, bs).await
     }
 
-    /// Write data with extra options.
+    /// Write all data to the specified path at once with additional options.
     ///
     /// # Notes
     ///
+    /// Visit [`performance::concurrent_write`][crate::docs::performance::concurrent_write] for more details on concurrent writes.
+    ///
     /// ## Streaming Write
     ///
-    /// This method performs a single bulk write operation for all bytes. For finer-grained
-    /// memory control or lazy writing, consider using [`Operator::writer_with`] instead.
+    /// This method executes a single bulk write operation. For more precise memory management
+    /// or to write data in a streaming fashion, use [`Operator::writer`] instead.
     ///
     /// ## Multipart Uploads
     ///
-    /// OpenDAL handles multipart uploads through the [`Writer`] abstraction, managing all
-    /// the upload details automatically. You can customize the upload behavior by configuring
-    /// `chunk` size and `concurrent` operations via [`Operator::writer_with`].
+    /// OpenDAL offers multipart upload capabilities through the [`Writer`] abstraction,
+    /// automatically managing all upload details for you. You can fine-tune the upload process
+    /// by adjusting the `chunk` size and the number of `concurrent` operations using [`Operator::writer_with`].
     ///
     /// # Options
     ///
-    /// Visit [`FutureWrite`] for all available options.
-    ///
-    /// - [`append`](./operator_futures/type.FutureWrite.html#method.append): Sets append mode for this write request.
-    /// - [`chunk`](./operator_futures/type.FutureWrite.html#method.chunk): Sets chunk size for buffered writes.
-    /// - [`concurrent`](./operator_futures/type.FutureWrite.html#method.concurrent): Sets concurrent write operations for this writer.
-    /// - [`cache_control`](./operator_futures/type.FutureWrite.html#method.cache_control): Sets cache control for this write request.
-    /// - [`content_type`](./operator_futures/type.FutureWrite.html#method.content_type): Sets content type for this write request.
-    /// - [`content_disposition`](./operator_futures/type.FutureWrite.html#method.content_disposition): Sets content disposition for this write request.
-    /// - [`content_encoding`](./operator_futures/type.FutureWrite.html#method.content_encoding): Sets content encoding for this write request.
-    /// - [`if_match`](./operator_futures/type.FutureWrite.html#method.if_match): Sets if-match for this write request.
-    /// - [`if_none_match`](./operator_futures/type.FutureWrite.html#method.if_none_match): Sets if-none-match for this write request.
-    /// - [`if_not_exist`](./operator_futures/type.FutureWrite.html#method.if_not_exist): Sets if-not-exist for this write request.
-    /// - [`user_metadata`](./operator_futures/type.FutureWrite.html#method.user_metadata): Sets user metadata for this write request.
+    /// Visit [`options::WriteOptions`] for all available options.
     ///
     /// # Examples
     ///
+    /// Write data to a file only when it does not already exist:
+    ///
     /// ```
     /// # use opendal::Result;
     /// # use opendal::Operator;
@@ -746,7 +757,42 @@ impl Operator {
         )
     }
 
-    /// Write data with extra options.
+    /// Write all data to the specified path at once with additional options.
+    ///
+    /// # Notes
+    ///
+    /// Visit [`performance::concurrent_write`][crate::docs::performance::concurrent_write] for more details on concurrent writes.
+    ///
+    /// ## Streaming Write
+    ///
+    /// This method executes a single bulk write operation. For more precise memory management
+    /// or to write data in a streaming fashion, use [`Operator::writer`] instead.
+    ///
+    /// ## Multipart Uploads
+    ///
+    /// OpenDAL offers multipart upload capabilities through the [`Writer`] abstraction,
+    /// automatically managing all upload details for you. You can fine-tune the upload process
+    /// by adjusting the `chunk` size and the number of `concurrent` operations using [`Operator::writer_with`].
+    ///
+    /// # Examples
+    ///
+    /// Write data to a file only when it does not already exist:
+    ///
+    /// ```
+    /// # use opendal::Result;
+    /// # use opendal::Operator;
+    /// use opendal::options;
+    ///
+    /// # async fn test(op: Operator) -> Result<()> {
+    /// let _ = op
+    ///     .write_options("path/to/file", vec![0; 4096], options::WriteOptions {
+    ///         if_not_exists: true,
+    ///         ..Default::default()
+    ///     })
+    ///     .await?;
+    /// # Ok(())
+    /// # }
+    /// ```
     pub async fn write_options(
         &self,
         path: &str,
@@ -780,7 +826,7 @@ impl Operator {
         w.close().await
     }
 
-    /// Create a writer for streaming data to the given path.
+    /// Create a new writer of given path.
     ///
     /// # Notes
     ///
@@ -793,21 +839,8 @@ impl Operator {
     ///
     /// ## Extra Options
     ///
-    /// [`Operator::writer`] is a simplified version of [`Operator::writer_with`] without additional options.
-    /// For advanced features like `content_type` and `cache_control`, use [`Operator::writer_with`] instead.
-    ///
-    /// ## Chunk Size Handling
-    ///
-    /// Storage services often have specific requirements for chunk sizes:
-    /// - Services like `s3` may return `EntityTooSmall` errors for undersized chunks
-    /// - Using small chunks in cloud storage services can lead to increased costs
-    ///
-    /// OpenDAL automatically determines optimal chunk sizes based on the service's
-    /// [Capability](crate::types::Capability). However, you can override this by explicitly
-    /// setting the `chunk` parameter.
-    ///
-    /// For improved performance, consider setting an appropriate chunk size using
-    /// [`Operator::writer_with`].
+    /// [`Operator::writer`] is a simplified version that does not include additional options.
+    /// For advanced features such as `chunk` and `concurrent`, use [`Operator::writer_with`] or [`Operator::writer_options`] instead.
     ///
     /// # Examples
     ///
@@ -828,13 +861,30 @@ impl Operator {
         self.writer_with(path).await
     }
 
-    /// Create a writer for streaming data to the given path with more options.
+    /// Create a new writer of given path with additional options.
     ///
-    /// ## Options
+    /// # Notes
     ///
-    /// Visit [`options::WriteOptions`] for all available options.
+    /// ## Writer Features
+    ///
+    /// The writer provides several powerful capabilities:
+    /// - Streaming writes for continuous data transfer
+    /// - Automatic multipart upload handling
+    /// - Memory-efficient chunk-based writing
+    ///
+    /// ## Chunk Size Handling
     ///
-    /// ## Examples
+    /// Storage services often have specific requirements for chunk sizes:
+    /// - Services like `s3` may return `EntityTooSmall` errors for undersized chunks
+    /// - Using small chunks in cloud storage services can lead to increased costs
+    ///
+    /// OpenDAL automatically determines optimal chunk sizes based on the service's
+    /// [Capability](crate::types::Capability). However, you can override this by explicitly
+    /// setting the `chunk` parameter.
+    ///
+    /// Visit [`performance::concurrent_write`][crate::docs::performance::concurrent_write] for more details on concurrent writes.
+    ///
+    /// # Examples
     ///
     /// ```
     /// # use opendal::Result;
@@ -864,11 +914,50 @@ impl Operator {
         )
     }
 
-    /// Create a writer for streaming data to the given path with more options.
+    /// Create a new writer of given path with additional options.
     ///
-    /// ## Options
+    /// # Notes
     ///
-    /// Visit [`options::WriteOptions`] for all available options.
+    /// ## Writer Features
+    ///
+    /// The writer provides several powerful capabilities:
+    /// - Streaming writes for continuous data transfer
+    /// - Automatic multipart upload handling
+    /// - Memory-efficient chunk-based writing
+    ///
+    /// ## Chunk Size Handling
+    ///
+    /// Storage services often have specific requirements for chunk sizes:
+    /// - Services like `s3` may return `EntityTooSmall` errors for undersized chunks
+    /// - Using small chunks in cloud storage services can lead to increased costs
+    ///
+    /// OpenDAL automatically determines optimal chunk sizes based on the service's
+    /// [Capability](crate::types::Capability). However, you can override this by explicitly
+    /// setting the `chunk` parameter.
+    ///
+    /// Visit [`performance::concurrent_write`][crate::docs::performance::concurrent_write] for more details on concurrent writes.
+    ///
+    /// # Examples
+    ///
+    /// Write data to a file in 4MiB chunk size and at 8 concurrency:
+    ///
+    /// ```
+    /// # use opendal::Result;
+    /// # use opendal::Operator;
+    /// use bytes::Bytes;
+    ///
+    /// # async fn test(op: Operator) -> Result<()> {
+    /// let mut w = op
+    ///     .writer_with("path/to/file")
+    ///     .chunk(4 * 1024 * 1024)
+    ///     .concurrent(8)
+    ///     .await?;
+    /// w.write(vec![0; 4096]).await?;
+    /// w.write(vec![1; 4096]).await?;
+    /// w.close().await?;
+    /// # Ok(())
+    /// # }
+    /// ```
     pub async fn writer_options(&self, path: &str, opts: options::WriteOptions) -> Result<Writer> {
         let path = normalize_path(path);
         Self::writer_inner(self.inner().clone(), path, opts).await
@@ -1031,7 +1120,7 @@ impl Operator {
         self.delete_with(path).await
     }
 
-    /// Delete the given path with extra options.
+    /// Delete the given path with additional options.
     ///
     /// # Notes
     ///
@@ -1039,13 +1128,11 @@ impl Operator {
     ///
     /// # Options
     ///
-    /// ## `version`
-    ///
-    /// Set `version` for this `delete` request.
+    /// Visit [`options::DeleteOptions`] for all available options.
     ///
-    /// remove a specific version of the given path.
+    /// # Examples
     ///
-    /// If the version doesn't exist, OpenDAL will not return errors.
+    /// Delete a specific version of a file:
     ///
     /// ```
     /// # use opendal::Result;
@@ -1056,19 +1143,6 @@ impl Operator {
     /// # Ok(())
     /// # }
     /// ```
-    ///
-    /// # Examples
-    ///
-    /// ```
-    /// # use anyhow::Result;
-    /// # use futures::io;
-    /// # use opendal::Operator;
-    ///
-    /// # async fn test(op: Operator) -> Result<()> {
-    /// op.delete_with("test").await?;
-    /// # Ok(())
-    /// # }
-    /// ```
     pub fn delete_with(&self, path: &str) -> FutureDelete<impl Future<Output = Result<()>>> {
         let path = normalize_path(path);
 
@@ -1080,11 +1154,30 @@ impl Operator {
         )
     }
 
-    /// Delete the given path with extra options.
+    /// Delete the given path with additional options.
     ///
-    /// ## Options
+    /// # Notes
     ///
-    /// Visit [`options::DeleteOptions`] for all available options.
+    /// - Deleting a file that does not exist won't return errors.
+    ///
+    /// # Examples
+    ///
+    /// Delete a specific version of a file:
+    ///
+    /// ```
+    /// # use opendal::Result;
+    /// # use opendal::Operator;
+    /// use opendal::options;
+    ///
+    /// # async fn test(op: Operator, version: &str) -> Result<()> {
+    /// op.delete_with("path/to/file", options::DeleteOptions {
+    ///     version: Some(version.to_string()),
+    ///     ..Defeault::default()
+    /// })
+    /// .await?;
+    /// # Ok(())
+    /// # }
+    /// ```
     pub async fn delete_options(&self, path: &str, opts: options::DeleteOptions) -> Result<()> {
         let path = normalize_path(path);
         Self::delete_inner(self.inner().clone(), path, opts).await
@@ -1179,68 +1272,6 @@ impl Operator {
         Deleter::create(self.inner().clone()).await
     }
 
-    /// # Notes
-    ///
-    /// If underlying services support delete in batch, we will use batch
-    /// delete instead.
-    ///
-    /// # Examples
-    ///
-    /// ```
-    /// # use anyhow::Result;
-    /// # use futures::io;
-    /// # use opendal::Operator;
-    /// #
-    /// # async fn test(op: Operator) -> Result<()> {
-    /// op.remove(vec!["abc".to_string(), "def".to_string()])
-    ///     .await?;
-    /// # Ok(())
-    /// # }
-    /// ```
-    #[deprecated(note = "use `Operator::delete_iter` instead", since = "0.52.0")]
-    pub async fn remove(&self, paths: Vec<String>) -> Result<()> {
-        let mut deleter = self.deleter().await?;
-        deleter.delete_iter(paths).await?;
-        deleter.close().await?;
-        Ok(())
-    }
-
-    /// remove will remove files via the given paths.
-    ///
-    /// remove_via will remove files via the given stream.
-    ///
-    /// We will delete by chunks with given batch limit on the stream.
-    ///
-    /// # Notes
-    ///
-    /// If underlying services support delete in batch, we will use batch
-    /// delete instead.
-    ///
-    /// # Examples
-    ///
-    /// ```
-    /// # use anyhow::Result;
-    /// # use futures::io;
-    /// # use opendal::Operator;
-    /// use futures::stream;
-    /// #
-    /// # async fn test(op: Operator) -> Result<()> {
-    /// let stream = stream::iter(vec!["abc".to_string(), "def".to_string()]);
-    /// op.remove_via(stream).await?;
-    /// # Ok(())
-    /// # }
-    /// ```
-    #[deprecated(note = "use `Operator::delete_stream` instead", since = "0.52.0")]
-    pub async fn remove_via(&self, input: impl Stream<Item = String> + Unpin) -> Result<()> {
-        let mut deleter = self.deleter().await?;
-        deleter
-            .delete_stream(input.map(|v| normalize_path(&v)))
-            .await?;
-        deleter.close().await?;
-
-        Ok(())
-    }
-
     /// Remove the path and all nested dirs and files recursively.
     ///
     /// # Notes
@@ -1284,29 +1315,23 @@ impl Operator {
         Ok(())
     }
 
-    /// List entries that starts with given `path` in parent dir.
+    /// List entries in the parent directory that start with the specified `path`.
     ///
     /// # Notes
     ///
     /// ## Recursively List
     ///
-    /// This function only read the children of the given directory. To read
-    /// all entries recursively, use `Operator::list_with("path").recursive(true)`
-    /// instead.
+    /// This function only reads the immediate children of the specified directory.
+    /// To list all entries recursively, use `Operator::list_with("path").recursive(true)` instead.
     ///
     /// ## Streaming List
     ///
-    /// This function will read all entries in the given directory. It could
-    /// take very long time and consume a lot of memory if the directory
-    /// contains a lot of entries.
+    /// This function reads all entries in the specified directory. If the directory contains many entries, this process may take a long time and use significant memory.
     ///
-    /// In order to avoid this, you can use [`Operator::lister`] to list entries in
-    /// a streaming way.
+    /// To prevent this, consider using [`Operator::lister`] to stream the entries instead.
     ///
     /// # Examples
     ///
-    /// ## List entries under a dir
-    ///
     /// This example will list all entries under the dir `path/to/dir/`.
     ///
     /// ```
@@ -1329,118 +1354,34 @@ impl Operator {
     /// # Ok(())
     /// # }
     /// ```
-    ///
-    /// ## List entries with prefix
-    ///
-    /// This example will list all entries under the prefix `path/to/prefix`.
-    ///
-    /// NOTE: it's possible that the prefix itself is also a dir. In this case, you could get
-    /// `path/to/prefix/`, `path/to/prefix_1` and so on. If you do want to list a dir, please
-    /// make sure the path is end with `/`.
-    ///
-    /// ```
-    /// # use anyhow::Result;
-    /// use opendal::EntryMode;
-    /// use opendal::Operator;
-    /// # async fn test(op: Operator) -> Result<()> {
-    /// let mut entries = op.list("path/to/prefix").await?;
-    /// for entry in entries {
-    ///     match entry.metadata().mode() {
-    ///         EntryMode::FILE => {
-    ///             println!("Handling file")
-    ///         }
-    ///         EntryMode::DIR => {
-    ///             println!("Handling dir {}", entry.path())
-    ///         }
-    ///         EntryMode::Unknown => continue,
-    ///     }
-    /// }
-    /// # Ok(())
-    /// # }
-    /// ```
     pub async fn list(&self, path: &str) -> Result<Vec<Entry>> {
         self.list_with(path).await
     }
 
-    /// List entries that starts with given `path` in parent dir with more options.
+    /// List entries in the parent directory that start with the specified `path` with additional options.
     ///
     /// # Notes
     ///
-    /// ## Streaming list
+    /// ## Streaming List
     ///
-    /// This function will read all entries in the given directory. It could
-    /// take very long time and consume a lot of memory if the directory
-    /// contains a lot of entries.
+    /// This function reads all entries in the specified directory. If the directory contains many entries, this process may take a long time and use significant memory.
     ///
-    /// In order to avoid this, you can use [`Operator::lister`] to list entries in
-    /// a streaming way.
+    /// To prevent this, consider using [`Operator::lister`] to stream the entries instead.
     ///
     /// # Options
     ///
-    /// ## `start_after`
-    ///
-    /// Specify the specified key to start listing from.
-    ///
-    /// This feature can be used to resume a listing from a previous point.
-    ///
-    /// The following example will resume the list operation from the `breakpoint`.
-    ///
-    /// ```
-    /// # use opendal::Result;
-    /// use opendal::Operator;
-    /// # async fn test(op: Operator) -> Result<()> {
-    /// let mut entries = op
-    ///     .list_with("path/to/dir/")
-    ///     .start_after("breakpoint")
-    ///     .await?;
-    /// # Ok(())
-    /// # }
-    /// ```
-    ///
-    /// ## `recursive`
-    ///
-    /// Specify whether to list recursively or not.
-    ///
-    /// If `recursive` is set to `true`, we will list all entries recursively. If not, we'll only
-    /// list the entries in the specified dir.
-    ///
-    /// ```
-    /// # use opendal::Result;
-    /// use opendal::Operator;
-    /// # async fn test(op: Operator) -> Result<()> {
-    /// let mut entries = op.list_with("path/to/dir/").recursive(true).await?;
-    /// # Ok(())
-    /// # }
-    /// ```
-    ///
-    /// ## `version`
-    ///
-    /// Specify whether to list files along with all their versions
-    ///
-    /// if `version` is enabled, all file versions will be returned; otherwise,
-    /// only the current files will be returned.
-    ///
-    /// ```
-    /// # use opendal::Result;
-    /// # use opendal::Operator;
-    /// # async fn test(op: Operator) -> Result<()> {
-    /// let mut entries = op.list_with("path/to/dir/").versions(true).await?;
-    /// # Ok(())
-    /// # }
-    /// ```
+    /// Visit [`options::ListOptions`] for all available options.
     ///
     /// # Examples
     ///
-    /// ## List all entries recursively
-    ///
-    /// This example will list all entries under the dir `path/to/dir/`
+    /// This example will list all entries recursively under the prefix `path/to/prefix`.
     ///
     /// ```
     /// # use anyhow::Result;
     /// use opendal::EntryMode;
     /// use opendal::Operator;
     /// # async fn test(op: Operator) -> Result<()> {
-    /// let mut entries = op.list_with("path/to/dir/").recursive(true).await?;
+    /// let mut entries = op.list_with("path/to/prefix").recursive(true).await?;
     /// for entry in entries {
     ///     match entry.metadata().mode() {
     ///         EntryMode::FILE => {
@@ -1455,17 +1396,47 @@ impl Operator {
     /// # Ok(())
     /// # }
     /// ```
+    pub fn list_with(&self, path: &str) -> FutureList<impl Future<Output = Result<Vec<Entry>>>> {
+        let path = normalize_path(path);
+
+        OperatorFuture::new(
+            self.inner().clone(),
+            path,
+            options::ListOptions::default(),
+            Self::list_inner,
+        )
+    }
+
+    /// List entries in the parent directory that start with the specified `path` with additional options.
+    ///
+    /// # Notes
+    ///
+    /// ## Streaming List
     ///
-    /// ## List all entries start with prefix
+    /// This function reads all entries in the specified directory. If the directory contains many entries, this process may take a long time and use significant memory.
+    ///
+    /// To prevent this, consider using [`Operator::lister`] to stream the entries instead.
+    ///
+    /// # Options
+    ///
+    /// Visit [`options::ListOptions`] for all available options.
+    ///
+    /// # Examples
     ///
-    /// This example will list all entries starts with prefix `path/to/prefix`
+    /// This example will list all entries recursively under the prefix `path/to/prefix`.
     ///
     /// ```
     /// # use anyhow::Result;
+    /// use opendal::options;
     /// use opendal::EntryMode;
     /// use opendal::Operator;
     /// # async fn test(op: Operator) -> Result<()> {
-    /// let mut entries = op.list_with("path/to/prefix").recursive(true).await?;
+    /// let mut entries = op
+    ///     .list_options("path/to/prefix", options::ListOptions {
+    ///         recursive: true,
+    ///         ..Default::default()
+    ///     })
+    ///     .await?;
     /// for entry in entries {
     ///     match entry.metadata().mode() {
     ///         EntryMode::FILE => {
@@ -1480,22 +1451,6 @@ impl Operator {
     /// # Ok(())
     /// # }
     /// ```
-    pub fn list_with(&self, path: &str) -> FutureList<impl Future<Output = Result<Vec<Entry>>>> {
-        let path = normalize_path(path);
-
-        OperatorFuture::new(
-            self.inner().clone(),
-            path,
-            options::ListOptions::default(),
-            Self::list_inner,
-        )
-    }
-
-    /// List entries that starts with given `path` in parent dir with more options.
-    ///
-    /// ## Options
-    ///
-    /// Visit [`options::ListOptions`] for all available options.
     pub async fn list_options(&self, path: &str, opts: options::ListOptions) -> Result<Vec<Entry>> {
         let path = normalize_path(path);
         Self::list_inner(self.inner().clone(), path, opts).await
@@ -1512,18 +1467,14 @@ impl Operator {
         lister.try_collect().await
     }
 
-    /// List entries that starts with given `path` in parent dir.
-    ///
-    /// This function will create a new [`Lister`] to list entries. Users can stop
-    /// listing via dropping this [`Lister`].
+    /// Create a new lister to list entries that starts with given `path` in parent dir.
     ///
     /// # Notes
     ///
     /// ## Recursively list
     ///
-    /// This function only read the children of the given directory. To read
-    /// all entries recursively, use [`Operator::lister_with`] and `recursive(true)`
-    /// instead.
+    /// This function only reads the immediate children of the specified directory.
+    /// To retrieve all entries recursively, use [`Operator::lister_with`] with `recursive(true)` instead.
     ///
     /// # Examples
     ///
@@ -1553,64 +1504,11 @@ impl Operator {
         self.lister_with(path).await
     }
 
-    /// List entries that starts with given `path` in parent dir with options.
-    ///
-    /// This function will create a new [`Lister`] to list entries. Users can stop listing via
-    /// dropping this [`Lister`].
+    /// Create a new lister to list entries that starts with given `path` in parent dir with additional options.
     ///
     /// # Options
     ///
-    /// ## `start_after`
-    ///
-    /// Specify the specified key to start listing from.
-    ///
-    /// This feature can be used to resume a listing from a previous point.
-    ///
-    /// The following example will resume the list operation from the `breakpoint`.
-    ///
-    /// ```
-    /// # use opendal::Result;
-    /// use opendal::Operator;
-    /// # async fn test(op: Operator) -> Result<()> {
-    /// let mut lister = op
-    ///     .lister_with("path/to/dir/")
-    ///     .start_after("breakpoint")
-    ///     .await?;
-    /// # Ok(())
-    /// # }
-    /// ```
-    ///
-    /// ## `recursive`
-    ///
-    /// Specify whether to list recursively or not.
-    ///
-    /// If `recursive` is set to `true`, we will list all entries recursively. If not, we'll only
-    /// list the entries in the specified dir.
-    ///
-    /// ```
-    /// # use opendal::Result;
-    /// use opendal::Operator;
-    /// # async fn test(op: Operator) -> Result<()> {
-    /// let mut lister = op.lister_with("path/to/dir/").recursive(true).await?;
-    /// # Ok(())
-    /// # }
-    /// ```
-    ///
-    /// ## `version`
-    ///
-    /// Specify whether to list files along with all their versions
-    ///
-    /// if `version` is enabled, all file versions will be returned; otherwise,
-    /// only the current files will be returned.
-    ///
-    /// ```
-    /// # use opendal::Result;
-    /// # use opendal::Operator;
-    /// # async fn test(op: Operator) -> Result<()> {
-    /// let mut entries = op.lister_with("path/to/dir/").versions(true).await?;
-    /// # Ok(())
-    /// # }
-    /// ```
+    /// Visit [`options::ListOptions`] for all available options.
     ///
     /// # Examples
     ///
@@ -1648,14 +1546,39 @@ impl Operator {
         )
     }
 
-    /// List entries that starts with given `path` in parent dir with options.
+    /// Create a new lister to list entries that starts with given `path` in parent dir with additional options.
     ///
-    /// This function will create a new [`Lister`] to list entries. Users can stop listing via
-    /// dropping this [`Lister`].
+    /// # Examples
     ///
-    /// ## Options
+    /// ## List all files recursively
     ///
-    /// Visit [`options::ListOptions`] for all available options.
+    /// ```
+    /// # use anyhow::Result;
+    /// use futures::TryStreamExt;
+    /// use opendal::options;
+    /// use opendal::EntryMode;
+    /// use opendal::Operator;
+    /// # async fn test(op: Operator) -> Result<()> {
+    /// let mut lister = op
+    ///     .lister_options("path/to/dir/", options::ListOptions {
+    ///         recursive: true,
+    ///         ..Default::default()
+    ///     })
+    ///     .await?;
+    /// while let Some(mut entry) = lister.try_next().await? {
+    ///     match entry.metadata().mode() {
+    ///         EntryMode::FILE => {
+    ///             println!("Handling file {}", entry.path())
+    ///         }
+    ///         EntryMode::DIR => {
+    ///             println!("Handling dir {}", entry.path())
+    ///         }
+    ///         EntryMode::Unknown => continue,
+    ///     }
+    /// }
+    /// # Ok(())
+    /// # }
+    /// ```
     pub async fn lister_options(&self, path: &str, opts: options::ListOptions) -> Result<Lister> {
         let path = normalize_path(path);
         Self::lister_inner(self.inner().clone(), path, opts).await