[{"data":1,"prerenderedAt":2064},["ShallowReactive",2],{"page-\u002Frust\u002F12-enums":3},{"id":4,"title":5,"body":6,"description":16,"extension":2058,"meta":2059,"navigation":104,"path":2060,"seo":2061,"stem":2062,"__hash__":2063},"content\u002Frust\u002F12-enums.md","12 — Enums (Algebraic Data Types)",{"type":7,"value":8,"toc":2033},"minimark",[9,13,17,22,184,192,196,279,307,310,412,419,464,479,602,609,660,663,667,717,720,724,845,851,858,927,942,946,966,1006,1010,1067,1078,1082,1341,1351,1413,1416,1420,1423,1486,1503,1515,1519,1522,1613,1619,1623,1664,1667,1671,1780,1786,1836,1845,1849,1852,1993,2003,2007,2026,2029],[10,11,5],"h1",{"id":12},"_12-enums-algebraic-data-types",[14,15,16],"p",{},"Enums are Rust's killer feature for modeling domain choices. Each variant can carry data of a different shape — they're algebraic data types (ADTs), more like F# discriminated unions than C enums.",[18,19,21],"h2",{"id":20},"basic-enum","Basic Enum",[23,24,26],"code-wrapper",{"language":25},"rust",[27,28,32],"pre",{"className":29,"code":30,"language":25,"meta":31,"style":31},"language-rust shiki shiki-themes github-light github-dark","enum IpAddr {\n    V4(u8, u8, u8, u8),\n    V6(String),\n}\n\nlet v4 = IpAddr::V4(127, 0, 0, 1);\nlet v6 = IpAddr::V6(String::from(\"::1\"));\n","",[33,34,35,52,80,93,99,106,149],"code",{"__ignoreMap":31},[36,37,40,44,48],"span",{"class":38,"line":39},"line",1,[36,41,43],{"class":42},"svdQ7","enum",[36,45,47],{"class":46},"sIsaT"," IpAddr",[36,49,51],{"class":50},"ssxIu"," {\n",[36,53,55,58,61,64,67,69,71,73,75,77],{"class":38,"line":54},2,[36,56,57],{"class":46},"    V4",[36,59,60],{"class":50},"(",[36,62,63],{"class":46},"u8",[36,65,66],{"class":50},", ",[36,68,63],{"class":46},[36,70,66],{"class":50},[36,72,63],{"class":46},[36,74,66],{"class":50},[36,76,63],{"class":46},[36,78,79],{"class":50},"),\n",[36,81,83,86,88,91],{"class":38,"line":82},3,[36,84,85],{"class":46},"    V6",[36,87,60],{"class":50},[36,89,90],{"class":46},"String",[36,92,79],{"class":50},[36,94,96],{"class":38,"line":95},4,[36,97,98],{"class":50},"}\n",[36,100,102],{"class":38,"line":101},5,[36,103,105],{"emptyLinePlaceholder":104},true,"\n",[36,107,109,112,115,118,120,123,126,128,132,134,137,139,141,143,146],{"class":38,"line":108},6,[36,110,111],{"class":42},"let",[36,113,114],{"class":50}," v4 ",[36,116,117],{"class":42},"=",[36,119,47],{"class":46},[36,121,122],{"class":42},"::",[36,124,125],{"class":46},"V4",[36,127,60],{"class":50},[36,129,131],{"class":130},"snvgF","127",[36,133,66],{"class":50},[36,135,136],{"class":130},"0",[36,138,66],{"class":50},[36,140,136],{"class":130},[36,142,66],{"class":50},[36,144,145],{"class":130},"1",[36,147,148],{"class":50},");\n",[36,150,152,154,157,159,161,163,166,168,170,172,175,177,181],{"class":38,"line":151},7,[36,153,111],{"class":42},[36,155,156],{"class":50}," v6 ",[36,158,117],{"class":42},[36,160,47],{"class":46},[36,162,122],{"class":42},[36,164,165],{"class":46},"V6",[36,167,60],{"class":50},[36,169,90],{"class":46},[36,171,122],{"class":42},[36,173,174],{"class":46},"from",[36,176,60],{"class":50},[36,178,180],{"class":179},"sJ6F3","\"::1\"",[36,182,183],{"class":50},"));\n",[14,185,186,187,191],{},"Each variant is a constructor; the enum value is ",[188,189,190],"em",{},"exactly one"," of them.",[18,193,195],{"id":194},"variants-with-named-fields","Variants with Named Fields",[23,197,198],{"language":25},[27,199,201],{"className":29,"code":200,"language":25,"meta":31,"style":31},"enum Message {\n    Quit,\n    Move { x: i32, y: i32 },\n    Write(String),\n    ChangeColor(i32, i32, i32),\n}\n",[33,202,203,212,220,244,255,275],{"__ignoreMap":31},[36,204,205,207,210],{"class":38,"line":39},[36,206,43],{"class":42},[36,208,209],{"class":46}," Message",[36,211,51],{"class":50},[36,213,214,217],{"class":38,"line":54},[36,215,216],{"class":46},"    Quit",[36,218,219],{"class":50},",\n",[36,221,222,225,228,231,234,237,239,241],{"class":38,"line":82},[36,223,224],{"class":46},"    Move",[36,226,227],{"class":50}," { x",[36,229,230],{"class":42},":",[36,232,233],{"class":46}," i32",[36,235,236],{"class":50},", y",[36,238,230],{"class":42},[36,240,233],{"class":46},[36,242,243],{"class":50}," },\n",[36,245,246,249,251,253],{"class":38,"line":95},[36,247,248],{"class":46},"    Write",[36,250,60],{"class":50},[36,252,90],{"class":46},[36,254,79],{"class":50},[36,256,257,260,262,265,267,269,271,273],{"class":38,"line":101},[36,258,259],{"class":46},"    ChangeColor",[36,261,60],{"class":50},[36,263,264],{"class":46},"i32",[36,266,66],{"class":50},[36,268,264],{"class":46},[36,270,66],{"class":50},[36,272,264],{"class":46},[36,274,79],{"class":50},[36,276,277],{"class":38,"line":108},[36,278,98],{"class":50},[280,281,282,289,295,301],"ul",{},[283,284,285,288],"li",{},[33,286,287],{},"Quit"," — unit variant (no data).",[283,290,291,294],{},[33,292,293],{},"Move"," — struct-like variant.",[283,296,297,300],{},[33,298,299],{},"Write"," — tuple-like variant.",[283,302,303,306],{},[33,304,305],{},"ChangeColor"," — tuple-like with multiple fields.",[14,308,309],{},"Pattern matching destructures them:",[23,311,312],{"language":25},[27,313,315],{"className":29,"code":314,"language":25,"meta":31,"style":31},"match msg {\n    Message::Quit => {},\n    Message::Move { x, y } => println!(\"{x},{y}\"),\n    Message::Write(s) => println!(\"{s}\"),\n    Message::ChangeColor(r, g, b) => println!(\"{r},{g},{b}\"),\n}\n",[33,316,317,325,340,364,386,408],{"__ignoreMap":31},[36,318,319,322],{"class":38,"line":39},[36,320,321],{"class":42},"match",[36,323,324],{"class":50}," msg {\n",[36,326,327,330,332,334,337],{"class":38,"line":54},[36,328,329],{"class":46},"    Message",[36,331,122],{"class":42},[36,333,287],{"class":46},[36,335,336],{"class":42}," =>",[36,338,339],{"class":50}," {},\n",[36,341,342,344,346,348,351,354,357,359,362],{"class":38,"line":82},[36,343,329],{"class":46},[36,345,122],{"class":42},[36,347,293],{"class":46},[36,349,350],{"class":50}," { x, y } ",[36,352,353],{"class":42},"=>",[36,355,356],{"class":46}," println!",[36,358,60],{"class":50},[36,360,361],{"class":179},"\"{x},{y}\"",[36,363,79],{"class":50},[36,365,366,368,370,372,375,377,379,381,384],{"class":38,"line":95},[36,367,329],{"class":46},[36,369,122],{"class":42},[36,371,299],{"class":46},[36,373,374],{"class":50},"(s) ",[36,376,353],{"class":42},[36,378,356],{"class":46},[36,380,60],{"class":50},[36,382,383],{"class":179},"\"{s}\"",[36,385,79],{"class":50},[36,387,388,390,392,394,397,399,401,403,406],{"class":38,"line":101},[36,389,329],{"class":46},[36,391,122],{"class":42},[36,393,305],{"class":46},[36,395,396],{"class":50},"(r, g, b) ",[36,398,353],{"class":42},[36,400,356],{"class":46},[36,402,60],{"class":50},[36,404,405],{"class":179},"\"{r},{g},{b}\"",[36,407,79],{"class":50},[36,409,410],{"class":38,"line":108},[36,411,98],{"class":50},[18,413,415,418],{"id":414},"optiont-the-null-replacement",[33,416,417],{},"Option\u003CT>"," — The Null Replacement",[23,420,421],{"language":25},[27,422,424],{"className":29,"code":423,"language":25,"meta":31,"style":31},"enum Option\u003CT> {\n    Some(T),\n    None,\n}\n",[33,425,426,442,453,460],{"__ignoreMap":31},[36,427,428,430,433,436,439],{"class":38,"line":39},[36,429,43],{"class":42},[36,431,432],{"class":46}," Option",[36,434,435],{"class":50},"\u003C",[36,437,438],{"class":46},"T",[36,440,441],{"class":50},"> {\n",[36,443,444,447,449,451],{"class":38,"line":54},[36,445,446],{"class":46},"    Some",[36,448,60],{"class":50},[36,450,438],{"class":46},[36,452,79],{"class":50},[36,454,455,458],{"class":38,"line":82},[36,456,457],{"class":46},"    None",[36,459,219],{"class":50},[36,461,462],{"class":38,"line":95},[36,463,98],{"class":50},[14,465,466,467,471,472,474,475,478],{},"There is ",[468,469,470],"strong",{},"no null"," in Rust. Use ",[33,473,417],{}," when a value may be absent. The compiler forces you to handle ",[33,476,477],{},"None",".",[23,480,481],{"language":25},[27,482,484],{"className":29,"code":483,"language":25,"meta":31,"style":31},"let v: Option\u003Ci32> = Some(5);\nlet none: Option\u003Ci32> = None;\nmatch v { Some(x) => println!(\"{x}\"), None => println!(\"none\") }\nlet unwrapped = v.unwrap_or(0);\n",[33,485,486,516,541,580],{"__ignoreMap":31},[36,487,488,490,493,495,497,499,501,504,506,509,511,514],{"class":38,"line":39},[36,489,111],{"class":42},[36,491,492],{"class":50}," v",[36,494,230],{"class":42},[36,496,432],{"class":46},[36,498,435],{"class":50},[36,500,264],{"class":46},[36,502,503],{"class":50},"> ",[36,505,117],{"class":42},[36,507,508],{"class":46}," Some",[36,510,60],{"class":50},[36,512,513],{"class":130},"5",[36,515,148],{"class":50},[36,517,518,520,523,525,527,529,531,533,535,538],{"class":38,"line":54},[36,519,111],{"class":42},[36,521,522],{"class":50}," none",[36,524,230],{"class":42},[36,526,432],{"class":46},[36,528,435],{"class":50},[36,530,264],{"class":46},[36,532,503],{"class":50},[36,534,117],{"class":42},[36,536,537],{"class":46}," None",[36,539,540],{"class":50},";\n",[36,542,543,545,548,551,554,556,558,560,563,566,568,570,572,574,577],{"class":38,"line":82},[36,544,321],{"class":42},[36,546,547],{"class":50}," v { ",[36,549,550],{"class":46},"Some",[36,552,553],{"class":50},"(x) ",[36,555,353],{"class":42},[36,557,356],{"class":46},[36,559,60],{"class":50},[36,561,562],{"class":179},"\"{x}\"",[36,564,565],{"class":50},"), ",[36,567,477],{"class":46},[36,569,336],{"class":42},[36,571,356],{"class":46},[36,573,60],{"class":50},[36,575,576],{"class":179},"\"none\"",[36,578,579],{"class":50},") }\n",[36,581,582,584,587,589,591,593,596,598,600],{"class":38,"line":95},[36,583,111],{"class":42},[36,585,586],{"class":50}," unwrapped ",[36,588,117],{"class":42},[36,590,492],{"class":50},[36,592,478],{"class":42},[36,594,595],{"class":46},"unwrap_or",[36,597,60],{"class":50},[36,599,136],{"class":130},[36,601,148],{"class":50},[18,603,605,608],{"id":604},"resultt-e-error-handling-primitive",[33,606,607],{},"Result\u003CT, E>"," — Error Handling Primitive",[23,610,611],{"language":25},[27,612,614],{"className":29,"code":613,"language":25,"meta":31,"style":31},"enum Result\u003CT, E> {\n    Ok(T),\n    Err(E),\n}\n",[33,615,616,634,645,656],{"__ignoreMap":31},[36,617,618,620,623,625,627,629,632],{"class":38,"line":39},[36,619,43],{"class":42},[36,621,622],{"class":46}," Result",[36,624,435],{"class":50},[36,626,438],{"class":46},[36,628,66],{"class":50},[36,630,631],{"class":46},"E",[36,633,441],{"class":50},[36,635,636,639,641,643],{"class":38,"line":54},[36,637,638],{"class":46},"    Ok",[36,640,60],{"class":50},[36,642,438],{"class":46},[36,644,79],{"class":50},[36,646,647,650,652,654],{"class":38,"line":82},[36,648,649],{"class":46},"    Err",[36,651,60],{"class":50},[36,653,631],{"class":46},[36,655,79],{"class":50},[36,657,658],{"class":38,"line":95},[36,659,98],{"class":50},[14,661,662],{},"The basis of Rust error handling. See Error Handling chapter.",[18,664,666],{"id":665},"methods-on-enums","Methods on Enums",[23,668,669],{"language":25},[27,670,672],{"className":29,"code":671,"language":25,"meta":31,"style":31},"impl Message {\n    fn call(&self) {\n        \u002F\u002F dispatch on self\n    }\n}\n",[33,673,674,683,702,708,713],{"__ignoreMap":31},[36,675,676,679,681],{"class":38,"line":39},[36,677,678],{"class":42},"impl",[36,680,209],{"class":46},[36,682,51],{"class":50},[36,684,685,688,691,693,696,699],{"class":38,"line":54},[36,686,687],{"class":42},"    fn",[36,689,690],{"class":46}," call",[36,692,60],{"class":50},[36,694,695],{"class":42},"&",[36,697,698],{"class":130},"self",[36,700,701],{"class":50},") {\n",[36,703,704],{"class":38,"line":82},[36,705,707],{"class":706},"sdCPZ","        \u002F\u002F dispatch on self\n",[36,709,710],{"class":38,"line":95},[36,711,712],{"class":50},"    }\n",[36,714,715],{"class":38,"line":101},[36,716,98],{"class":50},[14,718,719],{},"Enums can have methods, just like structs.",[18,721,723],{"id":722},"enums-with-generic-parameters","Enums with Generic Parameters",[23,725,726],{"language":25},[27,727,729],{"className":29,"code":728,"language":25,"meta":31,"style":31},"enum Either\u003CL, R> {\n    Left(L),\n    Right(R),\n}\n\nenum Tree\u003CT> {\n    Leaf,\n    Node(Box\u003CTree\u003CT>>, T, Box\u003CTree\u003CT>>),\n}\n",[33,730,731,750,761,772,776,780,793,800,840],{"__ignoreMap":31},[36,732,733,735,738,740,743,745,748],{"class":38,"line":39},[36,734,43],{"class":42},[36,736,737],{"class":46}," Either",[36,739,435],{"class":50},[36,741,742],{"class":46},"L",[36,744,66],{"class":50},[36,746,747],{"class":46},"R",[36,749,441],{"class":50},[36,751,752,755,757,759],{"class":38,"line":54},[36,753,754],{"class":46},"    Left",[36,756,60],{"class":50},[36,758,742],{"class":46},[36,760,79],{"class":50},[36,762,763,766,768,770],{"class":38,"line":82},[36,764,765],{"class":46},"    Right",[36,767,60],{"class":50},[36,769,747],{"class":46},[36,771,79],{"class":50},[36,773,774],{"class":38,"line":95},[36,775,98],{"class":50},[36,777,778],{"class":38,"line":101},[36,779,105],{"emptyLinePlaceholder":104},[36,781,782,784,787,789,791],{"class":38,"line":108},[36,783,43],{"class":42},[36,785,786],{"class":46}," Tree",[36,788,435],{"class":50},[36,790,438],{"class":46},[36,792,441],{"class":50},[36,794,795,798],{"class":38,"line":151},[36,796,797],{"class":46},"    Leaf",[36,799,219],{"class":50},[36,801,803,806,808,811,813,816,818,820,823,825,827,829,831,833,835,837],{"class":38,"line":802},8,[36,804,805],{"class":46},"    Node",[36,807,60],{"class":50},[36,809,810],{"class":46},"Box",[36,812,435],{"class":50},[36,814,815],{"class":46},"Tree",[36,817,435],{"class":50},[36,819,438],{"class":46},[36,821,822],{"class":50},">>, ",[36,824,438],{"class":46},[36,826,66],{"class":50},[36,828,810],{"class":46},[36,830,435],{"class":50},[36,832,815],{"class":46},[36,834,435],{"class":50},[36,836,438],{"class":46},[36,838,839],{"class":50},">>),\n",[36,841,843],{"class":38,"line":842},9,[36,844,98],{"class":50},[14,846,847,848,850],{},"Recursive enums need indirection (",[33,849,810],{},") because the compiler needs to know the size — direct self-recursion would be infinitely sized.",[18,852,854,857],{"id":853},"derive-for-enums",[33,855,856],{},"#[derive]"," for Enums",[23,859,860],{"language":25},[27,861,863],{"className":29,"code":862,"language":25,"meta":31,"style":31},"#[derive(Debug, Clone, Copy, PartialEq, Eq, Hash)]\nenum Color { Red, Green, Blue }\n",[33,864,865,901],{"__ignoreMap":31},[36,866,867,870,873,875,878,880,883,885,888,890,893,895,898],{"class":38,"line":39},[36,868,869],{"class":50},"#[derive(",[36,871,872],{"class":46},"Debug",[36,874,66],{"class":50},[36,876,877],{"class":46},"Clone",[36,879,66],{"class":50},[36,881,882],{"class":46},"Copy",[36,884,66],{"class":50},[36,886,887],{"class":46},"PartialEq",[36,889,66],{"class":50},[36,891,892],{"class":46},"Eq",[36,894,66],{"class":50},[36,896,897],{"class":46},"Hash",[36,899,900],{"class":50},")]\n",[36,902,903,905,908,911,914,916,919,921,924],{"class":38,"line":54},[36,904,43],{"class":42},[36,906,907],{"class":46}," Color",[36,909,910],{"class":50}," { ",[36,912,913],{"class":46},"Red",[36,915,66],{"class":50},[36,917,918],{"class":46},"Green",[36,920,66],{"class":50},[36,922,923],{"class":46},"Blue",[36,925,926],{"class":50}," }\n",[14,928,929,931,932,935,936,938,939,941],{},[33,930,882],{}," only works if ",[468,933,934],{},"every"," variant's data is ",[33,937,882],{}," (e.g., no ",[33,940,90],{},").",[18,943,945],{"id":944},"match-exhaustiveness","Match Exhaustiveness",[14,947,948,950,951,954,955,958,959,961,962,965],{},[33,949,321],{}," must cover every variant. Use ",[33,952,953],{},"_"," for \"everything else\". For ",[33,956,957],{},"#[non_exhaustive]"," enums from external crates, ",[33,960,953],{}," is ",[188,963,964],{},"required"," even if you cover all current variants (upstream may add more).",[23,967,968],{"language":25},[27,969,971],{"className":29,"code":970,"language":25,"meta":31,"style":31},"#[non_exhaustive]\npub enum Event { Login, Logout }\n\u002F\u002F External crate must write `_ => ...` arm.\n",[33,972,973,978,1001],{"__ignoreMap":31},[36,974,975],{"class":38,"line":39},[36,976,977],{"class":50},"#[non_exhaustive]\n",[36,979,980,983,986,989,991,994,996,999],{"class":38,"line":54},[36,981,982],{"class":42},"pub",[36,984,985],{"class":42}," enum",[36,987,988],{"class":46}," Event",[36,990,910],{"class":50},[36,992,993],{"class":46},"Login",[36,995,66],{"class":50},[36,997,998],{"class":46},"Logout",[36,1000,926],{"class":50},[36,1002,1003],{"class":38,"line":82},[36,1004,1005],{"class":706},"\u002F\u002F External crate must write `_ => ...` arm.\n",[18,1007,1009],{"id":1008},"field-access-on-tuple-variants","Field-Access on Tuple Variants",[23,1011,1012],{"language":25},[27,1013,1015],{"className":29,"code":1014,"language":25,"meta":31,"style":31},"let m = Message::Write(\"hi\".into());\nlet s = m.0;  \u002F\u002F ERROR: cannot access field — must pattern match\n",[33,1016,1017,1045],{"__ignoreMap":31},[36,1018,1019,1021,1024,1026,1028,1030,1032,1034,1037,1039,1042],{"class":38,"line":39},[36,1020,111],{"class":42},[36,1022,1023],{"class":50}," m ",[36,1025,117],{"class":42},[36,1027,209],{"class":46},[36,1029,122],{"class":42},[36,1031,299],{"class":46},[36,1033,60],{"class":50},[36,1035,1036],{"class":179},"\"hi\"",[36,1038,478],{"class":42},[36,1040,1041],{"class":46},"into",[36,1043,1044],{"class":50},"());\n",[36,1046,1047,1049,1052,1054,1057,1059,1061,1064],{"class":38,"line":54},[36,1048,111],{"class":42},[36,1050,1051],{"class":50}," s ",[36,1053,117],{"class":42},[36,1055,1056],{"class":50}," m",[36,1058,478],{"class":42},[36,1060,136],{"class":130},[36,1062,1063],{"class":50},";  ",[36,1065,1066],{"class":706},"\u002F\u002F ERROR: cannot access field — must pattern match\n",[14,1068,1069,1070,1073,1074,1077],{},"Tuple-variant fields aren't accessible via ",[33,1071,1072],{},".0"," — you must destructure with ",[33,1075,1076],{},"let Message::Write(s) = m;",". (Some newer nightly features relax this.)",[18,1079,1081],{"id":1080},"pattern-matching-patterns","Pattern Matching Patterns",[23,1083,1084],{"language":25},[27,1085,1087],{"className":29,"code":1086,"language":25,"meta":31,"style":31},"match opt {\n    Some(0) => \"zero\",\n    Some(1..=9) => \"small\",\n    Some(n) if n > 1000 => \"big\",     \u002F\u002F guard\n    Some(_) => \"other\",\n    None => \"none\",\n}\n\n\u002F\u002F binding with @\nmatch n {\n    0..=9 => \"digit\",\n    x @ 10..=99 => \"two digits: {x}\",\n    _ => \"big\",\n}\n\n\u002F\u002F or-patterns\nmatch c {\n    'a' | 'e' | 'i' | 'o' | 'u' => \"vowel\",\n    _ => \"consonant\",\n}\n",[33,1088,1089,1096,1114,1137,1167,1181,1192,1196,1200,1205,1213,1230,1254,1266,1271,1276,1282,1290,1324,1336],{"__ignoreMap":31},[36,1090,1091,1093],{"class":38,"line":39},[36,1092,321],{"class":42},[36,1094,1095],{"class":50}," opt {\n",[36,1097,1098,1100,1102,1104,1107,1109,1112],{"class":38,"line":54},[36,1099,446],{"class":46},[36,1101,60],{"class":50},[36,1103,136],{"class":130},[36,1105,1106],{"class":50},") ",[36,1108,353],{"class":42},[36,1110,1111],{"class":179}," \"zero\"",[36,1113,219],{"class":50},[36,1115,1116,1118,1120,1122,1125,1128,1130,1132,1135],{"class":38,"line":82},[36,1117,446],{"class":46},[36,1119,60],{"class":50},[36,1121,145],{"class":130},[36,1123,1124],{"class":42},"..=",[36,1126,1127],{"class":130},"9",[36,1129,1106],{"class":50},[36,1131,353],{"class":42},[36,1133,1134],{"class":179}," \"small\"",[36,1136,219],{"class":50},[36,1138,1139,1141,1144,1147,1150,1153,1156,1158,1161,1164],{"class":38,"line":95},[36,1140,446],{"class":46},[36,1142,1143],{"class":50},"(n) ",[36,1145,1146],{"class":42},"if",[36,1148,1149],{"class":50}," n ",[36,1151,1152],{"class":42},">",[36,1154,1155],{"class":130}," 1000",[36,1157,336],{"class":42},[36,1159,1160],{"class":179}," \"big\"",[36,1162,1163],{"class":50},",     ",[36,1165,1166],{"class":706},"\u002F\u002F guard\n",[36,1168,1169,1171,1174,1176,1179],{"class":38,"line":101},[36,1170,446],{"class":46},[36,1172,1173],{"class":50},"(_) ",[36,1175,353],{"class":42},[36,1177,1178],{"class":179}," \"other\"",[36,1180,219],{"class":50},[36,1182,1183,1185,1187,1190],{"class":38,"line":108},[36,1184,457],{"class":46},[36,1186,336],{"class":42},[36,1188,1189],{"class":179}," \"none\"",[36,1191,219],{"class":50},[36,1193,1194],{"class":38,"line":151},[36,1195,98],{"class":50},[36,1197,1198],{"class":38,"line":802},[36,1199,105],{"emptyLinePlaceholder":104},[36,1201,1202],{"class":38,"line":842},[36,1203,1204],{"class":706},"\u002F\u002F binding with @\n",[36,1206,1208,1210],{"class":38,"line":1207},10,[36,1209,321],{"class":42},[36,1211,1212],{"class":50}," n {\n",[36,1214,1216,1219,1221,1223,1225,1228],{"class":38,"line":1215},11,[36,1217,1218],{"class":130},"    0",[36,1220,1124],{"class":42},[36,1222,1127],{"class":130},[36,1224,336],{"class":42},[36,1226,1227],{"class":179}," \"digit\"",[36,1229,219],{"class":50},[36,1231,1233,1236,1239,1242,1244,1247,1249,1252],{"class":38,"line":1232},12,[36,1234,1235],{"class":50},"    x ",[36,1237,1238],{"class":42},"@",[36,1240,1241],{"class":130}," 10",[36,1243,1124],{"class":42},[36,1245,1246],{"class":130},"99",[36,1248,336],{"class":42},[36,1250,1251],{"class":179}," \"two digits: {x}\"",[36,1253,219],{"class":50},[36,1255,1257,1260,1262,1264],{"class":38,"line":1256},13,[36,1258,1259],{"class":50},"    _ ",[36,1261,353],{"class":42},[36,1263,1160],{"class":179},[36,1265,219],{"class":50},[36,1267,1269],{"class":38,"line":1268},14,[36,1270,98],{"class":50},[36,1272,1274],{"class":38,"line":1273},15,[36,1275,105],{"emptyLinePlaceholder":104},[36,1277,1279],{"class":38,"line":1278},16,[36,1280,1281],{"class":706},"\u002F\u002F or-patterns\n",[36,1283,1285,1287],{"class":38,"line":1284},17,[36,1286,321],{"class":42},[36,1288,1289],{"class":50}," c {\n",[36,1291,1293,1296,1299,1302,1304,1307,1309,1312,1314,1317,1319,1322],{"class":38,"line":1292},18,[36,1294,1295],{"class":179},"    'a'",[36,1297,1298],{"class":42}," |",[36,1300,1301],{"class":179}," 'e'",[36,1303,1298],{"class":42},[36,1305,1306],{"class":179}," 'i'",[36,1308,1298],{"class":42},[36,1310,1311],{"class":179}," 'o'",[36,1313,1298],{"class":42},[36,1315,1316],{"class":179}," 'u'",[36,1318,336],{"class":42},[36,1320,1321],{"class":179}," \"vowel\"",[36,1323,219],{"class":50},[36,1325,1327,1329,1331,1334],{"class":38,"line":1326},19,[36,1328,1259],{"class":50},[36,1330,353],{"class":42},[36,1332,1333],{"class":179}," \"consonant\"",[36,1335,219],{"class":50},[36,1337,1339],{"class":38,"line":1338},20,[36,1340,98],{"class":50},[18,1342,1344,1347,1348],{"id":1343},"if-let-and-while-let",[33,1345,1346],{},"if let"," and ",[33,1349,1350],{},"while let",[23,1352,1353],{"language":25},[27,1354,1356],{"className":29,"code":1355,"language":25,"meta":31,"style":31},"if let Some(x) = opt { println!(\"{x}\"); }\nwhile let Some(x) = iter.next() { \u002F* ... *\u002F }\n",[33,1357,1358,1384],{"__ignoreMap":31},[36,1359,1360,1362,1365,1367,1369,1371,1374,1377,1379,1381],{"class":38,"line":39},[36,1361,1146],{"class":42},[36,1363,1364],{"class":42}," let",[36,1366,508],{"class":46},[36,1368,553],{"class":50},[36,1370,117],{"class":42},[36,1372,1373],{"class":50}," opt { ",[36,1375,1376],{"class":46},"println!",[36,1378,60],{"class":50},[36,1380,562],{"class":179},[36,1382,1383],{"class":50},"); }\n",[36,1385,1386,1389,1391,1393,1395,1397,1400,1402,1405,1408,1411],{"class":38,"line":54},[36,1387,1388],{"class":42},"while",[36,1390,1364],{"class":42},[36,1392,508],{"class":46},[36,1394,553],{"class":50},[36,1396,117],{"class":42},[36,1398,1399],{"class":50}," iter",[36,1401,478],{"class":42},[36,1403,1404],{"class":46},"next",[36,1406,1407],{"class":50},"() { ",[36,1409,1410],{"class":706},"\u002F* ... *\u002F",[36,1412,926],{"class":50},[14,1414,1415],{},"Short for \"match one pattern and ignore the rest\". Use when you only care about one case.",[18,1417,1419],{"id":1418},"enum-memory-layout","Enum Memory Layout",[14,1421,1422],{},"Enums store a discriminant (tag) plus enough space for the largest variant's payload:",[23,1424,1425],{"language":25},[27,1426,1428],{"className":29,"code":1427,"language":25,"meta":31,"style":31},"enum E {\n    A,\n    B(i64),\n    C([u8; 16]),\n}\n\u002F\u002F size = max(payload size) + discriminant (often optimized)\n",[33,1429,1430,1439,1446,1458,1477,1481],{"__ignoreMap":31},[36,1431,1432,1434,1437],{"class":38,"line":39},[36,1433,43],{"class":42},[36,1435,1436],{"class":46}," E",[36,1438,51],{"class":50},[36,1440,1441,1444],{"class":38,"line":54},[36,1442,1443],{"class":46},"    A",[36,1445,219],{"class":50},[36,1447,1448,1451,1453,1456],{"class":38,"line":82},[36,1449,1450],{"class":46},"    B",[36,1452,60],{"class":50},[36,1454,1455],{"class":46},"i64",[36,1457,79],{"class":50},[36,1459,1460,1463,1466,1468,1471,1474],{"class":38,"line":95},[36,1461,1462],{"class":46},"    C",[36,1464,1465],{"class":50},"([",[36,1467,63],{"class":46},[36,1469,1470],{"class":50},"; ",[36,1472,1473],{"class":130},"16",[36,1475,1476],{"class":50},"]),\n",[36,1478,1479],{"class":38,"line":101},[36,1480,98],{"class":50},[36,1482,1483],{"class":38,"line":108},[36,1484,1485],{"class":706},"\u002F\u002F size = max(payload size) + discriminant (often optimized)\n",[14,1487,1488,1489,1492,1493,1496,1497,1500,1501,941],{},"The compiler performs ",[468,1490,1491],{},"niche optimization",": if a variant is impossible to overlap with another, it can drop the discriminant. Classic case: ",[33,1494,1495],{},"Option\u003C&T>"," is the same size as ",[33,1498,1499],{},"&T"," (null pointer is reserved for ",[33,1502,477],{},[14,1504,1505,66,1508,66,1511,1514],{},[33,1506,1507],{},"Option\u003CNonNull\u003CT>>",[33,1509,1510],{},"Option\u003CBox\u003CT>>",[33,1512,1513],{},"Option\u003C&mut T>"," are all pointer-sized.",[18,1516,1518],{"id":1517},"state-machines","State Machines",[14,1520,1521],{},"Enums are perfect for state machines:",[23,1523,1524],{"language":25},[27,1525,1527],{"className":29,"code":1526,"language":25,"meta":31,"style":31},"enum Conn {\n    Idle,\n    Connecting(std::time::Instant),\n    Connected { addr: String, since: std::time::Instant },\n    Error(String),\n}\n",[33,1528,1529,1538,1545,1567,1598,1609],{"__ignoreMap":31},[36,1530,1531,1533,1536],{"class":38,"line":39},[36,1532,43],{"class":42},[36,1534,1535],{"class":46}," Conn",[36,1537,51],{"class":50},[36,1539,1540,1543],{"class":38,"line":54},[36,1541,1542],{"class":46},"    Idle",[36,1544,219],{"class":50},[36,1546,1547,1550,1552,1555,1557,1560,1562,1565],{"class":38,"line":82},[36,1548,1549],{"class":46},"    Connecting",[36,1551,60],{"class":50},[36,1553,1554],{"class":46},"std",[36,1556,122],{"class":42},[36,1558,1559],{"class":46},"time",[36,1561,122],{"class":42},[36,1563,1564],{"class":46},"Instant",[36,1566,79],{"class":50},[36,1568,1569,1572,1575,1577,1580,1583,1585,1588,1590,1592,1594,1596],{"class":38,"line":95},[36,1570,1571],{"class":46},"    Connected",[36,1573,1574],{"class":50}," { addr",[36,1576,230],{"class":42},[36,1578,1579],{"class":46}," String",[36,1581,1582],{"class":50},", since",[36,1584,230],{"class":42},[36,1586,1587],{"class":46}," std",[36,1589,122],{"class":42},[36,1591,1559],{"class":46},[36,1593,122],{"class":42},[36,1595,1564],{"class":46},[36,1597,243],{"class":50},[36,1599,1600,1603,1605,1607],{"class":38,"line":101},[36,1601,1602],{"class":46},"    Error",[36,1604,60],{"class":50},[36,1606,90],{"class":46},[36,1608,79],{"class":50},[36,1610,1611],{"class":38,"line":108},[36,1612,98],{"class":50},[14,1614,1615,1616,478],{},"Each state carries the data relevant to it. Transitions are explicit functions returning a new ",[33,1617,1618],{},"Conn",[18,1620,1622],{"id":1621},"variants-as-constructors","Variants as Constructors",[23,1624,1625],{"language":25},[27,1626,1628],{"className":29,"code":1627,"language":25,"meta":31,"style":31},"let f: fn(String) -> Message = Message::Write;\n",[33,1629,1630],{"__ignoreMap":31},[36,1631,1632,1634,1637,1639,1642,1644,1646,1648,1651,1653,1656,1658,1660,1662],{"class":38,"line":39},[36,1633,111],{"class":42},[36,1635,1636],{"class":50}," f",[36,1638,230],{"class":42},[36,1640,1641],{"class":46}," fn",[36,1643,60],{"class":50},[36,1645,90],{"class":46},[36,1647,1106],{"class":50},[36,1649,1650],{"class":42},"->",[36,1652,209],{"class":46},[36,1654,1655],{"class":42}," =",[36,1657,209],{"class":46},[36,1659,122],{"class":42},[36,1661,299],{"class":46},[36,1663,540],{"class":50},[14,1665,1666],{},"Each variant acts as a function. Useful for higher-order code.",[18,1668,1670],{"id":1669},"edge-cases-pitfalls","Edge Cases & Pitfalls",[280,1672,1673,1688,1700,1710,1726,1738,1755,1768],{},[283,1674,1675,1680,1681,1684,1685,478],{},[468,1676,1677,1678],{},"Recursive enums without ",[33,1679,810],{},": ",[33,1682,1683],{},"enum Bad { Node(Bad) }"," — infinite size, compile error. Use ",[33,1686,1687],{},"Box\u003CBad>",[283,1689,1690,1680,1693,1696,1697,478],{},[468,1691,1692],{},"Variant equality",[33,1694,1695],{},"Option::Some(5) == Option::Some(5)"," works only if ",[33,1698,1699],{},"T: PartialEq",[283,1701,1702,1707,1708,478],{},[468,1703,1704,1706],{},[33,1705,882],{}," enums",": only if all payloads are ",[33,1709,882],{},[283,1711,1712,1718,1719,1722,1723,941],{},[468,1713,1714,1717],{},[33,1715,1716],{},"Default"," for enums",": not derivable for enums (no obvious default). You can ",[33,1720,1721],{},"impl Default"," manually — convention is \"smallest\u002Fzero\" variant (e.g., ",[33,1724,1725],{},"Option::None",[283,1727,1728,1733,1734,1737],{},[468,1729,1730],{},[33,1731,1732],{},"#[repr(C)]",": gives C-style layout with explicit discriminant (size depends on largest discriminant). Use ",[33,1735,1736],{},"#[repr(C, u8)]"," etc. to fix discriminant width.",[283,1739,1740,1680,1743,1746,1747,1750,1751,1754],{},[468,1741,1742],{},"Comparing variants",[33,1744,1745],{},"PartialOrd","\u002F",[33,1748,1749],{},"Ord"," compares by ",[468,1752,1753],{},"declaration order"," of variants, then by payload.",[283,1756,1757,1763,1764,1767],{},[468,1758,1759,1762],{},[33,1760,1761],{},"is_x()"," methods",": idiom is to write ",[33,1765,1766],{},"matches!(self, Self::X)"," or a helper method rather than exposing internal representation.",[283,1769,1770,1680,1776,1779],{},[468,1771,1772,1775],{},[33,1773,1774],{},"matches!"," macro",[33,1777,1778],{},"if matches!(opt, Some(0)) { }"," — concise single-pattern check.",[18,1781,1783,1785],{"id":1782},"matches-macro",[33,1784,1774],{}," Macro",[23,1787,1788],{"language":25},[27,1789,1791],{"className":29,"code":1790,"language":25,"meta":31,"style":31},"let ok = matches!(result, Ok(_));\nlet small = matches!(n, 0..=9);\n",[33,1792,1793,1814],{"__ignoreMap":31},[36,1794,1795,1797,1800,1802,1805,1808,1811],{"class":38,"line":39},[36,1796,111],{"class":42},[36,1798,1799],{"class":50}," ok ",[36,1801,117],{"class":42},[36,1803,1804],{"class":46}," matches!",[36,1806,1807],{"class":50},"(result, ",[36,1809,1810],{"class":46},"Ok",[36,1812,1813],{"class":50},"(_));\n",[36,1815,1816,1818,1821,1823,1825,1828,1830,1832,1834],{"class":38,"line":54},[36,1817,111],{"class":42},[36,1819,1820],{"class":50}," small ",[36,1822,117],{"class":42},[36,1824,1804],{"class":46},[36,1826,1827],{"class":50},"(n, ",[36,1829,136],{"class":130},[36,1831,1124],{"class":42},[36,1833,1127],{"class":130},[36,1835,148],{"class":50},[14,1837,1838,1839,1841,1842,478],{},"Like a tiny ",[33,1840,321],{}," returning ",[33,1843,1844],{},"bool",[18,1846,1848],{"id":1847},"typestate-pattern-advanced","Typestate Pattern (advanced)",[14,1850,1851],{},"Use type params to encode states:",[23,1853,1854],{"language":25},[27,1855,1857],{"className":29,"code":1856,"language":25,"meta":31,"style":31},"struct Builder\u003CT>(PhantomData\u003CT>);\nstruct Unconfigured;\nstruct Configured;\nimpl Builder\u003CUnconfigured> {\n    fn configure(self) -> Builder\u003CConfigured> { Builder(PhantomData) }\n}\nimpl Builder\u003CConfigured> {\n    fn build(self) -> Product { \u002F* ... *\u002F }\n}\n",[33,1858,1859,1884,1893,1902,1915,1949,1953,1965,1989],{"__ignoreMap":31},[36,1860,1861,1864,1867,1869,1871,1874,1877,1879,1881],{"class":38,"line":39},[36,1862,1863],{"class":42},"struct",[36,1865,1866],{"class":46}," Builder",[36,1868,435],{"class":50},[36,1870,438],{"class":46},[36,1872,1873],{"class":50},">(",[36,1875,1876],{"class":46},"PhantomData",[36,1878,435],{"class":50},[36,1880,438],{"class":46},[36,1882,1883],{"class":50},">);\n",[36,1885,1886,1888,1891],{"class":38,"line":54},[36,1887,1863],{"class":42},[36,1889,1890],{"class":46}," Unconfigured",[36,1892,540],{"class":50},[36,1894,1895,1897,1900],{"class":38,"line":82},[36,1896,1863],{"class":42},[36,1898,1899],{"class":46}," Configured",[36,1901,540],{"class":50},[36,1903,1904,1906,1908,1910,1913],{"class":38,"line":95},[36,1905,678],{"class":42},[36,1907,1866],{"class":46},[36,1909,435],{"class":50},[36,1911,1912],{"class":46},"Unconfigured",[36,1914,441],{"class":50},[36,1916,1917,1919,1922,1924,1926,1928,1930,1932,1934,1937,1940,1943,1945,1947],{"class":38,"line":101},[36,1918,687],{"class":42},[36,1920,1921],{"class":46}," configure",[36,1923,60],{"class":50},[36,1925,698],{"class":130},[36,1927,1106],{"class":50},[36,1929,1650],{"class":42},[36,1931,1866],{"class":46},[36,1933,435],{"class":50},[36,1935,1936],{"class":46},"Configured",[36,1938,1939],{"class":50},"> { ",[36,1941,1942],{"class":46},"Builder",[36,1944,60],{"class":50},[36,1946,1876],{"class":46},[36,1948,579],{"class":50},[36,1950,1951],{"class":38,"line":108},[36,1952,98],{"class":50},[36,1954,1955,1957,1959,1961,1963],{"class":38,"line":151},[36,1956,678],{"class":42},[36,1958,1866],{"class":46},[36,1960,435],{"class":50},[36,1962,1936],{"class":46},[36,1964,441],{"class":50},[36,1966,1967,1969,1972,1974,1976,1978,1980,1983,1985,1987],{"class":38,"line":802},[36,1968,687],{"class":42},[36,1970,1971],{"class":46}," build",[36,1973,60],{"class":50},[36,1975,698],{"class":130},[36,1977,1106],{"class":50},[36,1979,1650],{"class":42},[36,1981,1982],{"class":46}," Product",[36,1984,910],{"class":50},[36,1986,1410],{"class":706},[36,1988,926],{"class":50},[36,1990,1991],{"class":38,"line":842},[36,1992,98],{"class":50},[14,1994,1995,1996,1999,2000,2002],{},"Calling ",[33,1997,1998],{},"build"," on an ",[33,2001,1912],{}," builder is a compile-time error. Encode invariants in the type system.",[18,2004,2006],{"id":2005},"summary","Summary",[14,2008,2009,2010,2012,2013,1746,2016,2019,2020,2022,2023,2025],{},"Enums are sum types: each value is one variant (with optional data). Combined with ",[33,2011,321],{},", they form Rust's modeling backbone. ",[33,2014,2015],{},"Option",[33,2017,2018],{},"Result"," are the canonical examples. Niche optimization makes them memory-efficient. Pattern matching with guards, or-patterns, ",[33,2021,1238],{},"-bindings, and ",[33,2024,1774],{}," give you expressive dispatch.",[14,2027,2028],{},"Next: Pattern Matching — a deep dive.",[2030,2031,2032],"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 .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);}html pre.shiki code .sdCPZ, html code.shiki .sdCPZ{--shiki-default:#6A737D;--shiki-github-dark:#6A737D}",{"title":31,"searchDepth":54,"depth":54,"links":2034},[2035,2036,2037,2039,2041,2042,2043,2045,2046,2047,2048,2050,2051,2052,2053,2054,2056,2057],{"id":20,"depth":54,"text":21},{"id":194,"depth":54,"text":195},{"id":414,"depth":54,"text":2038},"Option\u003CT> — The Null Replacement",{"id":604,"depth":54,"text":2040},"Result\u003CT, E> — Error Handling Primitive",{"id":665,"depth":54,"text":666},{"id":722,"depth":54,"text":723},{"id":853,"depth":54,"text":2044},"#[derive] for Enums",{"id":944,"depth":54,"text":945},{"id":1008,"depth":54,"text":1009},{"id":1080,"depth":54,"text":1081},{"id":1343,"depth":54,"text":2049},"if let and while let",{"id":1418,"depth":54,"text":1419},{"id":1517,"depth":54,"text":1518},{"id":1621,"depth":54,"text":1622},{"id":1669,"depth":54,"text":1670},{"id":1782,"depth":54,"text":2055},"matches! Macro",{"id":1847,"depth":54,"text":1848},{"id":2005,"depth":54,"text":2006},"md",{},"\u002Frust\u002F12-enums",{"title":5,"description":16},"rust\u002F12-enums","KdzNut3pmb7KJyct2irlF5LUpzf02nnGIe7pCgru5r4",1785944093228]