[{"data":1,"prerenderedAt":2505},["ShallowReactive",2],{"page-\u002Frust\u002F16-traits-and-generics":3},{"id":4,"title":5,"body":6,"description":2498,"extension":2499,"meta":2500,"navigation":157,"path":2501,"seo":2502,"stem":2503,"__hash__":2504},"content\u002Frust\u002F16-traits-and-generics.md","16 — Traits and Generics",{"type":7,"value":8,"toc":2467},"minimark",[9,13,22,27,238,259,263,343,362,366,369,397,420,489,493,498,597,611,615,669,673,835,841,847,851,934,938,1021,1047,1051,1291,1299,1379,1394,1404,1411,1536,1555,1559,1756,1798,1804,1912,1927,1936,1941,1992,1999,2003,2042,2045,2049,2111,2114,2118,2178,2181,2185,2243,2247,2261,2265,2268,2321,2331,2335,2434,2438,2460,2463],[10,11,5],"h1",{"id":12},"_16-traits-and-generics",[14,15,16,17,21],"p",{},"Traits are Rust's answer to interfaces\u002Ftypeclasses — they define ",[18,19,20],"strong",{},"shared behavior",". Generics parametrize code over types. Together they're the foundation of Rust's abstraction.",[23,24,26],"h2",{"id":25},"defining-and-implementing-traits","Defining and Implementing Traits",[28,29,31],"code-wrapper",{"language":30},"rust",[32,33,37],"pre",{"className":34,"code":35,"language":30,"meta":36,"style":36},"language-rust shiki shiki-themes github-light github-dark","trait Greet {\n    fn say_hi(&self) -> String;\n    fn say_loud(&self) -> String {\n        format!(\"{}!!!\", self.say_hi())    \u002F\u002F default method body\n    }\n}\n\nstruct User { name: String }\nimpl Greet for User {\n    fn say_hi(&self) -> String { format!(\"hi {}\", self.name) }\n}\n","",[38,39,40,57,88,110,140,146,152,159,179,194,233],"code",{"__ignoreMap":36},[41,42,45,49,53],"span",{"class":43,"line":44},"line",1,[41,46,48],{"class":47},"svdQ7","trait",[41,50,52],{"class":51},"sIsaT"," Greet",[41,54,56],{"class":55},"ssxIu"," {\n",[41,58,60,63,66,69,72,76,79,82,85],{"class":43,"line":59},2,[41,61,62],{"class":47},"    fn",[41,64,65],{"class":51}," say_hi",[41,67,68],{"class":55},"(",[41,70,71],{"class":47},"&",[41,73,75],{"class":74},"snvgF","self",[41,77,78],{"class":55},") ",[41,80,81],{"class":47},"->",[41,83,84],{"class":51}," String",[41,86,87],{"class":55},";\n",[41,89,91,93,96,98,100,102,104,106,108],{"class":43,"line":90},3,[41,92,62],{"class":47},[41,94,95],{"class":51}," say_loud",[41,97,68],{"class":55},[41,99,71],{"class":47},[41,101,75],{"class":74},[41,103,78],{"class":55},[41,105,81],{"class":47},[41,107,84],{"class":51},[41,109,56],{"class":55},[41,111,113,116,118,122,125,127,130,133,136],{"class":43,"line":112},4,[41,114,115],{"class":51},"        format!",[41,117,68],{"class":55},[41,119,121],{"class":120},"sJ6F3","\"{}!!!\"",[41,123,124],{"class":55},", ",[41,126,75],{"class":74},[41,128,129],{"class":47},".",[41,131,132],{"class":51},"say_hi",[41,134,135],{"class":55},"())    ",[41,137,139],{"class":138},"sdCPZ","\u002F\u002F default method body\n",[41,141,143],{"class":43,"line":142},5,[41,144,145],{"class":55},"    }\n",[41,147,149],{"class":43,"line":148},6,[41,150,151],{"class":55},"}\n",[41,153,155],{"class":43,"line":154},7,[41,156,158],{"emptyLinePlaceholder":157},true,"\n",[41,160,162,165,168,171,174,176],{"class":43,"line":161},8,[41,163,164],{"class":47},"struct",[41,166,167],{"class":51}," User",[41,169,170],{"class":55}," { name",[41,172,173],{"class":47},":",[41,175,84],{"class":51},[41,177,178],{"class":55}," }\n",[41,180,182,185,187,190,192],{"class":43,"line":181},9,[41,183,184],{"class":47},"impl",[41,186,52],{"class":51},[41,188,189],{"class":47}," for",[41,191,167],{"class":51},[41,193,56],{"class":55},[41,195,197,199,201,203,205,207,209,211,213,216,219,221,224,226,228,230],{"class":43,"line":196},10,[41,198,62],{"class":47},[41,200,65],{"class":51},[41,202,68],{"class":55},[41,204,71],{"class":47},[41,206,75],{"class":74},[41,208,78],{"class":55},[41,210,81],{"class":47},[41,212,84],{"class":51},[41,214,215],{"class":55}," { ",[41,217,218],{"class":51},"format!",[41,220,68],{"class":55},[41,222,223],{"class":120},"\"hi {}\"",[41,225,124],{"class":55},[41,227,75],{"class":74},[41,229,129],{"class":47},[41,231,232],{"class":55},"name) }\n",[41,234,236],{"class":43,"line":235},11,[41,237,151],{"class":55},[239,240,241,245,248],"ul",{},[242,243,244],"li",{},"Default methods can be overridden.",[242,246,247],{},"Implementations are explicit (no automatic interface implementation like Java).",[242,249,250,251,254,255,258],{},"You can implement a trait for a type only if either the trait or the type is ",[18,252,253],{},"local"," to your crate (the ",[18,256,257],{},"orphan rule",") — prevents conflicting impls across crates.",[23,260,262],{"id":261},"trait-objects-vs-static-dispatch","Trait Objects vs Static Dispatch",[28,264,265],{"language":30},[32,266,268],{"className":34,"code":267,"language":30,"meta":36,"style":36},"fn print_all\u003CT: Greet>(items: &[T]) { \u002F* monomorphized per T *\u002F }\nfn print_dyn(items: &[Box\u003Cdyn Greet>]) { \u002F* dynamic dispatch *\u002F }\n",[38,269,270,309],{"__ignoreMap":36},[41,271,272,275,278,281,284,286,288,291,293,296,299,301,304,307],{"class":43,"line":44},[41,273,274],{"class":47},"fn",[41,276,277],{"class":51}," print_all",[41,279,280],{"class":55},"\u003C",[41,282,283],{"class":51},"T",[41,285,173],{"class":47},[41,287,52],{"class":51},[41,289,290],{"class":55},">(items",[41,292,173],{"class":47},[41,294,295],{"class":47}," &",[41,297,298],{"class":55},"[",[41,300,283],{"class":51},[41,302,303],{"class":55},"]) { ",[41,305,306],{"class":138},"\u002F* monomorphized per T *\u002F",[41,308,178],{"class":55},[41,310,311,313,316,319,321,323,325,328,330,333,335,338,341],{"class":43,"line":59},[41,312,274],{"class":47},[41,314,315],{"class":51}," print_dyn",[41,317,318],{"class":55},"(items",[41,320,173],{"class":47},[41,322,295],{"class":47},[41,324,298],{"class":55},[41,326,327],{"class":51},"Box",[41,329,280],{"class":55},[41,331,332],{"class":47},"dyn",[41,334,52],{"class":51},[41,336,337],{"class":55},">]) { ",[41,339,340],{"class":138},"\u002F* dynamic dispatch *\u002F",[41,342,178],{"class":55},[239,344,345,352],{},[242,346,347,348,351],{},"Generics + trait bounds = ",[18,349,350],{},"static dispatch"," (inlined, zero-cost, code duplication per type).",[242,353,354,357,358,361],{},[38,355,356],{},"dyn Trait"," = ",[18,359,360],{},"dynamic dispatch"," via vtable (one copy, indirect call, slightly slower, enables heterogeneous collections).",[23,363,365],{"id":364},"trait-object-requirements-object-safety","Trait Object Requirements (Object Safety)",[14,367,368],{},"A trait is object-safe iff:",[239,370,371,378,381,391],{},[242,372,373,374,377],{},"No associated functions \u002F methods returning ",[38,375,376],{},"Self"," (by value).",[242,379,380],{},"No generics in methods.",[242,382,383,384,386,387,390],{},"All methods take ",[38,385,75],{}," by reference (or have ",[38,388,389],{},"where Self: Sized",").",[242,392,393,396],{},[38,394,395],{},"Self: Sized"," super-bound disqualifies.",[14,398,399,402,403,402,406,409,410,124,413,124,416,419],{},[38,400,401],{},"Clone","\u002F",[38,404,405],{},"Iterator",[38,407,408],{},"PartialEq"," aren't object-safe. ",[38,411,412],{},"Greet",[38,414,415],{},"Display",[38,417,418],{},"Debug"," are.",[28,421,422],{"language":30},[32,423,425],{"className":34,"code":424,"language":30,"meta":36,"style":36},"let v: Vec\u003CBox\u003Cdyn Greet>> = vec![Box::new(User { name: \"a\".into() })];\n",[38,426,427],{"__ignoreMap":36},[41,428,429,432,435,437,440,442,444,446,448,450,453,456,459,461,463,466,469,471,474,476,478,481,483,486],{"class":43,"line":44},[41,430,431],{"class":47},"let",[41,433,434],{"class":55}," v",[41,436,173],{"class":47},[41,438,439],{"class":51}," Vec",[41,441,280],{"class":55},[41,443,327],{"class":51},[41,445,280],{"class":55},[41,447,332],{"class":47},[41,449,52],{"class":51},[41,451,452],{"class":55},">> ",[41,454,455],{"class":47},"=",[41,457,458],{"class":51}," vec!",[41,460,298],{"class":55},[41,462,327],{"class":51},[41,464,465],{"class":47},"::",[41,467,468],{"class":51},"new",[41,470,68],{"class":55},[41,472,473],{"class":51},"User",[41,475,170],{"class":55},[41,477,173],{"class":47},[41,479,480],{"class":120}," \"a\"",[41,482,129],{"class":47},[41,484,485],{"class":51},"into",[41,487,488],{"class":55},"() })];\n",[23,490,492],{"id":491},"default-type-parameters-and-associated-types","Default Type Parameters and Associated Types",[494,495,497],"h3",{"id":496},"generics-vs-associated-types","Generics vs Associated Types",[28,499,500],{"language":30},[32,501,503],{"className":34,"code":502,"language":30,"meta":36,"style":36},"\u002F\u002F Generic trait — caller picks T:\ntrait Container\u003CT> { fn item(&self) -> &T; }\n\n\u002F\u002F Associated type — impl picks the type:\ntrait Container { type Item; fn item(&self) -> &Self::Item; }\n",[38,504,505,510,546,550,555],{"__ignoreMap":36},[41,506,507],{"class":43,"line":44},[41,508,509],{"class":138},"\u002F\u002F Generic trait — caller picks T:\n",[41,511,512,514,517,519,521,524,526,529,531,533,535,537,539,541,543],{"class":43,"line":59},[41,513,48],{"class":47},[41,515,516],{"class":51}," Container",[41,518,280],{"class":55},[41,520,283],{"class":51},[41,522,523],{"class":55},"> { ",[41,525,274],{"class":47},[41,527,528],{"class":51}," item",[41,530,68],{"class":55},[41,532,71],{"class":47},[41,534,75],{"class":74},[41,536,78],{"class":55},[41,538,81],{"class":47},[41,540,295],{"class":47},[41,542,283],{"class":51},[41,544,545],{"class":55},"; }\n",[41,547,548],{"class":43,"line":90},[41,549,158],{"emptyLinePlaceholder":157},[41,551,552],{"class":43,"line":112},[41,553,554],{"class":138},"\u002F\u002F Associated type — impl picks the type:\n",[41,556,557,559,561,563,566,569,572,574,576,578,580,582,584,586,588,590,592,595],{"class":43,"line":142},[41,558,48],{"class":47},[41,560,516],{"class":51},[41,562,215],{"class":55},[41,564,565],{"class":47},"type",[41,567,568],{"class":51}," Item",[41,570,571],{"class":55},"; ",[41,573,274],{"class":47},[41,575,528],{"class":51},[41,577,68],{"class":55},[41,579,71],{"class":47},[41,581,75],{"class":74},[41,583,78],{"class":55},[41,585,81],{"class":47},[41,587,295],{"class":47},[41,589,376],{"class":74},[41,591,465],{"class":47},[41,593,594],{"class":51},"Item",[41,596,545],{"class":55},[14,598,599,600,603,604,607,608,390],{},"Use associated types when each type has ",[18,601,602],{},"one"," natural inner type (e.g., ",[38,605,606],{},"Iterator::Item","). Use generics when the type can carry multiple variants (e.g., ",[38,609,610],{},"From\u003CT>",[494,612,614],{"id":613},"default-associated-type","Default Associated Type",[28,616,617],{"language":30},[32,618,620],{"className":34,"code":619,"language":30,"meta":36,"style":36},"trait Rng { type Output = u64; fn next(&self) -> Self::Output; }\n",[38,621,622],{"__ignoreMap":36},[41,623,624,626,629,631,633,636,639,642,644,646,649,651,653,655,657,659,662,664,667],{"class":43,"line":44},[41,625,48],{"class":47},[41,627,628],{"class":51}," Rng",[41,630,215],{"class":55},[41,632,565],{"class":47},[41,634,635],{"class":51}," Output",[41,637,638],{"class":47}," =",[41,640,641],{"class":51}," u64",[41,643,571],{"class":55},[41,645,274],{"class":47},[41,647,648],{"class":51}," next",[41,650,68],{"class":55},[41,652,71],{"class":47},[41,654,75],{"class":74},[41,656,78],{"class":55},[41,658,81],{"class":47},[41,660,661],{"class":74}," Self",[41,663,465],{"class":47},[41,665,666],{"class":51},"Output",[41,668,545],{"class":55},[23,670,672],{"id":671},"trait-bounds","Trait Bounds",[28,674,675],{"language":30},[32,676,678],{"className":34,"code":677,"language":30,"meta":36,"style":36},"fn max\u003CT: PartialOrd + Copy>(a: T, b: T) -> T { if a > b { a } else { b } }\n\nfn sum_all\u003CT>(items: &[T]) -> T\nwhere\n    T: Sum + Copy,\n{\n    items.iter().copied().sum()\n}\n",[38,679,680,743,747,776,781,798,803,831],{"__ignoreMap":36},[41,681,682,684,687,689,691,693,696,699,702,705,707,710,713,715,717,719,721,723,725,728,731,734,737,740],{"class":43,"line":44},[41,683,274],{"class":47},[41,685,686],{"class":51}," max",[41,688,280],{"class":55},[41,690,283],{"class":51},[41,692,173],{"class":47},[41,694,695],{"class":51}," PartialOrd",[41,697,698],{"class":47}," +",[41,700,701],{"class":51}," Copy",[41,703,704],{"class":55},">(a",[41,706,173],{"class":47},[41,708,709],{"class":51}," T",[41,711,712],{"class":55},", b",[41,714,173],{"class":47},[41,716,709],{"class":51},[41,718,78],{"class":55},[41,720,81],{"class":47},[41,722,709],{"class":51},[41,724,215],{"class":55},[41,726,727],{"class":47},"if",[41,729,730],{"class":55}," a ",[41,732,733],{"class":47},">",[41,735,736],{"class":55}," b { a } ",[41,738,739],{"class":47},"else",[41,741,742],{"class":55}," { b } }\n",[41,744,745],{"class":43,"line":59},[41,746,158],{"emptyLinePlaceholder":157},[41,748,749,751,754,756,758,760,762,764,766,768,771,773],{"class":43,"line":90},[41,750,274],{"class":47},[41,752,753],{"class":51}," sum_all",[41,755,280],{"class":55},[41,757,283],{"class":51},[41,759,290],{"class":55},[41,761,173],{"class":47},[41,763,295],{"class":47},[41,765,298],{"class":55},[41,767,283],{"class":51},[41,769,770],{"class":55},"]) ",[41,772,81],{"class":47},[41,774,775],{"class":51}," T\n",[41,777,778],{"class":43,"line":112},[41,779,780],{"class":47},"where\n",[41,782,783,786,788,791,793,795],{"class":43,"line":142},[41,784,785],{"class":51},"    T",[41,787,173],{"class":47},[41,789,790],{"class":51}," Sum",[41,792,698],{"class":47},[41,794,701],{"class":51},[41,796,797],{"class":55},",\n",[41,799,800],{"class":43,"line":148},[41,801,802],{"class":55},"{\n",[41,804,805,808,810,813,816,818,821,823,825,828],{"class":43,"line":154},[41,806,807],{"class":55},"    items",[41,809,129],{"class":47},[41,811,812],{"class":51},"iter",[41,814,815],{"class":55},"()",[41,817,129],{"class":47},[41,819,820],{"class":51},"copied",[41,822,815],{"class":55},[41,824,129],{"class":47},[41,826,827],{"class":51},"sum",[41,829,830],{"class":55},"()\n",[41,832,833],{"class":43,"line":161},[41,834,151],{"class":55},[14,836,837,840],{},[38,838,839],{},"where"," clauses are more readable for long bounds and enable more expressiveness (bounds on associated types, lifetimes).",[23,842,844],{"id":843},"impl-trait",[38,845,846],{},"impl Trait",[494,848,850],{"id":849},"in-argument-position","In argument position",[28,852,853],{"language":30},[32,854,856],{"className":34,"code":855,"language":30,"meta":36,"style":36},"fn print(it: impl Iterator\u003CItem = i32>) { \u002F* ... *\u002F }\n\u002F\u002F equivalent to:\nfn print\u003CT: Iterator\u003CItem = i32>>(it: T) { \u002F* ... *\u002F }\n",[38,857,858,893,898],{"__ignoreMap":36},[41,859,860,862,865,868,870,873,876,878,880,882,885,888,891],{"class":43,"line":44},[41,861,274],{"class":47},[41,863,864],{"class":51}," print",[41,866,867],{"class":55},"(it",[41,869,173],{"class":47},[41,871,872],{"class":47}," impl",[41,874,875],{"class":51}," Iterator",[41,877,280],{"class":55},[41,879,594],{"class":51},[41,881,638],{"class":47},[41,883,884],{"class":51}," i32",[41,886,887],{"class":55},">) { ",[41,889,890],{"class":138},"\u002F* ... *\u002F",[41,892,178],{"class":55},[41,894,895],{"class":43,"line":59},[41,896,897],{"class":138},"\u002F\u002F equivalent to:\n",[41,899,900,902,904,906,908,910,912,914,916,918,920,923,925,927,930,932],{"class":43,"line":90},[41,901,274],{"class":47},[41,903,864],{"class":51},[41,905,280],{"class":55},[41,907,283],{"class":51},[41,909,173],{"class":47},[41,911,875],{"class":51},[41,913,280],{"class":55},[41,915,594],{"class":51},[41,917,638],{"class":47},[41,919,884],{"class":51},[41,921,922],{"class":55},">>(it",[41,924,173],{"class":47},[41,926,709],{"class":51},[41,928,929],{"class":55},") { ",[41,931,890],{"class":138},[41,933,178],{"class":55},[494,935,937],{"id":936},"in-return-position","In return position",[28,939,940],{"language":30},[32,941,943],{"className":34,"code":942,"language":30,"meta":36,"style":36},"fn counter() -> impl Iterator\u003CItem = u32> {\n    (0..5).map(|x| x * 2)\n}\n",[38,944,945,973,1017],{"__ignoreMap":36},[41,946,947,949,952,955,957,959,961,963,965,967,970],{"class":43,"line":44},[41,948,274],{"class":47},[41,950,951],{"class":51}," counter",[41,953,954],{"class":55},"() ",[41,956,81],{"class":47},[41,958,872],{"class":47},[41,960,875],{"class":51},[41,962,280],{"class":55},[41,964,594],{"class":51},[41,966,638],{"class":47},[41,968,969],{"class":51}," u32",[41,971,972],{"class":55},"> {\n",[41,974,975,978,981,984,987,990,992,995,997,1000,1003,1005,1008,1011,1014],{"class":43,"line":59},[41,976,977],{"class":55},"    (",[41,979,980],{"class":74},"0",[41,982,983],{"class":47},"..",[41,985,986],{"class":74},"5",[41,988,989],{"class":55},")",[41,991,129],{"class":47},[41,993,994],{"class":51},"map",[41,996,68],{"class":55},[41,998,999],{"class":47},"|",[41,1001,1002],{"class":55},"x",[41,1004,999],{"class":47},[41,1006,1007],{"class":55}," x ",[41,1009,1010],{"class":47},"*",[41,1012,1013],{"class":74}," 2",[41,1015,1016],{"class":55},")\n",[41,1018,1019],{"class":43,"line":90},[41,1020,151],{"class":55},[239,1022,1023,1031,1037,1040],{},[242,1024,1025,1026,1030],{},"Returns ",[1027,1028,1029],"em",{},"some"," concrete type that implements the trait — the actual type is hidden from the caller.",[242,1032,1033,1034,390],{},"Cannot be conditional (no ",[38,1035,1036],{},"if cond { type A } else { type B }",[242,1038,1039],{},"Each return-site must use a single concrete type.",[242,1041,1042,1043,1046],{},"For returning different types, use ",[38,1044,1045],{},"Box\u003Cdyn Trait>"," or trait objects.",[23,1048,1050],{"id":1049},"common-standard-traits","Common Standard Traits",[1052,1053,1054,1067],"table",{},[1055,1056,1057],"thead",{},[1058,1059,1060,1064],"tr",{},[1061,1062,1063],"th",{},"Trait",[1061,1065,1066],{},"Purpose",[1068,1069,1070,1083,1095,1107,1119,1132,1142,1154,1173,1186,1195,1214,1229,1239,1249,1262,1275],"tbody",{},[1058,1071,1072,1077],{},[1073,1074,1075],"td",{},[38,1076,415],{},[1073,1078,1079,1080,989],{},"User-facing string (",[38,1081,1082],{},"{}",[1058,1084,1085,1089],{},[1073,1086,1087],{},[38,1088,418],{},[1073,1090,1091,1092,989],{},"Developer string (",[38,1093,1094],{},"{:?}",[1058,1096,1097,1104],{},[1073,1098,1099,124,1101],{},[38,1100,401],{},[38,1102,1103],{},"Copy",[1073,1105,1106],{},"Duplication",[1058,1108,1109,1116],{},[1073,1110,1111,124,1113],{},[38,1112,408],{},[38,1114,1115],{},"Eq",[1073,1117,1118],{},"Equality",[1058,1120,1121,1129],{},[1073,1122,1123,124,1126],{},[38,1124,1125],{},"PartialOrd",[38,1127,1128],{},"Ord",[1073,1130,1131],{},"Ordering",[1058,1133,1134,1139],{},[1073,1135,1136],{},[38,1137,1138],{},"Hash",[1073,1140,1141],{},"Hashing",[1058,1143,1144,1149],{},[1073,1145,1146],{},[38,1147,1148],{},"Default",[1073,1150,1151],{},[38,1152,1153],{},"Default::default()",[1058,1155,1156,1170],{},[1073,1157,1158,124,1161,124,1164,124,1167],{},[38,1159,1160],{},"From",[38,1162,1163],{},"Into",[38,1165,1166],{},"TryFrom",[38,1168,1169],{},"TryInto",[1073,1171,1172],{},"Conversions",[1058,1174,1175,1183],{},[1073,1176,1177,124,1180],{},[38,1178,1179],{},"AsRef",[38,1181,1182],{},"AsMut",[1073,1184,1185],{},"Cheap borrows",[1058,1187,1188,1192],{},[1073,1189,1190],{},[38,1191,405],{},[1073,1193,1194],{},"Iteration",[1058,1196,1197,1211],{},[1073,1198,1199,124,1202,124,1205,124,1208],{},[38,1200,1201],{},"Add",[38,1203,1204],{},"Sub",[38,1206,1207],{},"Mul",[38,1209,1210],{},"Div",[1073,1212,1213],{},"Operator overloading",[1058,1215,1216,1224],{},[1073,1217,1218,124,1221],{},[38,1219,1220],{},"Index",[38,1222,1223],{},"IndexMut",[1073,1225,1226],{},[38,1227,1228],{},"[]",[1058,1230,1231,1236],{},[1073,1232,1233],{},[38,1234,1235],{},"Drop",[1073,1237,1238],{},"Destructor",[1058,1240,1241,1246],{},[1073,1242,1243],{},[38,1244,1245],{},"Sized",[1073,1247,1248],{},"Has a known size",[1058,1250,1251,1259],{},[1073,1252,1253,124,1256],{},[38,1254,1255],{},"Send",[38,1257,1258],{},"Sync",[1073,1260,1261],{},"Thread safety (auto)",[1058,1263,1264,1272],{},[1073,1265,1266,124,1269],{},[38,1267,1268],{},"Unpin",[38,1270,1271],{},"Pin",[1073,1273,1274],{},"Async\u002Fpinning",[1058,1276,1277,1288],{},[1073,1278,1279,124,1282,124,1285],{},[38,1280,1281],{},"Fn",[38,1283,1284],{},"FnMut",[38,1286,1287],{},"FnOnce",[1073,1289,1290],{},"Closures",[23,1292,1294,1296,1297],{"id":1293},"from-and-into",[38,1295,1160],{}," and ",[38,1298,1163],{},[28,1300,1301],{"language":30},[32,1302,1304],{"className":34,"code":1303,"language":30,"meta":36,"style":36},"impl From\u003Ci32> for My { fn from(x: i32) -> Self { \u002F* ... *\u002F } }\nlet m: My = 5i32.into();\n",[38,1305,1306,1354],{"__ignoreMap":36},[41,1307,1308,1310,1313,1315,1318,1321,1324,1327,1329,1331,1334,1337,1339,1341,1343,1345,1347,1349,1351],{"class":43,"line":44},[41,1309,184],{"class":47},[41,1311,1312],{"class":51}," From",[41,1314,280],{"class":55},[41,1316,1317],{"class":51},"i32",[41,1319,1320],{"class":55},"> ",[41,1322,1323],{"class":47},"for",[41,1325,1326],{"class":51}," My",[41,1328,215],{"class":55},[41,1330,274],{"class":47},[41,1332,1333],{"class":51}," from",[41,1335,1336],{"class":55},"(x",[41,1338,173],{"class":47},[41,1340,884],{"class":51},[41,1342,78],{"class":55},[41,1344,81],{"class":47},[41,1346,661],{"class":74},[41,1348,215],{"class":55},[41,1350,890],{"class":138},[41,1352,1353],{"class":55}," } }\n",[41,1355,1356,1358,1361,1363,1365,1367,1370,1372,1374,1376],{"class":43,"line":59},[41,1357,431],{"class":47},[41,1359,1360],{"class":55}," m",[41,1362,173],{"class":47},[41,1364,1326],{"class":51},[41,1366,638],{"class":47},[41,1368,1369],{"class":74}," 5",[41,1371,1317],{"class":51},[41,1373,129],{"class":47},[41,1375,485],{"class":51},[41,1377,1378],{"class":55},"();\n",[14,1380,1381,1382,1384,1385,1387,1388,1390,1391,1393],{},"Implementing ",[38,1383,1160],{}," automatically gives you ",[38,1386,1163],{},". Idiomatic: implement ",[38,1389,1160],{},", never ",[38,1392,1163],{}," directly.",[14,1395,1396,1399,1400,1403],{},[38,1397,1398],{},"FromStr"," is the parsing version (",[38,1401,1402],{},"str::parse()"," uses it).",[23,1405,1407,1296,1409],{"id":1406},"asref-and-asmut",[38,1408,1179],{},[38,1410,1182],{},[28,1412,1413],{"language":30},[32,1414,1416],{"className":34,"code":1415,"language":30,"meta":36,"style":36},"fn open\u003CP: AsRef\u003CPath>>(path: P) { let p = path.as_ref(); \u002F* p: &Path *\u002F }\nopen(\"file.txt\");           \u002F\u002F &str: AsRef\u003CPath>\nopen(Path::new(\"f\"));       \u002F\u002F &Path: AsRef\u003CPath>\nopen(String::from(\"f\"));    \u002F\u002F String: AsRef\u003CPath>\n",[38,1417,1418,1473,1489,1512],{"__ignoreMap":36},[41,1419,1420,1422,1425,1427,1430,1432,1435,1437,1440,1443,1445,1448,1450,1452,1455,1457,1460,1462,1465,1468,1471],{"class":43,"line":44},[41,1421,274],{"class":47},[41,1423,1424],{"class":51}," open",[41,1426,280],{"class":55},[41,1428,1429],{"class":51},"P",[41,1431,173],{"class":47},[41,1433,1434],{"class":51}," AsRef",[41,1436,280],{"class":55},[41,1438,1439],{"class":51},"Path",[41,1441,1442],{"class":55},">>(path",[41,1444,173],{"class":47},[41,1446,1447],{"class":51}," P",[41,1449,929],{"class":55},[41,1451,431],{"class":47},[41,1453,1454],{"class":55}," p ",[41,1456,455],{"class":47},[41,1458,1459],{"class":55}," path",[41,1461,129],{"class":47},[41,1463,1464],{"class":51},"as_ref",[41,1466,1467],{"class":55},"(); ",[41,1469,1470],{"class":138},"\u002F* p: &Path *\u002F",[41,1472,178],{"class":55},[41,1474,1475,1478,1480,1483,1486],{"class":43,"line":59},[41,1476,1477],{"class":51},"open",[41,1479,68],{"class":55},[41,1481,1482],{"class":120},"\"file.txt\"",[41,1484,1485],{"class":55},");           ",[41,1487,1488],{"class":138},"\u002F\u002F &str: AsRef\u003CPath>\n",[41,1490,1491,1493,1495,1497,1499,1501,1503,1506,1509],{"class":43,"line":90},[41,1492,1477],{"class":51},[41,1494,68],{"class":55},[41,1496,1439],{"class":51},[41,1498,465],{"class":47},[41,1500,468],{"class":51},[41,1502,68],{"class":55},[41,1504,1505],{"class":120},"\"f\"",[41,1507,1508],{"class":55},"));       ",[41,1510,1511],{"class":138},"\u002F\u002F &Path: AsRef\u003CPath>\n",[41,1513,1514,1516,1518,1521,1523,1526,1528,1530,1533],{"class":43,"line":112},[41,1515,1477],{"class":51},[41,1517,68],{"class":55},[41,1519,1520],{"class":51},"String",[41,1522,465],{"class":47},[41,1524,1525],{"class":51},"from",[41,1527,68],{"class":55},[41,1529,1505],{"class":120},[41,1531,1532],{"class":55},"));    ",[41,1534,1535],{"class":138},"\u002F\u002F String: AsRef\u003CPath>\n",[14,1537,1538,1539,1542,1543,124,1546,124,1548,124,1551,1554],{},"Multi-source APIs use ",[38,1540,1541],{},"AsRef\u003CT>"," to accept ",[38,1544,1545],{},"&str",[38,1547,1520],{},[38,1549,1550],{},"&Path",[38,1552,1553],{},"&OsStr",", etc.",[23,1556,1558],{"id":1557},"operator-overloading","Operator Overloading",[28,1560,1561],{"language":30},[32,1562,1564],{"className":34,"code":1563,"language":30,"meta":36,"style":36},"use std::ops::Add;\nstruct Vec2 { x: f64, y: f64 }\nimpl Add for Vec2 {\n    type Output = Vec2;\n    fn add(self, rhs: Vec2) -> Vec2 { Vec2 { x: self.x + rhs.x, y: self.y + rhs.y } }\n}\nlet v = Vec2 { x: 1.0, y: 0.0 } + Vec2 { x: 0.0, y: 1.0 };\n",[38,1565,1566,1585,1609,1622,1635,1705,1709],{"__ignoreMap":36},[41,1567,1568,1571,1574,1576,1579,1581,1583],{"class":43,"line":44},[41,1569,1570],{"class":47},"use",[41,1572,1573],{"class":51}," std",[41,1575,465],{"class":47},[41,1577,1578],{"class":51},"ops",[41,1580,465],{"class":47},[41,1582,1201],{"class":51},[41,1584,87],{"class":55},[41,1586,1587,1589,1592,1595,1597,1600,1603,1605,1607],{"class":43,"line":59},[41,1588,164],{"class":47},[41,1590,1591],{"class":51}," Vec2",[41,1593,1594],{"class":55}," { x",[41,1596,173],{"class":47},[41,1598,1599],{"class":51}," f64",[41,1601,1602],{"class":55},", y",[41,1604,173],{"class":47},[41,1606,1599],{"class":51},[41,1608,178],{"class":55},[41,1610,1611,1613,1616,1618,1620],{"class":43,"line":90},[41,1612,184],{"class":47},[41,1614,1615],{"class":51}," Add",[41,1617,189],{"class":47},[41,1619,1591],{"class":51},[41,1621,56],{"class":55},[41,1623,1624,1627,1629,1631,1633],{"class":43,"line":112},[41,1625,1626],{"class":47},"    type",[41,1628,635],{"class":51},[41,1630,638],{"class":47},[41,1632,1591],{"class":51},[41,1634,87],{"class":55},[41,1636,1637,1639,1642,1644,1646,1649,1651,1653,1655,1657,1659,1661,1664,1666,1668,1671,1673,1676,1679,1682,1684,1687,1689,1691,1693,1696,1698,1700,1702],{"class":43,"line":142},[41,1638,62],{"class":47},[41,1640,1641],{"class":51}," add",[41,1643,68],{"class":55},[41,1645,75],{"class":74},[41,1647,1648],{"class":55},", rhs",[41,1650,173],{"class":47},[41,1652,1591],{"class":51},[41,1654,78],{"class":55},[41,1656,81],{"class":47},[41,1658,1591],{"class":51},[41,1660,215],{"class":55},[41,1662,1663],{"class":51},"Vec2",[41,1665,1594],{"class":55},[41,1667,173],{"class":47},[41,1669,1670],{"class":74}," self",[41,1672,129],{"class":47},[41,1674,1675],{"class":55},"x ",[41,1677,1678],{"class":47},"+",[41,1680,1681],{"class":55}," rhs",[41,1683,129],{"class":47},[41,1685,1686],{"class":55},"x, y",[41,1688,173],{"class":47},[41,1690,1670],{"class":74},[41,1692,129],{"class":47},[41,1694,1695],{"class":55},"y ",[41,1697,1678],{"class":47},[41,1699,1681],{"class":55},[41,1701,129],{"class":47},[41,1703,1704],{"class":55},"y } }\n",[41,1706,1707],{"class":43,"line":148},[41,1708,151],{"class":55},[41,1710,1711,1713,1716,1718,1720,1722,1724,1727,1729,1731,1734,1737,1739,1741,1743,1745,1747,1749,1751,1753],{"class":43,"line":154},[41,1712,431],{"class":47},[41,1714,1715],{"class":55}," v ",[41,1717,455],{"class":47},[41,1719,1591],{"class":51},[41,1721,1594],{"class":55},[41,1723,173],{"class":47},[41,1725,1726],{"class":74}," 1.0",[41,1728,1602],{"class":55},[41,1730,173],{"class":47},[41,1732,1733],{"class":74}," 0.0",[41,1735,1736],{"class":55}," } ",[41,1738,1678],{"class":47},[41,1740,1591],{"class":51},[41,1742,1594],{"class":55},[41,1744,173],{"class":47},[41,1746,1733],{"class":74},[41,1748,1602],{"class":55},[41,1750,173],{"class":47},[41,1752,1726],{"class":74},[41,1754,1755],{"class":55}," };\n",[14,1757,1758,1759,124,1761,124,1763,124,1765,124,1767,124,1770,124,1773,124,1775,124,1777,124,1780,124,1783,124,1786,124,1789,124,1792,124,1795,1554],{},"You can overload ",[38,1760,1201],{},[38,1762,1204],{},[38,1764,1207],{},[38,1766,1210],{},[38,1768,1769],{},"Rem",[38,1771,1772],{},"Neg",[38,1774,1220],{},[38,1776,1223],{},[38,1778,1779],{},"Deref",[38,1781,1782],{},"DerefMut",[38,1784,1785],{},"BitAnd",[38,1787,1788],{},"BitOr",[38,1790,1791],{},"Shl",[38,1793,1794],{},"Shr",[38,1796,1797],{},"Fn*",[23,1799,1801,1803],{"id":1800},"deref-coercion",[38,1802,1779],{}," Coercion",[28,1805,1806],{"language":30},[32,1807,1809],{"className":34,"code":1808,"language":30,"meta":36,"style":36},"impl Deref for My { type Target = Inner; fn deref(&self) -> &Inner { &self.inner } }\nlet m = My { inner: Inner { x: 5 } };\nlet x = m.x;     \u002F\u002F m.x works via Deref coercion\n",[38,1810,1811,1867,1894],{"__ignoreMap":36},[41,1812,1813,1815,1818,1820,1822,1824,1826,1829,1831,1834,1836,1838,1841,1843,1845,1847,1849,1851,1853,1856,1858,1860,1862,1864],{"class":43,"line":44},[41,1814,184],{"class":47},[41,1816,1817],{"class":51}," Deref",[41,1819,189],{"class":47},[41,1821,1326],{"class":51},[41,1823,215],{"class":55},[41,1825,565],{"class":47},[41,1827,1828],{"class":51}," Target",[41,1830,638],{"class":47},[41,1832,1833],{"class":51}," Inner",[41,1835,571],{"class":55},[41,1837,274],{"class":47},[41,1839,1840],{"class":51}," deref",[41,1842,68],{"class":55},[41,1844,71],{"class":47},[41,1846,75],{"class":74},[41,1848,78],{"class":55},[41,1850,81],{"class":47},[41,1852,295],{"class":47},[41,1854,1855],{"class":51},"Inner",[41,1857,215],{"class":55},[41,1859,71],{"class":47},[41,1861,75],{"class":74},[41,1863,129],{"class":47},[41,1865,1866],{"class":55},"inner } }\n",[41,1868,1869,1871,1874,1876,1878,1881,1883,1885,1887,1889,1891],{"class":43,"line":59},[41,1870,431],{"class":47},[41,1872,1873],{"class":55}," m ",[41,1875,455],{"class":47},[41,1877,1326],{"class":51},[41,1879,1880],{"class":55}," { inner",[41,1882,173],{"class":47},[41,1884,1833],{"class":51},[41,1886,1594],{"class":55},[41,1888,173],{"class":47},[41,1890,1369],{"class":74},[41,1892,1893],{"class":55}," } };\n",[41,1895,1896,1898,1900,1902,1904,1906,1909],{"class":43,"line":90},[41,1897,431],{"class":47},[41,1899,1007],{"class":55},[41,1901,455],{"class":47},[41,1903,1360],{"class":55},[41,1905,129],{"class":47},[41,1907,1908],{"class":55},"x;     ",[41,1910,1911],{"class":138},"\u002F\u002F m.x works via Deref coercion\n",[14,1913,1914,124,1917,124,1920,1923,1924,1926],{},[38,1915,1916],{},"String: Deref\u003CTarget = str>",[38,1918,1919],{},"Vec\u003CT>: Deref\u003CTarget = [T]>",[38,1921,1922],{},"Box\u003CT>: Deref\u003CTarget = T>",". This enables method\u002Ffield forwarding and ",[38,1925,71],{},"-coercions.",[14,1928,1929,1932,1933,1935],{},[18,1930,1931],{},"Don't"," abuse ",[38,1934,1779],{}," for inheritance — it's a memory-layout mechanism, not a modeling tool.",[23,1937,1939],{"id":1938},"drop",[38,1940,1235],{},[28,1942,1943],{"language":30},[32,1944,1946],{"className":34,"code":1945,"language":30,"meta":36,"style":36},"impl Drop for File {\n    fn drop(&mut self) {\n        \u002F\u002F close file, free resources\n    }\n}\n",[38,1947,1948,1962,1979,1984,1988],{"__ignoreMap":36},[41,1949,1950,1952,1955,1957,1960],{"class":43,"line":44},[41,1951,184],{"class":47},[41,1953,1954],{"class":51}," Drop",[41,1956,189],{"class":47},[41,1958,1959],{"class":51}," File",[41,1961,56],{"class":55},[41,1963,1964,1966,1969,1971,1974,1976],{"class":43,"line":59},[41,1965,62],{"class":47},[41,1967,1968],{"class":51}," drop",[41,1970,68],{"class":55},[41,1972,1973],{"class":47},"&mut",[41,1975,1670],{"class":74},[41,1977,1978],{"class":55},") {\n",[41,1980,1981],{"class":43,"line":90},[41,1982,1983],{"class":138},"        \u002F\u002F close file, free resources\n",[41,1985,1986],{"class":43,"line":112},[41,1987,145],{"class":55},[41,1989,1990],{"class":43,"line":142},[41,1991,151],{"class":55},[14,1993,1994,1995,1998],{},"Runs automatically at scope end. Don't call directly — use ",[38,1996,1997],{},"std::mem::drop(value)"," to drop early.",[23,2000,2002],{"id":2001},"supertraits","Supertraits",[28,2004,2005],{"language":30},[32,2006,2008],{"className":34,"code":2007,"language":30,"meta":36,"style":36},"trait Pretty: Debug { fn pretty(&self) { \u002F* can use {:?} *\u002F } }\n",[38,2009,2010],{"__ignoreMap":36},[41,2011,2012,2014,2017,2019,2022,2024,2026,2029,2031,2033,2035,2037,2040],{"class":43,"line":44},[41,2013,48],{"class":47},[41,2015,2016],{"class":51}," Pretty",[41,2018,173],{"class":47},[41,2020,2021],{"class":51}," Debug",[41,2023,215],{"class":55},[41,2025,274],{"class":47},[41,2027,2028],{"class":51}," pretty",[41,2030,68],{"class":55},[41,2032,71],{"class":47},[41,2034,75],{"class":74},[41,2036,929],{"class":55},[41,2038,2039],{"class":138},"\u002F* can use {:?} *\u002F",[41,2041,1353],{"class":55},[14,2043,2044],{},"A supertrait bound means \"any type implementing Pretty must also implement Debug\".",[23,2046,2048],{"id":2047},"trait-composition","Trait Composition",[28,2050,2051],{"language":30},[32,2052,2054],{"className":34,"code":2053,"language":30,"meta":36,"style":36},"trait Read: io::Read + BufRead {}\nimpl\u003CT: io::Read + BufRead> Read for T {}\n",[38,2055,2056,2081],{"__ignoreMap":36},[41,2057,2058,2060,2063,2065,2068,2070,2073,2075,2078],{"class":43,"line":44},[41,2059,48],{"class":47},[41,2061,2062],{"class":51}," Read",[41,2064,173],{"class":47},[41,2066,2067],{"class":51}," io",[41,2069,465],{"class":47},[41,2071,2072],{"class":51},"Read",[41,2074,698],{"class":47},[41,2076,2077],{"class":51}," BufRead",[41,2079,2080],{"class":55}," {}\n",[41,2082,2083,2085,2087,2089,2091,2093,2095,2097,2099,2101,2103,2105,2107,2109],{"class":43,"line":59},[41,2084,184],{"class":47},[41,2086,280],{"class":55},[41,2088,283],{"class":51},[41,2090,173],{"class":47},[41,2092,2067],{"class":51},[41,2094,465],{"class":47},[41,2096,2072],{"class":51},[41,2098,698],{"class":47},[41,2100,2077],{"class":51},[41,2102,1320],{"class":55},[41,2104,2072],{"class":51},[41,2106,189],{"class":47},[41,2108,709],{"class":51},[41,2110,2080],{"class":55},[14,2112,2113],{},"Blanket impl gives any type with both underlying traits the composite trait.",[23,2115,2117],{"id":2116},"blanket-implementations","Blanket Implementations",[28,2119,2120],{"language":30},[32,2121,2123],{"className":34,"code":2122,"language":30,"meta":36,"style":36},"impl\u003CT: Display> ToString for T {\n    fn to_string(&self) -> String { \u002F* ... *\u002F }\n}\n",[38,2124,2125,2149,2174],{"__ignoreMap":36},[41,2126,2127,2129,2131,2133,2135,2138,2140,2143,2145,2147],{"class":43,"line":44},[41,2128,184],{"class":47},[41,2130,280],{"class":55},[41,2132,283],{"class":51},[41,2134,173],{"class":47},[41,2136,2137],{"class":51}," Display",[41,2139,1320],{"class":55},[41,2141,2142],{"class":51},"ToString",[41,2144,189],{"class":47},[41,2146,709],{"class":51},[41,2148,56],{"class":55},[41,2150,2151,2153,2156,2158,2160,2162,2164,2166,2168,2170,2172],{"class":43,"line":59},[41,2152,62],{"class":47},[41,2154,2155],{"class":51}," to_string",[41,2157,68],{"class":55},[41,2159,71],{"class":47},[41,2161,75],{"class":74},[41,2163,78],{"class":55},[41,2165,81],{"class":47},[41,2167,84],{"class":51},[41,2169,215],{"class":55},[41,2171,890],{"class":138},[41,2173,178],{"class":55},[41,2175,2176],{"class":43,"line":90},[41,2177,151],{"class":55},[14,2179,2180],{},"A blanket impl covers all matching types. Powerful but can lock out other impls (orphan-rule implications).",[23,2182,2184],{"id":2183},"traits-with-const-generics","Traits with Const Generics",[28,2186,2187],{"language":30},[32,2188,2190],{"className":34,"code":2189,"language":30,"meta":36,"style":36},"trait Bytes\u003Cconst N: usize> { fn data(&self) -> [u8; N]; }\n",[38,2191,2192],{"__ignoreMap":36},[41,2193,2194,2196,2199,2201,2204,2207,2209,2212,2214,2216,2219,2221,2223,2225,2227,2229,2232,2235,2237,2240],{"class":43,"line":44},[41,2195,48],{"class":47},[41,2197,2198],{"class":51}," Bytes",[41,2200,280],{"class":55},[41,2202,2203],{"class":47},"const",[41,2205,2206],{"class":74}," N",[41,2208,173],{"class":47},[41,2210,2211],{"class":51}," usize",[41,2213,523],{"class":55},[41,2215,274],{"class":47},[41,2217,2218],{"class":51}," data",[41,2220,68],{"class":55},[41,2222,71],{"class":47},[41,2224,75],{"class":74},[41,2226,78],{"class":55},[41,2228,81],{"class":47},[41,2230,2231],{"class":55}," [",[41,2233,2234],{"class":51},"u8",[41,2236,571],{"class":55},[41,2238,2239],{"class":51},"N",[41,2241,2242],{"class":55},"]; }\n",[23,2244,2246],{"id":2245},"marker-traits","Marker Traits",[14,2248,2249,2250,124,2252,124,2254,124,2256,124,2258,2260],{},"Zero-method traits that tag types: ",[38,2251,1245],{},[38,2253,1255],{},[38,2255,1258],{},[38,2257,1268],{},[38,2259,1103],{},". Some are auto-traits (compiler-implemented when possible).",[23,2262,2264],{"id":2263},"sealed-traits","Sealed Traits",[14,2266,2267],{},"To prevent downstream impls while still exposing a stable API:",[28,2269,2270],{"language":30},[32,2271,2273],{"className":34,"code":2272,"language":30,"meta":36,"style":36},"mod private { pub trait Sealed {} }\npub trait Public: private::Sealed { \u002F* ... *\u002F }\n",[38,2274,2275,2297],{"__ignoreMap":36},[41,2276,2277,2280,2283,2285,2288,2291,2294],{"class":43,"line":44},[41,2278,2279],{"class":47},"mod",[41,2281,2282],{"class":51}," private",[41,2284,215],{"class":55},[41,2286,2287],{"class":47},"pub",[41,2289,2290],{"class":47}," trait",[41,2292,2293],{"class":51}," Sealed",[41,2295,2296],{"class":55}," {} }\n",[41,2298,2299,2301,2303,2306,2308,2310,2312,2315,2317,2319],{"class":43,"line":59},[41,2300,2287],{"class":47},[41,2302,2290],{"class":47},[41,2304,2305],{"class":51}," Public",[41,2307,173],{"class":47},[41,2309,2282],{"class":51},[41,2311,465],{"class":47},[41,2313,2314],{"class":51},"Sealed",[41,2316,215],{"class":55},[41,2318,890],{"class":138},[41,2320,178],{"class":55},[14,2322,2323,2324,2326,2327,2330],{},"Downstream types can't implement ",[38,2325,2314],{},", so they can't implement ",[38,2328,2329],{},"Public",". Used by std and many crates for forward compatibility.",[23,2332,2334],{"id":2333},"edge-cases-pitfalls","Edge Cases & Pitfalls",[239,2336,2337,2347,2360,2370,2376,2391,2403,2411,2419,2425],{},[242,2338,2339,2342,2343,2346],{},[18,2340,2341],{},"Orphan rule",": can't implement external trait for external type. Use the ",[18,2344,2345],{},"newtype pattern"," to wrap and implement.",[242,2348,2349,2354,2355,2357,2358,129],{},[18,2350,2351,2353],{},[38,2352,376],{}," returns break object safety",": traits returning ",[38,2356,376],{}," can't be made into ",[38,2359,356],{},[242,2361,2362,2365,2366,2369],{},[18,2363,2364],{},"Method resolution",": when multiple traits provide the same method name, you must write ",[38,2367,2368],{},"Trait::method(&self)"," or use UFCS.",[242,2371,2372,2375],{},[18,2373,2374],{},"Conflicting impls",": blanket impls can cause \"conflicting implementations\" errors; design carefully.",[242,2377,2378,2385,2386,2388,2389,129],{},[18,2379,2380,2382,2383],{},[38,2381,408],{}," vs ",[38,2384,1115],{},": ",[38,2387,1115],{}," is a marker requiring reflexivity; floats lack ",[38,2390,1115],{},[242,2392,2393,2396,2397,2400,2401,129],{},[18,2394,2395],{},"Trait objects can't have generic methods"," at runtime: ",[38,2398,2399],{},"fn dyn_call\u003CT>(&self, x: T)"," is forbidden on ",[38,2402,356],{},[242,2404,2405,2410],{},[18,2406,2407,2409],{},[38,2408,846],{}," in argument position"," is sugar for a generic — not a way to accept trait objects.",[242,2412,2413,2418],{},[18,2414,2415,2417],{},[38,2416,395],{}," bound on a method"," excludes it from the vtable — useful for \"static-only\" methods on an object-safe trait.",[242,2420,2421,2424],{},[18,2422,2423],{},"Generic method on trait object"," is impossible — workaround is to expose concrete variants.",[242,2426,2427,2385,2430,2433],{},[18,2428,2429],{},"Lifetime bounds on traits",[38,2431,2432],{},"trait Foo\u003C'a>"," requires the impl to specify a lifetime; used when methods borrow from inputs.",[23,2435,2437],{"id":2436},"summary","Summary",[14,2439,2440,2441,2443,2444,2446,2447,124,2449,402,2451,2453,2454,2456,2457,2459],{},"Traits define behavior; generics parametrize code; ",[38,2442,846],{}," is sugar for both. Use trait bounds to require capabilities. Object safety decides whether you can use ",[38,2445,356],{},". Implement ",[38,2448,1160],{},[38,2450,415],{},[38,2452,418],{},", and ",[38,2455,1148],{}," for ergonomics. Avoid abusing ",[38,2458,1779],{},". Sealed traits give you stable APIs.",[14,2461,2462],{},"Next: Lifetimes in generics + the deeper type-system chapter.",[2464,2465,2466],"style",{},"html pre.shiki code .svdQ7, html code.shiki .svdQ7{--shiki-default:#D73A49;--shiki-github-dark:#F97583}html pre.shiki code .sIsaT, html code.shiki .sIsaT{--shiki-default:#6F42C1;--shiki-github-dark:#B392F0}html pre.shiki code .ssxIu, html code.shiki .ssxIu{--shiki-default:#24292E;--shiki-github-dark:#E1E4E8}html pre.shiki code .snvgF, html code.shiki .snvgF{--shiki-default:#005CC5;--shiki-github-dark:#79B8FF}html pre.shiki code .sJ6F3, html code.shiki .sJ6F3{--shiki-default:#032F62;--shiki-github-dark:#9ECBFF}html pre.shiki code .sdCPZ, html code.shiki .sdCPZ{--shiki-default:#6A737D;--shiki-github-dark:#6A737D}html .default .shiki span {color: var(--shiki-default);background: var(--shiki-default-bg);font-style: var(--shiki-default-font-style);font-weight: var(--shiki-default-font-weight);text-decoration: var(--shiki-default-text-decoration);}html .shiki span {color: var(--shiki-default);background: var(--shiki-default-bg);font-style: var(--shiki-default-font-style);font-weight: var(--shiki-default-font-weight);text-decoration: var(--shiki-default-text-decoration);}html .github-dark .shiki span {color: var(--shiki-github-dark);background: var(--shiki-github-dark-bg);font-style: var(--shiki-github-dark-font-style);font-weight: var(--shiki-github-dark-font-weight);text-decoration: var(--shiki-github-dark-text-decoration);}html.github-dark .shiki span {color: var(--shiki-github-dark);background: var(--shiki-github-dark-bg);font-style: var(--shiki-github-dark-font-style);font-weight: var(--shiki-github-dark-font-weight);text-decoration: var(--shiki-github-dark-text-decoration);}",{"title":36,"searchDepth":59,"depth":59,"links":2468},[2469,2470,2471,2472,2476,2477,2481,2482,2484,2486,2487,2489,2490,2491,2492,2493,2494,2495,2496,2497],{"id":25,"depth":59,"text":26},{"id":261,"depth":59,"text":262},{"id":364,"depth":59,"text":365},{"id":491,"depth":59,"text":492,"children":2473},[2474,2475],{"id":496,"depth":90,"text":497},{"id":613,"depth":90,"text":614},{"id":671,"depth":59,"text":672},{"id":843,"depth":59,"text":846,"children":2478},[2479,2480],{"id":849,"depth":90,"text":850},{"id":936,"depth":90,"text":937},{"id":1049,"depth":59,"text":1050},{"id":1293,"depth":59,"text":2483},"From and Into",{"id":1406,"depth":59,"text":2485},"AsRef and AsMut",{"id":1557,"depth":59,"text":1558},{"id":1800,"depth":59,"text":2488},"Deref Coercion",{"id":1938,"depth":59,"text":1235},{"id":2001,"depth":59,"text":2002},{"id":2047,"depth":59,"text":2048},{"id":2116,"depth":59,"text":2117},{"id":2183,"depth":59,"text":2184},{"id":2245,"depth":59,"text":2246},{"id":2263,"depth":59,"text":2264},{"id":2333,"depth":59,"text":2334},{"id":2436,"depth":59,"text":2437},"Traits are Rust's answer to interfaces\u002Ftypeclasses — they define shared behavior. Generics parametrize code over types. Together they're the foundation of Rust's abstraction.","md",{},"\u002Frust\u002F16-traits-and-generics",{"title":5,"description":2498},"rust\u002F16-traits-and-generics","kqjte4PGVDwuy5xoF-uoH9R7HlCQgaop87cWnKjIXps",1785944093237]