Rust E0446: Private Type in Public Interface — What It Means & How to Fix It

What Does This Error Mean?

Rust error E0446 means a public function or method in your code returns or accepts a private type as part of its signature. If a public function returns a type, external code must be able to use that type — but if the type is private, external callers cannot work with the returned value. The fix is either to make the type public or to change the function to return or accept a different, public type.

Affected Models

Rust 1.70+
Rust 1.80+
cargo build
rustc compiler
Any Rust project

Common Causes

A public function (pub fn) returns a struct or enum that is not marked pub
A public function accepts a parameter of a private type that external callers cannot construct
A public trait implementation exposes a private type in its associated types
A private struct's fields are accessed through a public method in a way that leaks the private type
A module reorganization made a type private but left public functions that reference it

How to Fix It

The simplest fix: add pub to the private type. Change 'struct MyStruct' to 'pub struct MyStruct'. This makes the type accessible to callers of the public function.

Consider whether you actually want external code to be able to construct and use this type directly. If yes, make it pub.
If the type should remain private (an internal implementation detail), change the public function to return or accept a different type. Return a trait object (Box<dyn Trait>), a public enum, or a simple primitive instead.

Returning impl Trait (a trait object) is a common pattern for hiding implementation details while keeping the function public.
Use pub(crate) if you want the type visible within your crate but not to external consumers. This resolves E0446 when the function is pub(crate) too, or when you use the type only within the crate.

pub(crate) visibility is a middle ground — internal to your crate, but not part of the public API.
Consider making the function private if it does not need to be public. If the function using the private type is internal-only, change pub fn to fn or pub(crate) fn.

Not every function needs to be part of your public API. Audit your pub declarations to ensure only intentionally public functions are exposed.
If returning a complex private struct, consider creating a public builder or factory pattern. Expose a public constructor that returns the private type wrapped in an opaque way, hiding the concrete type from callers.

The opaque type pattern (returning impl Trait) is idiomatic in Rust for APIs that need to hide implementation types.

When to Call a Professional

E0446 is a visibility design error in your Rust code — no external service is needed. The fix is either making the type public or changing the function signature.

Frequently Asked Questions

Why does Rust enforce this rule?

Rust's visibility rules ensure that your public API is usable. If a public function returns a private type, callers receive a value they cannot name, store in a variable with an explicit type, or pass to other functions that require that type. This creates an unusable API. Rust catches this at compile time to prevent confusing and broken library interfaces.

What does 'pub(crate)' mean in Rust?

pub(crate) is a restricted visibility modifier that makes an item visible to all code within the same crate but not to external crates. It is useful for types that are shared across modules within your library but are not part of the public API. pub(super) limits visibility to the parent module. pub(in path) limits visibility to a specific module path.

Can I return an impl Trait to hide a private type?

Yes — returning impl Trait from a public function is the idiomatic Rust way to hide implementation types. Example: pub fn make_iterator() -> impl Iterator<Item = i32> { PrivateIter::new() } Callers know they get an iterator of i32, but they do not know (and do not need to know) the concrete type PrivateIter. This is especially useful for closures and complex iterator chains where the concrete type would be verbose.