Qué es la Orphan Rule de Rust y por qué aparece error[E0117]
Cualquier equipo que lleve suficiente tiempo escribiendo Rust termina chocando con error[E0117]. El escenario es cotidiano: tienes una librería de serialización que define un trait ToJson y una librería de terceros como uuid. Quieres convertir un uuid::Uuid a JSON y escribes el impl natural. El compilador lo rechaza con un mensaje tajante: solo los traits definidos en el crate actual pueden implementarse para tipos definidos fuera de él.
Esa es la Orphan Rule. La lógica detrás es simple: si quieres que un tipo implemente un trait, al menos uno de los dos debe pertenecer a tu crate. No puedes dictar reglas para los tipos de otros.
El motivo es la coherencia global. Si el crate A implementa ToJson para uuid::Uuid devolviendo un UUID con guiones y el crate B hace lo mismo devolviendo 32 caracteres hexadecimales sin guiones, un proyecto que dependa de ambos no tiene forma de saber cuál implementación usar cuando escribe uuid.to_json(). La regla evita ese conflicto a medida que crecen los árboles de dependencias.
¿Y esto cómo se aplica en tu negocio?
Dueños de negocio de Latinoamérica y España usan un agente de IA para ganar más y recuperar su tiempo. El Kit «tu mano derecha con IA» te muestra cómo en un video de 11 minutos, con una ficha para armar el tuyo. CAR está cerrada por ahora; al anotarte, te avisamos cuando abra.
👥 Quiero el Kit →El problema real no es la regla, sino la necesidad que aparece todo el tiempo: hacer que un tipo de terceros implemente un trait de otro tercero. Ni el tipo ni el trait son tuyos, y aun así pegar librerías entre sí es el pan de cada día.
Por qué el NewType y los feature flags se quedan cortos
Hoy el ecosistema resuelve esto de dos maneras, y ambas se vuelven incómodas rápido.
La primera es meter la implementación dentro de la librería. Abres el Cargo.toml de un crate fundacional y encuentras una lista larga de flags: with-uuid, with-chrono, with-time, with-jiff, with-url, with-rust-decimal. Funciona hasta que deja de funcionar: nunca vas a cubrir todo el ecosistema, cada salto de versión mayor de un crate de tipos te deja bloqueado hasta que el crate del trait publique una actualización, y si el comportamiento por defecto no coincide con tu especificación de API (por ejemplo, serializa DateTime<Utc> como ISO-8601 cuando tu contrato pide un timestamp entero en milisegundos) no tienes forma de cambiarlo.
La segunda es envolver todo en un NewType. pub struct MyUuid(pub uuid::Uuid) y a implementar el trait sobre el wrapper. Con uno o dos tipos no pasa nada. El problema arranca cuando un modelo de dominio mezcla Uuid, Url, DateTime, HashMap y tipos propios: la lógica de negocio se llena de .0, y pasas el día envolviendo y desenvolviendo valores. El NewType es un patrón valioso para expresar significado de dominio o esconder internals, pero usarlo solo para aplacar al compilador infla el código sin aportar nada.
La salida: un parámetro genérico de contexto en el trait
Aquí está el detalle que mucha gente pasa por alto. Bajo la Orphan Rule (RFC 2451), el chequeo del compilador no mira solo el trait y el tipo: también mira los parámetros genéricos del trait. En impl Trait<P> for Type, si aparece un tipo local dentro de los parámetros genéricos del trait y no hay parámetros de tipo sin cubrir antes, el compilador entiende que esa implementación es exclusiva de tu crate. Ningún otro crate puede entrar en conflicto, así que la deja pasar.
La consecuencia para quien diseña librerías es una sola decisión: dejar un parámetro genérico en el trait como punto de extensión.
pub trait ToJson<Ctx = ()> {
fn to_json(&self) -> String;
}
El Ctx = () con valor por defecto es la clave. Cuando la librería implementa el trait para tipos básicos como i32 o String, lo hace de forma genérica sobre cualquier Ctx. Los usuarios normales nunca se enteran de que Ctx existe: todo funciona igual que antes con () como contexto por defecto.
Cuando necesitas conectar un tipo de terceros, defines un marcador vacío en tu propio crate —pub struct MyCtx;— y escribes las implementaciones que quieras para uuid::Uuid o chrono::DateTime<Utc>. El compilador ve un trait ajeno, tipos ajenos y un MyCtx local, y acepta. La coherencia global queda intacta porque nadie más puede escribir una implementación conflictiva usando tu MyCtx.
Vale la pena pensarlo como un racimo de uvas: MyCtx es el tallo y los tipos de terceros son las uvas. Agarras el tallo y levantas el racimo entero. Y puedes tener varios tallos en el mismo proyecto: tu capa HTTP usa ApiCtx para formatear timestamps como texto, mientras una capa RPC interna usa RpcCtx para formatearlos como enteros. Reglas separadas, aisladas en tiempo de compilación, cero conflicto.
Un detalle: el tipo local tiene que ser un tipo nuevo de verdad. Un alias de tipo sobre un tipo ajeno no sirve.
El orden del tipo local importa
Si tu trait tiene más de un parámetro genérico, hay una restricción de orden fácil de pisar. El compilador escanea en orden fijo: primero el tipo Self, después el primer parámetro genérico del trait, luego el segundo, y así. La regla se resume en una frase: ningún parámetro de tipo genérico desnudo puede aparecer antes del primer tipo local.
// Permitido: escanea ForeignType, encuentra MyCtx primero; la T final queda libre
impl<T> ForeignTrait<MyCtx, T> for ForeignType {}
// Error: encuentra una T desnuda antes de ver MyCtx
impl<T> ForeignTrait<T, MyCtx> for ForeignType {}
// Error: encuentra una T desnuda en Self, antes de que MyCtx tenga chance
impl<T> ForeignTrait<MyCtx, String> for T {}
La palabra clave es desnudo. En la jerga de Rust se llama parámetro de tipo sin cubrir. Una T suelta está sin cubrir; envuelta en un tipo concreto no fundamental como Vec<T> deja de estarlo, y entonces no bloquea a un MyCtx posterior. Los tipos fundamentales como &T y Box<T> no cuentan como cobertura.
Para quien diseña una librería, la conclusión práctica es que no basta con agregar el slot genérico: hay que ponerlo en el lugar correcto. Si el trait tiene varios parámetros genéricos y no hay una razón fuerte para lo contrario, el contexto va en la primera posición.
Un crate de modelos que se sostiene solo
El patrón también desarma un nudo arquitectónico clásico. Cuando un proyecto crece, se parte en un workspace de Cargo: un crate de API gateway, algunos de servicios de negocio, un worker de fondo. Todos comparten las mismas estructuras de datos, así que lo natural es extraerlas a un crate models.
Tradicionalmente eso duele. Si models define un Product con campos Uuid, Url y DateTime, y tu librería de serialización espera que esos tipos ya implementen sus traits dentro de models, quedas entre dos malas opciones: envolver todo en NewTypes y arrastrar dependencias pesadas a un crate que debería contener solo estructuras de datos, o rendirte y mezclar modelos con lógica de negocio.
Con el parámetro Ctx, el nudo se desata. models declara un contrato diferido: quien use esto después, siempre que su contexto sepa manejar Uuid y DateTime, Product soporta el trait automáticamente. El crate queda liviano, sin lógica de conversión concreta, y compila rápido. Las conversiones reales se difieren a los crates de servicio, donde cada uno conecta lo que necesita con su propio contexto local.
Cómo lo aplica Kova, una ORM en Rust
El autor del artículo llevó el patrón a todo el sistema de tipos de Kova, su ORM para PostgreSQL y SQLite sin macros. Las ORM son el terreno donde la Orphan Rule más duele, porque una tabla suele mezclar Uuid, Url, DateTime, HashMap y tipos de dominio propios.
Los traits centrales de Kova, Encode y Decode, usan exactamente este diseño de slot genérico. Como el punto de extensión queda en manos del usuario, la librería solo necesita soporte para primitivas de base de datos: enteros, flotantes, booleanos, strings y arreglos de bytes. Su Cargo.toml no mantiene una pila de dependencias opcionales para uuid, chrono, jiff o url.
En una aplicación real el flujo es: defines las estructuras con tipos nativos en un crate de modelos con #[derive(Model)], y en el crate de servicio declaras un marcador como pub struct AppCodec; con las conversiones que correspondan a tu layout de almacenamiento —Uuid como 16 bytes crudos, DateTime<Utc> como timestamp entero en milisegundos—. Cambiar el contexto del cliente no tiene costo en runtime: por debajo solo se intercambia un marcador PhantomData.
El mismo slot genérico se extiende a los traits de capacidades SQL (CanString<X>, CanMath<X>, Compatible<Target, X>). Así, un tipo de terceros como Url puede ganar métodos de búsqueda tipo like o ilike sin dejar de ser un tipo ajeno.
Qué significa esto para tu startup
Si tu equipo escribe Rust, este patrón cambia decisiones de arquitectura que suelen tomarse mal por desconocimiento del compilador.
- Si diseñas una librería interna o publicas un crate: agrega un parámetro genérico de contexto con valor por defecto
()en tus traits de conversión y ponlo en la primera posición. Evitas mantener una lista de feature flags por cada tipo del ecosistema y dejas que cada equipo decida cómo serializar sus datos. - Si mantienes un workspace grande: extrae tus estructuras a un crate de modelos con tipos nativos y declara implementaciones genéricas sobre
Ctx. El crate queda sin dependencias pesadas y los tiempos de compilación dejan de ser un problema de equipo. - Antes de envolver un tipo en un NewType, pregúntate por qué: si la única razón es aplacar la Orphan Rule, el wrapper es deuda técnica disfrazada de patrón. El NewType vale cuando expresa significado de dominio, esconde internals o impone invariantes.
- Si usas una ORM o framework que te obliga a envolver todo: es una señal de que su sistema de tipos no te da un punto de extensión. Vale la pena evaluar alternativas antes de que el modelo de dominio se llene de
.0.
El contexto de mercado acompaña: según el repaso de índices de popularidad que publicó Analytics Insight, Rust ocupa el décimo lugar del índice TIOBE con 1,44%, y en la encuesta de Stack Overflow de 2026 el 67,4% de quienes ya lo usan quiere seguir usándolo. Es un lenguaje con una base de usuarios que se queda, y ese es justamente el perfil que termina chocando con la Orphan Rule en producción.
Conclusión
La Orphan Rule no está ahí para hacerte la vida difícil: existe para evitar conflictos globales de implementación y que los crates no se pisen entre sí. Deja de pelear por una implementación globalmente única y deja un slot genérico en el trait para acotar esa unicidad a un contexto local. No hay magia negra: es un cambio de perspectiva que ordena tanto el diseño de librerías como los límites de dependencias en workspaces grandes.
El autor anticipa que el siguiente problema es el que viene inmediatamente después: cuando tus traits y builders cargan un parámetro de contexto genérico, cómo evitar que se conviertan en tipos genéricos anidados que ralentizan la compilación. Eso lo aborda en la próxima entrega, con validación de límites y borrado de tipos.
Fuentes
- How to Bypass Rust’s Orphan Rule (fuente original)
- Which Programming Languages are Leading the Latest Popularity Rankings?
¿Y esto cómo se aplica en tu negocio?
Dueños de negocio de Latinoamérica y España usan un agente de IA para ganar más y recuperar su tiempo. El Kit «tu mano derecha con IA» te muestra cómo en un video de 11 minutos, con una ficha para armar el tuyo. CAR está cerrada por ahora; al anotarte, te avisamos cuando abra.
👥 Quiero el Kit →













