Public function returns type in a private module

jeffdavis · June 15, 2021, 6:03am

If a public function returns a type that's defined in a private module, how do I store the resulting value in a struct? If I try to define the struct using the type, I get an error that the type is private.

alice · June 15, 2021, 6:24am

If all you need to know about the type is that it implements some trait, then you could convert the value into a Box<dyn SomeTrait> and store that. This is often used for futures in async Rust.

Besides this, there's no way to do it.

jeffdavis · June 15, 2021, 6:34am

Hmm. Is that generally a bad practice? Should I ask the library author to make the type public? It seems strange to me that I can get the value, but can't keep it.

Cerber-Ursi · June 15, 2021, 6:51am

You might be not supposed to store this value in struct, only in local variable, where the type can be inferred. However, I agree that this looks like a very edge case.

alice · June 15, 2021, 7:20am

Can you link to the function? Sometimes there are good reasons.

jeffdavis · June 15, 2021, 3:05pm

(it won't let me post more than two links, please excuse the plain text)

PR https://github.com/sfackler/rust-postgres/pull/778

Function defined here:

github.com

sfackler/rust-postgres/blob/909f2dce67159d91577134773f6739d2a03ff1e6/tokio-postgres/src/client.rs#L468


      
          pub async fn copy_out<T>(&self, statement: &T) -> Result<CopyOutStream, Error>
          where
              T: ?Sized + ToStatement,
          {
              let statement = statement.__convert().into_statement(self).await?;
              copy_out::copy_out(self.inner(), statement).await
          }
          
          
/// Executes a CopyBoth query, returning a combined Stream+Sink type to read and write copy
          /// data.
          pub async fn copy_both_simple<T>(&self, query: &str) -> Result<CopyBothDuplex<T>, Error>
          where
              T: Buf + 'static + Send,
          {
              copy_both::copy_both_simple(self.inner(), query).await
          }
          
          
/// Executes a sequence of SQL statements using the simple query protocol, returning the resulting rows.
          ///
          /// Statements should be separated by semicolons. If an error occurs, execution of the sequence will stop at that
          /// point. The simple query protocol returns the values in rows as strings rather than in their binary encodings,

Type defined here:

https://github.com/sfackler/rust-postgres/blob/909f2dce67159d91577134773f6739d2a03ff1e6/tokio-postgres/src/copy_both.rs#L229

Module declared here:

https://github.com/sfackler/rust-postgres/blob/909f2dce67159d91577134773f6739d2a03ff1e6/tokio-postgres/src/lib.rs#L160

I left a comment on the PR that it should include pub use crate::copy_both::CopyBothDuplex which seems to match the similar CopyOutStream and CopyInSink.

system · September 13, 2021, 3:05pm

This topic was automatically closed 90 days after the last reply. We invite you to open a new topic if you have further questions or comments.

Topic		Replies	Views
Why can't I return a private enum from a public function?	12	2172	January 12, 2023
Public type in private mod is not documented	8	771	November 20, 2022
N00b question on "A private type was used in a public type signature" help	5	503	March 4, 2021
Storing a function taking a function in a struct help	3	7128	January 12, 2023
Private struct can be exposed into public scope	9	2681	April 6, 2023

Public function returns type in a private module

Related topics