[{"data":1,"prerenderedAt":1667},["ShallowReactive",2],{"page-\u002Frust\u002F08-references-and-borrowing":3},{"id":4,"title":5,"body":6,"description":1660,"extension":1661,"meta":1662,"navigation":95,"path":1663,"seo":1664,"stem":1665,"__hash__":1666},"content\u002Frust\u002F08-references-and-borrowing.md","08 — References & Borrowing",{"type":7,"value":8,"toc":1633},"minimark",[9,13,22,31,169,201,208,301,329,333,353,360,478,482,488,567,570,574,662,674,678,793,796,871,875,878,973,976,980,1049,1056,1060,1068,1145,1155,1171,1247,1254,1260,1364,1382,1392,1446,1455,1459,1515,1522,1565,1574,1580,1583,1593,1603,1607,1626,1629],[10,11,5],"h1",{"id":12},"_08-references-borrowing",[14,15,16,17,21],"p",{},"Ownership is heavy. ",[18,19,20],"strong",{},"References"," let you use a value without taking ownership.",[23,24,26,27],"h2",{"id":25},"shared-references-t","Shared References ",[28,29,30],"code",{},"&T",[32,33,35],"code-wrapper",{"language":34},"rust",[36,37,41],"pre",{"className":38,"code":39,"language":34,"meta":40,"style":40},"language-rust shiki shiki-themes github-light github-dark","fn len(s: &String) -> usize { s.len() }\n\nlet s = String::from(\"hi\");\nlet l = len(&s);     \u002F\u002F borrow — s still owned by caller\nprintln!(\"{s} {l}\"); \u002F\u002F OK\n","",[28,42,43,90,97,128,152],{"__ignoreMap":40},[44,45,48,52,56,60,63,66,69,72,75,78,81,84,87],"span",{"class":46,"line":47},"line",1,[44,49,51],{"class":50},"svdQ7","fn",[44,53,55],{"class":54},"sIsaT"," len",[44,57,59],{"class":58},"ssxIu","(s",[44,61,62],{"class":50},":",[44,64,65],{"class":50}," &",[44,67,68],{"class":54},"String",[44,70,71],{"class":58},") ",[44,73,74],{"class":50},"->",[44,76,77],{"class":54}," usize",[44,79,80],{"class":58}," { s",[44,82,83],{"class":50},".",[44,85,86],{"class":54},"len",[44,88,89],{"class":58},"() }\n",[44,91,93],{"class":46,"line":92},2,[44,94,96],{"emptyLinePlaceholder":95},true,"\n",[44,98,100,103,106,109,112,115,118,121,125],{"class":46,"line":99},3,[44,101,102],{"class":50},"let",[44,104,105],{"class":58}," s ",[44,107,108],{"class":50},"=",[44,110,111],{"class":54}," String",[44,113,114],{"class":50},"::",[44,116,117],{"class":54},"from",[44,119,120],{"class":58},"(",[44,122,124],{"class":123},"sJ6F3","\"hi\"",[44,126,127],{"class":58},");\n",[44,129,131,133,136,138,140,142,145,148],{"class":46,"line":130},4,[44,132,102],{"class":50},[44,134,135],{"class":58}," l ",[44,137,108],{"class":50},[44,139,55],{"class":54},[44,141,120],{"class":58},[44,143,144],{"class":50},"&",[44,146,147],{"class":58},"s);     ",[44,149,151],{"class":150},"sdCPZ","\u002F\u002F borrow — s still owned by caller\n",[44,153,155,158,160,163,166],{"class":46,"line":154},5,[44,156,157],{"class":54},"println!",[44,159,120],{"class":58},[44,161,162],{"class":123},"\"{s} {l}\"",[44,164,165],{"class":58},"); ",[44,167,168],{"class":150},"\u002F\u002F OK\n",[170,171,172,182,192],"ul",{},[173,174,175,177,178,181],"li",{},[28,176,30],{}," is a ",[18,179,180],{},"shared, immutable"," borrow.",[173,183,184,185,188,189,191],{},"You can have ",[18,186,187],{},"any number"," of simultaneous ",[28,190,30],{}," to the same value.",[173,193,194,196,197,200],{},[28,195,30],{}," is ",[28,198,199],{},"Copy"," (the reference itself can be copied).",[23,202,204,205],{"id":203},"mutable-references-mut-t","Mutable References ",[28,206,207],{},"&mut T",[32,209,210],{"language":34},[36,211,213],{"className":38,"code":212,"language":34,"meta":40,"style":40},"fn push(s: &mut String) { s.push('!'); }\n\nlet mut s = String::from(\"hi\");\npush(&mut s);\nprintln!(\"{s}\");   \u002F\u002F \"hi!\"\n",[28,214,215,247,251,274,286],{"__ignoreMap":40},[44,216,217,219,222,224,226,229,231,234,236,239,241,244],{"class":46,"line":47},[44,218,51],{"class":50},[44,220,221],{"class":54}," push",[44,223,59],{"class":58},[44,225,62],{"class":50},[44,227,228],{"class":50}," &mut",[44,230,111],{"class":54},[44,232,233],{"class":58},") { s",[44,235,83],{"class":50},[44,237,238],{"class":54},"push",[44,240,120],{"class":58},[44,242,243],{"class":123},"'!'",[44,245,246],{"class":58},"); }\n",[44,248,249],{"class":46,"line":92},[44,250,96],{"emptyLinePlaceholder":95},[44,252,253,255,258,260,262,264,266,268,270,272],{"class":46,"line":99},[44,254,102],{"class":50},[44,256,257],{"class":50}," mut",[44,259,105],{"class":58},[44,261,108],{"class":50},[44,263,111],{"class":54},[44,265,114],{"class":50},[44,267,117],{"class":54},[44,269,120],{"class":58},[44,271,124],{"class":123},[44,273,127],{"class":58},[44,275,276,278,280,283],{"class":46,"line":130},[44,277,238],{"class":54},[44,279,120],{"class":58},[44,281,282],{"class":50},"&mut",[44,284,285],{"class":58}," s);\n",[44,287,288,290,292,295,298],{"class":46,"line":154},[44,289,157],{"class":54},[44,291,120],{"class":58},[44,293,294],{"class":123},"\"{s}\"",[44,296,297],{"class":58},");   ",[44,299,300],{"class":150},"\u002F\u002F \"hi!\"\n",[170,302,303,311,320],{},[173,304,305,307,308,181],{},[28,306,207],{}," is an ",[18,309,310],{},"exclusive",[173,312,184,313,316,317,319],{},[18,314,315],{},"exactly one"," active ",[28,318,207],{}," at a time.",[173,321,322,323,325,326,328],{},"You cannot mix ",[28,324,30],{}," and ",[28,327,207],{}," to the same data while both are alive.",[23,330,332],{"id":331},"the-borrow-rules","The Borrow Rules",[334,335,336,342],"blockquote",{},[14,337,338,339,62],{},"At any given time, you can have ",[18,340,341],{},"either",[170,343,344,350],{},[173,345,346,347],{},"One mutable reference, ",[18,348,349],{},"or",[173,351,352],{},"Any number of immutable references.",[14,354,355,356,359],{},"These rules are checked at compile time. Violations produce ",[28,357,358],{},"E0502"," (aliased mutable borrow) and similar.",[32,361,362],{"language":34},[36,363,365],{"className":38,"code":364,"language":34,"meta":40,"style":40},"let mut v = vec![1, 2, 3];\nlet r = &v;\nlet r2 = &v;          \u002F\u002F OK — multiple shared\nprintln!(\"{r} {r2}\");\nlet m = &mut v;       \u002F\u002F OK — shared refs ended above (NLL)\nm.push(4);\n",[28,366,367,402,416,433,444,461],{"__ignoreMap":40},[44,368,369,371,373,376,378,381,384,388,391,394,396,399],{"class":46,"line":47},[44,370,102],{"class":50},[44,372,257],{"class":50},[44,374,375],{"class":58}," v ",[44,377,108],{"class":50},[44,379,380],{"class":54}," vec!",[44,382,383],{"class":58},"[",[44,385,387],{"class":386},"snvgF","1",[44,389,390],{"class":58},", ",[44,392,393],{"class":386},"2",[44,395,390],{"class":58},[44,397,398],{"class":386},"3",[44,400,401],{"class":58},"];\n",[44,403,404,406,409,411,413],{"class":46,"line":92},[44,405,102],{"class":50},[44,407,408],{"class":58}," r ",[44,410,108],{"class":50},[44,412,65],{"class":50},[44,414,415],{"class":58},"v;\n",[44,417,418,420,423,425,427,430],{"class":46,"line":99},[44,419,102],{"class":50},[44,421,422],{"class":58}," r2 ",[44,424,108],{"class":50},[44,426,65],{"class":50},[44,428,429],{"class":58},"v;          ",[44,431,432],{"class":150},"\u002F\u002F OK — multiple shared\n",[44,434,435,437,439,442],{"class":46,"line":130},[44,436,157],{"class":54},[44,438,120],{"class":58},[44,440,441],{"class":123},"\"{r} {r2}\"",[44,443,127],{"class":58},[44,445,446,448,451,453,455,458],{"class":46,"line":154},[44,447,102],{"class":50},[44,449,450],{"class":58}," m ",[44,452,108],{"class":50},[44,454,228],{"class":50},[44,456,457],{"class":58}," v;       ",[44,459,460],{"class":150},"\u002F\u002F OK — shared refs ended above (NLL)\n",[44,462,464,467,469,471,473,476],{"class":46,"line":463},6,[44,465,466],{"class":58},"m",[44,468,83],{"class":50},[44,470,238],{"class":54},[44,472,120],{"class":58},[44,474,475],{"class":386},"4",[44,477,127],{"class":58},[23,479,481],{"id":480},"non-lexical-lifetimes-nll","Non-Lexical Lifetimes (NLL)",[14,483,484,485,62],{},"Pre-2018, references were valid until the end of their lexical scope. NLL shrinks a reference's lifetime to its ",[18,486,487],{},"last use",[32,489,490],{"language":34},[36,491,493],{"className":38,"code":492,"language":34,"meta":40,"style":40},"let mut v = vec![1, 2, 3];\nlet r = &v;\nprintln!(\"{r}\");      \u002F\u002F last use of r\nv.push(4);           \u002F\u002F OK — r no longer used\n",[28,494,495,521,533,548],{"__ignoreMap":40},[44,496,497,499,501,503,505,507,509,511,513,515,517,519],{"class":46,"line":47},[44,498,102],{"class":50},[44,500,257],{"class":50},[44,502,375],{"class":58},[44,504,108],{"class":50},[44,506,380],{"class":54},[44,508,383],{"class":58},[44,510,387],{"class":386},[44,512,390],{"class":58},[44,514,393],{"class":386},[44,516,390],{"class":58},[44,518,398],{"class":386},[44,520,401],{"class":58},[44,522,523,525,527,529,531],{"class":46,"line":92},[44,524,102],{"class":50},[44,526,408],{"class":58},[44,528,108],{"class":50},[44,530,65],{"class":50},[44,532,415],{"class":58},[44,534,535,537,539,542,545],{"class":46,"line":99},[44,536,157],{"class":54},[44,538,120],{"class":58},[44,540,541],{"class":123},"\"{r}\"",[44,543,544],{"class":58},");      ",[44,546,547],{"class":150},"\u002F\u002F last use of r\n",[44,549,550,553,555,557,559,561,564],{"class":46,"line":130},[44,551,552],{"class":58},"v",[44,554,83],{"class":50},[44,556,238],{"class":54},[44,558,120],{"class":58},[44,560,475],{"class":386},[44,562,563],{"class":58},");           ",[44,565,566],{"class":150},"\u002F\u002F OK — r no longer used\n",[14,568,569],{},"Without NLL this would error. With NLL it compiles.",[23,571,573],{"id":572},"reference-scope-edge-cases","Reference Scope Edge Cases",[32,575,576],{"language":34},[36,577,579],{"className":38,"code":578,"language":34,"meta":40,"style":40},"let mut v = vec![1, 2, 3];\nlet r = &v;\nlet r2 = &v;          \u002F\u002F multiple shared OK\nv.push(4);            \u002F\u002F ERROR: cannot borrow v as mutable because r\u002Fr2 alive\nprintln!(\"{r} {r2}\");\n",[28,580,581,607,619,634,652],{"__ignoreMap":40},[44,582,583,585,587,589,591,593,595,597,599,601,603,605],{"class":46,"line":47},[44,584,102],{"class":50},[44,586,257],{"class":50},[44,588,375],{"class":58},[44,590,108],{"class":50},[44,592,380],{"class":54},[44,594,383],{"class":58},[44,596,387],{"class":386},[44,598,390],{"class":58},[44,600,393],{"class":386},[44,602,390],{"class":58},[44,604,398],{"class":386},[44,606,401],{"class":58},[44,608,609,611,613,615,617],{"class":46,"line":92},[44,610,102],{"class":50},[44,612,408],{"class":58},[44,614,108],{"class":50},[44,616,65],{"class":50},[44,618,415],{"class":58},[44,620,621,623,625,627,629,631],{"class":46,"line":99},[44,622,102],{"class":50},[44,624,422],{"class":58},[44,626,108],{"class":50},[44,628,65],{"class":50},[44,630,429],{"class":58},[44,632,633],{"class":150},"\u002F\u002F multiple shared OK\n",[44,635,636,638,640,642,644,646,649],{"class":46,"line":130},[44,637,552],{"class":58},[44,639,83],{"class":50},[44,641,238],{"class":54},[44,643,120],{"class":58},[44,645,475],{"class":386},[44,647,648],{"class":58},");            ",[44,650,651],{"class":150},"\u002F\u002F ERROR: cannot borrow v as mutable because r\u002Fr2 alive\n",[44,653,654,656,658,660],{"class":46,"line":154},[44,655,157],{"class":54},[44,657,120],{"class":58},[44,659,441],{"class":123},[44,661,127],{"class":58},[14,663,664,665,669,670,673],{},"Here the mutable borrow happens ",[666,667,668],"em",{},"before"," the last use of ",[28,671,672],{},"r",", so it's rejected.",[23,675,677],{"id":676},"reborrowing","Reborrowing",[32,679,680],{"language":34},[36,681,683],{"className":38,"code":682,"language":34,"meta":40,"style":40},"let mut s = String::from(\"hi\");\nlet r1: &mut String = &mut s;\nlet r2: &mut String = &mut *r1;    \u002F\u002F reborrow — r1 temporarily inactive\nr2.push('!');\n\u002F\u002F r1 still inactive until r2 dies\nr1.push('!');                       \u002F\u002F OK now\n",[28,684,685,707,728,754,769,774],{"__ignoreMap":40},[44,686,687,689,691,693,695,697,699,701,703,705],{"class":46,"line":47},[44,688,102],{"class":50},[44,690,257],{"class":50},[44,692,105],{"class":58},[44,694,108],{"class":50},[44,696,111],{"class":54},[44,698,114],{"class":50},[44,700,117],{"class":54},[44,702,120],{"class":58},[44,704,124],{"class":123},[44,706,127],{"class":58},[44,708,709,711,714,716,718,720,723,725],{"class":46,"line":92},[44,710,102],{"class":50},[44,712,713],{"class":58}," r1",[44,715,62],{"class":50},[44,717,228],{"class":50},[44,719,111],{"class":54},[44,721,722],{"class":50}," =",[44,724,228],{"class":50},[44,726,727],{"class":58}," s;\n",[44,729,730,732,735,737,739,741,743,745,748,751],{"class":46,"line":99},[44,731,102],{"class":50},[44,733,734],{"class":58}," r2",[44,736,62],{"class":50},[44,738,228],{"class":50},[44,740,111],{"class":54},[44,742,722],{"class":50},[44,744,228],{"class":50},[44,746,747],{"class":50}," *",[44,749,750],{"class":58},"r1;    ",[44,752,753],{"class":150},"\u002F\u002F reborrow — r1 temporarily inactive\n",[44,755,756,759,761,763,765,767],{"class":46,"line":130},[44,757,758],{"class":58},"r2",[44,760,83],{"class":50},[44,762,238],{"class":54},[44,764,120],{"class":58},[44,766,243],{"class":123},[44,768,127],{"class":58},[44,770,771],{"class":46,"line":154},[44,772,773],{"class":150},"\u002F\u002F r1 still inactive until r2 dies\n",[44,775,776,779,781,783,785,787,790],{"class":46,"line":463},[44,777,778],{"class":58},"r1",[44,780,83],{"class":50},[44,782,238],{"class":54},[44,784,120],{"class":58},[44,786,243],{"class":123},[44,788,789],{"class":58},");                       ",[44,791,792],{"class":150},"\u002F\u002F OK now\n",[14,794,795],{},"Reborrowing is the mechanism by which you can chain mutable references through function calls:",[32,797,798],{"language":34},[36,799,801],{"className":38,"code":800,"language":34,"meta":40,"style":40},"fn push_all(dst: &mut Vec\u003Ci32>, src: &[i32]) {\n    for &x in src { dst.push(x); }   \u002F\u002F dst reborrows each call\n}\n",[28,802,803,840,866],{"__ignoreMap":40},[44,804,805,807,810,813,815,817,820,823,826,829,831,833,835,837],{"class":46,"line":47},[44,806,51],{"class":50},[44,808,809],{"class":54}," push_all",[44,811,812],{"class":58},"(dst",[44,814,62],{"class":50},[44,816,228],{"class":50},[44,818,819],{"class":54}," Vec",[44,821,822],{"class":58},"\u003C",[44,824,825],{"class":54},"i32",[44,827,828],{"class":58},">, src",[44,830,62],{"class":50},[44,832,65],{"class":50},[44,834,383],{"class":58},[44,836,825],{"class":54},[44,838,839],{"class":58},"]) {\n",[44,841,842,845,847,850,853,856,858,860,863],{"class":46,"line":92},[44,843,844],{"class":50},"    for",[44,846,65],{"class":50},[44,848,849],{"class":58},"x ",[44,851,852],{"class":50},"in",[44,854,855],{"class":58}," src { dst",[44,857,83],{"class":50},[44,859,238],{"class":54},[44,861,862],{"class":58},"(x); }   ",[44,864,865],{"class":150},"\u002F\u002F dst reborrows each call\n",[44,867,868],{"class":46,"line":99},[44,869,870],{"class":58},"}\n",[23,872,874],{"id":873},"lifetimes-of-references-preview","Lifetimes of References (preview)",[14,876,877],{},"The compiler tracks lifetimes. A function returning a reference must tie its output lifetime to an input:",[32,879,880],{"language":34},[36,881,883],{"className":38,"code":882,"language":34,"meta":40,"style":40},"fn longest\u003C'a>(x: &'a str, y: &'a str) -> &'a str {\n    if x.len() > y.len() { x } else { y }\n}\n",[28,884,885,941,969],{"__ignoreMap":40},[44,886,887,889,892,895,898,901,903,905,908,910,913,916,918,920,922,924,926,928,930,932,934,936,938],{"class":46,"line":47},[44,888,51],{"class":50},[44,890,891],{"class":54}," longest",[44,893,894],{"class":58},"\u003C'",[44,896,897],{"class":54},"a",[44,899,900],{"class":58},">(x",[44,902,62],{"class":50},[44,904,65],{"class":50},[44,906,907],{"class":58},"'",[44,909,897],{"class":54},[44,911,912],{"class":54}," str",[44,914,915],{"class":58},", y",[44,917,62],{"class":50},[44,919,65],{"class":50},[44,921,907],{"class":58},[44,923,897],{"class":54},[44,925,912],{"class":54},[44,927,71],{"class":58},[44,929,74],{"class":50},[44,931,65],{"class":50},[44,933,907],{"class":58},[44,935,897],{"class":54},[44,937,912],{"class":54},[44,939,940],{"class":58}," {\n",[44,942,943,946,949,951,953,956,958,960,963,966],{"class":46,"line":92},[44,944,945],{"class":50},"    if",[44,947,948],{"class":58}," x",[44,950,83],{"class":50},[44,952,86],{"class":54},[44,954,955],{"class":58},"() > y",[44,957,83],{"class":50},[44,959,86],{"class":54},[44,961,962],{"class":58},"() { x } ",[44,964,965],{"class":50},"else",[44,967,968],{"class":58}," { y }\n",[44,970,971],{"class":46,"line":99},[44,972,870],{"class":58},[14,974,975],{},"See the Lifetimes chapter for full details.",[23,977,979],{"id":978},"dangling-references-impossible","Dangling References — Impossible",[32,981,982],{"language":34},[36,983,985],{"className":38,"code":984,"language":34,"meta":40,"style":40},"let r;\n{\n    let s = String::from(\"hi\");\n    r = &s;            \u002F\u002F ERROR: s does not live long enough\n}\nprintln!(\"{r}\");\n",[28,986,987,994,999,1020,1035,1039],{"__ignoreMap":40},[44,988,989,991],{"class":46,"line":47},[44,990,102],{"class":50},[44,992,993],{"class":58}," r;\n",[44,995,996],{"class":46,"line":92},[44,997,998],{"class":58},"{\n",[44,1000,1001,1004,1006,1008,1010,1012,1014,1016,1018],{"class":46,"line":99},[44,1002,1003],{"class":50},"    let",[44,1005,105],{"class":58},[44,1007,108],{"class":50},[44,1009,111],{"class":54},[44,1011,114],{"class":50},[44,1013,117],{"class":54},[44,1015,120],{"class":58},[44,1017,124],{"class":123},[44,1019,127],{"class":58},[44,1021,1022,1025,1027,1029,1032],{"class":46,"line":130},[44,1023,1024],{"class":58},"    r ",[44,1026,108],{"class":50},[44,1028,65],{"class":50},[44,1030,1031],{"class":58},"s;            ",[44,1033,1034],{"class":150},"\u002F\u002F ERROR: s does not live long enough\n",[44,1036,1037],{"class":46,"line":154},[44,1038,870],{"class":58},[44,1040,1041,1043,1045,1047],{"class":46,"line":463},[44,1042,157],{"class":54},[44,1044,120],{"class":58},[44,1046,541],{"class":123},[44,1048,127],{"class":58},[14,1050,1051,1052,1055],{},"The borrow checker rejects code that could produce a dangling reference. This is ",[666,1053,1054],{},"the"," guarantee that prevents use-after-free in safe Rust.",[23,1057,1059],{"id":1058},"reference-coercion","Reference Coercion",[14,1061,1062,1064,1065,1067],{},[28,1063,207],{}," coerces to ",[28,1066,30],{}," when needed:",[32,1069,1070],{"language":34},[36,1071,1073],{"className":38,"code":1072,"language":34,"meta":40,"style":40},"fn len(s: &String) -> usize { s.len() }\nlet mut s = String::from(\"hi\");\nlet l = len(&mut s);     \u002F\u002F &mut String coerces to &String\n",[28,1074,1075,1103,1125],{"__ignoreMap":40},[44,1076,1077,1079,1081,1083,1085,1087,1089,1091,1093,1095,1097,1099,1101],{"class":46,"line":47},[44,1078,51],{"class":50},[44,1080,55],{"class":54},[44,1082,59],{"class":58},[44,1084,62],{"class":50},[44,1086,65],{"class":50},[44,1088,68],{"class":54},[44,1090,71],{"class":58},[44,1092,74],{"class":50},[44,1094,77],{"class":54},[44,1096,80],{"class":58},[44,1098,83],{"class":50},[44,1100,86],{"class":54},[44,1102,89],{"class":58},[44,1104,1105,1107,1109,1111,1113,1115,1117,1119,1121,1123],{"class":46,"line":92},[44,1106,102],{"class":50},[44,1108,257],{"class":50},[44,1110,105],{"class":58},[44,1112,108],{"class":50},[44,1114,111],{"class":54},[44,1116,114],{"class":50},[44,1118,117],{"class":54},[44,1120,120],{"class":58},[44,1122,124],{"class":123},[44,1124,127],{"class":58},[44,1126,1127,1129,1131,1133,1135,1137,1139,1142],{"class":46,"line":99},[44,1128,102],{"class":50},[44,1130,135],{"class":58},[44,1132,108],{"class":50},[44,1134,55],{"class":54},[44,1136,120],{"class":58},[44,1138,282],{"class":50},[44,1140,1141],{"class":58}," s);     ",[44,1143,1144],{"class":150},"\u002F\u002F &mut String coerces to &String\n",[23,1146,1148,1151,1152],{"id":1147},"str-vs-string",[28,1149,1150],{},"&str"," vs ",[28,1153,1154],{},"&String",[14,1156,1157,1159,1160,1162,1163,1165,1166,390,1168,1170],{},[28,1158,1154],{}," auto-derefs to ",[28,1161,1150],{},". Idiomatic API: take ",[28,1164,1150],{}," (more general; accepts ",[28,1167,1154],{},[28,1169,1150],{},", string literals).",[32,1172,1173],{"language":34},[36,1174,1176],{"className":38,"code":1175,"language":34,"meta":40,"style":40},"fn greet(name: &str) { println!(\"hi {name}\"); }\ngreet(\"Ada\");              \u002F\u002F &str\ngreet(&String::from(\"Ada\"));   \u002F\u002F &String coerces to &str\n",[28,1177,1178,1207,1223],{"__ignoreMap":40},[44,1179,1180,1182,1185,1188,1190,1192,1195,1198,1200,1202,1205],{"class":46,"line":47},[44,1181,51],{"class":50},[44,1183,1184],{"class":54}," greet",[44,1186,1187],{"class":58},"(name",[44,1189,62],{"class":50},[44,1191,65],{"class":50},[44,1193,1194],{"class":54},"str",[44,1196,1197],{"class":58},") { ",[44,1199,157],{"class":54},[44,1201,120],{"class":58},[44,1203,1204],{"class":123},"\"hi {name}\"",[44,1206,246],{"class":58},[44,1208,1209,1212,1214,1217,1220],{"class":46,"line":92},[44,1210,1211],{"class":54},"greet",[44,1213,120],{"class":58},[44,1215,1216],{"class":123},"\"Ada\"",[44,1218,1219],{"class":58},");              ",[44,1221,1222],{"class":150},"\u002F\u002F &str\n",[44,1224,1225,1227,1229,1231,1233,1235,1237,1239,1241,1244],{"class":46,"line":99},[44,1226,1211],{"class":54},[44,1228,120],{"class":58},[44,1230,144],{"class":50},[44,1232,68],{"class":54},[44,1234,114],{"class":50},[44,1236,117],{"class":54},[44,1238,120],{"class":58},[44,1240,1216],{"class":123},[44,1242,1243],{"class":58},"));   ",[44,1245,1246],{"class":150},"\u002F\u002F &String coerces to &str\n",[23,1248,1250,1253],{"id":1249},"deref-coercion",[28,1251,1252],{},"Deref"," Coercion",[14,1255,1256,1257,1259],{},"Types implementing ",[28,1258,1252],{}," allow chained deref coercions:",[32,1261,1262],{"language":34},[36,1263,1265],{"className":38,"code":1264,"language":34,"meta":40,"style":40},"let s = String::from(\"hi\");\nlet r: &str = &s;          \u002F\u002F &String -> &str via Deref\nlet b = Box::new(String::from(\"hi\"));\nlet r: &str = &b;          \u002F\u002F &Box\u003CString> -> &String -> &str\n",[28,1266,1267,1287,1310,1342],{"__ignoreMap":40},[44,1268,1269,1271,1273,1275,1277,1279,1281,1283,1285],{"class":46,"line":47},[44,1270,102],{"class":50},[44,1272,105],{"class":58},[44,1274,108],{"class":50},[44,1276,111],{"class":54},[44,1278,114],{"class":50},[44,1280,117],{"class":54},[44,1282,120],{"class":58},[44,1284,124],{"class":123},[44,1286,127],{"class":58},[44,1288,1289,1291,1294,1296,1298,1300,1302,1304,1307],{"class":46,"line":92},[44,1290,102],{"class":50},[44,1292,1293],{"class":58}," r",[44,1295,62],{"class":50},[44,1297,65],{"class":50},[44,1299,1194],{"class":54},[44,1301,722],{"class":50},[44,1303,65],{"class":50},[44,1305,1306],{"class":58},"s;          ",[44,1308,1309],{"class":150},"\u002F\u002F &String -> &str via Deref\n",[44,1311,1312,1314,1317,1319,1322,1324,1327,1329,1331,1333,1335,1337,1339],{"class":46,"line":99},[44,1313,102],{"class":50},[44,1315,1316],{"class":58}," b ",[44,1318,108],{"class":50},[44,1320,1321],{"class":54}," Box",[44,1323,114],{"class":50},[44,1325,1326],{"class":54},"new",[44,1328,120],{"class":58},[44,1330,68],{"class":54},[44,1332,114],{"class":50},[44,1334,117],{"class":54},[44,1336,120],{"class":58},[44,1338,124],{"class":123},[44,1340,1341],{"class":58},"));\n",[44,1343,1344,1346,1348,1350,1352,1354,1356,1358,1361],{"class":46,"line":130},[44,1345,102],{"class":50},[44,1347,1293],{"class":58},[44,1349,62],{"class":50},[44,1351,65],{"class":50},[44,1353,1194],{"class":54},[44,1355,722],{"class":50},[44,1357,65],{"class":50},[44,1359,1360],{"class":58},"b;          ",[44,1362,1363],{"class":150},"\u002F\u002F &Box\u003CString> -> &String -> &str\n",[14,1365,1366,1367,390,1370,390,1373,390,1375,1378,1379,1381],{},"This is how ",[28,1368,1369],{},"Box",[28,1371,1372],{},"Rc",[28,1374,68],{},[28,1376,1377],{},"Vec"," all play nicely with ",[28,1380,144],{},"-APIs.",[23,1383,1385,1388,1389],{"id":1384},"as_ref-as_mut",[28,1386,1387],{},"as_ref"," \u002F ",[28,1390,1391],{},"as_mut",[32,1393,1394],{"language":34},[36,1395,1397],{"className":38,"code":1396,"language":34,"meta":40,"style":40},"let s = String::from(\"hi\");\nlet r: &str = s.as_ref();   \u002F\u002F explicit AsRef coercion\n",[28,1398,1399,1419],{"__ignoreMap":40},[44,1400,1401,1403,1405,1407,1409,1411,1413,1415,1417],{"class":46,"line":47},[44,1402,102],{"class":50},[44,1404,105],{"class":58},[44,1406,108],{"class":50},[44,1408,111],{"class":54},[44,1410,114],{"class":50},[44,1412,117],{"class":54},[44,1414,120],{"class":58},[44,1416,124],{"class":123},[44,1418,127],{"class":58},[44,1420,1421,1423,1425,1427,1429,1431,1433,1436,1438,1440,1443],{"class":46,"line":92},[44,1422,102],{"class":50},[44,1424,1293],{"class":58},[44,1426,62],{"class":50},[44,1428,65],{"class":50},[44,1430,1194],{"class":54},[44,1432,722],{"class":50},[44,1434,1435],{"class":58}," s",[44,1437,83],{"class":50},[44,1439,1387],{"class":54},[44,1441,1442],{"class":58},"();   ",[44,1444,1445],{"class":150},"\u002F\u002F explicit AsRef coercion\n",[14,1447,1448,325,1451,1454],{},[28,1449,1450],{},"AsRef\u003CT>",[28,1452,1453],{},"AsMut\u003CT>"," allow flexible type-erased borrowing.",[23,1456,1458],{"id":1457},"mutable-reference-footguns","Mutable Reference Footguns",[170,1460,1461,1481,1490],{},[173,1462,1463,1469,1470,196,1473,1476,1477,1480],{},[18,1464,1465,1466,1468],{},"Two ",[28,1467,282],{}," to overlapping memory",": ",[28,1471,1472],{},"let (a, b) = (&mut v[0], &mut v[1]);",[666,1474,1475],{},"OK"," (non-overlapping), but ",[28,1478,1479],{},"let (a, b) = (&mut v[0], &mut v[0]);"," is a compile error.",[173,1482,1483,1469,1486,1489],{},[18,1484,1485],{},"Splitting borrows of a struct",[28,1487,1488],{},"let (a, b) = (&mut s.x, &mut s.y);"," is allowed (non-overlapping fields).",[173,1491,1492,1495,1496,1499,1500,1503,1504,1507,1508,1511,1512,83],{},[18,1493,1494],{},"Borrowing through a method",": if ",[28,1497,1498],{},"vec.push(x)"," mutably borrows ",[28,1501,1502],{},"vec",", you can't also ",[28,1505,1506],{},"&vec[0]"," simultaneously. The classic ",[28,1509,1510],{},"v.push(v[0])"," error — copy first: ",[28,1513,1514],{},"let x = v[0]; v.push(x);",[23,1516,1518,1519],{"id":1517},"common-error-cannot-borrow-as-mutable-as-it-is-not-declared-as-mut","Common Error: ",[28,1520,1521],{},"cannot borrow ... as mutable, as it is not declared as mut",[32,1523,1524],{"language":34},[36,1525,1527],{"className":38,"code":1526,"language":34,"meta":40,"style":40},"let s = String::from(\"hi\");\nlet r = &mut s;    \u002F\u002F ERROR: s is not mut\n",[28,1528,1529,1549],{"__ignoreMap":40},[44,1530,1531,1533,1535,1537,1539,1541,1543,1545,1547],{"class":46,"line":47},[44,1532,102],{"class":50},[44,1534,105],{"class":58},[44,1536,108],{"class":50},[44,1538,111],{"class":54},[44,1540,114],{"class":50},[44,1542,117],{"class":54},[44,1544,120],{"class":58},[44,1546,124],{"class":123},[44,1548,127],{"class":58},[44,1550,1551,1553,1555,1557,1559,1562],{"class":46,"line":92},[44,1552,102],{"class":50},[44,1554,408],{"class":58},[44,1556,108],{"class":50},[44,1558,228],{"class":50},[44,1560,1561],{"class":58}," s;    ",[44,1563,1564],{"class":150},"\u002F\u002F ERROR: s is not mut\n",[14,1566,1567,1568,1571,1572,83],{},"The variable itself must be ",[28,1569,1570],{},"mut"," to allow ",[28,1573,282],{},[23,1575,1518,1577],{"id":1576},"common-error-cannot-borrow-as-mutable-because-it-is-also-borrowed-as-immutable",[28,1578,1579],{},"cannot borrow ... as mutable ... because it is also borrowed as immutable",[14,1581,1582],{},"Fix by reordering so the immutable borrow ends before the mutable borrow (NLL), or by cloning, or by restructuring.",[23,1584,1586,325,1589,1592],{"id":1585},"ref-and-refmut-interior-mutability",[28,1587,1588],{},"Ref",[28,1590,1591],{},"RefMut"," (Interior Mutability)",[14,1594,1595,1598,1599,1602],{},[28,1596,1597],{},"std::cell::RefCell"," provides ",[666,1600,1601],{},"runtime-checked"," borrow rules (single mutable xor multiple immutable), enabling interior mutability behind an immutable reference. Covered in Interior Mutability chapter.",[23,1604,1606],{"id":1605},"summary","Summary",[170,1608,1609,1617,1620,1623],{},[173,1610,1611,1613,1614,1616],{},[28,1612,30],{}," = shared, many at once; ",[28,1615,207],{}," = exclusive, one at a time.",[173,1618,1619],{},"NLL makes references live only as long as needed.",[173,1621,1622],{},"Borrowing lets you write APIs that don't steal ownership.",[173,1624,1625],{},"Dangling references are impossible in safe Rust.",[14,1627,1628],{},"Next: Slices — borrowed views into contiguous data.",[1630,1631,1632],"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 .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);}html pre.shiki code .snvgF, html code.shiki .snvgF{--shiki-default:#005CC5;--shiki-github-dark:#79B8FF}",{"title":40,"searchDepth":92,"depth":92,"links":1634},[1635,1637,1639,1640,1641,1642,1643,1644,1645,1646,1648,1650,1652,1653,1655,1657,1659],{"id":25,"depth":92,"text":1636},"Shared References &T",{"id":203,"depth":92,"text":1638},"Mutable References &mut T",{"id":331,"depth":92,"text":332},{"id":480,"depth":92,"text":481},{"id":572,"depth":92,"text":573},{"id":676,"depth":92,"text":677},{"id":873,"depth":92,"text":874},{"id":978,"depth":92,"text":979},{"id":1058,"depth":92,"text":1059},{"id":1147,"depth":92,"text":1647},"&str vs &String",{"id":1249,"depth":92,"text":1649},"Deref Coercion",{"id":1384,"depth":92,"text":1651},"as_ref \u002F as_mut",{"id":1457,"depth":92,"text":1458},{"id":1517,"depth":92,"text":1654},"Common Error: cannot borrow ... as mutable, as it is not declared as mut",{"id":1576,"depth":92,"text":1656},"Common Error: cannot borrow ... as mutable ... because it is also borrowed as immutable",{"id":1585,"depth":92,"text":1658},"Ref and RefMut (Interior Mutability)",{"id":1605,"depth":92,"text":1606},"Ownership is heavy. References let you use a value without taking ownership.","md",{},"\u002Frust\u002F08-references-and-borrowing",{"title":5,"description":1660},"rust\u002F08-references-and-borrowing","boDM1O6dcHjO9iWKfwcfB0x_bRG2kW8BRhe3SU2bvdE",1785944093215]