[{"data":1,"prerenderedAt":2780},["ShallowReactive",2],{"page-\u002Frust\u002F19-smart-pointers":3},{"id":4,"title":5,"body":6,"description":16,"extension":2774,"meta":2775,"navigation":1086,"path":2776,"seo":2777,"stem":2778,"__hash__":2779},"content\u002Frust\u002F19-smart-pointers.md","19 — Smart Pointers & Memory Management",{"type":7,"value":8,"toc":2727},"minimark",[9,13,17,26,109,125,133,159,220,227,307,310,317,429,469,475,483,557,561,681,686,693,806,828,837,858,862,995,1005,1009,1021,1149,1156,1242,1270,1277,1387,1418,1428,1435,1444,1698,1725,1729,1747,1760,1929,1943,1950,2065,2071,2137,2144,2154,2207,2213,2226,2239,2243,2447,2451,2463,2540,2544,2564,2568,2646,2650,2685,2689,2720,2723],[10,11,5],"h1",{"id":12},"_19-smart-pointers-memory-management",[14,15,16],"p",{},"Smart pointers own data and provide extra behavior beyond references. They're the bridge between Rust's ownership model and dynamic data structures.",[18,19,21,25],"h2",{"id":20},"boxt-heap-allocation",[22,23,24],"code",{},"Box\u003CT>"," — Heap Allocation",[27,28,30],"code-wrapper",{"language":29},"rust",[31,32,36],"pre",{"className":33,"code":34,"language":29,"meta":35,"style":35},"language-rust shiki shiki-themes github-light github-dark","let b = Box::new(5);\nlet s = Box::new(String::from(\"hi\"));\n","",[22,37,38,74],{"__ignoreMap":35},[39,40,43,47,51,54,58,61,64,67,71],"span",{"class":41,"line":42},"line",1,[39,44,46],{"class":45},"svdQ7","let",[39,48,50],{"class":49},"ssxIu"," b ",[39,52,53],{"class":45},"=",[39,55,57],{"class":56},"sIsaT"," Box",[39,59,60],{"class":45},"::",[39,62,63],{"class":56},"new",[39,65,66],{"class":49},"(",[39,68,70],{"class":69},"snvgF","5",[39,72,73],{"class":49},");\n",[39,75,77,79,82,84,86,88,90,92,95,97,100,102,106],{"class":41,"line":76},2,[39,78,46],{"class":45},[39,80,81],{"class":49}," s ",[39,83,53],{"class":45},[39,85,57],{"class":56},[39,87,60],{"class":45},[39,89,63],{"class":56},[39,91,66],{"class":49},[39,93,94],{"class":56},"String",[39,96,60],{"class":45},[39,98,99],{"class":56},"from",[39,101,66],{"class":49},[39,103,105],{"class":104},"sJ6F3","\"hi\"",[39,107,108],{"class":49},"));\n",[110,111,112,116,119],"ul",{},[113,114,115],"li",{},"Allocates on the heap; owned.",[113,117,118],{},"Single owner; dropped when out of scope.",[113,120,121,122,124],{},"Sized: ",[22,123,24],{}," has the size of a pointer.",[126,127,129,130],"h3",{"id":128},"when-you-need-box","When You Need ",[22,131,132],{},"Box",[110,134,135,138,141,148],{},[113,136,137],{},"Recursive types (linked structures need indirection to have a finite size).",[113,139,140],{},"Large data you don't want to copy on the stack.",[113,142,143,144,147],{},"Trait objects (",[22,145,146],{},"Box\u003Cdyn Trait>",") — unsized types need a wide pointer.",[113,149,150,151,154,155,158],{},"Sending owned data to a thread (",[22,152,153],{},"Box::new"," makes it ",[22,156,157],{},"'static",").",[27,160,161],{"language":29},[31,162,164],{"className":33,"code":163,"language":29,"meta":35,"style":35},"enum List {\n    Cons(i32, Box\u003CList>),   \u002F\u002F recursive — needs Box\n    Nil,\n}\n",[22,165,166,177,205,214],{"__ignoreMap":35},[39,167,168,171,174],{"class":41,"line":42},[39,169,170],{"class":45},"enum",[39,172,173],{"class":56}," List",[39,175,176],{"class":49}," {\n",[39,178,179,182,184,187,190,192,195,198,201],{"class":41,"line":76},[39,180,181],{"class":56},"    Cons",[39,183,66],{"class":49},[39,185,186],{"class":56},"i32",[39,188,189],{"class":49},", ",[39,191,132],{"class":56},[39,193,194],{"class":49},"\u003C",[39,196,197],{"class":56},"List",[39,199,200],{"class":49},">),   ",[39,202,204],{"class":203},"sdCPZ","\u002F\u002F recursive — needs Box\n",[39,206,208,211],{"class":41,"line":207},3,[39,209,210],{"class":56},"    Nil",[39,212,213],{"class":49},",\n",[39,215,217],{"class":41,"line":216},4,[39,218,219],{"class":49},"}\n",[126,221,223,226],{"id":222},"boxleak-permanent-reference",[22,224,225],{},"Box::leak"," — Permanent Reference",[27,228,229],{"language":29},[31,230,232],{"className":33,"code":231,"language":29,"meta":35,"style":35},"let leaked: &'static mut [u8] = Box::leak(vec![1, 2, 3].into_boxed_slice());\n",[22,233,234],{"__ignoreMap":35},[39,235,236,238,241,244,247,250,253,256,259,262,265,267,269,271,274,276,279,282,285,287,290,292,295,298,301,304],{"class":41,"line":42},[39,237,46],{"class":45},[39,239,240],{"class":49}," leaked",[39,242,243],{"class":45},":",[39,245,246],{"class":45}," &",[39,248,249],{"class":49},"'",[39,251,252],{"class":56},"static",[39,254,255],{"class":45}," mut",[39,257,258],{"class":49}," [",[39,260,261],{"class":56},"u8",[39,263,264],{"class":49},"] ",[39,266,53],{"class":45},[39,268,57],{"class":56},[39,270,60],{"class":45},[39,272,273],{"class":56},"leak",[39,275,66],{"class":49},[39,277,278],{"class":56},"vec!",[39,280,281],{"class":49},"[",[39,283,284],{"class":69},"1",[39,286,189],{"class":49},[39,288,289],{"class":69},"2",[39,291,189],{"class":49},[39,293,294],{"class":69},"3",[39,296,297],{"class":49},"]",[39,299,300],{"class":45},".",[39,302,303],{"class":56},"into_boxed_slice",[39,305,306],{"class":49},"());\n",[14,308,309],{},"Leaks forever; useful for one-time configs but a real memory leak.",[18,311,313,316],{"id":312},"rct-reference-counted-single-threaded",[22,314,315],{},"Rc\u003CT>"," — Reference Counted (single-threaded)",[27,318,319],{"language":29},[31,320,322],{"className":33,"code":321,"language":29,"meta":35,"style":35},"use std::rc::Rc;\nlet a = Rc::new(String::from(\"hi\"));\nlet b = Rc::clone(&a);    \u002F\u002F increments refcount, doesn't copy\nlet c = a.clone();         \u002F\u002F same\n\u002F\u002F a, b, c all share the same String\n",[22,323,324,345,375,401,423],{"__ignoreMap":35},[39,325,326,329,332,334,337,339,342],{"class":41,"line":42},[39,327,328],{"class":45},"use",[39,330,331],{"class":56}," std",[39,333,60],{"class":45},[39,335,336],{"class":56},"rc",[39,338,60],{"class":45},[39,340,341],{"class":56},"Rc",[39,343,344],{"class":49},";\n",[39,346,347,349,352,354,357,359,361,363,365,367,369,371,373],{"class":41,"line":76},[39,348,46],{"class":45},[39,350,351],{"class":49}," a ",[39,353,53],{"class":45},[39,355,356],{"class":56}," Rc",[39,358,60],{"class":45},[39,360,63],{"class":56},[39,362,66],{"class":49},[39,364,94],{"class":56},[39,366,60],{"class":45},[39,368,99],{"class":56},[39,370,66],{"class":49},[39,372,105],{"class":104},[39,374,108],{"class":49},[39,376,377,379,381,383,385,387,390,392,395,398],{"class":41,"line":207},[39,378,46],{"class":45},[39,380,50],{"class":49},[39,382,53],{"class":45},[39,384,356],{"class":56},[39,386,60],{"class":45},[39,388,389],{"class":56},"clone",[39,391,66],{"class":49},[39,393,394],{"class":45},"&",[39,396,397],{"class":49},"a);    ",[39,399,400],{"class":203},"\u002F\u002F increments refcount, doesn't copy\n",[39,402,403,405,408,410,413,415,417,420],{"class":41,"line":216},[39,404,46],{"class":45},[39,406,407],{"class":49}," c ",[39,409,53],{"class":45},[39,411,412],{"class":49}," a",[39,414,300],{"class":45},[39,416,389],{"class":56},[39,418,419],{"class":49},"();         ",[39,421,422],{"class":203},"\u002F\u002F same\n",[39,424,426],{"class":41,"line":425},5,[39,427,428],{"class":203},"\u002F\u002F a, b, c all share the same String\n",[110,430,431,438,441,455,458],{},[113,432,433,434,300],{},"Multiple owners in a ",[435,436,437],"strong",{},"single thread",[113,439,440],{},"Atomic increment\u002Fdecrement of a refcount.",[113,442,443,444,447,448,451,452,158],{},"Not ",[22,445,446],{},"Send","\u002F",[22,449,450],{},"Sync"," (uses non-atomic counters; cheaper than ",[22,453,454],{},"Arc",[113,456,457],{},"When the count hits 0, the value is dropped.",[113,459,460,461,464,465,468],{},"Use ",[22,462,463],{},"Rc::clone(&rc)"," (idiomatic) — don't use ",[22,466,467],{},"rc.clone()"," (looks like a deep clone).",[126,470,472,474],{"id":471},"rc-doesnt-allow-mutation",[22,473,341],{}," Doesn't Allow Mutation",[14,476,477,479,480,243],{},[22,478,315],{}," gives shared read access. To mutate shared state, wrap in ",[22,481,482],{},"RefCell",[27,484,485],{"language":29},[31,486,488],{"className":33,"code":487,"language":29,"meta":35,"style":35},"let shared = Rc::new(RefCell::new(vec![1, 2, 3]));\nshared.borrow_mut().push(4);\n",[22,489,490,532],{"__ignoreMap":35},[39,491,492,494,497,499,501,503,505,507,509,511,513,515,517,519,521,523,525,527,529],{"class":41,"line":42},[39,493,46],{"class":45},[39,495,496],{"class":49}," shared ",[39,498,53],{"class":45},[39,500,356],{"class":56},[39,502,60],{"class":45},[39,504,63],{"class":56},[39,506,66],{"class":49},[39,508,482],{"class":56},[39,510,60],{"class":45},[39,512,63],{"class":56},[39,514,66],{"class":49},[39,516,278],{"class":56},[39,518,281],{"class":49},[39,520,284],{"class":69},[39,522,189],{"class":49},[39,524,289],{"class":69},[39,526,189],{"class":49},[39,528,294],{"class":69},[39,530,531],{"class":49},"]));\n",[39,533,534,537,539,542,545,547,550,552,555],{"class":41,"line":76},[39,535,536],{"class":49},"shared",[39,538,300],{"class":45},[39,540,541],{"class":56},"borrow_mut",[39,543,544],{"class":49},"()",[39,546,300],{"class":45},[39,548,549],{"class":56},"push",[39,551,66],{"class":49},[39,553,554],{"class":69},"4",[39,556,73],{"class":49},[126,558,560],{"id":559},"weak-references","Weak References",[27,562,563],{"language":29},[31,564,566],{"className":33,"code":565,"language":29,"meta":35,"style":35},"use std::rc::{Rc, Weak};\nlet strong = Rc::new(5);\nlet weak: Weak\u003Ci32> = Rc::downgrade(&strong);\nif let Some(v) = weak.upgrade() { \u002F* ... *\u002F }\n",[22,567,568,593,614,649],{"__ignoreMap":35},[39,569,570,572,574,576,578,580,583,585,587,590],{"class":41,"line":42},[39,571,328],{"class":45},[39,573,331],{"class":56},[39,575,60],{"class":45},[39,577,336],{"class":56},[39,579,60],{"class":45},[39,581,582],{"class":49},"{",[39,584,341],{"class":56},[39,586,189],{"class":49},[39,588,589],{"class":56},"Weak",[39,591,592],{"class":49},"};\n",[39,594,595,597,600,602,604,606,608,610,612],{"class":41,"line":76},[39,596,46],{"class":45},[39,598,599],{"class":49}," strong ",[39,601,53],{"class":45},[39,603,356],{"class":56},[39,605,60],{"class":45},[39,607,63],{"class":56},[39,609,66],{"class":49},[39,611,70],{"class":69},[39,613,73],{"class":49},[39,615,616,618,621,623,626,628,630,633,635,637,639,642,644,646],{"class":41,"line":207},[39,617,46],{"class":45},[39,619,620],{"class":49}," weak",[39,622,243],{"class":45},[39,624,625],{"class":56}," Weak",[39,627,194],{"class":49},[39,629,186],{"class":56},[39,631,632],{"class":49},"> ",[39,634,53],{"class":45},[39,636,356],{"class":56},[39,638,60],{"class":45},[39,640,641],{"class":56},"downgrade",[39,643,66],{"class":49},[39,645,394],{"class":45},[39,647,648],{"class":49},"strong);\n",[39,650,651,654,657,660,663,665,667,669,672,675,678],{"class":41,"line":216},[39,652,653],{"class":45},"if",[39,655,656],{"class":45}," let",[39,658,659],{"class":56}," Some",[39,661,662],{"class":49},"(v) ",[39,664,53],{"class":45},[39,666,620],{"class":49},[39,668,300],{"class":45},[39,670,671],{"class":56},"upgrade",[39,673,674],{"class":49},"() { ",[39,676,677],{"class":203},"\u002F* ... *\u002F",[39,679,680],{"class":49}," }\n",[14,682,683,685],{},[22,684,589],{}," doesn't count toward ownership; avoids cycles. Crucial for parent\u002Fchild links (e.g., GUI trees, linked structures).",[18,687,689,692],{"id":688},"arct-atomic-reference-counted-thread-safe",[22,690,691],{},"Arc\u003CT>"," — Atomic Reference Counted (thread-safe)",[27,694,695],{"language":29},[31,696,698],{"className":33,"code":697,"language":29,"meta":35,"style":35},"use std::sync::Arc;\nlet a = Arc::new(vec![1, 2, 3]);\nlet b = Arc::clone(&a);\nstd::thread::spawn(move || println!(\"{:?}\", b));\n",[22,699,700,717,751,772],{"__ignoreMap":35},[39,701,702,704,706,708,711,713,715],{"class":41,"line":42},[39,703,328],{"class":45},[39,705,331],{"class":56},[39,707,60],{"class":45},[39,709,710],{"class":56},"sync",[39,712,60],{"class":45},[39,714,454],{"class":56},[39,716,344],{"class":49},[39,718,719,721,723,725,728,730,732,734,736,738,740,742,744,746,748],{"class":41,"line":76},[39,720,46],{"class":45},[39,722,351],{"class":49},[39,724,53],{"class":45},[39,726,727],{"class":56}," Arc",[39,729,60],{"class":45},[39,731,63],{"class":56},[39,733,66],{"class":49},[39,735,278],{"class":56},[39,737,281],{"class":49},[39,739,284],{"class":69},[39,741,189],{"class":49},[39,743,289],{"class":69},[39,745,189],{"class":49},[39,747,294],{"class":69},[39,749,750],{"class":49},"]);\n",[39,752,753,755,757,759,761,763,765,767,769],{"class":41,"line":207},[39,754,46],{"class":45},[39,756,50],{"class":49},[39,758,53],{"class":45},[39,760,727],{"class":56},[39,762,60],{"class":45},[39,764,389],{"class":56},[39,766,66],{"class":49},[39,768,394],{"class":45},[39,770,771],{"class":49},"a);\n",[39,773,774,777,779,782,784,787,789,792,795,798,800,803],{"class":41,"line":216},[39,775,776],{"class":56},"std",[39,778,60],{"class":45},[39,780,781],{"class":56},"thread",[39,783,60],{"class":45},[39,785,786],{"class":56},"spawn",[39,788,66],{"class":49},[39,790,791],{"class":45},"move",[39,793,794],{"class":45}," ||",[39,796,797],{"class":56}," println!",[39,799,66],{"class":49},[39,801,802],{"class":104},"\"{:?}\"",[39,804,805],{"class":49},", b));\n",[110,807,808,814,825],{},[113,809,810,811,813],{},"Thread-safe version of ",[22,812,341],{}," (atomic ops, slower).",[113,815,816,818,819,821,822,300],{},[22,817,446],{}," and ",[22,820,450],{}," if ",[22,823,824],{},"T: Send + Sync",[113,826,827],{},"Idiomatic for sharing across threads.",[126,829,831,832,834,835],{"id":830},"when-rc-vs-arc","When ",[22,833,341],{}," vs ",[22,836,454],{},[110,838,839,845,850],{},[113,840,841,842,844],{},"Single-threaded: ",[22,843,341],{}," (faster, simpler).",[113,846,847,848,300],{},"Multi-threaded: ",[22,849,454],{},[113,851,852,853,855,856,300],{},"Never use ",[22,854,341],{}," across threads — the compiler forbids it via ",[22,857,446],{},[18,859,861],{"id":860},"cycles-and-memory-leaks","Cycles and Memory Leaks",[27,863,864],{"language":29},[31,865,867],{"className":33,"code":866,"language":29,"meta":35,"style":35},"let a = Rc::new(RefCell::new(None));\nlet b = Rc::new(RefCell::new(None));\n*a.borrow_mut() = Some(Rc::clone(&b));\n*b.borrow_mut() = Some(Rc::clone(&a));    \u002F\u002F CYCLE: refcount never hits 0\n",[22,868,869,898,926,960],{"__ignoreMap":35},[39,870,871,873,875,877,879,881,883,885,887,889,891,893,896],{"class":41,"line":42},[39,872,46],{"class":45},[39,874,351],{"class":49},[39,876,53],{"class":45},[39,878,356],{"class":56},[39,880,60],{"class":45},[39,882,63],{"class":56},[39,884,66],{"class":49},[39,886,482],{"class":56},[39,888,60],{"class":45},[39,890,63],{"class":56},[39,892,66],{"class":49},[39,894,895],{"class":56},"None",[39,897,108],{"class":49},[39,899,900,902,904,906,908,910,912,914,916,918,920,922,924],{"class":41,"line":76},[39,901,46],{"class":45},[39,903,50],{"class":49},[39,905,53],{"class":45},[39,907,356],{"class":56},[39,909,60],{"class":45},[39,911,63],{"class":56},[39,913,66],{"class":49},[39,915,482],{"class":56},[39,917,60],{"class":45},[39,919,63],{"class":56},[39,921,66],{"class":49},[39,923,895],{"class":56},[39,925,108],{"class":49},[39,927,928,931,934,936,938,941,943,945,947,949,951,953,955,957],{"class":41,"line":207},[39,929,930],{"class":45},"*",[39,932,933],{"class":49},"a",[39,935,300],{"class":45},[39,937,541],{"class":56},[39,939,940],{"class":49},"() ",[39,942,53],{"class":45},[39,944,659],{"class":56},[39,946,66],{"class":49},[39,948,341],{"class":56},[39,950,60],{"class":45},[39,952,389],{"class":56},[39,954,66],{"class":49},[39,956,394],{"class":45},[39,958,959],{"class":49},"b));\n",[39,961,962,964,967,969,971,973,975,977,979,981,983,985,987,989,992],{"class":41,"line":216},[39,963,930],{"class":45},[39,965,966],{"class":49},"b",[39,968,300],{"class":45},[39,970,541],{"class":56},[39,972,940],{"class":49},[39,974,53],{"class":45},[39,976,659],{"class":56},[39,978,66],{"class":49},[39,980,341],{"class":56},[39,982,60],{"class":45},[39,984,389],{"class":56},[39,986,66],{"class":49},[39,988,394],{"class":45},[39,990,991],{"class":49},"a));    ",[39,993,994],{"class":203},"\u002F\u002F CYCLE: refcount never hits 0\n",[14,996,997,447,999,1001,1002,1004],{},[22,998,341],{},[22,1000,454],{}," cycles leak. Use ",[22,1003,589],{}," for back-references. Rust can't prevent this; design matters.",[18,1006,1008],{"id":1007},"interior-mutability-pattern","Interior Mutability Pattern",[14,1010,1011,447,1013,1015,1016,447,1018,243],{},[22,1012,341],{},[22,1014,454],{}," give shared ownership but no mutation. Wrap the inner in ",[22,1017,482],{},[22,1019,1020],{},"Mutex",[27,1022,1023],{"language":29},[31,1024,1026],{"className":33,"code":1025,"language":29,"meta":35,"style":35},"\u002F\u002F single-threaded\nlet shared = Rc::new(RefCell::new(0));\n*shared.borrow_mut() += 1;\n\n\u002F\u002F multi-threaded\nlet shared = Arc::new(Mutex::new(0));\n*shared.lock().unwrap() += 1;\n",[22,1027,1028,1033,1062,1082,1088,1093,1122],{"__ignoreMap":35},[39,1029,1030],{"class":41,"line":42},[39,1031,1032],{"class":203},"\u002F\u002F single-threaded\n",[39,1034,1035,1037,1039,1041,1043,1045,1047,1049,1051,1053,1055,1057,1060],{"class":41,"line":76},[39,1036,46],{"class":45},[39,1038,496],{"class":49},[39,1040,53],{"class":45},[39,1042,356],{"class":56},[39,1044,60],{"class":45},[39,1046,63],{"class":56},[39,1048,66],{"class":49},[39,1050,482],{"class":56},[39,1052,60],{"class":45},[39,1054,63],{"class":56},[39,1056,66],{"class":49},[39,1058,1059],{"class":69},"0",[39,1061,108],{"class":49},[39,1063,1064,1066,1068,1070,1072,1074,1077,1080],{"class":41,"line":207},[39,1065,930],{"class":45},[39,1067,536],{"class":49},[39,1069,300],{"class":45},[39,1071,541],{"class":56},[39,1073,940],{"class":49},[39,1075,1076],{"class":45},"+=",[39,1078,1079],{"class":69}," 1",[39,1081,344],{"class":49},[39,1083,1084],{"class":41,"line":216},[39,1085,1087],{"emptyLinePlaceholder":1086},true,"\n",[39,1089,1090],{"class":41,"line":425},[39,1091,1092],{"class":203},"\u002F\u002F multi-threaded\n",[39,1094,1096,1098,1100,1102,1104,1106,1108,1110,1112,1114,1116,1118,1120],{"class":41,"line":1095},6,[39,1097,46],{"class":45},[39,1099,496],{"class":49},[39,1101,53],{"class":45},[39,1103,727],{"class":56},[39,1105,60],{"class":45},[39,1107,63],{"class":56},[39,1109,66],{"class":49},[39,1111,1020],{"class":56},[39,1113,60],{"class":45},[39,1115,63],{"class":56},[39,1117,66],{"class":49},[39,1119,1059],{"class":69},[39,1121,108],{"class":49},[39,1123,1125,1127,1129,1131,1134,1136,1138,1141,1143,1145,1147],{"class":41,"line":1124},7,[39,1126,930],{"class":45},[39,1128,536],{"class":49},[39,1130,300],{"class":45},[39,1132,1133],{"class":56},"lock",[39,1135,544],{"class":49},[39,1137,300],{"class":45},[39,1139,1140],{"class":56},"unwrap",[39,1142,940],{"class":49},[39,1144,1076],{"class":45},[39,1146,1079],{"class":69},[39,1148,344],{"class":49},[18,1150,1152,1155],{"id":1151},"cellt-copy-type-interior-mutability",[22,1153,1154],{},"Cell\u003CT>"," — Copy-Type Interior Mutability",[27,1157,1158],{"language":29},[31,1159,1161],{"className":33,"code":1160,"language":29,"meta":35,"style":35},"use std::cell::Cell;\nlet c = Cell::new(5);\nc.set(10);\nlet v = c.get();          \u002F\u002F requires T: Copy\n",[22,1162,1163,1181,1202,1219],{"__ignoreMap":35},[39,1164,1165,1167,1169,1171,1174,1176,1179],{"class":41,"line":42},[39,1166,328],{"class":45},[39,1168,331],{"class":56},[39,1170,60],{"class":45},[39,1172,1173],{"class":56},"cell",[39,1175,60],{"class":45},[39,1177,1178],{"class":56},"Cell",[39,1180,344],{"class":49},[39,1182,1183,1185,1187,1189,1192,1194,1196,1198,1200],{"class":41,"line":76},[39,1184,46],{"class":45},[39,1186,407],{"class":49},[39,1188,53],{"class":45},[39,1190,1191],{"class":56}," Cell",[39,1193,60],{"class":45},[39,1195,63],{"class":56},[39,1197,66],{"class":49},[39,1199,70],{"class":69},[39,1201,73],{"class":49},[39,1203,1204,1207,1209,1212,1214,1217],{"class":41,"line":207},[39,1205,1206],{"class":49},"c",[39,1208,300],{"class":45},[39,1210,1211],{"class":56},"set",[39,1213,66],{"class":49},[39,1215,1216],{"class":69},"10",[39,1218,73],{"class":49},[39,1220,1221,1223,1226,1228,1231,1233,1236,1239],{"class":41,"line":216},[39,1222,46],{"class":45},[39,1224,1225],{"class":49}," v ",[39,1227,53],{"class":45},[39,1229,1230],{"class":49}," c",[39,1232,300],{"class":45},[39,1234,1235],{"class":56},"get",[39,1237,1238],{"class":49},"();          ",[39,1240,1241],{"class":203},"\u002F\u002F requires T: Copy\n",[110,1243,1244,1251,1254,1265],{},[113,1245,1246,1247,1250],{},"Zero-cost interior mutability for ",[22,1248,1249],{},"Copy"," types.",[113,1252,1253],{},"No borrow checking (just stores the value).",[113,1255,1256,1257,1260,1261,447,1263,158],{},"Cannot get a ",[22,1258,1259],{},"&T"," out (only ",[22,1262,1235],{},[22,1264,1211],{},[113,1266,1267,1268,1250],{},"Use for simple flags, counters, small ",[22,1269,1249],{},[18,1271,1273,1276],{"id":1272},"refcellt-borrow-checked-interior-mutability",[22,1274,1275],{},"RefCell\u003CT>"," — Borrow-Checked Interior Mutability",[27,1278,1279],{"language":29},[31,1280,1282],{"className":33,"code":1281,"language":29,"meta":35,"style":35},"use std::cell::RefCell;\nlet c = RefCell::new(vec![1, 2, 3]);\nc.borrow_mut().push(4);\nlet r = c.borrow();      \u002F\u002F immutable borrow\nprintln!(\"{:?}\", r);\n",[22,1283,1284,1300,1333,1353,1375],{"__ignoreMap":35},[39,1285,1286,1288,1290,1292,1294,1296,1298],{"class":41,"line":42},[39,1287,328],{"class":45},[39,1289,331],{"class":56},[39,1291,60],{"class":45},[39,1293,1173],{"class":56},[39,1295,60],{"class":45},[39,1297,482],{"class":56},[39,1299,344],{"class":49},[39,1301,1302,1304,1306,1308,1311,1313,1315,1317,1319,1321,1323,1325,1327,1329,1331],{"class":41,"line":76},[39,1303,46],{"class":45},[39,1305,407],{"class":49},[39,1307,53],{"class":45},[39,1309,1310],{"class":56}," RefCell",[39,1312,60],{"class":45},[39,1314,63],{"class":56},[39,1316,66],{"class":49},[39,1318,278],{"class":56},[39,1320,281],{"class":49},[39,1322,284],{"class":69},[39,1324,189],{"class":49},[39,1326,289],{"class":69},[39,1328,189],{"class":49},[39,1330,294],{"class":69},[39,1332,750],{"class":49},[39,1334,1335,1337,1339,1341,1343,1345,1347,1349,1351],{"class":41,"line":207},[39,1336,1206],{"class":49},[39,1338,300],{"class":45},[39,1340,541],{"class":56},[39,1342,544],{"class":49},[39,1344,300],{"class":45},[39,1346,549],{"class":56},[39,1348,66],{"class":49},[39,1350,554],{"class":69},[39,1352,73],{"class":49},[39,1354,1355,1357,1360,1362,1364,1366,1369,1372],{"class":41,"line":216},[39,1356,46],{"class":45},[39,1358,1359],{"class":49}," r ",[39,1361,53],{"class":45},[39,1363,1230],{"class":49},[39,1365,300],{"class":45},[39,1367,1368],{"class":56},"borrow",[39,1370,1371],{"class":49},"();      ",[39,1373,1374],{"class":203},"\u002F\u002F immutable borrow\n",[39,1376,1377,1380,1382,1384],{"class":41,"line":425},[39,1378,1379],{"class":56},"println!",[39,1381,66],{"class":49},[39,1383,802],{"class":104},[39,1385,1386],{"class":49},", r);\n",[110,1388,1389,1403,1412],{},[113,1390,1391,1392,1395,1396,818,1399,1402],{},"Moves borrow checking to ",[435,1393,1394],{},"runtime",": ",[22,1397,1398],{},"borrow()",[22,1400,1401],{},"borrow_mut()"," track active borrows.",[113,1404,1405,1406,1408,1409,1411],{},"Multiple ",[22,1407,1398],{}," OK; one ",[22,1410,1401],{}," exclusive.",[113,1413,1414,1417],{},[435,1415,1416],{},"Panics"," on borrow violation: \"already borrowed\" \u002F \"already mutably borrowed\".",[126,1419,1421,1424,1425],{"id":1420},"try_borrow-try_borrow_mut",[22,1422,1423],{},"try_borrow"," \u002F ",[22,1426,1427],{},"try_borrow_mut",[14,1429,1430,1431,1434],{},"Non-panicking variants returning ",[22,1432,1433],{},"Result",". Useful when you might encounter a borrow conflict gracefully.",[18,1436,1438,818,1441],{"id":1437},"mutext-and-rwlockt",[22,1439,1440],{},"Mutex\u003CT>",[22,1442,1443],{},"RwLock\u003CT>",[27,1445,1446],{"language":29},[31,1447,1449],{"className":33,"code":1448,"language":29,"meta":35,"style":35},"use std::sync::Mutex;\nlet m = Mutex::new(0);\nlet guard = m.lock().unwrap();\n*guard += 1;\n\u002F\u002F guard drops here, unlocking\n\nuse std::sync::RwLock;\nlet rw = RwLock::new(0);\n{\n    let r1 = rw.read().unwrap();\n    let r2 = rw.read().unwrap();   \u002F\u002F multiple readers OK\n}\n{\n    let mut w = rw.write().unwrap();  \u002F\u002F exclusive writer\n    *w += 1;\n}\n",[22,1450,1451,1467,1489,1514,1527,1532,1536,1553,1576,1582,1609,1637,1642,1647,1678,1693],{"__ignoreMap":35},[39,1452,1453,1455,1457,1459,1461,1463,1465],{"class":41,"line":42},[39,1454,328],{"class":45},[39,1456,331],{"class":56},[39,1458,60],{"class":45},[39,1460,710],{"class":56},[39,1462,60],{"class":45},[39,1464,1020],{"class":56},[39,1466,344],{"class":49},[39,1468,1469,1471,1474,1476,1479,1481,1483,1485,1487],{"class":41,"line":76},[39,1470,46],{"class":45},[39,1472,1473],{"class":49}," m ",[39,1475,53],{"class":45},[39,1477,1478],{"class":56}," Mutex",[39,1480,60],{"class":45},[39,1482,63],{"class":56},[39,1484,66],{"class":49},[39,1486,1059],{"class":69},[39,1488,73],{"class":49},[39,1490,1491,1493,1496,1498,1501,1503,1505,1507,1509,1511],{"class":41,"line":207},[39,1492,46],{"class":45},[39,1494,1495],{"class":49}," guard ",[39,1497,53],{"class":45},[39,1499,1500],{"class":49}," m",[39,1502,300],{"class":45},[39,1504,1133],{"class":56},[39,1506,544],{"class":49},[39,1508,300],{"class":45},[39,1510,1140],{"class":56},[39,1512,1513],{"class":49},"();\n",[39,1515,1516,1518,1521,1523,1525],{"class":41,"line":216},[39,1517,930],{"class":45},[39,1519,1520],{"class":49},"guard ",[39,1522,1076],{"class":45},[39,1524,1079],{"class":69},[39,1526,344],{"class":49},[39,1528,1529],{"class":41,"line":425},[39,1530,1531],{"class":203},"\u002F\u002F guard drops here, unlocking\n",[39,1533,1534],{"class":41,"line":1095},[39,1535,1087],{"emptyLinePlaceholder":1086},[39,1537,1538,1540,1542,1544,1546,1548,1551],{"class":41,"line":1124},[39,1539,328],{"class":45},[39,1541,331],{"class":56},[39,1543,60],{"class":45},[39,1545,710],{"class":56},[39,1547,60],{"class":45},[39,1549,1550],{"class":56},"RwLock",[39,1552,344],{"class":49},[39,1554,1556,1558,1561,1563,1566,1568,1570,1572,1574],{"class":41,"line":1555},8,[39,1557,46],{"class":45},[39,1559,1560],{"class":49}," rw ",[39,1562,53],{"class":45},[39,1564,1565],{"class":56}," RwLock",[39,1567,60],{"class":45},[39,1569,63],{"class":56},[39,1571,66],{"class":49},[39,1573,1059],{"class":69},[39,1575,73],{"class":49},[39,1577,1579],{"class":41,"line":1578},9,[39,1580,1581],{"class":49},"{\n",[39,1583,1585,1588,1591,1593,1596,1598,1601,1603,1605,1607],{"class":41,"line":1584},10,[39,1586,1587],{"class":45},"    let",[39,1589,1590],{"class":49}," r1 ",[39,1592,53],{"class":45},[39,1594,1595],{"class":49}," rw",[39,1597,300],{"class":45},[39,1599,1600],{"class":56},"read",[39,1602,544],{"class":49},[39,1604,300],{"class":45},[39,1606,1140],{"class":56},[39,1608,1513],{"class":49},[39,1610,1612,1614,1617,1619,1621,1623,1625,1627,1629,1631,1634],{"class":41,"line":1611},11,[39,1613,1587],{"class":45},[39,1615,1616],{"class":49}," r2 ",[39,1618,53],{"class":45},[39,1620,1595],{"class":49},[39,1622,300],{"class":45},[39,1624,1600],{"class":56},[39,1626,544],{"class":49},[39,1628,300],{"class":45},[39,1630,1140],{"class":56},[39,1632,1633],{"class":49},"();   ",[39,1635,1636],{"class":203},"\u002F\u002F multiple readers OK\n",[39,1638,1640],{"class":41,"line":1639},12,[39,1641,219],{"class":49},[39,1643,1645],{"class":41,"line":1644},13,[39,1646,1581],{"class":49},[39,1648,1650,1652,1654,1657,1659,1661,1663,1666,1668,1670,1672,1675],{"class":41,"line":1649},14,[39,1651,1587],{"class":45},[39,1653,255],{"class":45},[39,1655,1656],{"class":49}," w ",[39,1658,53],{"class":45},[39,1660,1595],{"class":49},[39,1662,300],{"class":45},[39,1664,1665],{"class":56},"write",[39,1667,544],{"class":49},[39,1669,300],{"class":45},[39,1671,1140],{"class":56},[39,1673,1674],{"class":49},"();  ",[39,1676,1677],{"class":203},"\u002F\u002F exclusive writer\n",[39,1679,1681,1684,1687,1689,1691],{"class":41,"line":1680},15,[39,1682,1683],{"class":45},"    *",[39,1685,1686],{"class":49},"w ",[39,1688,1076],{"class":45},[39,1690,1079],{"class":69},[39,1692,344],{"class":49},[39,1694,1696],{"class":41,"line":1695},16,[39,1697,219],{"class":49},[110,1699,1700,1705,1710,1719],{},[113,1701,1702,1704],{},[22,1703,1020],{},": one accessor at a time.",[113,1706,1707,1709],{},[22,1708,1550],{},": many readers or one writer.",[113,1711,1712,1713,1715,1716,300],{},"Locks return ",[22,1714,1433],{}," because a poisoned lock (holder panicked) returns ",[22,1717,1718],{},"Err",[113,1720,1721,1724],{},[22,1722,1723],{},"Lock"," guards auto-unlock on drop (RAII).",[126,1726,1728],{"id":1727},"poison","Poison",[14,1730,1731,1732,1735,1736,1738,1739,1742,1743,1746],{},"If a thread panics while holding a lock, the lock becomes \"poisoned\"; subsequent ",[22,1733,1734],{},".lock()"," returns ",[22,1737,1718],{},". This signals possibly-corrupted state. Recover with ",[22,1740,1741],{},"into_inner()"," if you're sure, or use ",[22,1744,1745],{},"lock().unwrap()"," to propagate the panic.",[18,1748,1750,189,1753,189,1756,1759],{"id":1749},"once-oncelock-lazylock-initialization",[22,1751,1752],{},"Once",[22,1754,1755],{},"OnceLock",[22,1757,1758],{},"LazyLock"," — Initialization",[27,1761,1762],{"language":29},[31,1763,1765],{"className":33,"code":1764,"language":29,"meta":35,"style":35},"use std::sync::OnceLock;\nstatic CONFIG: OnceLock\u003CConfig> = OnceLock::new();\nlet c = CONFIG.get_or_init(|| Config::load());\n\n\u002F\u002F 1.80+: LazyLock\nuse std::sync::LazyLock;\nstatic DB: LazyLock\u003CDb> = LazyLock::new(|| Db::open());\nlet _ = &*DB;     \u002F\u002F initialized on first access\n",[22,1766,1767,1783,1812,1842,1846,1851,1867,1908],{"__ignoreMap":35},[39,1768,1769,1771,1773,1775,1777,1779,1781],{"class":41,"line":42},[39,1770,328],{"class":45},[39,1772,331],{"class":56},[39,1774,60],{"class":45},[39,1776,710],{"class":56},[39,1778,60],{"class":45},[39,1780,1755],{"class":56},[39,1782,344],{"class":49},[39,1784,1785,1787,1790,1792,1795,1797,1800,1802,1804,1806,1808,1810],{"class":41,"line":76},[39,1786,252],{"class":45},[39,1788,1789],{"class":69}," CONFIG",[39,1791,243],{"class":45},[39,1793,1794],{"class":56}," OnceLock",[39,1796,194],{"class":49},[39,1798,1799],{"class":56},"Config",[39,1801,632],{"class":49},[39,1803,53],{"class":45},[39,1805,1794],{"class":56},[39,1807,60],{"class":45},[39,1809,63],{"class":56},[39,1811,1513],{"class":49},[39,1813,1814,1816,1818,1820,1822,1824,1827,1829,1832,1835,1837,1840],{"class":41,"line":207},[39,1815,46],{"class":45},[39,1817,407],{"class":49},[39,1819,53],{"class":45},[39,1821,1789],{"class":69},[39,1823,300],{"class":45},[39,1825,1826],{"class":56},"get_or_init",[39,1828,66],{"class":49},[39,1830,1831],{"class":45},"||",[39,1833,1834],{"class":56}," Config",[39,1836,60],{"class":45},[39,1838,1839],{"class":56},"load",[39,1841,306],{"class":49},[39,1843,1844],{"class":41,"line":216},[39,1845,1087],{"emptyLinePlaceholder":1086},[39,1847,1848],{"class":41,"line":425},[39,1849,1850],{"class":203},"\u002F\u002F 1.80+: LazyLock\n",[39,1852,1853,1855,1857,1859,1861,1863,1865],{"class":41,"line":1095},[39,1854,328],{"class":45},[39,1856,331],{"class":56},[39,1858,60],{"class":45},[39,1860,710],{"class":56},[39,1862,60],{"class":45},[39,1864,1758],{"class":56},[39,1866,344],{"class":49},[39,1868,1869,1871,1874,1876,1879,1881,1884,1886,1888,1890,1892,1894,1896,1898,1901,1903,1906],{"class":41,"line":1124},[39,1870,252],{"class":45},[39,1872,1873],{"class":69}," DB",[39,1875,243],{"class":45},[39,1877,1878],{"class":56}," LazyLock",[39,1880,194],{"class":49},[39,1882,1883],{"class":56},"Db",[39,1885,632],{"class":49},[39,1887,53],{"class":45},[39,1889,1878],{"class":56},[39,1891,60],{"class":45},[39,1893,63],{"class":56},[39,1895,66],{"class":49},[39,1897,1831],{"class":45},[39,1899,1900],{"class":56}," Db",[39,1902,60],{"class":45},[39,1904,1905],{"class":56},"open",[39,1907,306],{"class":49},[39,1909,1910,1912,1915,1917,1920,1923,1926],{"class":41,"line":1555},[39,1911,46],{"class":45},[39,1913,1914],{"class":49}," _ ",[39,1916,53],{"class":45},[39,1918,1919],{"class":45}," &*",[39,1921,1922],{"class":69},"DB",[39,1924,1925],{"class":49},";     ",[39,1927,1928],{"class":203},"\u002F\u002F initialized on first access\n",[14,1930,1931,1932,1934,1935,1938,1939,1942],{},"Pre-",[22,1933,1758],{}," you'd use the ",[22,1936,1937],{},"once_cell"," or ",[22,1940,1941],{},"lazy_static"," crates. Modern std has you covered.",[18,1944,1946,1949],{"id":1945},"cowt-clone-on-write",[22,1947,1948],{},"Cow\u003CT>"," — Clone-on-Write",[27,1951,1952],{"language":29},[31,1953,1955],{"className":33,"code":1954,"language":29,"meta":35,"style":35},"use std::borrow::Cow;\nfn greet(name: Cow\u003Cstr>) {\n    println!(\"{name}\");\n}\ngreet(\"literal\".into());           \u002F\u002F borrowed\ngreet(String::from(\"owned\").into()); \u002F\u002F owned\n",[22,1956,1957,1974,1998,2010,2014,2035],{"__ignoreMap":35},[39,1958,1959,1961,1963,1965,1967,1969,1972],{"class":41,"line":42},[39,1960,328],{"class":45},[39,1962,331],{"class":56},[39,1964,60],{"class":45},[39,1966,1368],{"class":56},[39,1968,60],{"class":45},[39,1970,1971],{"class":56},"Cow",[39,1973,344],{"class":49},[39,1975,1976,1979,1982,1985,1987,1990,1992,1995],{"class":41,"line":76},[39,1977,1978],{"class":45},"fn",[39,1980,1981],{"class":56}," greet",[39,1983,1984],{"class":49},"(name",[39,1986,243],{"class":45},[39,1988,1989],{"class":56}," Cow",[39,1991,194],{"class":49},[39,1993,1994],{"class":56},"str",[39,1996,1997],{"class":49},">) {\n",[39,1999,2000,2003,2005,2008],{"class":41,"line":207},[39,2001,2002],{"class":56},"    println!",[39,2004,66],{"class":49},[39,2006,2007],{"class":104},"\"{name}\"",[39,2009,73],{"class":49},[39,2011,2012],{"class":41,"line":216},[39,2013,219],{"class":49},[39,2015,2016,2019,2021,2024,2026,2029,2032],{"class":41,"line":425},[39,2017,2018],{"class":56},"greet",[39,2020,66],{"class":49},[39,2022,2023],{"class":104},"\"literal\"",[39,2025,300],{"class":45},[39,2027,2028],{"class":56},"into",[39,2030,2031],{"class":49},"());           ",[39,2033,2034],{"class":203},"\u002F\u002F borrowed\n",[39,2036,2037,2039,2041,2043,2045,2047,2049,2052,2055,2057,2059,2062],{"class":41,"line":1095},[39,2038,2018],{"class":56},[39,2040,66],{"class":49},[39,2042,94],{"class":56},[39,2044,60],{"class":45},[39,2046,99],{"class":56},[39,2048,66],{"class":49},[39,2050,2051],{"class":104},"\"owned\"",[39,2053,2054],{"class":49},")",[39,2056,300],{"class":45},[39,2058,2028],{"class":56},[39,2060,2061],{"class":49},"()); ",[39,2063,2064],{"class":203},"\u002F\u002F owned\n",[14,2066,2067,2070],{},[22,2068,2069],{},"Cow\u003C'a, B>"," is either borrowed or owned — lets you write APIs that accept either, deferring the clone until mutation.",[27,2072,2073],{"language":29},[31,2074,2076],{"className":33,"code":2075,"language":29,"meta":35,"style":35},"let mut c: Cow\u003Cstr> = Cow::Borrowed(\"hi\");\nc.to_mut().push('!');     \u002F\u002F clones once, now owned\n",[22,2077,2078,2111],{"__ignoreMap":35},[39,2079,2080,2082,2084,2086,2088,2090,2092,2094,2096,2098,2100,2102,2105,2107,2109],{"class":41,"line":42},[39,2081,46],{"class":45},[39,2083,255],{"class":45},[39,2085,1230],{"class":49},[39,2087,243],{"class":45},[39,2089,1989],{"class":56},[39,2091,194],{"class":49},[39,2093,1994],{"class":56},[39,2095,632],{"class":49},[39,2097,53],{"class":45},[39,2099,1989],{"class":56},[39,2101,60],{"class":45},[39,2103,2104],{"class":56},"Borrowed",[39,2106,66],{"class":49},[39,2108,105],{"class":104},[39,2110,73],{"class":49},[39,2112,2113,2115,2117,2120,2122,2124,2126,2128,2131,2134],{"class":41,"line":76},[39,2114,1206],{"class":49},[39,2116,300],{"class":45},[39,2118,2119],{"class":56},"to_mut",[39,2121,544],{"class":49},[39,2123,300],{"class":45},[39,2125,549],{"class":56},[39,2127,66],{"class":49},[39,2129,2130],{"class":104},"'!'",[39,2132,2133],{"class":49},");     ",[39,2135,2136],{"class":203},"\u002F\u002F clones once, now owned\n",[18,2138,2140,2143],{"id":2139},"pint-pinned-pointers",[22,2141,2142],{},"Pin\u003CT>"," — Pinned Pointers",[14,2145,2146,2149,2150,2153],{},[22,2147,2148],{},"Pin"," guarantees a value won't be moved in memory after pinning. Essential for self-referential data (e.g., async futures holding references across ",[22,2151,2152],{},".await"," points):",[27,2155,2156],{"language":29},[31,2157,2159],{"className":33,"code":2158,"language":29,"meta":35,"style":35},"let mut fut = async { 5 };\nlet pinned = Pin::new(&mut fut);\n",[22,2160,2161,2183],{"__ignoreMap":35},[39,2162,2163,2165,2167,2170,2172,2175,2178,2180],{"class":41,"line":42},[39,2164,46],{"class":45},[39,2166,255],{"class":45},[39,2168,2169],{"class":49}," fut ",[39,2171,53],{"class":45},[39,2173,2174],{"class":45}," async",[39,2176,2177],{"class":49}," { ",[39,2179,70],{"class":69},[39,2181,2182],{"class":49}," };\n",[39,2184,2185,2187,2190,2192,2195,2197,2199,2201,2204],{"class":41,"line":76},[39,2186,46],{"class":45},[39,2188,2189],{"class":49}," pinned ",[39,2191,53],{"class":45},[39,2193,2194],{"class":56}," Pin",[39,2196,60],{"class":45},[39,2198,63],{"class":56},[39,2200,66],{"class":49},[39,2202,2203],{"class":45},"&mut",[39,2205,2206],{"class":49}," fut);\n",[14,2208,2209,2210,2212],{},"You usually don't write ",[22,2211,2148],{}," by hand — async\u002Fawait generates it. The Pin chapter (Async) covers the details.",[18,2214,2216,189,2219,189,2222,2225],{"id":2215},"nonnullt-mut-t-const-t-unsafe",[22,2217,2218],{},"NonNull\u003CT>",[22,2220,2221],{},"*mut T",[22,2223,2224],{},"*const T"," (Unsafe)",[14,2227,2228,2229,2232,2233,2235,2236,2238],{},"Raw pointers, no automatic lifetime tracking; only usable in ",[22,2230,2231],{},"unsafe"," blocks. ",[22,2234,2218],{}," is non-null ",[22,2237,2221],{}," and is covariant. Used in collections\u002FFFI. See Unsafe chapter.",[18,2240,2242],{"id":2241},"smart-pointer-cheat-sheet","Smart Pointer Cheat Sheet",[2244,2245,2246,2268],"table",{},[2247,2248,2249],"thead",{},[2250,2251,2252,2256,2259,2262,2265],"tr",{},[2253,2254,2255],"th",{},"Type",[2253,2257,2258],{},"Ownership",[2253,2260,2261],{},"Mutability",[2253,2263,2264],{},"Thread-safe",[2253,2266,2267],{},"Use",[2269,2270,2271,2296,2316,2336,2356,2372,2387,2403,2424],"tbody",{},[2250,2272,2273,2278,2281,2287,2293],{},[2274,2275,2276],"td",{},[22,2277,24],{},[2274,2279,2280],{},"Single",[2274,2282,2283,2284,2054],{},"direct (",[22,2285,2286],{},"mut",[2274,2288,2289,2290],{},"if ",[22,2291,2292],{},"T: Send",[2274,2294,2295],{},"Heap, recursion",[2250,2297,2298,2302,2305,2310,2313],{},[2274,2299,2300],{},[22,2301,315],{},[2274,2303,2304],{},"Shared",[2274,2306,2307,2308],{},"via ",[22,2309,482],{},[2274,2311,2312],{},"NO",[2274,2314,2315],{},"Graphs, trees",[2250,2317,2318,2322,2324,2330,2333],{},[2274,2319,2320],{},[22,2321,691],{},[2274,2323,2304],{},[2274,2325,2307,2326,447,2328],{},[22,2327,1020],{},[22,2329,1550],{},[2274,2331,2332],{},"YES",[2274,2334,2335],{},"Cross-thread share",[2250,2337,2338,2342,2344,2349,2351],{},[2274,2339,2340],{},[22,2341,1154],{},[2274,2343,2280],{},[2274,2345,2346],{},[22,2347,2348],{},"set\u002Fget",[2274,2350,2312],{},[2274,2352,2353,2355],{},[22,2354,1249],{}," flags",[2250,2357,2358,2362,2364,2367,2369],{},[2274,2359,2360],{},[22,2361,1275],{},[2274,2363,2280],{},[2274,2365,2366],{},"runtime borrow",[2274,2368,2312],{},[2274,2370,2371],{},"Single-thread mut share",[2250,2373,2374,2378,2380,2382,2384],{},[2274,2375,2376],{},[22,2377,1440],{},[2274,2379,2280],{},[2274,2381,1133],{},[2274,2383,2332],{},[2274,2385,2386],{},"Cross-thread mut share",[2250,2388,2389,2393,2395,2398,2400],{},[2274,2390,2391],{},[22,2392,1443],{},[2274,2394,2280],{},[2274,2396,2397],{},"read\u002Fwrite lock",[2274,2399,2332],{},[2274,2401,2402],{},"Read-heavy share",[2250,2404,2405,2409,2412,2416,2421],{},[2274,2406,2407],{},[22,2408,2069],{},[2274,2410,2411],{},"Either",[2274,2413,2414],{},[22,2415,2119],{},[2274,2417,2289,2418],{},[22,2419,2420],{},"B: Send",[2274,2422,2423],{},"Borrowed-or-owned",[2250,2425,2426,2431,2434,2439,2444],{},[2274,2427,2428],{},[22,2429,2430],{},"Pin\u003CP>",[2274,2432,2433],{},"(wrapper)",[2274,2435,2307,2436],{},[22,2437,2438],{},"DerefMut",[2274,2440,2289,2441],{},[22,2442,2443],{},"P: Send",[2274,2445,2446],{},"Self-referential",[18,2448,2450],{"id":2449},"deref-and-derefmut","Deref and DerefMut",[14,2452,2453,2454,447,2457,2459,2460,2462],{},"Smart pointers implement ",[22,2455,2456],{},"Deref",[22,2458,2438],{}," to enable ",[22,2461,394],{},"-coercions and method forwarding:",[27,2464,2465],{"language":29},[31,2466,2468],{"className":33,"code":2467,"language":29,"meta":35,"style":35},"let b = Box::new(String::from(\"hi\"));\nb.push('!');              \u002F\u002F Box\u003CString> derefs to String, which derefs to str\nlet s: &str = &b;          \u002F\u002F &Box\u003CString> -> &String -> &str\n",[22,2469,2470,2498,2516],{"__ignoreMap":35},[39,2471,2472,2474,2476,2478,2480,2482,2484,2486,2488,2490,2492,2494,2496],{"class":41,"line":42},[39,2473,46],{"class":45},[39,2475,50],{"class":49},[39,2477,53],{"class":45},[39,2479,57],{"class":56},[39,2481,60],{"class":45},[39,2483,63],{"class":56},[39,2485,66],{"class":49},[39,2487,94],{"class":56},[39,2489,60],{"class":45},[39,2491,99],{"class":56},[39,2493,66],{"class":49},[39,2495,105],{"class":104},[39,2497,108],{"class":49},[39,2499,2500,2502,2504,2506,2508,2510,2513],{"class":41,"line":76},[39,2501,966],{"class":49},[39,2503,300],{"class":45},[39,2505,549],{"class":56},[39,2507,66],{"class":49},[39,2509,2130],{"class":104},[39,2511,2512],{"class":49},");              ",[39,2514,2515],{"class":203},"\u002F\u002F Box\u003CString> derefs to String, which derefs to str\n",[39,2517,2518,2520,2523,2525,2527,2529,2532,2534,2537],{"class":41,"line":207},[39,2519,46],{"class":45},[39,2521,2522],{"class":49}," s",[39,2524,243],{"class":45},[39,2526,246],{"class":45},[39,2528,1994],{"class":56},[39,2530,2531],{"class":45}," =",[39,2533,246],{"class":45},[39,2535,2536],{"class":49},"b;          ",[39,2538,2539],{"class":203},"\u002F\u002F &Box\u003CString> -> &String -> &str\n",[18,2541,2543],{"id":2542},"drop-order-for-smart-pointers","Drop Order for Smart Pointers",[110,2545,2546,2555],{},[113,2547,2548,447,2550,447,2552,2554],{},[22,2549,132],{},[22,2551,341],{},[22,2553,454],{}," drop their contents when refcount hits 0.",[113,2556,2557,447,2560,2563],{},[22,2558,2559],{},"MutexGuard",[22,2561,2562],{},"RwLockReadGuard"," release the lock on drop — keep guards short-scoped.",[18,2565,2567],{"id":2566},"common-pitfalls","Common Pitfalls",[110,2569,2570,2581,2592,2598,2604,2618,2629,2638],{},[113,2571,2572,1395,2577,2580],{},[435,2573,2574,2576],{},[22,2575,341],{}," across threads",[22,2578,2579],{},"Rc: !Send",", compile error.",[113,2582,2583,2591],{},[435,2584,2585,834,2588],{},[22,2586,2587],{},"Arc\u003CMutex\u003CT>>",[22,2589,2590],{},"Mutex\u003CArc\u003CT>>",": the former mutates shared data; the latter replaces the entire shared pointer atomically.",[113,2593,2594,2597],{},[435,2595,2596],{},"Lock granularity",": too coarse = contention; too fine = deadlocks.",[113,2599,2600,2603],{},[435,2601,2602],{},"Deadlock",": lock ordering must be consistent across threads. Acquire locks in a fixed order.",[113,2605,2606,2614,2615,2617],{},[435,2607,2608,834,2611],{},[22,2609,2610],{},"Rc::clone",[22,2612,2613],{},"Clone::clone",": same; ",[22,2616,463],{}," makes it obvious it's cheap.",[113,2619,2620,2628],{},[435,2621,2622,1735,2625],{},[22,2623,2624],{},"Weak::upgrade",[22,2626,2627],{},"Option",": handle the case where the value was dropped.",[113,2630,2631,2637],{},[435,2632,2633,2636],{},[22,2634,2635],{},"RefCell::borrow_mut"," panic",": can happen in complex call graphs; structure borrows to release before re-borrowing.",[113,2639,2640,2645],{},[435,2641,2642],{},[22,2643,2644],{},"Mutex::lock().unwrap()",": panics on poison. Consider graceful recovery.",[18,2647,2649],{"id":2648},"memory-layout-of-smart-pointers","Memory Layout of Smart Pointers",[110,2651,2652,2657,2668,2678],{},[113,2653,2654,2656],{},[22,2655,24],{},": a single pointer.",[113,2658,2659,447,2661,2663,2664,2667],{},[22,2660,315],{},[22,2662,691],{},": pointer to a heap-allocated ",[22,2665,2666],{},"{ strong_count, weak_count, value }"," block.",[113,2669,2670,447,2672,2674,2675,2677],{},[22,2671,1154],{},[22,2673,1275],{},": in-place storage; ",[22,2676,482],{}," adds a borrow-state field.",[113,2679,2680,447,2682,2684],{},[22,2681,1440],{},[22,2683,1443],{},": in-place storage + OS synchronization primitives.",[18,2686,2688],{"id":2687},"summary","Summary",[14,2690,2691,2693,2694,447,2696,2698,2699,447,2701,447,2703,447,2705,2707,2708,2710,2711,2713,2714,2716,2717,2719],{},[22,2692,132],{}," = single-owner heap. ",[22,2695,341],{},[22,2697,454],{}," = shared ownership. ",[22,2700,1178],{},[22,2702,482],{},[22,2704,1020],{},[22,2706,1550],{}," = interior mutability. ",[22,2709,1971],{}," = borrowed-or-owned. ",[22,2712,2148],{}," = no-move guarantee for async. ",[22,2715,589],{}," avoids cycles. Memory leaks via reference cycles are possible in safe Rust — design with ",[22,2718,589],{}," back-references.",[14,2721,2722],{},"Next: Modules and crates — organizing code.",[2724,2725,2726],"style",{},"html pre.shiki code .svdQ7, html code.shiki .svdQ7{--shiki-default:#D73A49;--shiki-github-dark:#F97583}html pre.shiki code .ssxIu, html code.shiki .ssxIu{--shiki-default:#24292E;--shiki-github-dark:#E1E4E8}html pre.shiki code .sIsaT, html code.shiki .sIsaT{--shiki-default:#6F42C1;--shiki-github-dark:#B392F0}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":35,"searchDepth":76,"depth":76,"links":2728},[2729,2736,2742,2747,2748,2749,2751,2756,2760,2762,2764,2766,2768,2769,2770,2771,2772,2773],{"id":20,"depth":76,"text":2730,"children":2731},"Box\u003CT> — Heap Allocation",[2732,2734],{"id":128,"depth":207,"text":2733},"When You Need Box",{"id":222,"depth":207,"text":2735},"Box::leak — Permanent Reference",{"id":312,"depth":76,"text":2737,"children":2738},"Rc\u003CT> — Reference Counted (single-threaded)",[2739,2741],{"id":471,"depth":207,"text":2740},"Rc Doesn't Allow Mutation",{"id":559,"depth":207,"text":560},{"id":688,"depth":76,"text":2743,"children":2744},"Arc\u003CT> — Atomic Reference Counted (thread-safe)",[2745],{"id":830,"depth":207,"text":2746},"When Rc vs Arc",{"id":860,"depth":76,"text":861},{"id":1007,"depth":76,"text":1008},{"id":1151,"depth":76,"text":2750},"Cell\u003CT> — Copy-Type Interior Mutability",{"id":1272,"depth":76,"text":2752,"children":2753},"RefCell\u003CT> — Borrow-Checked Interior Mutability",[2754],{"id":1420,"depth":207,"text":2755},"try_borrow \u002F try_borrow_mut",{"id":1437,"depth":76,"text":2757,"children":2758},"Mutex\u003CT> and RwLock\u003CT>",[2759],{"id":1727,"depth":207,"text":1728},{"id":1749,"depth":76,"text":2761},"Once, OnceLock, LazyLock — Initialization",{"id":1945,"depth":76,"text":2763},"Cow\u003CT> — Clone-on-Write",{"id":2139,"depth":76,"text":2765},"Pin\u003CT> — Pinned Pointers",{"id":2215,"depth":76,"text":2767},"NonNull\u003CT>, *mut T, *const T (Unsafe)",{"id":2241,"depth":76,"text":2242},{"id":2449,"depth":76,"text":2450},{"id":2542,"depth":76,"text":2543},{"id":2566,"depth":76,"text":2567},{"id":2648,"depth":76,"text":2649},{"id":2687,"depth":76,"text":2688},"md",{},"\u002Frust\u002F19-smart-pointers",{"title":5,"description":16},"rust\u002F19-smart-pointers","-U_d4nMi5SGsdqehGP6A9WiJWuH1Z3fGisTfLt3aWFA",1785944093246]