[{"data":1,"prerenderedAt":1487},["ShallowReactive",2],{"page-\u002Frust\u002F05-functions":3},{"id":4,"title":5,"body":6,"description":27,"extension":1481,"meta":1482,"navigation":99,"path":1483,"seo":1484,"stem":1485,"__hash__":1486},"content\u002Frust\u002F05-functions.md","05 — Functions",{"type":7,"value":8,"toc":1461},"minimark",[9,13,18,133,160,164,245,264,268,271,343,351,418,424,485,489,497,521,525,664,671,841,876,886,904,908,915,967,980,984,1085,1098,1102,1105,1180,1186,1189,1253,1259,1263,1365,1368,1372,1447,1451,1457],[10,11,5],"h1",{"id":12},"_05-functions",[14,15,17],"h2",{"id":16},"basics","Basics",[19,20,22],"code-wrapper",{"language":21},"rust",[23,24,28],"pre",{"className":25,"code":26,"language":21,"meta":27,"style":27},"language-rust shiki shiki-themes github-light github-dark","fn add(a: i32, b: i32) -> i32 {\n    a + b            \u002F\u002F last expression — no semicolon — is the return value\n}\n\nfn no_return() {\n    println!(\"returns ()\");\n}\n","",[29,30,31,72,88,94,101,112,128],"code",{"__ignoreMap":27},[32,33,36,40,44,48,51,54,57,59,61,64,67,69],"span",{"class":34,"line":35},"line",1,[32,37,39],{"class":38},"svdQ7","fn",[32,41,43],{"class":42},"sIsaT"," add",[32,45,47],{"class":46},"ssxIu","(a",[32,49,50],{"class":38},":",[32,52,53],{"class":42}," i32",[32,55,56],{"class":46},", b",[32,58,50],{"class":38},[32,60,53],{"class":42},[32,62,63],{"class":46},") ",[32,65,66],{"class":38},"->",[32,68,53],{"class":42},[32,70,71],{"class":46}," {\n",[32,73,75,78,81,84],{"class":34,"line":74},2,[32,76,77],{"class":46},"    a ",[32,79,80],{"class":38},"+",[32,82,83],{"class":46}," b            ",[32,85,87],{"class":86},"sdCPZ","\u002F\u002F last expression — no semicolon — is the return value\n",[32,89,91],{"class":34,"line":90},3,[32,92,93],{"class":46},"}\n",[32,95,97],{"class":34,"line":96},4,[32,98,100],{"emptyLinePlaceholder":99},true,"\n",[32,102,104,106,109],{"class":34,"line":103},5,[32,105,39],{"class":38},[32,107,108],{"class":42}," no_return",[32,110,111],{"class":46},"() {\n",[32,113,115,118,121,125],{"class":34,"line":114},6,[32,116,117],{"class":42},"    println!",[32,119,120],{"class":46},"(",[32,122,124],{"class":123},"sJ6F3","\"returns ()\"",[32,126,127],{"class":46},");\n",[32,129,131],{"class":34,"line":130},7,[32,132,93],{"class":46},[134,135,136,144,154],"ul",{},[137,138,139,140,143],"li",{},"The last expression (without ",[29,141,142],{},";",") is the return value.",[137,145,146,147,149,150,153],{},"A trailing ",[29,148,142],{}," makes it a statement returning ",[29,151,152],{},"()",".",[137,155,156,159],{},[29,157,158],{},"return x;"," is for early returns; the implicit last-expression form is idiomatic for the common case.",[14,161,163],{"id":162},"statements-vs-expressions","Statements vs Expressions",[19,165,166],{"language":21},[23,167,169],{"className":25,"code":168,"language":21,"meta":27,"style":27},"let x = (let y = 5;);   \u002F\u002F ERROR: statements don't produce values\nlet y = {\n    let z = 5;\n    z + 1                \u002F\u002F expression — block evaluates to 6\n};\n",[29,170,171,202,212,227,240],{"__ignoreMap":27},[32,172,173,176,179,182,185,187,190,192,196,199],{"class":34,"line":35},[32,174,175],{"class":38},"let",[32,177,178],{"class":46}," x ",[32,180,181],{"class":38},"=",[32,183,184],{"class":46}," (",[32,186,175],{"class":38},[32,188,189],{"class":46}," y ",[32,191,181],{"class":38},[32,193,195],{"class":194},"snvgF"," 5",[32,197,198],{"class":46},";);   ",[32,200,201],{"class":86},"\u002F\u002F ERROR: statements don't produce values\n",[32,203,204,206,208,210],{"class":34,"line":74},[32,205,175],{"class":38},[32,207,189],{"class":46},[32,209,181],{"class":38},[32,211,71],{"class":46},[32,213,214,217,220,222,224],{"class":34,"line":90},[32,215,216],{"class":38},"    let",[32,218,219],{"class":46}," z ",[32,221,181],{"class":38},[32,223,195],{"class":194},[32,225,226],{"class":46},";\n",[32,228,229,232,234,237],{"class":34,"line":96},[32,230,231],{"class":46},"    z ",[32,233,80],{"class":38},[32,235,236],{"class":194}," 1",[32,238,239],{"class":86},"                \u002F\u002F expression — block evaluates to 6\n",[32,241,242],{"class":34,"line":103},[32,243,244],{"class":46},"};\n",[246,247,248,249,252,253,256,257,256,260,263],"p",{},"Blocks ",[29,250,251],{},"{ ... }"," are expressions. ",[29,254,255],{},"if",", ",[29,258,259],{},"match",[29,261,262],{},"loop"," are also expressions.",[14,265,267],{"id":266},"parameters-patterns","Parameters & Patterns",[246,269,270],{},"Parameters can be patterns:",[19,272,273],{"language":21},[23,274,276],{"className":25,"code":275,"language":21,"meta":27,"style":27},"fn print_pair((a, b): (i32, i32)) { println!(\"{a} {b}\"); }\nfn first((a, _): (i32, i32)) -> i32 { a }\n",[29,277,278,313],{"__ignoreMap":27},[32,279,280,282,285,288,290,292,295,297,299,302,305,307,310],{"class":34,"line":35},[32,281,39],{"class":38},[32,283,284],{"class":42}," print_pair",[32,286,287],{"class":46},"((a, b)",[32,289,50],{"class":38},[32,291,184],{"class":46},[32,293,294],{"class":42},"i32",[32,296,256],{"class":46},[32,298,294],{"class":42},[32,300,301],{"class":46},")) { ",[32,303,304],{"class":42},"println!",[32,306,120],{"class":46},[32,308,309],{"class":123},"\"{a} {b}\"",[32,311,312],{"class":46},"); }\n",[32,314,315,317,320,323,325,327,329,331,333,336,338,340],{"class":34,"line":74},[32,316,39],{"class":38},[32,318,319],{"class":42}," first",[32,321,322],{"class":46},"((a, _)",[32,324,50],{"class":38},[32,326,184],{"class":46},[32,328,294],{"class":42},[32,330,256],{"class":46},[32,332,294],{"class":42},[32,334,335],{"class":46},")) ",[32,337,66],{"class":38},[32,339,53],{"class":42},[32,341,342],{"class":46}," { a }\n",[14,344,346,347,350],{"id":345},"diverging-functions","Diverging Functions (",[29,348,349],{},"-> !",")",[19,352,353],{"language":21},[23,354,356],{"className":25,"code":355,"language":21,"meta":27,"style":27},"fn forever() -> ! {\n    loop {}\n}\nfn die() -> ! {\n    panic!(\"bye\");\n}\n",[29,357,358,375,383,387,402,414],{"__ignoreMap":27},[32,359,360,362,365,368,370,373],{"class":34,"line":35},[32,361,39],{"class":38},[32,363,364],{"class":42}," forever",[32,366,367],{"class":46},"() ",[32,369,66],{"class":38},[32,371,372],{"class":38}," !",[32,374,71],{"class":46},[32,376,377,380],{"class":34,"line":74},[32,378,379],{"class":38},"    loop",[32,381,382],{"class":46}," {}\n",[32,384,385],{"class":34,"line":90},[32,386,93],{"class":46},[32,388,389,391,394,396,398,400],{"class":34,"line":96},[32,390,39],{"class":38},[32,392,393],{"class":42}," die",[32,395,367],{"class":46},[32,397,66],{"class":38},[32,399,372],{"class":38},[32,401,71],{"class":46},[32,403,404,407,409,412],{"class":34,"line":103},[32,405,406],{"class":42},"    panic!",[32,408,120],{"class":46},[32,410,411],{"class":123},"\"bye\"",[32,413,127],{"class":46},[32,415,416],{"class":34,"line":114},[32,417,93],{"class":46},[246,419,420,423],{},[29,421,422],{},"!"," coerces to any type, allowing it anywhere a value is expected:",[19,425,426],{"language":21},[23,427,429],{"className":25,"code":428,"language":21,"meta":27,"style":27},"let v: i32 = match opt {\n    Some(x) => x,\n    None => die(),    \u002F\u002F ! coerces to i32\n};\n",[29,430,431,451,465,481],{"__ignoreMap":27},[32,432,433,435,438,440,442,445,448],{"class":34,"line":35},[32,434,175],{"class":38},[32,436,437],{"class":46}," v",[32,439,50],{"class":38},[32,441,53],{"class":42},[32,443,444],{"class":38}," =",[32,446,447],{"class":38}," match",[32,449,450],{"class":46}," opt {\n",[32,452,453,456,459,462],{"class":34,"line":74},[32,454,455],{"class":42},"    Some",[32,457,458],{"class":46},"(x) ",[32,460,461],{"class":38},"=>",[32,463,464],{"class":46}," x,\n",[32,466,467,470,473,475,478],{"class":34,"line":90},[32,468,469],{"class":42},"    None",[32,471,472],{"class":38}," =>",[32,474,393],{"class":42},[32,476,477],{"class":46},"(),    ",[32,479,480],{"class":86},"\u002F\u002F ! coerces to i32\n",[32,482,483],{"class":34,"line":96},[32,484,244],{"class":46},[14,486,488],{"id":487},"default-optional-parameters","Default & Optional Parameters?",[246,490,491,492,496],{},"Rust has ",[493,494,495],"strong",{},"no function overloading or default parameters",". Use:",[134,498,499,502,511],{},[137,500,501],{},"Builder pattern",[137,503,504,505,256,508,350],{},"Multiple methods (",[29,506,507],{},"new",[29,509,510],{},"with_capacity",[137,512,513,514,517,518,350],{},"Traits for \"overloading\" semantics (e.g., ",[29,515,516],{},"From","\u002F",[29,519,520],{},"Into",[14,522,524],{"id":523},"generic-functions-preview","Generic Functions (preview)",[19,526,527],{"language":21},[23,528,530],{"className":25,"code":529,"language":21,"meta":27,"style":27},"fn first\u003CT>(v: &[T]) -> Option\u003C&T> {\n    v.first()\n}\n\nfn max\u003CT: PartialOrd + Copy>(a: T, b: T) -> T {\n    if a > b { a } else { b }\n}\n",[29,531,532,575,588,592,596,640,660],{"__ignoreMap":27},[32,533,534,536,538,541,544,547,549,552,555,557,560,562,565,567,570,572],{"class":34,"line":35},[32,535,39],{"class":38},[32,537,319],{"class":42},[32,539,540],{"class":46},"\u003C",[32,542,543],{"class":42},"T",[32,545,546],{"class":46},">(v",[32,548,50],{"class":38},[32,550,551],{"class":38}," &",[32,553,554],{"class":46},"[",[32,556,543],{"class":42},[32,558,559],{"class":46},"]) ",[32,561,66],{"class":38},[32,563,564],{"class":42}," Option",[32,566,540],{"class":46},[32,568,569],{"class":38},"&",[32,571,543],{"class":42},[32,573,574],{"class":46},"> {\n",[32,576,577,580,582,585],{"class":34,"line":74},[32,578,579],{"class":46},"    v",[32,581,153],{"class":38},[32,583,584],{"class":42},"first",[32,586,587],{"class":46},"()\n",[32,589,590],{"class":34,"line":90},[32,591,93],{"class":46},[32,593,594],{"class":34,"line":96},[32,595,100],{"emptyLinePlaceholder":99},[32,597,598,600,603,605,607,609,612,615,618,621,623,626,628,630,632,634,636,638],{"class":34,"line":103},[32,599,39],{"class":38},[32,601,602],{"class":42}," max",[32,604,540],{"class":46},[32,606,543],{"class":42},[32,608,50],{"class":38},[32,610,611],{"class":42}," PartialOrd",[32,613,614],{"class":38}," +",[32,616,617],{"class":42}," Copy",[32,619,620],{"class":46},">(a",[32,622,50],{"class":38},[32,624,625],{"class":42}," T",[32,627,56],{"class":46},[32,629,50],{"class":38},[32,631,625],{"class":42},[32,633,63],{"class":46},[32,635,66],{"class":38},[32,637,625],{"class":42},[32,639,71],{"class":46},[32,641,642,645,648,651,654,657],{"class":34,"line":114},[32,643,644],{"class":38},"    if",[32,646,647],{"class":46}," a ",[32,649,650],{"class":38},">",[32,652,653],{"class":46}," b { a } ",[32,655,656],{"class":38},"else",[32,658,659],{"class":46}," { b }\n",[32,661,662],{"class":34,"line":130},[32,663,93],{"class":46},[14,665,667,670],{"id":666},"impl-blocks-methods",[29,668,669],{},"impl"," Blocks (Methods)",[19,672,673],{"language":21},[23,674,676],{"className":25,"code":675,"language":21,"meta":27,"style":27},"struct Rect { w: u32, h: u32 }\n\nimpl Rect {\n    fn area(&self) -> u32 { self.w * self.h }          \u002F\u002F method\n    fn new(w: u32, h: u32) -> Self { Rect { w, h } }    \u002F\u002F associated fn\n    fn set(&mut self, w: u32) { self.w = w; }           \u002F\u002F mut borrow\n}\n",[29,677,678,704,708,716,761,799,837],{"__ignoreMap":27},[32,679,680,683,686,689,691,694,697,699,701],{"class":34,"line":35},[32,681,682],{"class":38},"struct",[32,684,685],{"class":42}," Rect",[32,687,688],{"class":46}," { w",[32,690,50],{"class":38},[32,692,693],{"class":42}," u32",[32,695,696],{"class":46},", h",[32,698,50],{"class":38},[32,700,693],{"class":42},[32,702,703],{"class":46}," }\n",[32,705,706],{"class":34,"line":74},[32,707,100],{"emptyLinePlaceholder":99},[32,709,710,712,714],{"class":34,"line":90},[32,711,669],{"class":38},[32,713,685],{"class":42},[32,715,71],{"class":46},[32,717,718,721,724,726,728,731,733,735,737,740,742,744,747,750,753,755,758],{"class":34,"line":96},[32,719,720],{"class":38},"    fn",[32,722,723],{"class":42}," area",[32,725,120],{"class":46},[32,727,569],{"class":38},[32,729,730],{"class":194},"self",[32,732,63],{"class":46},[32,734,66],{"class":38},[32,736,693],{"class":42},[32,738,739],{"class":46}," { ",[32,741,730],{"class":194},[32,743,153],{"class":38},[32,745,746],{"class":46},"w ",[32,748,749],{"class":38},"*",[32,751,752],{"class":194}," self",[32,754,153],{"class":38},[32,756,757],{"class":46},"h }          ",[32,759,760],{"class":86},"\u002F\u002F method\n",[32,762,763,765,768,771,773,775,777,779,781,783,785,788,790,793,796],{"class":34,"line":103},[32,764,720],{"class":38},[32,766,767],{"class":42}," new",[32,769,770],{"class":46},"(w",[32,772,50],{"class":38},[32,774,693],{"class":42},[32,776,696],{"class":46},[32,778,50],{"class":38},[32,780,693],{"class":42},[32,782,63],{"class":46},[32,784,66],{"class":38},[32,786,787],{"class":194}," Self",[32,789,739],{"class":46},[32,791,792],{"class":42},"Rect",[32,794,795],{"class":46}," { w, h } }    ",[32,797,798],{"class":86},"\u002F\u002F associated fn\n",[32,800,801,803,806,808,811,813,816,818,820,823,825,827,829,831,834],{"class":34,"line":114},[32,802,720],{"class":38},[32,804,805],{"class":42}," set",[32,807,120],{"class":46},[32,809,810],{"class":38},"&mut",[32,812,752],{"class":194},[32,814,815],{"class":46},", w",[32,817,50],{"class":38},[32,819,693],{"class":42},[32,821,822],{"class":46},") { ",[32,824,730],{"class":194},[32,826,153],{"class":38},[32,828,746],{"class":46},[32,830,181],{"class":38},[32,832,833],{"class":46}," w; }           ",[32,835,836],{"class":86},"\u002F\u002F mut borrow\n",[32,838,839],{"class":34,"line":130},[32,840,93],{"class":46},[134,842,843,853,859,866],{},[137,844,845,848,849,852],{},[29,846,847],{},"&self"," = ",[29,850,851],{},"self: &Self"," (immutable borrow).",[137,854,855,858],{},[29,856,857],{},"&mut self"," = mutable borrow.",[137,860,861,863,864,153],{},[29,862,730],{}," (by value) = consumes ",[29,865,730],{},[137,867,868,869,871,872,875],{},"Associated functions (no ",[29,870,730],{},") called as ",[29,873,874],{},"Rect::new(...)"," (like static methods).",[14,877,879,882,883,885],{"id":878},"self-and-self-keywords",[29,880,881],{},"Self"," and ",[29,884,730],{}," Keywords",[246,887,888,890,891,893,894,896,897,899,900,903],{},[29,889,881],{}," is the type the ",[29,892,669],{}," is for. ",[29,895,730],{}," is the receiver shorthand. ",[29,898,881],{}," in a ",[29,901,902],{},"trait"," body refers to the implementing type.",[14,905,907],{"id":906},"variadic-functions","Variadic Functions",[246,909,910,911,914],{},"Only ",[29,912,913],{},"extern \"C\""," FFI functions can be C-style variadic:",[19,916,917],{"language":21},[23,918,920],{"className":25,"code":919,"language":21,"meta":27,"style":27},"extern \"C\" {\n    fn printf(fmt: *const u8, ...) -> i32;\n}\n",[29,921,922,932,963],{"__ignoreMap":27},[32,923,924,927,930],{"class":34,"line":35},[32,925,926],{"class":38},"extern",[32,928,929],{"class":123}," \"C\"",[32,931,71],{"class":46},[32,933,934,936,939,942,944,947,950,952,955,957,959,961],{"class":34,"line":74},[32,935,720],{"class":38},[32,937,938],{"class":42}," printf",[32,940,941],{"class":46},"(fmt",[32,943,50],{"class":38},[32,945,946],{"class":38}," *const",[32,948,949],{"class":42}," u8",[32,951,256],{"class":46},[32,953,954],{"class":38},"...",[32,956,63],{"class":46},[32,958,66],{"class":38},[32,960,53],{"class":42},[32,962,226],{"class":46},[32,964,965],{"class":34,"line":90},[32,966,93],{"class":46},[246,968,969,970,256,972,975,976,979],{},"Idiomatic variadic-ness comes from macros (",[29,971,304],{},[29,973,974],{},"vec!",") or slices (",[29,977,978],{},"fn sum(nums: &[i32])",").",[14,981,983],{"id":982},"function-pointers-vs-closures","Function Pointers vs Closures",[19,985,986],{"language":21},[23,987,989],{"className":25,"code":988,"language":21,"meta":27,"style":27},"fn add(a: i32, b: i32) -> i32 { a + b }\nlet fp: fn(i32, i32) -> i32 = add;       \u002F\u002F function pointer, Copy, Sized\nlet cl = |a, b| a + b;                    \u002F\u002F closure, captures env, !Sized\n",[29,990,991,1023,1057],{"__ignoreMap":27},[32,992,993,995,997,999,1001,1003,1005,1007,1009,1011,1013,1015,1018,1020],{"class":34,"line":35},[32,994,39],{"class":38},[32,996,43],{"class":42},[32,998,47],{"class":46},[32,1000,50],{"class":38},[32,1002,53],{"class":42},[32,1004,56],{"class":46},[32,1006,50],{"class":38},[32,1008,53],{"class":42},[32,1010,63],{"class":46},[32,1012,66],{"class":38},[32,1014,53],{"class":42},[32,1016,1017],{"class":46}," { a ",[32,1019,80],{"class":38},[32,1021,1022],{"class":46}," b }\n",[32,1024,1025,1027,1030,1032,1035,1037,1039,1041,1043,1045,1047,1049,1051,1054],{"class":34,"line":74},[32,1026,175],{"class":38},[32,1028,1029],{"class":46}," fp",[32,1031,50],{"class":38},[32,1033,1034],{"class":42}," fn",[32,1036,120],{"class":46},[32,1038,294],{"class":42},[32,1040,256],{"class":46},[32,1042,294],{"class":42},[32,1044,63],{"class":46},[32,1046,66],{"class":38},[32,1048,53],{"class":42},[32,1050,444],{"class":38},[32,1052,1053],{"class":46}," add;       ",[32,1055,1056],{"class":86},"\u002F\u002F function pointer, Copy, Sized\n",[32,1058,1059,1061,1064,1066,1069,1072,1075,1077,1079,1082],{"class":34,"line":90},[32,1060,175],{"class":38},[32,1062,1063],{"class":46}," cl ",[32,1065,181],{"class":38},[32,1067,1068],{"class":38}," |",[32,1070,1071],{"class":46},"a, b",[32,1073,1074],{"class":38},"|",[32,1076,647],{"class":46},[32,1078,80],{"class":38},[32,1080,1081],{"class":46}," b;                    ",[32,1083,1084],{"class":86},"\u002F\u002F closure, captures env, !Sized\n",[246,1086,1087,1088,517,1091,517,1094,1097],{},"See the Closures chapter for ",[29,1089,1090],{},"Fn",[29,1092,1093],{},"FnMut",[29,1095,1096],{},"FnOnce"," distinctions.",[14,1099,1101],{"id":1100},"recursion","Recursion",[246,1103,1104],{},"Rust doesn't guarantee tail-call optimization. Deep recursion can overflow the stack. For deep\u002Fiterative algorithms, convert to an explicit loop with a stack.",[19,1106,1107],{"language":21},[23,1108,1110],{"className":25,"code":1109,"language":21,"meta":27,"style":27},"fn fact(n: u64) -> u64 {\n    if n == 0 { 1 } else { n * fact(n - 1) }\n}\n",[29,1111,1112,1135,1176],{"__ignoreMap":27},[32,1113,1114,1116,1119,1122,1124,1127,1129,1131,1133],{"class":34,"line":35},[32,1115,39],{"class":38},[32,1117,1118],{"class":42}," fact",[32,1120,1121],{"class":46},"(n",[32,1123,50],{"class":38},[32,1125,1126],{"class":42}," u64",[32,1128,63],{"class":46},[32,1130,66],{"class":38},[32,1132,1126],{"class":42},[32,1134,71],{"class":46},[32,1136,1137,1139,1142,1145,1148,1150,1153,1156,1158,1161,1163,1165,1168,1171,1173],{"class":34,"line":74},[32,1138,644],{"class":38},[32,1140,1141],{"class":46}," n ",[32,1143,1144],{"class":38},"==",[32,1146,1147],{"class":194}," 0",[32,1149,739],{"class":46},[32,1151,1152],{"class":194},"1",[32,1154,1155],{"class":46}," } ",[32,1157,656],{"class":38},[32,1159,1160],{"class":46}," { n ",[32,1162,749],{"class":38},[32,1164,1118],{"class":42},[32,1166,1167],{"class":46},"(n ",[32,1169,1170],{"class":38},"-",[32,1172,236],{"class":194},[32,1174,1175],{"class":46},") }\n",[32,1177,1178],{"class":34,"line":90},[32,1179,93],{"class":46},[14,1181,1183],{"id":1182},"const-fn",[29,1184,1185],{},"const fn",[246,1187,1188],{},"Compile-time-callable functions with a restricted feature set:",[19,1190,1191],{"language":21},[23,1192,1194],{"className":25,"code":1193,"language":21,"meta":27,"style":27},"const fn square(x: i32) -> i32 { x * x }\nconst N: i32 = square(5);   \u002F\u002F evaluated at compile time\n",[29,1195,1196,1227],{"__ignoreMap":27},[32,1197,1198,1201,1203,1206,1209,1211,1213,1215,1217,1219,1222,1224],{"class":34,"line":35},[32,1199,1200],{"class":38},"const",[32,1202,1034],{"class":38},[32,1204,1205],{"class":42}," square",[32,1207,1208],{"class":46},"(x",[32,1210,50],{"class":38},[32,1212,53],{"class":42},[32,1214,63],{"class":46},[32,1216,66],{"class":38},[32,1218,53],{"class":42},[32,1220,1221],{"class":46}," { x ",[32,1223,749],{"class":38},[32,1225,1226],{"class":46}," x }\n",[32,1228,1229,1231,1234,1236,1238,1240,1242,1244,1247,1250],{"class":34,"line":74},[32,1230,1200],{"class":38},[32,1232,1233],{"class":194}," N",[32,1235,50],{"class":38},[32,1237,53],{"class":42},[32,1239,444],{"class":38},[32,1241,1205],{"class":42},[32,1243,120],{"class":46},[32,1245,1246],{"class":194},"5",[32,1248,1249],{"class":46},");   ",[32,1251,1252],{"class":86},"\u002F\u002F evaluated at compile time\n",[246,1254,1255,1256,1258],{},"Each release expands what's allowed in ",[29,1257,1185],{}," (loops, mutable locals, etc.).",[14,1260,1262],{"id":1261},"calling-conventions-abi","Calling Conventions & ABI",[19,1264,1265],{"language":21},[23,1266,1268],{"className":25,"code":1267,"language":21,"meta":27,"style":27},"extern \"C\" fn c_fn(x: i32) -> i32 { x + 1 }\nextern \"Rust\" fn rust_fn(x: i32) -> i32 { x + 1 }   \u002F\u002F default\nextern \"C\" { fn imported(x: i32) -> i32; }\n",[29,1269,1270,1301,1337],{"__ignoreMap":27},[32,1271,1272,1274,1276,1278,1281,1283,1285,1287,1289,1291,1293,1295,1297,1299],{"class":34,"line":35},[32,1273,926],{"class":38},[32,1275,929],{"class":123},[32,1277,1034],{"class":38},[32,1279,1280],{"class":42}," c_fn",[32,1282,1208],{"class":46},[32,1284,50],{"class":38},[32,1286,53],{"class":42},[32,1288,63],{"class":46},[32,1290,66],{"class":38},[32,1292,53],{"class":42},[32,1294,1221],{"class":46},[32,1296,80],{"class":38},[32,1298,236],{"class":194},[32,1300,703],{"class":46},[32,1302,1303,1305,1308,1310,1313,1315,1317,1319,1321,1323,1325,1327,1329,1331,1334],{"class":34,"line":74},[32,1304,926],{"class":38},[32,1306,1307],{"class":123}," \"Rust\"",[32,1309,1034],{"class":38},[32,1311,1312],{"class":42}," rust_fn",[32,1314,1208],{"class":46},[32,1316,50],{"class":38},[32,1318,53],{"class":42},[32,1320,63],{"class":46},[32,1322,66],{"class":38},[32,1324,53],{"class":42},[32,1326,1221],{"class":46},[32,1328,80],{"class":38},[32,1330,236],{"class":194},[32,1332,1333],{"class":46}," }   ",[32,1335,1336],{"class":86},"\u002F\u002F default\n",[32,1338,1339,1341,1343,1345,1347,1350,1352,1354,1356,1358,1360,1362],{"class":34,"line":90},[32,1340,926],{"class":38},[32,1342,929],{"class":123},[32,1344,739],{"class":46},[32,1346,39],{"class":38},[32,1348,1349],{"class":42}," imported",[32,1351,1208],{"class":46},[32,1353,50],{"class":38},[32,1355,53],{"class":42},[32,1357,63],{"class":46},[32,1359,66],{"class":38},[32,1361,53],{"class":42},[32,1363,1364],{"class":46},"; }\n",[246,1366,1367],{},"Useful for FFI and callbacks passed to C libraries.",[14,1369,1371],{"id":1370},"edge-cases","Edge Cases",[134,1373,1374,1395,1407,1420,1429,1435],{},[137,1375,1376,1382,1383,1385,1386,1390,1391,1394],{},[493,1377,1378,1381],{},[29,1379,1380],{},"return"," in a closure",": ",[29,1384,1380],{}," inside a closure returns from the ",[1387,1388,1389],"em",{},"closure",", not the enclosing function (unlike some languages). Use labeled loops\u002Fbreaks or ",[29,1392,1393],{},"?"," carefully.",[137,1396,1397,1400,1401,1403,1404,1406],{},[493,1398,1399],{},"Block-as-expression footgun",": forgetting the trailing ",[29,1402,142],{}," returns the value; adding it silently changes the return type to ",[29,1405,152],{},". The compiler catches this.",[137,1408,1409,1417,1418,153],{},[493,1410,1411,1413,1414],{},[29,1412,39],{}," types are ",[29,1415,1416],{},"Copy",": you can copy function pointers freely; closures are not necessarily ",[29,1419,1416],{},[137,1421,1422,1382,1425,1428],{},[493,1423,1424],{},"Lifetime elision in fn signatures",[29,1426,1427],{},"fn first(s: &str) -> &str"," has elided lifetimes; the compiler infers one input lifetime → output lifetime.",[137,1430,1431,1434],{},[493,1432,1433],{},"Recursion + generics",": monomorphized per type — code bloat risk.",[137,1436,1437,1442,1443,1446],{},[493,1438,1439],{},[29,1440,1441],{},"#[inline]",": a hint; ",[29,1444,1445],{},"#[inline(always)]"," can bloat code; usually trust the compiler.",[14,1448,1450],{"id":1449},"summary","Summary",[246,1452,1453,1454,1456],{},"Functions are expressions, support patterns in parameters, can diverge, have no overloading, and methods live in ",[29,1455,669],{}," blocks. Next: control flow.",[1458,1459,1460],"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 .sdCPZ, html code.shiki .sdCPZ{--shiki-default:#6A737D;--shiki-github-dark:#6A737D}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 .snvgF, html code.shiki .snvgF{--shiki-default:#005CC5;--shiki-github-dark:#79B8FF}",{"title":27,"searchDepth":74,"depth":74,"links":1462},[1463,1464,1465,1466,1468,1469,1470,1472,1474,1475,1476,1477,1478,1479,1480],{"id":16,"depth":74,"text":17},{"id":162,"depth":74,"text":163},{"id":266,"depth":74,"text":267},{"id":345,"depth":74,"text":1467},"Diverging Functions (-> !)",{"id":487,"depth":74,"text":488},{"id":523,"depth":74,"text":524},{"id":666,"depth":74,"text":1471},"impl Blocks (Methods)",{"id":878,"depth":74,"text":1473},"Self and self Keywords",{"id":906,"depth":74,"text":907},{"id":982,"depth":74,"text":983},{"id":1100,"depth":74,"text":1101},{"id":1182,"depth":74,"text":1185},{"id":1261,"depth":74,"text":1262},{"id":1370,"depth":74,"text":1371},{"id":1449,"depth":74,"text":1450},"md",{},"\u002Frust\u002F05-functions",{"title":5,"description":27},"rust\u002F05-functions","K8FlLyfArv6t6eGPUBcoSlbLE8IBPW7DdPOoLDi7KAg",1785944093199]