Límites de traits
Restrinja los tipos genéricos con traits
Límites de traits es una lección gratuita de Learn Rust Coding en CoddyKit. Esta es la lección 3 de 4. Puedes leer la lección completa abajo gratuitamente — luego la practicas en el navegador con un editor de código integrado y un tutor de IA 24/7. Forma parte de la ruta de aprendizaje de Learn Rust Coding, y tu progreso se sincroniza en la web y la app de CoddyKit. El curso de Learn Rust Coding incluye 4 lecciones en total.
Qué hacen los límites de traits
Un límite de trait restringe un tipo genérico a aquellos tipos que implementan un trait determinado. Indica al compilador qué comportamiento garantiza el tipo.
Esto habilita los métodos del trait dentro del código genérico, a la vez que mantiene la función utilizable con muchos tipos.
Sintaxis de límite en línea
La forma más sencilla coloca el límite justo después del parámetro de tipo: T: Trait. Aquí, T debe implementar Display para poder imprimirse.
Dentro de la función, ya puede llamar a cualquier método que proporcione Display.
use std::fmt::Display;
fn show<T: Display>(value: T) {
println!("value = {}", value);
}Un trait personalizado
Los límites también funcionan con sus propios traits. Defina un trait con un método y, después, limite una función genérica mediante él.
Este trait Summary requiere un método summarize que devuelva una cadena.
trait Summary {
fn summarize(&self) -> String;
}Implementar y establecer límites
Implemente el trait para un tipo y, después, una función con límites podrá aceptar cualquier tipo que lo implemente. La función llama al método del trait sin conocer el tipo concreto.
Este programa completo imprime un resumen de un Article.
trait Summary { fn summarize(&self) -> String; }
struct Article { title: String }
impl Summary for Article {
fn summarize(&self) -> String {
format!("Article: {}", self.title)
}
}
fn notify<T: Summary>(item: &T) {
println!("{}", item.summarize());
}
fn main() {
let a = Article { title: String::from("Rust") };
notify(&a);
}Combinar límites con +
Exija varios traits a la vez uniéndolos con +. Aquí, T debe implementar tanto Display como Clone.
La función puede imprimir el valor y clonarlo.
use std::fmt::Display;
fn process<T: Display + Clone>(value: T) {
let copy = value.clone();
println!("{}", copy);
}impl Trait en los argumentos
La sintaxis impl Trait en la posición de un argumento es una forma abreviada de un límite sencillo. item: &impl Summary significa lo mismo que un parámetro <T: Summary>.
Es concisa para casos con un solo argumento, pero ofrece menos control cuando reutiliza el tipo.
trait Summary { fn summarize(&self) -> String; }
fn notify(item: &impl Summary) {
println!("{}", item.summarize());
}Devolver impl Trait
También puede devolver impl Trait para ocultar un tipo concreto y garantizar que implementa un trait. Esto resulta práctico para closures e iteradores.
El código que llama solo sabe que el resultado implementa el trait indicado.
fn make_adder(n: i32) -> impl Fn(i32) -> i32 {
move |x| x + n
}
fn main() {
let add5 = make_adder(5);
println!("{}", add5(10));
}Los límites habilitan operadores
Los operadores se corresponden con traits: + necesita Add, == necesita PartialEq y las comparaciones necesitan PartialOrd. Establecer límites con estos traits permite que el código genérico use los operadores.
Aquí, la suma requiere que T implemente Add consigo mismo.
use std::ops::Add;
fn sum<T: Add<Output = T>>(a: T, b: T) -> T {
a + b
}Métodos predeterminados de los traits
Los traits pueden proporcionar implementaciones predeterminadas de sus métodos. Los tipos que los implementan pueden sobrescribirlas o usar el valor predeterminado. Los genéricos con límites usan la implementación vigente.
Este Summary tiene un summarize predeterminado que los tipos pueden conservar tal cual.
trait Summary {
fn summarize(&self) -> String {
String::from("(no summary)")
}
}
struct Note;
impl Summary for Note {}Despacho estático frente a dinámico
Los límites de traits usan despacho estático: el compilador elige el método exacto en tiempo de compilación mediante la monomorfización. En cambio, dyn Trait usa despacho dinámico mediante una vtable.
Los límites suelen ser más rápidos; dyn intercambia velocidad por binarios más pequeños y flexibilidad en tiempo de ejecución.
Límites en structs genéricas
Los límites de traits no se limitan a las funciones. Puede exigirlos al definir una struct para que todas las instancias cumplan el trait.
Aquí, cada Sortable<T> garantiza que sus elementos se pueden comparar.
struct Sortable<T: PartialOrd> {
items: Vec<T>,
}Comprobación rápida
Compruebe su comprensión de los límites de traits.
Repaso
Los límites de traits restringen los tipos genéricos para que el compilador permita usar los métodos y operadores del trait. Combine traits con + y use impl Trait como forma abreviada en argumentos o valores devueltos.
Los límites proporcionan despacho estático sin sobrecoste, a diferencia del despacho dinámico de dyn Trait.
Preguntas frecuentes
¿La lección «Límites de traits» es gratis?
Sí — el texto completo de «Límites de traits» es gratis para leer aquí en la web. Para practicarla de forma interactiva (editor de código integrado y tutor de IA 24/7) y desbloquear el resto del curso de Learn Rust Coding, actualiza a CoddyKit PRO. El curso de Learn Rust Coding incluye 4 lecciones en total.
¿Qué aprenderé en «Límites de traits»?
Restrinja los tipos genéricos con traits Practicas Learn Rust Coding con código real que ejecutas directamente en el navegador, y un tutor de IA 24/7 responde tus preguntas mientras trabajas en la lección.
¿Necesito experiencia previa para empezar Learn Rust Coding?
No se requiere experiencia previa. Learn Rust Coding en CoddyKit está estructurado para principiantes hasta estudiantes avanzados, así que puedes empezar aquí o desde el inicio y avanzar a tu ritmo. Esta es la lección 3 de 4.
¿Cuánto tiempo toma la lección «Límites de traits»?
La mayoría de las lecciones de CoddyKit toman alrededor de 5–10 minutos. Cada una es compacta e interactiva, así que avanzas constantemente y retomas exactamente por donde dejaste en la web y la app.
¿Puedo escribir y ejecutar código en esta lección de Learn Rust Coding?
Sí. Cada lección de Learn Rust Coding incluye un editor de código integrado, así que escribes y ejecutas código real directamente en tu navegador y obtienes retroalimentación instantánea de IA — sin configuración local necesaria.