[{"data":1,"prerenderedAt":2365},["ShallowReactive",2],{"page-\u002Frust\u002F17-closures":3},{"id":4,"title":5,"body":6,"description":2358,"extension":2359,"meta":2360,"navigation":836,"path":2361,"seo":2362,"stem":2363,"__hash__":2364},"content\u002Frust\u002F17-closures.md","17 — Closures",{"type":7,"value":8,"toc":2329},"minimark",[9,13,22,27,229,250,254,257,348,353,403,419,501,508,511,565,573,577,653,661,665,865,872,923,927,1028,1033,1039,1160,1164,1170,1174,1212,1226,1237,1403,1409,1413,1416,1507,1514,1567,1580,1584,1587,1607,1613,1665,1689,1693,1844,1857,1861,1942,1945,1952,1958,2034,2038,2176,2184,2265,2283,2287,2315,2325],[10,11,5],"h1",{"id":12},"_17-closures",[14,15,16,17,21],"p",{},"Closures are anonymous functions that ",[18,19,20],"strong",{},"capture"," their environment. They bridge the gap between functions and objects.",[23,24,26],"h2",{"id":25},"syntax","Syntax",[28,29,31],"code-wrapper",{"language":30},"rust",[32,33,37],"pre",{"className":34,"code":35,"language":30,"meta":36,"style":36},"language-rust shiki shiki-themes github-light github-dark","let add = |a, b| a + b;\nlet square = |x: i32| x * x;\nlet greet = |name: &str| format!(\"hi {name}\");\nlet block = |x| { let y = x + 1; y * 2 };\nlet no_args = || 42;\nlet void_closure = || { \u002F* do something *\u002F };\n","",[38,39,40,74,107,145,190,209],"code",{"__ignoreMap":36},[41,42,45,49,53,56,59,62,65,68,71],"span",{"class":43,"line":44},"line",1,[41,46,48],{"class":47},"svdQ7","let",[41,50,52],{"class":51},"ssxIu"," add ",[41,54,55],{"class":47},"=",[41,57,58],{"class":47}," |",[41,60,61],{"class":51},"a, b",[41,63,64],{"class":47},"|",[41,66,67],{"class":51}," a ",[41,69,70],{"class":47},"+",[41,72,73],{"class":51}," b;\n",[41,75,77,79,82,84,86,89,92,96,98,101,104],{"class":43,"line":76},2,[41,78,48],{"class":47},[41,80,81],{"class":51}," square ",[41,83,55],{"class":47},[41,85,58],{"class":47},[41,87,88],{"class":51},"x",[41,90,91],{"class":47},":",[41,93,95],{"class":94},"sIsaT"," i32",[41,97,64],{"class":47},[41,99,100],{"class":51}," x ",[41,102,103],{"class":47},"*",[41,105,106],{"class":51}," x;\n",[41,108,110,112,115,117,119,122,124,127,130,132,135,138,142],{"class":43,"line":109},3,[41,111,48],{"class":47},[41,113,114],{"class":51}," greet ",[41,116,55],{"class":47},[41,118,58],{"class":47},[41,120,121],{"class":51},"name",[41,123,91],{"class":47},[41,125,126],{"class":47}," &",[41,128,129],{"class":94},"str",[41,131,64],{"class":47},[41,133,134],{"class":94}," format!",[41,136,137],{"class":51},"(",[41,139,141],{"class":140},"sJ6F3","\"hi {name}\"",[41,143,144],{"class":51},");\n",[41,146,148,150,153,155,157,159,161,164,166,169,171,173,175,179,182,184,187],{"class":43,"line":147},4,[41,149,48],{"class":47},[41,151,152],{"class":51}," block ",[41,154,55],{"class":47},[41,156,58],{"class":47},[41,158,88],{"class":51},[41,160,64],{"class":47},[41,162,163],{"class":51}," { ",[41,165,48],{"class":47},[41,167,168],{"class":51}," y ",[41,170,55],{"class":47},[41,172,100],{"class":51},[41,174,70],{"class":47},[41,176,178],{"class":177},"snvgF"," 1",[41,180,181],{"class":51},"; y ",[41,183,103],{"class":47},[41,185,186],{"class":177}," 2",[41,188,189],{"class":51}," };\n",[41,191,193,195,198,200,203,206],{"class":43,"line":192},5,[41,194,48],{"class":47},[41,196,197],{"class":51}," no_args ",[41,199,55],{"class":47},[41,201,202],{"class":47}," ||",[41,204,205],{"class":177}," 42",[41,207,208],{"class":51},";\n",[41,210,212,214,217,219,221,223,227],{"class":43,"line":211},6,[41,213,48],{"class":47},[41,215,216],{"class":51}," void_closure ",[41,218,55],{"class":47},[41,220,202],{"class":47},[41,222,163],{"class":51},[41,224,226],{"class":225},"sdCPZ","\u002F* do something *\u002F",[41,228,189],{"class":51},[230,231,232,236,243],"ul",{},[233,234,235],"li",{},"Parameter types often inferred (especially when called immediately).",[233,237,238,239,242],{},"Single expression OR ",[38,240,241],{},"{ }"," block.",[233,244,245,246,249],{},"Can't have generic parameters (no ",[38,247,248],{},"|\u003CT> x| ...",").",[23,251,253],{"id":252},"capturing-the-environment","Capturing the Environment",[14,255,256],{},"Closures capture variables from the enclosing scope. The capture mode determines how:",[28,258,259],{"language":30},[32,260,262],{"className":34,"code":261,"language":30,"meta":36,"style":36},"let n = 5;\nlet add_n = |x| x + n;            \u002F\u002F borrows n by reference\nlet n_mut = String::from(\"a\");\nlet consume = move || n_mut;       \u002F\u002F moves n_mut into closure\n",[38,263,264,278,303,328],{"__ignoreMap":36},[41,265,266,268,271,273,276],{"class":43,"line":44},[41,267,48],{"class":47},[41,269,270],{"class":51}," n ",[41,272,55],{"class":47},[41,274,275],{"class":177}," 5",[41,277,208],{"class":51},[41,279,280,282,285,287,289,291,293,295,297,300],{"class":43,"line":76},[41,281,48],{"class":47},[41,283,284],{"class":51}," add_n ",[41,286,55],{"class":47},[41,288,58],{"class":47},[41,290,88],{"class":51},[41,292,64],{"class":47},[41,294,100],{"class":51},[41,296,70],{"class":47},[41,298,299],{"class":51}," n;            ",[41,301,302],{"class":225},"\u002F\u002F borrows n by reference\n",[41,304,305,307,310,312,315,318,321,323,326],{"class":43,"line":109},[41,306,48],{"class":47},[41,308,309],{"class":51}," n_mut ",[41,311,55],{"class":47},[41,313,314],{"class":94}," String",[41,316,317],{"class":47},"::",[41,319,320],{"class":94},"from",[41,322,137],{"class":51},[41,324,325],{"class":140},"\"a\"",[41,327,144],{"class":51},[41,329,330,332,335,337,340,342,345],{"class":43,"line":147},[41,331,48],{"class":47},[41,333,334],{"class":51}," consume ",[41,336,55],{"class":47},[41,338,339],{"class":47}," move",[41,341,202],{"class":47},[41,343,344],{"class":51}," n_mut;       ",[41,346,347],{"class":225},"\u002F\u002F moves n_mut into closure\n",[349,350,352],"h3",{"id":351},"capture-modes-trait-hierarchy","Capture Modes (Trait Hierarchy)",[354,355,356,369],"table",{},[357,358,359],"thead",{},[360,361,362,366],"tr",{},[363,364,365],"th",{},"Trait",[363,367,368],{},"How it captures",[370,371,372,383,393],"tbody",{},[360,373,374,380],{},[375,376,377],"td",{},[38,378,379],{},"FnOnce",[375,381,382],{},"May consume captures (move out) — callable once",[360,384,385,390],{},[375,386,387],{},[38,388,389],{},"FnMut",[375,391,392],{},"May mutate captures — callable multiple times (mutably)",[360,394,395,400],{},[375,396,397],{},[38,398,399],{},"Fn",[375,401,402],{},"Only immutable borrows — callable any number of times",[14,404,405,406,409,410,412,413,415,416,418],{},"Each is a supertrait of the next: ",[38,407,408],{},"Fn: FnMut: FnOnce",". So every ",[38,411,399],{}," is also ",[38,414,389],{}," and ",[38,417,379],{},".",[28,420,421],{"language":30},[32,422,424],{"className":34,"code":423,"language":30,"meta":36,"style":36},"let mut s = String::from(\"hi\");\nlet push_closure = || s.push('!');       \u002F\u002F FnMut — needs mut capture\nlet consume_closure = || drop(s);         \u002F\u002F FnOnce — consumes s\n",[38,425,426,451,481],{"__ignoreMap":36},[41,427,428,430,433,436,438,440,442,444,446,449],{"class":43,"line":44},[41,429,48],{"class":47},[41,431,432],{"class":47}," mut",[41,434,435],{"class":51}," s ",[41,437,55],{"class":47},[41,439,314],{"class":94},[41,441,317],{"class":47},[41,443,320],{"class":94},[41,445,137],{"class":51},[41,447,448],{"class":140},"\"hi\"",[41,450,144],{"class":51},[41,452,453,455,458,460,462,465,467,470,472,475,478],{"class":43,"line":76},[41,454,48],{"class":47},[41,456,457],{"class":51}," push_closure ",[41,459,55],{"class":47},[41,461,202],{"class":47},[41,463,464],{"class":51}," s",[41,466,418],{"class":47},[41,468,469],{"class":94},"push",[41,471,137],{"class":51},[41,473,474],{"class":140},"'!'",[41,476,477],{"class":51},");       ",[41,479,480],{"class":225},"\u002F\u002F FnMut — needs mut capture\n",[41,482,483,485,488,490,492,495,498],{"class":43,"line":109},[41,484,48],{"class":47},[41,486,487],{"class":51}," consume_closure ",[41,489,55],{"class":47},[41,491,202],{"class":47},[41,493,494],{"class":94}," drop",[41,496,497],{"class":51},"(s);         ",[41,499,500],{"class":225},"\u002F\u002F FnOnce — consumes s\n",[349,502,504,507],{"id":503},"move-keyword",[38,505,506],{},"move"," Keyword",[14,509,510],{},"Forces capture by value (move) regardless of how the closure uses them:",[28,512,513],{"language":30},[32,514,516],{"className":34,"code":515,"language":30,"meta":36,"style":36},"let s = String::from(\"hi\");\nlet f = move || println!(\"{s}\");   \u002F\u002F s moved into f; original invalid\n",[38,517,518,538],{"__ignoreMap":36},[41,519,520,522,524,526,528,530,532,534,536],{"class":43,"line":44},[41,521,48],{"class":47},[41,523,435],{"class":51},[41,525,55],{"class":47},[41,527,314],{"class":94},[41,529,317],{"class":47},[41,531,320],{"class":94},[41,533,137],{"class":51},[41,535,448],{"class":140},[41,537,144],{"class":51},[41,539,540,542,545,547,549,551,554,556,559,562],{"class":43,"line":76},[41,541,48],{"class":47},[41,543,544],{"class":51}," f ",[41,546,55],{"class":47},[41,548,339],{"class":47},[41,550,202],{"class":47},[41,552,553],{"class":94}," println!",[41,555,137],{"class":51},[41,557,558],{"class":140},"\"{s}\"",[41,560,561],{"class":51},");   ",[41,563,564],{"class":225},"\u002F\u002F s moved into f; original invalid\n",[14,566,567,569,570,249],{},[38,568,506],{}," is essential for thread spawning — closures sent to other threads must own their captures (",[38,571,572],{},"'static",[349,574,576],{"id":575},"disjoint-closure-captures-edition-2021","Disjoint Closure Captures (Edition 2021)",[28,578,579],{"language":30},[32,580,582],{"className":34,"code":581,"language":30,"meta":36,"style":36},"let a = String::from(\"a\");\nlet b = String::from(\"b\");\nlet f = || println!(\"{a} {b}\");   \u002F\u002F edition 2018: borrows BOTH a and b\n                                   \u002F\u002F edition 2021: borrows only what's used in each branch\n",[38,583,584,604,626,648],{"__ignoreMap":36},[41,585,586,588,590,592,594,596,598,600,602],{"class":43,"line":44},[41,587,48],{"class":47},[41,589,67],{"class":51},[41,591,55],{"class":47},[41,593,314],{"class":94},[41,595,317],{"class":47},[41,597,320],{"class":94},[41,599,137],{"class":51},[41,601,325],{"class":140},[41,603,144],{"class":51},[41,605,606,608,611,613,615,617,619,621,624],{"class":43,"line":76},[41,607,48],{"class":47},[41,609,610],{"class":51}," b ",[41,612,55],{"class":47},[41,614,314],{"class":94},[41,616,317],{"class":47},[41,618,320],{"class":94},[41,620,137],{"class":51},[41,622,623],{"class":140},"\"b\"",[41,625,144],{"class":51},[41,627,628,630,632,634,636,638,640,643,645],{"class":43,"line":109},[41,629,48],{"class":47},[41,631,544],{"class":51},[41,633,55],{"class":47},[41,635,202],{"class":47},[41,637,553],{"class":94},[41,639,137],{"class":51},[41,641,642],{"class":140},"\"{a} {b}\"",[41,644,561],{"class":51},[41,646,647],{"class":225},"\u002F\u002F edition 2018: borrows BOTH a and b\n",[41,649,650],{"class":43,"line":147},[41,651,652],{"class":225},"                                   \u002F\u002F edition 2021: borrows only what's used in each branch\n",[14,654,655,656,660],{},"The 2021 edition captures only the ",[657,658,659],"em",{},"used"," fields of disjoint structs, enabling more code to compile.",[23,662,664],{"id":663},"closures-as-arguments","Closures as Arguments",[28,666,667],{"language":30},[32,668,670],{"className":34,"code":669,"language":30,"meta":36,"style":36},"fn apply\u003CF: Fn(i32) -> i32>(f: F, x: i32) -> i32 { f(x) }\nfn apply_mut\u003CF: FnMut(i32) -> i32>(mut f: F, x: i32) -> i32 { f(x) }\nfn apply_once\u003CF: FnOnce() -> i32>(f: F) -> i32 { f() }\n\napply(|x| x + 1, 5);\n",[38,671,672,733,790,832,838],{"__ignoreMap":36},[41,673,674,677,680,683,686,688,691,693,696,699,702,704,707,709,712,715,717,719,721,723,725,727,730],{"class":43,"line":44},[41,675,676],{"class":47},"fn",[41,678,679],{"class":94}," apply",[41,681,682],{"class":51},"\u003C",[41,684,685],{"class":94},"F",[41,687,91],{"class":47},[41,689,690],{"class":94}," Fn",[41,692,137],{"class":51},[41,694,695],{"class":94},"i32",[41,697,698],{"class":51},") ",[41,700,701],{"class":47},"->",[41,703,95],{"class":94},[41,705,706],{"class":51},">(f",[41,708,91],{"class":47},[41,710,711],{"class":94}," F",[41,713,714],{"class":51},", x",[41,716,91],{"class":47},[41,718,95],{"class":94},[41,720,698],{"class":51},[41,722,701],{"class":47},[41,724,95],{"class":94},[41,726,163],{"class":51},[41,728,729],{"class":94},"f",[41,731,732],{"class":51},"(x) }\n",[41,734,735,737,740,742,744,746,749,751,753,755,757,759,762,765,768,770,772,774,776,778,780,782,784,786,788],{"class":43,"line":76},[41,736,676],{"class":47},[41,738,739],{"class":94}," apply_mut",[41,741,682],{"class":51},[41,743,685],{"class":94},[41,745,91],{"class":47},[41,747,748],{"class":94}," FnMut",[41,750,137],{"class":51},[41,752,695],{"class":94},[41,754,698],{"class":51},[41,756,701],{"class":47},[41,758,95],{"class":94},[41,760,761],{"class":51},">(",[41,763,764],{"class":47},"mut",[41,766,767],{"class":51}," f",[41,769,91],{"class":47},[41,771,711],{"class":94},[41,773,714],{"class":51},[41,775,91],{"class":47},[41,777,95],{"class":94},[41,779,698],{"class":51},[41,781,701],{"class":47},[41,783,95],{"class":94},[41,785,163],{"class":51},[41,787,729],{"class":94},[41,789,732],{"class":51},[41,791,792,794,797,799,801,803,806,809,811,813,815,817,819,821,823,825,827,829],{"class":43,"line":109},[41,793,676],{"class":47},[41,795,796],{"class":94}," apply_once",[41,798,682],{"class":51},[41,800,685],{"class":94},[41,802,91],{"class":47},[41,804,805],{"class":94}," FnOnce",[41,807,808],{"class":51},"() ",[41,810,701],{"class":47},[41,812,95],{"class":94},[41,814,706],{"class":51},[41,816,91],{"class":47},[41,818,711],{"class":94},[41,820,698],{"class":51},[41,822,701],{"class":47},[41,824,95],{"class":94},[41,826,163],{"class":51},[41,828,729],{"class":94},[41,830,831],{"class":51},"() }\n",[41,833,834],{"class":43,"line":147},[41,835,837],{"emptyLinePlaceholder":836},true,"\n",[41,839,840,843,845,847,849,851,853,855,857,860,863],{"class":43,"line":192},[41,841,842],{"class":94},"apply",[41,844,137],{"class":51},[41,846,64],{"class":47},[41,848,88],{"class":51},[41,850,64],{"class":47},[41,852,100],{"class":51},[41,854,70],{"class":47},[41,856,178],{"class":177},[41,858,859],{"class":51},", ",[41,861,862],{"class":177},"5",[41,864,144],{"class":51},[14,866,867,868,871],{},"Use ",[38,869,870],{},"impl Fn(...)"," for shorthand:",[28,873,874],{"language":30},[32,875,877],{"className":34,"code":876,"language":30,"meta":36,"style":36},"fn apply(f: impl Fn(i32) -> i32, x: i32) -> i32 { f(x) }\n",[38,878,879],{"__ignoreMap":36},[41,880,881,883,885,888,890,893,895,897,899,901,903,905,907,909,911,913,915,917,919,921],{"class":43,"line":44},[41,882,676],{"class":47},[41,884,679],{"class":94},[41,886,887],{"class":51},"(f",[41,889,91],{"class":47},[41,891,892],{"class":47}," impl",[41,894,690],{"class":94},[41,896,137],{"class":51},[41,898,695],{"class":94},[41,900,698],{"class":51},[41,902,701],{"class":47},[41,904,95],{"class":94},[41,906,714],{"class":51},[41,908,91],{"class":47},[41,910,95],{"class":94},[41,912,698],{"class":51},[41,914,701],{"class":47},[41,916,95],{"class":94},[41,918,163],{"class":51},[41,920,729],{"class":94},[41,922,732],{"class":51},[23,924,926],{"id":925},"returning-closures","Returning Closures",[28,928,929],{"language":30},[32,930,932],{"className":34,"code":931,"language":30,"meta":36,"style":36},"fn make_adder(n: i32) -> impl Fn(i32) -> i32 {\n    move |x| x + n\n}\n\nlet add5 = make_adder(5);\nadd5(10);   \u002F\u002F 15\n",[38,933,934,969,987,992,996,1013],{"__ignoreMap":36},[41,935,936,938,941,944,946,948,950,952,954,956,958,960,962,964,966],{"class":43,"line":44},[41,937,676],{"class":47},[41,939,940],{"class":94}," make_adder",[41,942,943],{"class":51},"(n",[41,945,91],{"class":47},[41,947,95],{"class":94},[41,949,698],{"class":51},[41,951,701],{"class":47},[41,953,892],{"class":47},[41,955,690],{"class":94},[41,957,137],{"class":51},[41,959,695],{"class":94},[41,961,698],{"class":51},[41,963,701],{"class":47},[41,965,95],{"class":94},[41,967,968],{"class":51}," {\n",[41,970,971,974,976,978,980,982,984],{"class":43,"line":76},[41,972,973],{"class":47},"    move",[41,975,58],{"class":47},[41,977,88],{"class":51},[41,979,64],{"class":47},[41,981,100],{"class":51},[41,983,70],{"class":47},[41,985,986],{"class":51}," n\n",[41,988,989],{"class":43,"line":109},[41,990,991],{"class":51},"}\n",[41,993,994],{"class":43,"line":147},[41,995,837],{"emptyLinePlaceholder":836},[41,997,998,1000,1003,1005,1007,1009,1011],{"class":43,"line":192},[41,999,48],{"class":47},[41,1001,1002],{"class":51}," add5 ",[41,1004,55],{"class":47},[41,1006,940],{"class":94},[41,1008,137],{"class":51},[41,1010,862],{"class":177},[41,1012,144],{"class":51},[41,1014,1015,1018,1020,1023,1025],{"class":43,"line":211},[41,1016,1017],{"class":94},"add5",[41,1019,137],{"class":51},[41,1021,1022],{"class":177},"10",[41,1024,561],{"class":51},[41,1026,1027],{"class":225},"\u002F\u002F 15\n",[14,1029,867,1030,1032],{},[38,1031,506],{}," so the closure owns its captures (otherwise it'd borrow a stack variable that's gone).",[14,1034,1035,1036,91],{},"For multiple closure types in different branches, use ",[38,1037,1038],{},"Box\u003Cdyn Fn()>",[28,1040,1041],{"language":30},[32,1042,1044],{"className":34,"code":1043,"language":30,"meta":36,"style":36},"fn make(pred: bool) -> Box\u003Cdyn Fn(i32) -> i32> {\n    if pred { Box::new(move |x| x + 1) }\n    else    { Box::new(move |x| x - 1) }\n}\n",[38,1045,1046,1088,1123,1156],{"__ignoreMap":36},[41,1047,1048,1050,1053,1056,1058,1061,1063,1065,1068,1070,1073,1075,1077,1079,1081,1083,1085],{"class":43,"line":44},[41,1049,676],{"class":47},[41,1051,1052],{"class":94}," make",[41,1054,1055],{"class":51},"(pred",[41,1057,91],{"class":47},[41,1059,1060],{"class":94}," bool",[41,1062,698],{"class":51},[41,1064,701],{"class":47},[41,1066,1067],{"class":94}," Box",[41,1069,682],{"class":51},[41,1071,1072],{"class":47},"dyn",[41,1074,690],{"class":94},[41,1076,137],{"class":51},[41,1078,695],{"class":94},[41,1080,698],{"class":51},[41,1082,701],{"class":47},[41,1084,95],{"class":94},[41,1086,1087],{"class":51},"> {\n",[41,1089,1090,1093,1096,1099,1101,1104,1106,1108,1110,1112,1114,1116,1118,1120],{"class":43,"line":76},[41,1091,1092],{"class":47},"    if",[41,1094,1095],{"class":51}," pred { ",[41,1097,1098],{"class":94},"Box",[41,1100,317],{"class":47},[41,1102,1103],{"class":94},"new",[41,1105,137],{"class":51},[41,1107,506],{"class":47},[41,1109,58],{"class":47},[41,1111,88],{"class":51},[41,1113,64],{"class":47},[41,1115,100],{"class":51},[41,1117,70],{"class":47},[41,1119,178],{"class":177},[41,1121,1122],{"class":51},") }\n",[41,1124,1125,1128,1131,1133,1135,1137,1139,1141,1143,1145,1147,1149,1152,1154],{"class":43,"line":109},[41,1126,1127],{"class":47},"    else",[41,1129,1130],{"class":51},"    { ",[41,1132,1098],{"class":94},[41,1134,317],{"class":47},[41,1136,1103],{"class":94},[41,1138,137],{"class":51},[41,1140,506],{"class":47},[41,1142,58],{"class":47},[41,1144,88],{"class":51},[41,1146,64],{"class":47},[41,1148,100],{"class":51},[41,1150,1151],{"class":47},"-",[41,1153,178],{"class":177},[41,1155,1122],{"class":51},[41,1157,1158],{"class":43,"line":147},[41,1159,991],{"class":51},[23,1161,1163],{"id":1162},"closure-type-is-unique","Closure Type is Unique",[14,1165,1166,1167,1169],{},"Each closure has an anonymous, unnameable type generated by the compiler. Two structurally identical closures have different types. This is why ",[38,1168,1038],{}," exists for heterogeneous collections.",[23,1171,1173],{"id":1172},"closures-implement-traits","Closures Implement Traits",[28,1175,1176],{"language":30},[32,1177,1179],{"className":34,"code":1178,"language":30,"meta":36,"style":36},"impl Fn(i32) -> i32 for SomeClosureType { ... }\n",[38,1180,1181],{"__ignoreMap":36},[41,1182,1183,1186,1188,1190,1192,1194,1196,1198,1201,1204,1206,1209],{"class":43,"line":44},[41,1184,1185],{"class":47},"impl",[41,1187,690],{"class":94},[41,1189,137],{"class":51},[41,1191,695],{"class":94},[41,1193,698],{"class":51},[41,1195,701],{"class":47},[41,1197,95],{"class":94},[41,1199,1200],{"class":47}," for",[41,1202,1203],{"class":94}," SomeClosureType",[41,1205,163],{"class":51},[41,1207,1208],{"class":47},"...",[41,1210,1211],{"class":51}," }\n",[14,1213,1214,1215,1218,1219,1221,1222,1225],{},"Function pointers ",[38,1216,1217],{},"fn(A) -> B"," also implement ",[38,1220,399],{},", so you can pass plain functions where ",[38,1223,1224],{},"impl Fn"," is expected.",[23,1227,1229,1231,1232,1231,1234,1236],{"id":1228},"fnfnmutfnonce-object-safety",[38,1230,399],{},"\u002F",[38,1233,389],{},[38,1235,379],{}," Object Safety",[28,1238,1239],{"language":30},[32,1240,1242],{"className":34,"code":1241,"language":30,"meta":36,"style":36},"let f: Box\u003Cdyn Fn(i32) -> i32> = Box::new(|x| x + 1);\nlet fm: Box\u003Cdyn FnMut(i32) -> i32> = Box::new(|x| x + 1);\nlet fo: Box\u003Cdyn FnOnce(i32) -> i32> = Box::new(|x| x + 1);\n",[38,1243,1244,1297,1350],{"__ignoreMap":36},[41,1245,1246,1248,1250,1252,1254,1256,1258,1260,1262,1264,1266,1268,1270,1273,1275,1277,1279,1281,1283,1285,1287,1289,1291,1293,1295],{"class":43,"line":44},[41,1247,48],{"class":47},[41,1249,767],{"class":51},[41,1251,91],{"class":47},[41,1253,1067],{"class":94},[41,1255,682],{"class":51},[41,1257,1072],{"class":47},[41,1259,690],{"class":94},[41,1261,137],{"class":51},[41,1263,695],{"class":94},[41,1265,698],{"class":51},[41,1267,701],{"class":47},[41,1269,95],{"class":94},[41,1271,1272],{"class":51},"> ",[41,1274,55],{"class":47},[41,1276,1067],{"class":94},[41,1278,317],{"class":47},[41,1280,1103],{"class":94},[41,1282,137],{"class":51},[41,1284,64],{"class":47},[41,1286,88],{"class":51},[41,1288,64],{"class":47},[41,1290,100],{"class":51},[41,1292,70],{"class":47},[41,1294,178],{"class":177},[41,1296,144],{"class":51},[41,1298,1299,1301,1304,1306,1308,1310,1312,1314,1316,1318,1320,1322,1324,1326,1328,1330,1332,1334,1336,1338,1340,1342,1344,1346,1348],{"class":43,"line":76},[41,1300,48],{"class":47},[41,1302,1303],{"class":51}," fm",[41,1305,91],{"class":47},[41,1307,1067],{"class":94},[41,1309,682],{"class":51},[41,1311,1072],{"class":47},[41,1313,748],{"class":94},[41,1315,137],{"class":51},[41,1317,695],{"class":94},[41,1319,698],{"class":51},[41,1321,701],{"class":47},[41,1323,95],{"class":94},[41,1325,1272],{"class":51},[41,1327,55],{"class":47},[41,1329,1067],{"class":94},[41,1331,317],{"class":47},[41,1333,1103],{"class":94},[41,1335,137],{"class":51},[41,1337,64],{"class":47},[41,1339,88],{"class":51},[41,1341,64],{"class":47},[41,1343,100],{"class":51},[41,1345,70],{"class":47},[41,1347,178],{"class":177},[41,1349,144],{"class":51},[41,1351,1352,1354,1357,1359,1361,1363,1365,1367,1369,1371,1373,1375,1377,1379,1381,1383,1385,1387,1389,1391,1393,1395,1397,1399,1401],{"class":43,"line":109},[41,1353,48],{"class":47},[41,1355,1356],{"class":51}," fo",[41,1358,91],{"class":47},[41,1360,1067],{"class":94},[41,1362,682],{"class":51},[41,1364,1072],{"class":47},[41,1366,805],{"class":94},[41,1368,137],{"class":51},[41,1370,695],{"class":94},[41,1372,698],{"class":51},[41,1374,701],{"class":47},[41,1376,95],{"class":94},[41,1378,1272],{"class":51},[41,1380,55],{"class":47},[41,1382,1067],{"class":94},[41,1384,317],{"class":47},[41,1386,1103],{"class":94},[41,1388,137],{"class":51},[41,1390,64],{"class":47},[41,1392,88],{"class":51},[41,1394,64],{"class":47},[41,1396,100],{"class":51},[41,1398,70],{"class":47},[41,1400,178],{"class":177},[41,1402,144],{"class":51},[14,1404,1405,1408],{},[38,1406,1407],{},"Box\u003Cdyn FnOnce>"," is callable since Rust 1.35 (special support).",[23,1410,1412],{"id":1411},"closures-and-iterators","Closures and Iterators",[14,1414,1415],{},"Closures are the currency of iterator adapters:",[28,1417,1418],{"language":30},[32,1419,1421],{"className":34,"code":1420,"language":30,"meta":36,"style":36},"v.iter().map(|x| x * 2).filter(|x| *x > 5).for_each(|x| println!(\"{x}\"));\n",[38,1422,1423],{"__ignoreMap":36},[41,1424,1425,1428,1430,1433,1436,1438,1441,1443,1445,1447,1449,1451,1453,1455,1458,1460,1463,1465,1467,1469,1471,1474,1477,1480,1482,1484,1486,1489,1491,1493,1495,1497,1499,1501,1504],{"class":43,"line":44},[41,1426,1427],{"class":51},"v",[41,1429,418],{"class":47},[41,1431,1432],{"class":94},"iter",[41,1434,1435],{"class":51},"()",[41,1437,418],{"class":47},[41,1439,1440],{"class":94},"map",[41,1442,137],{"class":51},[41,1444,64],{"class":47},[41,1446,88],{"class":51},[41,1448,64],{"class":47},[41,1450,100],{"class":51},[41,1452,103],{"class":47},[41,1454,186],{"class":177},[41,1456,1457],{"class":51},")",[41,1459,418],{"class":47},[41,1461,1462],{"class":94},"filter",[41,1464,137],{"class":51},[41,1466,64],{"class":47},[41,1468,88],{"class":51},[41,1470,64],{"class":47},[41,1472,1473],{"class":47}," *",[41,1475,1476],{"class":51},"x ",[41,1478,1479],{"class":47},">",[41,1481,275],{"class":177},[41,1483,1457],{"class":51},[41,1485,418],{"class":47},[41,1487,1488],{"class":94},"for_each",[41,1490,137],{"class":51},[41,1492,64],{"class":47},[41,1494,88],{"class":51},[41,1496,64],{"class":47},[41,1498,553],{"class":94},[41,1500,137],{"class":51},[41,1502,1503],{"class":140},"\"{x}\"",[41,1505,1506],{"class":51},"));\n",[23,1508,1510,1513],{"id":1509},"in-closures",[38,1511,1512],{},"?"," in Closures",[28,1515,1516],{"language":30},[32,1517,1519],{"className":34,"code":1518,"language":30,"meta":36,"style":36},"let parse = |s: &str| s.parse::\u003Ci32>()?;   \u002F\u002F closure can use ?\n",[38,1520,1521],{"__ignoreMap":36},[41,1522,1523,1525,1528,1530,1532,1535,1537,1539,1541,1543,1545,1547,1550,1552,1554,1556,1559,1561,1564],{"class":43,"line":44},[41,1524,48],{"class":47},[41,1526,1527],{"class":51}," parse ",[41,1529,55],{"class":47},[41,1531,58],{"class":47},[41,1533,1534],{"class":51},"s",[41,1536,91],{"class":47},[41,1538,126],{"class":47},[41,1540,129],{"class":94},[41,1542,64],{"class":47},[41,1544,464],{"class":51},[41,1546,418],{"class":47},[41,1548,1549],{"class":94},"parse",[41,1551,317],{"class":47},[41,1553,682],{"class":51},[41,1555,695],{"class":94},[41,1557,1558],{"class":51},">()",[41,1560,1512],{"class":47},[41,1562,1563],{"class":51},";   ",[41,1565,1566],{"class":225},"\u002F\u002F closure can use ?\n",[14,1568,1569,1570,1572,1573,1576,1577,249],{},"Closures can use ",[38,1571,1512],{}," if their return type supports it (",[38,1574,1575],{},"Result"," or ",[38,1578,1579],{},"Option",[23,1581,1583],{"id":1582},"recursion-in-closures","Recursion in Closures",[14,1585,1586],{},"Closures can't easily recurse — they don't have a name. Workarounds:",[230,1588,1589,1594,1601],{},[233,1590,1591,1592,418],{},"Use a regular ",[38,1593,676],{},[233,1595,1596,1597,1600],{},"Use a ",[38,1598,1599],{},"Box\u003Cdyn Fn>"," and pass it to itself.",[233,1602,867,1603,1606],{},[38,1604,1605],{},"Y"," combinator (academic).",[23,1608,1610,1612],{"id":1609},"move-closure-captures-and-lifetime",[38,1611,506],{}," Closure Captures and Lifetime",[28,1614,1615],{"language":30},[32,1616,1618],{"className":34,"code":1617,"language":30,"meta":36,"style":36},"let s = String::from(\"hi\");\nlet f = move || println!(\"{s}\");\n\u002F\u002F s moved into f; f now owns the String\n",[38,1619,1620,1640,1660],{"__ignoreMap":36},[41,1621,1622,1624,1626,1628,1630,1632,1634,1636,1638],{"class":43,"line":44},[41,1623,48],{"class":47},[41,1625,435],{"class":51},[41,1627,55],{"class":47},[41,1629,314],{"class":94},[41,1631,317],{"class":47},[41,1633,320],{"class":94},[41,1635,137],{"class":51},[41,1637,448],{"class":140},[41,1639,144],{"class":51},[41,1641,1642,1644,1646,1648,1650,1652,1654,1656,1658],{"class":43,"line":76},[41,1643,48],{"class":47},[41,1645,544],{"class":51},[41,1647,55],{"class":47},[41,1649,339],{"class":47},[41,1651,202],{"class":47},[41,1653,553],{"class":94},[41,1655,137],{"class":51},[41,1657,558],{"class":140},[41,1659,144],{"class":51},[41,1661,1662],{"class":43,"line":109},[41,1663,1664],{"class":225},"\u002F\u002F s moved into f; f now owns the String\n",[14,1666,1667,1668,859,1670,1672,1673,1675,1676,1678,1679,1681,1682,859,1684,1686,1687,418],{},"Without ",[38,1669,506],{},[38,1671,729],{}," would borrow ",[38,1674,1534],{},", which means ",[38,1677,1534],{}," must outlive ",[38,1680,729],{},". With ",[38,1683,506],{},[38,1685,729],{}," owns its captures and can be ",[38,1688,572],{},[23,1690,1692],{"id":1691},"capture-by-reference-by-mut-reference-by-value","Capture By Reference, By Mut Reference, By Value",[28,1694,1695],{"language":30},[32,1696,1698],{"className":34,"code":1697,"language":30,"meta":36,"style":36},"let n = 5;\nlet f1 = || println!(\"{n}\");        \u002F\u002F &n\nlet mut m = 0;\nlet mut f2 = || m += 1;             \u002F\u002F &mut m\nlet s = String::from(\"x\");\nlet f3 = || drop(s);                 \u002F\u002F moves s out — FnOnce\nlet f4 = move || println!(\"{n}\");    \u002F\u002F copies n (i32 is Copy)\n",[38,1699,1700,1712,1736,1752,1778,1799,1818],{"__ignoreMap":36},[41,1701,1702,1704,1706,1708,1710],{"class":43,"line":44},[41,1703,48],{"class":47},[41,1705,270],{"class":51},[41,1707,55],{"class":47},[41,1709,275],{"class":177},[41,1711,208],{"class":51},[41,1713,1714,1716,1719,1721,1723,1725,1727,1730,1733],{"class":43,"line":76},[41,1715,48],{"class":47},[41,1717,1718],{"class":51}," f1 ",[41,1720,55],{"class":47},[41,1722,202],{"class":47},[41,1724,553],{"class":94},[41,1726,137],{"class":51},[41,1728,1729],{"class":140},"\"{n}\"",[41,1731,1732],{"class":51},");        ",[41,1734,1735],{"class":225},"\u002F\u002F &n\n",[41,1737,1738,1740,1742,1745,1747,1750],{"class":43,"line":109},[41,1739,48],{"class":47},[41,1741,432],{"class":47},[41,1743,1744],{"class":51}," m ",[41,1746,55],{"class":47},[41,1748,1749],{"class":177}," 0",[41,1751,208],{"class":51},[41,1753,1754,1756,1758,1761,1763,1765,1767,1770,1772,1775],{"class":43,"line":147},[41,1755,48],{"class":47},[41,1757,432],{"class":47},[41,1759,1760],{"class":51}," f2 ",[41,1762,55],{"class":47},[41,1764,202],{"class":47},[41,1766,1744],{"class":51},[41,1768,1769],{"class":47},"+=",[41,1771,178],{"class":177},[41,1773,1774],{"class":51},";             ",[41,1776,1777],{"class":225},"\u002F\u002F &mut m\n",[41,1779,1780,1782,1784,1786,1788,1790,1792,1794,1797],{"class":43,"line":192},[41,1781,48],{"class":47},[41,1783,435],{"class":51},[41,1785,55],{"class":47},[41,1787,314],{"class":94},[41,1789,317],{"class":47},[41,1791,320],{"class":94},[41,1793,137],{"class":51},[41,1795,1796],{"class":140},"\"x\"",[41,1798,144],{"class":51},[41,1800,1801,1803,1806,1808,1810,1812,1815],{"class":43,"line":211},[41,1802,48],{"class":47},[41,1804,1805],{"class":51}," f3 ",[41,1807,55],{"class":47},[41,1809,202],{"class":47},[41,1811,494],{"class":94},[41,1813,1814],{"class":51},"(s);                 ",[41,1816,1817],{"class":225},"\u002F\u002F moves s out — FnOnce\n",[41,1819,1821,1823,1826,1828,1830,1832,1834,1836,1838,1841],{"class":43,"line":1820},7,[41,1822,48],{"class":47},[41,1824,1825],{"class":51}," f4 ",[41,1827,55],{"class":47},[41,1829,339],{"class":47},[41,1831,202],{"class":47},[41,1833,553],{"class":94},[41,1835,137],{"class":51},[41,1837,1729],{"class":140},[41,1839,1840],{"class":51},");    ",[41,1842,1843],{"class":225},"\u002F\u002F copies n (i32 is Copy)\n",[14,1845,1846,1847,1850,1851,1853,1854,249],{},"The compiler picks the ",[657,1848,1849],{},"least restrictive"," capture mode by default. ",[38,1852,506],{}," forces everything to move (or copy if ",[38,1855,1856],{},"Copy",[23,1858,1860],{"id":1859},"higher-order-closures","Higher-Order Closures",[28,1862,1863],{"language":30},[32,1864,1866],{"className":34,"code":1865,"language":30,"meta":36,"style":36},"fn make\u003CF: Fn(i32) -> i32>(f: F) -> impl Fn(i32) -> i32 {\n    move |x| f(x) + 1\n}\n",[38,1867,1868,1918,1938],{"__ignoreMap":36},[41,1869,1870,1872,1874,1876,1878,1880,1882,1884,1886,1888,1890,1892,1894,1896,1898,1900,1902,1904,1906,1908,1910,1912,1914,1916],{"class":43,"line":44},[41,1871,676],{"class":47},[41,1873,1052],{"class":94},[41,1875,682],{"class":51},[41,1877,685],{"class":94},[41,1879,91],{"class":47},[41,1881,690],{"class":94},[41,1883,137],{"class":51},[41,1885,695],{"class":94},[41,1887,698],{"class":51},[41,1889,701],{"class":47},[41,1891,95],{"class":94},[41,1893,706],{"class":51},[41,1895,91],{"class":47},[41,1897,711],{"class":94},[41,1899,698],{"class":51},[41,1901,701],{"class":47},[41,1903,892],{"class":47},[41,1905,690],{"class":94},[41,1907,137],{"class":51},[41,1909,695],{"class":94},[41,1911,698],{"class":51},[41,1913,701],{"class":47},[41,1915,95],{"class":94},[41,1917,968],{"class":51},[41,1919,1920,1922,1924,1926,1928,1930,1933,1935],{"class":43,"line":76},[41,1921,973],{"class":47},[41,1923,58],{"class":47},[41,1925,88],{"class":51},[41,1927,64],{"class":47},[41,1929,767],{"class":94},[41,1931,1932],{"class":51},"(x) ",[41,1934,70],{"class":47},[41,1936,1937],{"class":177}," 1\n",[41,1939,1940],{"class":43,"line":109},[41,1941,991],{"class":51},[14,1943,1944],{},"Functions returning closures returning closures — typical in functional pipelines.",[23,1946,1948,1951],{"id":1947},"partial-currying",[38,1949,1950],{},"partial"," \u002F Currying",[14,1953,1954,1955,1957],{},"Rust doesn't have built-in currying, but ",[38,1956,506],{}," closures make it easy:",[28,1959,1960],{"language":30},[32,1961,1963],{"className":34,"code":1962,"language":30,"meta":36,"style":36},"let add = |a: i32| move |b: i32| a + b;\nlet add5 = add(5);\nadd5(3);   \u002F\u002F 8\n",[38,1964,1965,2003,2020],{"__ignoreMap":36},[41,1966,1967,1969,1971,1973,1975,1978,1980,1982,1984,1986,1988,1991,1993,1995,1997,1999,2001],{"class":43,"line":44},[41,1968,48],{"class":47},[41,1970,52],{"class":51},[41,1972,55],{"class":47},[41,1974,58],{"class":47},[41,1976,1977],{"class":51},"a",[41,1979,91],{"class":47},[41,1981,95],{"class":94},[41,1983,64],{"class":47},[41,1985,339],{"class":47},[41,1987,58],{"class":47},[41,1989,1990],{"class":51},"b",[41,1992,91],{"class":47},[41,1994,95],{"class":94},[41,1996,64],{"class":47},[41,1998,67],{"class":51},[41,2000,70],{"class":47},[41,2002,73],{"class":51},[41,2004,2005,2007,2009,2011,2014,2016,2018],{"class":43,"line":76},[41,2006,48],{"class":47},[41,2008,1002],{"class":51},[41,2010,55],{"class":47},[41,2012,2013],{"class":94}," add",[41,2015,137],{"class":51},[41,2017,862],{"class":177},[41,2019,144],{"class":51},[41,2021,2022,2024,2026,2029,2031],{"class":43,"line":109},[41,2023,1017],{"class":94},[41,2025,137],{"class":51},[41,2027,2028],{"class":177},"3",[41,2030,561],{"class":51},[41,2032,2033],{"class":225},"\u002F\u002F 8\n",[23,2035,2037],{"id":2036},"edge-cases-pitfalls","Edge Cases & Pitfalls",[230,2039,2040,2052,2068,2090,2099,2116,2132,2160],{},[233,2041,2042,2045,2046,2048,2049,2051],{},[18,2043,2044],{},"Capture lifetime",": a closure borrowing from local vars can't escape the local's scope. Use ",[38,2047,506],{}," (often with ",[38,2050,572],{}," requirement).",[233,2053,2054,2061,2062,2064,2065,2067],{},[18,2055,2056,415,2058],{},[38,2057,379],{},[38,2059,2060],{},"Vec::map",": ",[38,2063,1440],{}," consumes the iterator but only requires ",[38,2066,389],{},"; if you consume captures inside, you might need a different signature.",[233,2069,2070,2080,2081,2083,2084,2086,2087,2089],{},[18,2071,2072,2074,2075,2074,2077,2079],{},[38,2073,399],{}," vs ",[38,2076,389],{},[38,2078,379],{}," matching",": passing a ",[38,2082,379],{}," closure to a function expecting ",[38,2085,399],{}," won't compile. Pass ",[38,2088,399],{}," when possible.",[233,2091,2092,2095,2096,2098],{},[18,2093,2094],{},"Recursive closure",": not directly possible; use a ",[38,2097,676],{}," instead.",[233,2100,2101,2107,2108,2111,2112,2115],{},[18,2102,2103,2104],{},"Closures with ",[38,2105,2106],{},"&mut self",": a method that takes a closure that ",[657,2109,2110],{},"also"," borrows ",[38,2113,2114],{},"self"," mutably conflicts. Restructure (e.g., extract a value first).",[233,2117,2118,2124,2125,2128,2129,2131],{},[18,2119,2120,2121],{},"Capturing by ",[38,2122,2123],{},"RefCell",": if you need to mutate through a closure called multiple times behind an ",[38,2126,2127],{},"&","-reference, use ",[38,2130,2123],{}," for interior mutability.",[233,2133,2134,2061,2139,2142,2143,2146,2147,2149,2150,2153,2154,2156,2157,2159],{},[18,2135,2136,2138],{},[38,2137,506],{}," doesn't always move",[38,2140,2141],{},"move || println!(\"{x}\")"," for ",[38,2144,2145],{},"x: i32"," copies; ",[38,2148,506],{}," only forces ",[657,2151,2152],{},"by-value"," capture (which is ",[38,2155,1856],{},"-duplicating for ",[38,2158,1856],{}," types).",[233,2161,2162,2168,2169,2172,2173,418],{},[18,2163,2164,2167],{},[38,2165,2166],{},"move ||"," in threads",": required for ",[38,2170,2171],{},"std::thread::spawn"," since the closure must be ",[38,2174,2175],{},"'static + Send",[23,2177,2179,415,2182],{"id":2178},"threadspawn-and-static-send",[38,2180,2181],{},"thread::spawn",[38,2183,2175],{},[28,2185,2186],{"language":30},[32,2187,2189],{"className":34,"code":2188,"language":30,"meta":36,"style":36},"let data = vec![1, 2, 3];\nstd::thread::spawn(move || {\n    println!(\"{:?}\", data);   \u002F\u002F OK — data moved in\n});\n",[38,2190,2191,2221,2244,2260],{"__ignoreMap":36},[41,2192,2193,2195,2198,2200,2203,2206,2209,2211,2214,2216,2218],{"class":43,"line":44},[41,2194,48],{"class":47},[41,2196,2197],{"class":51}," data ",[41,2199,55],{"class":47},[41,2201,2202],{"class":94}," vec!",[41,2204,2205],{"class":51},"[",[41,2207,2208],{"class":177},"1",[41,2210,859],{"class":51},[41,2212,2213],{"class":177},"2",[41,2215,859],{"class":51},[41,2217,2028],{"class":177},[41,2219,2220],{"class":51},"];\n",[41,2222,2223,2226,2228,2231,2233,2236,2238,2240,2242],{"class":43,"line":76},[41,2224,2225],{"class":94},"std",[41,2227,317],{"class":47},[41,2229,2230],{"class":94},"thread",[41,2232,317],{"class":47},[41,2234,2235],{"class":94},"spawn",[41,2237,137],{"class":51},[41,2239,506],{"class":47},[41,2241,202],{"class":47},[41,2243,968],{"class":51},[41,2245,2246,2249,2251,2254,2257],{"class":43,"line":109},[41,2247,2248],{"class":94},"    println!",[41,2250,137],{"class":51},[41,2252,2253],{"class":140},"\"{:?}\"",[41,2255,2256],{"class":51},", data);   ",[41,2258,2259],{"class":225},"\u002F\u002F OK — data moved in\n",[41,2261,2262],{"class":43,"line":147},[41,2263,2264],{"class":51},"});\n",[14,2266,1667,2267,2269,2270,2273,2274,2276,2277,2279,2280,2282],{},[38,2268,506],{},", you'd borrow ",[38,2271,2272],{},"data",", which doesn't satisfy ",[38,2275,572],{},". ",[38,2278,506],{}," + ",[38,2281,2175],{}," is the recipe for thread closures.",[23,2284,2286],{"id":2285},"summary","Summary",[14,2288,2289,2290,2292,2293,2295,2296,2298,2299,2301,2302,1231,2304,1231,2306,2308,2309,2311,2312,2314],{},"Closures capture by ref (",[38,2291,399],{},"), mut ref (",[38,2294,389],{},"), or value (",[38,2297,379],{},"). ",[38,2300,506],{}," forces by-value. Use ",[38,2303,870],{},[38,2305,389],{},[38,2307,379],{}," for generic APIs. Closures are essential for iterator combinators and async. Returning closures requires ",[38,2310,1224],{}," (single type) or ",[38,2313,1599],{}," (heterogeneous).",[14,2316,2317,2318,859,2320,2322,2323,418],{},"Next: Error handling — ",[38,2319,1575],{},[38,2321,1579],{},", and ",[38,2324,1512],{},[2326,2327,2328],"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 .sJ6F3, html code.shiki .sJ6F3{--shiki-default:#032F62;--shiki-github-dark:#9ECBFF}html pre.shiki code .snvgF, html code.shiki .snvgF{--shiki-default:#005CC5;--shiki-github-dark:#79B8FF}html pre.shiki code .sdCPZ, html code.shiki .sdCPZ{--shiki-default:#6A737D;--shiki-github-dark:#6A737D}html .default .shiki span {color: var(--shiki-default);background: var(--shiki-default-bg);font-style: var(--shiki-default-font-style);font-weight: var(--shiki-default-font-weight);text-decoration: var(--shiki-default-text-decoration);}html .shiki span {color: var(--shiki-default);background: var(--shiki-default-bg);font-style: var(--shiki-default-font-style);font-weight: var(--shiki-default-font-weight);text-decoration: var(--shiki-default-text-decoration);}html .github-dark .shiki span {color: var(--shiki-github-dark);background: var(--shiki-github-dark-bg);font-style: var(--shiki-github-dark-font-style);font-weight: var(--shiki-github-dark-font-weight);text-decoration: var(--shiki-github-dark-text-decoration);}html.github-dark .shiki span {color: var(--shiki-github-dark);background: var(--shiki-github-dark-bg);font-style: var(--shiki-github-dark-font-style);font-weight: var(--shiki-github-dark-font-weight);text-decoration: var(--shiki-github-dark-text-decoration);}",{"title":36,"searchDepth":76,"depth":76,"links":2330},[2331,2332,2338,2339,2340,2341,2342,2344,2345,2347,2348,2350,2351,2352,2354,2355,2357],{"id":25,"depth":76,"text":26},{"id":252,"depth":76,"text":253,"children":2333},[2334,2335,2337],{"id":351,"depth":109,"text":352},{"id":503,"depth":109,"text":2336},"move Keyword",{"id":575,"depth":109,"text":576},{"id":663,"depth":76,"text":664},{"id":925,"depth":76,"text":926},{"id":1162,"depth":76,"text":1163},{"id":1172,"depth":76,"text":1173},{"id":1228,"depth":76,"text":2343},"Fn\u002FFnMut\u002FFnOnce Object Safety",{"id":1411,"depth":76,"text":1412},{"id":1509,"depth":76,"text":2346},"? in Closures",{"id":1582,"depth":76,"text":1583},{"id":1609,"depth":76,"text":2349},"move Closure Captures and Lifetime",{"id":1691,"depth":76,"text":1692},{"id":1859,"depth":76,"text":1860},{"id":1947,"depth":76,"text":2353},"partial \u002F Currying",{"id":2036,"depth":76,"text":2037},{"id":2178,"depth":76,"text":2356},"thread::spawn and 'static + Send",{"id":2285,"depth":76,"text":2286},"Closures are anonymous functions that capture their environment. They bridge the gap between functions and objects.","md",{},"\u002Frust\u002F17-closures",{"title":5,"description":2358},"rust\u002F17-closures","EO6SSdeyg_q5zHgL1vK0U0lNvc8HKNJ_bwE6Ahly6GU",1785944093241]