fix bindings: cpp, dotnet, haskell, ocaml, ruby

bindings/cpp/src/lib.rs

@@ -124,7 +124,7 @@ impl Operator {
     // Safety: The bytes created from bs will be dropped after the function call.
     // So it's safe to declare its lifetime as 'static.
     fn write(&self, path: &str, bs: &'static [u8]) -> Result<()> {
-        Ok(self.0.write(path, bs)?)
+        Ok(self.0.write(path, bs).map(|_| ())?)
     }
 
     fn exists(&self, path: &str) -> Result<bool> {

bindings/dotnet/src/lib.rs

@@ -61,7 +61,7 @@ pub unsafe extern "C" fn blocking_operator_write(
     let op = &*(op);
     let path = std::ffi::CStr::from_ptr(path).to_str().unwrap();
     let content = std::ffi::CStr::from_ptr(content).to_str().unwrap();
-    op.write(path, content.to_owned()).unwrap()
+    op.write(path, content.to_owned()).map(|_| ()).unwrap()
 }
 
 /// # Safety

bindings/haskell/src/lib.rs

@@ -206,7 +206,7 @@ pub unsafe extern "C" fn blocking_write(
     let bytes = Vec::from_raw_parts(bytes as *mut u8, len, len);
 
     let res = match op.write(path_str, bytes.clone()) {
-        Ok(()) => FFIResult::ok(()),
+        Ok(_) => FFIResult::ok(()),
         Err(e) => FFIResult::err_with_source("Failed to write", e),
     };
 

bindings/ocaml/src/operator/mod.rs

@@ -91,7 +91,7 @@ pub fn blocking_write(
     path: String,
     bs: &'static [u8],
 ) -> Result<(), String> {
-    map_res_error(operator.0.write(path.as_str(), bs))
+    map_res_error(operator.0.write(path.as_str(), bs).map(|_| ()))
 }
 
 #[ocaml::func]

bindings/ruby/src/operator.rs

@@ -69,6 +69,7 @@ impl Operator {
         rb_self
             .0
             .write(&path, bs.to_bytes())
+            .map(|_| ())
             .map_err(|err| Error::new(ruby.exception_runtime_error(), err.to_string()))
     }
 

core/src/layers/dtrace.rs

@@ -388,8 +388,9 @@ impl<R: oio::Write> oio::Write for DtraceLayerWrapper<R> {
         self.inner
             .close()
             .await
-            .map(|_| {
+            .map(|meta| {
                 probe_lazy!(opendal, writer_close_ok, c_path.as_ptr());
+                meta
             })
             .map_err(|err| {
                 probe_lazy!(opendal, writer_close_error, c_path.as_ptr());
@@ -418,8 +419,9 @@ impl<R: oio::BlockingWrite> oio::BlockingWrite for DtraceLayerWrapper<R> {
         probe_lazy!(opendal, blocking_writer_close_start, c_path.as_ptr());
         self.inner
             .close()
-            .map(|_| {
+            .map(|meta| {
                 probe_lazy!(opendal, blocking_writer_close_ok, c_path.as_ptr());
+                meta
             })
             .map_err(|err| {
                 probe_lazy!(opendal, blocking_writer_close_error, c_path.as_ptr());