[{"data":1,"prerenderedAt":1173},["ShallowReactive",2],{"navigation_docs":3,"-core-features-functions":198,"-core-features-functions-surround":1168},[4,30,81,118,147,171,184],{"title":5,"icon":6,"path":7,"stem":8,"children":9,"page":6},"Getting Started",false,"/getting-started","1.getting-started",[10,15,20,25],{"title":11,"path":12,"stem":13,"icon":14},"Introduction","/getting-started/introduction","1.getting-started/2.introduction","i-lucide-house",{"title":16,"path":17,"stem":18,"icon":19},"Installation","/getting-started/installation","1.getting-started/3.installation","i-lucide-download",{"title":21,"path":22,"stem":23,"icon":24},"Quick start","/getting-started/quickstart","1.getting-started/4.quickstart","i-lucide-code-xml",{"title":26,"path":27,"stem":28,"icon":29},"Troubleshooting","/getting-started/troubleshooting","1.getting-started/5.troubleshooting","i-lucide-wrench",{"title":31,"icon":6,"path":32,"stem":33,"children":34,"page":6},"Core Features","/core-features","2.core-features",[35,39,43,48,52,56,60,64,68,73,77],{"title":36,"path":37,"stem":38,"icon":24},"Main function","/core-features/main-function","2.core-features/1.main-function",{"title":40,"path":41,"stem":42,"icon":24},"Variables","/core-features/variables","2.core-features/2.variables",{"title":44,"path":45,"stem":46,"icon":47},"Comment","/core-features/comment","2.core-features/3.comment","i-lucide-hash",{"title":49,"path":50,"stem":51,"icon":24},"Conditionals","/core-features/conditionals","2.core-features/4.conditionals",{"title":53,"path":54,"stem":55,"icon":24},"Loops","/core-features/loops","2.core-features/5.loops",{"title":57,"path":58,"stem":59,"icon":24},"Functions","/core-features/functions","2.core-features/6.functions",{"title":61,"path":62,"stem":63,"icon":24},"Pointers","/core-features/pointers","2.core-features/7.pointers",{"title":65,"path":66,"stem":67,"icon":24},"Data types","/core-features/datatypes","2.core-features/8.datatypes",{"title":69,"path":70,"stem":71,"icon":72},"Operators","/core-features/operators","2.core-features/9.operators","i-lucide-percent",{"title":74,"path":75,"stem":76,"icon":24},"Literals","/core-features/a.literals","2.core-features/a.literals",{"title":78,"path":79,"stem":80,"icon":24},"Keywords","/core-features/b.keywords","2.core-features/b.keywords",{"title":82,"icon":6,"path":83,"stem":84,"children":85,"page":6},"Features","/features","3.features",[86,90,94,98,102,106,110,114],{"title":87,"path":88,"stem":89,"icon":24},"Const","/features/const","3.features/1.const",{"title":91,"path":92,"stem":93,"icon":24},"Define","/features/define","3.features/2.define",{"title":95,"path":96,"stem":97,"icon":24},"Enum","/features/enum","3.features/3.enum",{"title":99,"path":100,"stem":101,"icon":24},"Union","/features/union","3.features/4.union",{"title":103,"path":104,"stem":105,"icon":24},"Overloading","/features/overloading","3.features/5.overloading",{"title":107,"path":108,"stem":109,"icon":24},"Lambda","/features/lambda","3.features/6.lambda",{"title":111,"path":112,"stem":113,"icon":24},"Callback","/features/callback","3.features/7.callback",{"title":115,"path":116,"stem":117,"icon":24},"Auto","/features/auto","3.features/8.auto",{"title":119,"icon":6,"path":120,"stem":121,"children":122,"page":6},"Advance Features","/advance","4.advance",[123,127,131,135,139,143],{"title":124,"path":125,"stem":126,"icon":24},"Generic Type","/advance/generic-type","4.advance/1.generic-type",{"title":128,"path":129,"stem":130,"icon":24},"Errors","/advance/error","4.advance/2.error",{"title":132,"path":133,"stem":134,"icon":24},"Annotation","/advance/annotation","4.advance/3.annotation",{"title":136,"path":137,"stem":138,"icon":24},"Variadic Function","/advance/variadic-func","4.advance/4.variadic-func",{"title":140,"path":141,"stem":142,"icon":24},"Module","/advance/module-interface","4.advance/5.module-interface",{"title":144,"path":145,"stem":146,"icon":24},"Operator Overloading","/advance/operator-overloading","4.advance/6.operator-overloading",{"title":148,"icon":6,"path":149,"stem":150,"children":151,"page":6},"Struct","/struct","5.struct",[152,155,159,163,167],{"title":148,"path":153,"stem":154,"icon":24},"/struct/struct","5.struct/1.struct",{"title":156,"path":157,"stem":158,"icon":24},"Methods","/struct/methods","5.struct/2.methods",{"title":160,"path":161,"stem":162,"icon":24},"Init/Deinit","/struct/init-deinit","5.struct/3.init-deinit",{"title":164,"path":165,"stem":166,"icon":24},"Encapsulation","/struct/encapsulation","5.struct/4.encapsulation",{"title":168,"path":169,"stem":170,"icon":24},"Static","/struct/static","5.struct/5.static",{"title":172,"icon":6,"path":173,"stem":174,"children":175,"page":6},"Data Structures","/data-structure","6.data-structure",[176,180],{"title":177,"path":178,"stem":179,"icon":24},"Array","/data-structure/array","6.data-structure/array",{"title":181,"path":182,"stem":183,"icon":24},"Structural Type","/data-structure/strutural-type","6.data-structure/strutural-type",{"title":185,"icon":6,"path":186,"stem":187,"children":188,"page":6},"Standard Libraries","/stdlib","7.stdlib",[189,194],{"title":190,"path":191,"stem":192,"icon":193},"stdlib","/stdlib/stdlib","7.stdlib/stdlib","i-lucide-library-big",{"title":195,"path":196,"stem":197,"icon":24},"syscall","/stdlib/syscall","7.stdlib/syscall",{"id":199,"title":57,"body":200,"description":1161,"extension":1162,"links":1163,"meta":1164,"navigation":1165,"path":58,"seo":1166,"stem":59,"__hash__":1167},"docs/2.core-features/6.functions.md",{"type":201,"value":202,"toc":1151},"minimark",[203,207,212,259,290,301,425,433,437,471,484,493,628,636,641,650,703,728,814,821,827,831,834,839,931,934,937,1018,1021,1034,1038,1140,1147],[204,205,206],"p",{},"Functions are a fundamental feature in the procedural programming, acting as the primary building blocks used to organize code into logical and reusable code. This allows developers break complex code into smaller and simpler logics.",[208,209,211],"h2",{"id":210},"simple-functions","Simple functions",[213,214,220],"pre",{"className":215,"code":216,"filename":217,"language":218,"meta":219,"style":219},"language-kh shiki shiki-themes material-theme-lighter one-light one-dark-pro","return_type function_name(parameter_list){\n  # code ...\n}\n","syntax","kh","",[221,222,223,246,253],"code",{"__ignoreMap":219},[224,225,228,232,236,240,243],"span",{"class":226,"line":227},"line",1,[224,229,231],{"class":230},"s8dPH","return_type",[224,233,235],{"class":234},"spnjr"," function_name",[224,237,239],{"class":238},"sM89C","(",[224,241,242],{"class":230},"parameter_list",[224,244,245],{"class":238},"){\n",[224,247,249],{"class":226,"line":248},2,[224,250,252],{"class":251},"seacL","  # code ...\n",[224,254,256],{"class":226,"line":255},3,[224,257,258],{"class":238},"}\n",[260,261,262],"blockquote",{},[263,264,265,271,285],"ul",{},[266,267,268,270],"li",{},[221,269,231],{}," can any, void, primitive types, or user-defined types, pointers, etc.",[266,272,273,276,277,280,281,284],{},[221,274,275],{},"function_name"," must be any valid identifier beside ",[221,278,279],{},"main",", see ",[282,283,279],"a",{"href":37},".",[266,286,287,289],{},[221,288,242],{}," is optional, can contain none or more parameters.",[204,291,292,296,297,300],{},[293,294,295],"strong",{},"Example:"," In this example, we're going to create a ",[221,298,299],{},"sum"," function to perform addition on two integers.",[213,302,304],{"className":215,"code":303,"language":218,"meta":219,"style":219},"int sum(int a, int b){\n  return a + b;\n}\n\nint main(string args[]){\n  int result = add(1, 2); # result = 3\n  return 0;\n}\n",[221,305,306,331,348,352,359,378,410,420],{"__ignoreMap":219},[224,307,308,311,314,316,318,321,324,326,329],{"class":226,"line":227},[224,309,310],{"class":230},"int",[224,312,313],{"class":234}," sum",[224,315,239],{"class":238},[224,317,310],{"class":230},[224,319,320],{"class":230}," a",[224,322,323],{"class":238},", ",[224,325,310],{"class":230},[224,327,328],{"class":230}," b",[224,330,245],{"class":238},[224,332,333,337,339,343,345],{"class":226,"line":248},[224,334,336],{"class":335},"sQsOY","  return",[224,338,320],{"class":230},[224,340,342],{"class":341},"sB4Xn"," +",[224,344,328],{"class":230},[224,346,347],{"class":238},";\n",[224,349,350],{"class":226,"line":255},[224,351,258],{"class":238},[224,353,355],{"class":226,"line":354},4,[224,356,358],{"emptyLinePlaceholder":357},true,"\n",[224,360,362,364,367,369,372,375],{"class":226,"line":361},5,[224,363,310],{"class":230},[224,365,366],{"class":234}," main",[224,368,239],{"class":238},[224,370,371],{"class":335},"string",[224,373,374],{"class":230}," args",[224,376,377],{"class":238},"[]){\n",[224,379,381,384,387,390,393,395,399,401,404,407],{"class":226,"line":380},6,[224,382,383],{"class":230},"  int",[224,385,386],{"class":230}," result",[224,388,389],{"class":341}," =",[224,391,392],{"class":234}," add",[224,394,239],{"class":238},[224,396,398],{"class":397},"sriKn","1",[224,400,323],{"class":238},[224,402,403],{"class":397},"2",[224,405,406],{"class":238},"); ",[224,408,409],{"class":251},"# result = 3\n",[224,411,413,415,418],{"class":226,"line":412},7,[224,414,336],{"class":335},[224,416,417],{"class":397}," 0",[224,419,347],{"class":238},[224,421,423],{"class":226,"line":422},8,[224,424,258],{"class":238},[426,427,428,429,432],"warning",{},"A value must be returned from a function unless its return type is ",[221,430,431],{},"void",", otherwise it will result in compilation error.",[208,434,436],{"id":435},"default-value-parameters","Default value parameters",[213,438,440],{"className":215,"code":439,"filename":217,"language":218,"meta":219,"style":219},"return_type function_name(type parameter_name = value){\n\n}  \n",[221,441,442,463,467],{"__ignoreMap":219},[224,443,444,446,448,450,453,456,458,461],{"class":226,"line":227},[224,445,231],{"class":230},[224,447,235],{"class":234},[224,449,239],{"class":238},[224,451,452],{"class":335},"type",[224,454,455],{"class":230}," parameter_name",[224,457,389],{"class":341},[224,459,460],{"class":230}," value",[224,462,245],{"class":238},[224,464,465],{"class":226,"line":248},[224,466,358],{"emptyLinePlaceholder":357},[224,468,469],{"class":226,"line":255},[224,470,258],{"class":238},[260,472,473],{},[263,474,475,478,481],{},[266,476,477],{},"A default value must be a constant, which is known at compile time.",[266,479,480],{},"A parameter with default value will become optional, can be skipped when calling.",[266,482,483],{},"All parameters with default values must be defined at the end of the parameter list.",[204,485,486,488,489,492],{},[293,487,295],{}," In this example below, we're going to create a ",[221,490,491],{},"scale"," function to muliply a number by a factor.",[213,494,496],{"className":215,"code":495,"language":218,"meta":219,"style":219},"float scale(float a, float factor = 1.0){\n  return a * factor;\n}\n\nint main(){\n\n  float r1 = scale(3.0);       # r1 = 3.0 * 1.0 = 3.0\n  float r2 = scale(3.0, 1.5);  # r2 = 3.0 * 1.5 = 4.5\n\n  return 0;\n}\n",[221,497,498,526,539,543,547,556,560,583,609,614,623],{"__ignoreMap":219},[224,499,500,503,506,508,510,512,514,516,519,521,524],{"class":226,"line":227},[224,501,502],{"class":230},"float",[224,504,505],{"class":234}," scale",[224,507,239],{"class":238},[224,509,502],{"class":230},[224,511,320],{"class":230},[224,513,323],{"class":238},[224,515,502],{"class":230},[224,517,518],{"class":230}," factor",[224,520,389],{"class":341},[224,522,523],{"class":397}," 1.0",[224,525,245],{"class":238},[224,527,528,530,532,535,537],{"class":226,"line":248},[224,529,336],{"class":335},[224,531,320],{"class":230},[224,533,534],{"class":341}," *",[224,536,518],{"class":230},[224,538,347],{"class":238},[224,540,541],{"class":226,"line":255},[224,542,258],{"class":238},[224,544,545],{"class":226,"line":354},[224,546,358],{"emptyLinePlaceholder":357},[224,548,549,551,553],{"class":226,"line":361},[224,550,310],{"class":230},[224,552,366],{"class":234},[224,554,555],{"class":238},"(){\n",[224,557,558],{"class":226,"line":380},[224,559,358],{"emptyLinePlaceholder":357},[224,561,562,565,568,570,572,574,577,580],{"class":226,"line":412},[224,563,564],{"class":230},"  float",[224,566,567],{"class":230}," r1",[224,569,389],{"class":341},[224,571,505],{"class":234},[224,573,239],{"class":238},[224,575,576],{"class":397},"3.0",[224,578,579],{"class":238},");       ",[224,581,582],{"class":251},"# r1 = 3.0 * 1.0 = 3.0\n",[224,584,585,587,590,592,594,596,598,600,603,606],{"class":226,"line":422},[224,586,564],{"class":230},[224,588,589],{"class":230}," r2",[224,591,389],{"class":341},[224,593,505],{"class":234},[224,595,239],{"class":238},[224,597,576],{"class":397},[224,599,323],{"class":238},[224,601,602],{"class":397},"1.5",[224,604,605],{"class":238},");  ",[224,607,608],{"class":251},"# r2 = 3.0 * 1.5 = 4.5\n",[224,610,612],{"class":226,"line":611},9,[224,613,358],{"emptyLinePlaceholder":357},[224,615,617,619,621],{"class":226,"line":616},10,[224,618,336],{"class":335},[224,620,417],{"class":397},[224,622,347],{"class":238},[224,624,626],{"class":226,"line":625},11,[224,627,258],{"class":238},[629,630,632,635],"h3",{"id":631},"default-keyword",[221,633,634],{},"default"," keyword",[204,637,638,640],{},[221,639,634],{}," is a keyword used to instruct the compiler to substitute a parameter's default value at the call site.",[204,642,643,645,646,649],{},[293,644,295],{}," In this code below, we have a function ",[221,647,648],{},"print_text"," with 3 parameters, two of which has their own default values.",[213,651,653],{"className":215,"code":652,"language":218,"meta":219,"style":219},"void print_text(string text, float opacity = 1.0, int size = 12){\n  # implementation ...\n}\n",[221,654,655,694,699],{"__ignoreMap":219},[224,656,657,659,662,664,666,669,671,673,676,678,680,682,684,687,689,692],{"class":226,"line":227},[224,658,431],{"class":335},[224,660,661],{"class":234}," print_text",[224,663,239],{"class":238},[224,665,371],{"class":335},[224,667,668],{"class":230}," text",[224,670,323],{"class":238},[224,672,502],{"class":230},[224,674,675],{"class":230}," opacity",[224,677,389],{"class":341},[224,679,523],{"class":397},[224,681,323],{"class":238},[224,683,310],{"class":230},[224,685,686],{"class":230}," size",[224,688,389],{"class":341},[224,690,691],{"class":397}," 12",[224,693,245],{"class":238},[224,695,696],{"class":226,"line":248},[224,697,698],{"class":251},"  # implementation ...\n",[224,700,701],{"class":226,"line":255},[224,702,258],{"class":238},[204,704,705,708,709,712,713,715,716,718,719,721,722,724,725,727],{},[221,706,707],{},"opacity"," and ",[221,710,711],{},"size"," have a default value, meaning they can be skipped when calling ",[221,714,648],{},". However, it's not possible to skip ",[221,717,707],{}," if ",[221,720,711],{}," need a new value rather than its default one. In a case that you want to keep ",[221,723,707],{}," as default but manually looking for its default value can be a troublesome. This is where the ",[221,726,634],{}," keyword comes to save the day.",[213,729,731],{"className":215,"code":730,"language":218,"meta":219,"style":219},"int main(string args[]){\n\n  print_text(\"hello, world!\\n\");\n  print_text(\"hello, world!\", default, 15);\n\n  return 0;\n}\n",[221,732,733,747,751,775,798,802,810],{"__ignoreMap":219},[224,734,735,737,739,741,743,745],{"class":226,"line":227},[224,736,310],{"class":230},[224,738,366],{"class":234},[224,740,239],{"class":238},[224,742,371],{"class":335},[224,744,374],{"class":230},[224,746,377],{"class":238},[224,748,749],{"class":226,"line":248},[224,750,358],{"emptyLinePlaceholder":357},[224,752,753,756,758,762,766,770,772],{"class":226,"line":255},[224,754,755],{"class":234},"  print_text",[224,757,239],{"class":238},[224,759,761],{"class":760},"sVH1b","\"",[224,763,765],{"class":764},"spZWa","hello, world!",[224,767,769],{"class":768},"scPpd","\\n",[224,771,761],{"class":760},[224,773,774],{"class":238},");\n",[224,776,777,779,781,783,785,787,789,791,793,796],{"class":226,"line":354},[224,778,755],{"class":234},[224,780,239],{"class":238},[224,782,761],{"class":760},[224,784,765],{"class":764},[224,786,761],{"class":760},[224,788,323],{"class":238},[224,790,634],{"class":335},[224,792,323],{"class":238},[224,794,795],{"class":397},"15",[224,797,774],{"class":238},[224,799,800],{"class":226,"line":361},[224,801,358],{"emptyLinePlaceholder":357},[224,803,804,806,808],{"class":226,"line":380},[224,805,336],{"class":335},[224,807,417],{"class":397},[224,809,347],{"class":238},[224,811,812],{"class":226,"line":412},[224,813,258],{"class":238},[815,816,817,818,820],"tip",{},"Passing the ",[221,819,634],{}," keyword removes the need to look for the actual default value of a parameter, as the compiler will substitute it during compilation.",[822,823,824,826],"note",{},[221,825,634],{}," can not be passed into an argument that does not have a default value.",[208,828,830],{"id":829},"function-overloading","Function Overloading",[204,832,833],{},"Overloaded functions are funtions that share exact same name but different parameters. And each function\nhas its own unique signature, which a combination of the function's name and parameters.",[835,836,838],"h4",{"id":837},"example","Example",[213,840,842],{"className":215,"code":841,"language":218,"meta":219,"style":219},"int add(int a, int b){\n  return a + b;\n}\n\nint add(int a, int b, int c){\n  return a + b + c;\n}\n",[221,843,844,864,876,880,884,911,927],{"__ignoreMap":219},[224,845,846,848,850,852,854,856,858,860,862],{"class":226,"line":227},[224,847,310],{"class":230},[224,849,392],{"class":234},[224,851,239],{"class":238},[224,853,310],{"class":230},[224,855,320],{"class":230},[224,857,323],{"class":238},[224,859,310],{"class":230},[224,861,328],{"class":230},[224,863,245],{"class":238},[224,865,866,868,870,872,874],{"class":226,"line":248},[224,867,336],{"class":335},[224,869,320],{"class":230},[224,871,342],{"class":341},[224,873,328],{"class":230},[224,875,347],{"class":238},[224,877,878],{"class":226,"line":255},[224,879,258],{"class":238},[224,881,882],{"class":226,"line":354},[224,883,358],{"emptyLinePlaceholder":357},[224,885,886,888,890,892,894,896,898,900,902,904,906,909],{"class":226,"line":361},[224,887,310],{"class":230},[224,889,392],{"class":234},[224,891,239],{"class":238},[224,893,310],{"class":230},[224,895,320],{"class":230},[224,897,323],{"class":238},[224,899,310],{"class":230},[224,901,328],{"class":230},[224,903,323],{"class":238},[224,905,310],{"class":230},[224,907,908],{"class":230}," c",[224,910,245],{"class":238},[224,912,913,915,917,919,921,923,925],{"class":226,"line":380},[224,914,336],{"class":335},[224,916,320],{"class":230},[224,918,342],{"class":341},[224,920,328],{"class":230},[224,922,342],{"class":341},[224,924,908],{"class":230},[224,926,347],{"class":238},[224,928,929],{"class":226,"line":412},[224,930,258],{"class":238},[204,932,933],{},"In this example, we define two functions sharing the same name, but each has different signature because\nof the different parameters. And you can define many functions sharing the same name as many as you want\nas long as they have different parameters.",[204,935,936],{},"Now look at another example",[213,938,940],{"className":215,"code":939,"language":218,"meta":219,"style":219},"int add(int a, int b){\n  return a + b;\n}\n\nfloat add(int a, int b){\n  return a + b;\n}\n",[221,941,942,962,974,978,982,1002,1014],{"__ignoreMap":219},[224,943,944,946,948,950,952,954,956,958,960],{"class":226,"line":227},[224,945,310],{"class":230},[224,947,392],{"class":234},[224,949,239],{"class":238},[224,951,310],{"class":230},[224,953,320],{"class":230},[224,955,323],{"class":238},[224,957,310],{"class":230},[224,959,328],{"class":230},[224,961,245],{"class":238},[224,963,964,966,968,970,972],{"class":226,"line":248},[224,965,336],{"class":335},[224,967,320],{"class":230},[224,969,342],{"class":341},[224,971,328],{"class":230},[224,973,347],{"class":238},[224,975,976],{"class":226,"line":255},[224,977,258],{"class":238},[224,979,980],{"class":226,"line":354},[224,981,358],{"emptyLinePlaceholder":357},[224,983,984,986,988,990,992,994,996,998,1000],{"class":226,"line":361},[224,985,502],{"class":230},[224,987,392],{"class":234},[224,989,239],{"class":238},[224,991,310],{"class":230},[224,993,320],{"class":230},[224,995,323],{"class":238},[224,997,310],{"class":230},[224,999,328],{"class":230},[224,1001,245],{"class":238},[224,1003,1004,1006,1008,1010,1012],{"class":226,"line":380},[224,1005,336],{"class":335},[224,1007,320],{"class":230},[224,1009,342],{"class":341},[224,1011,328],{"class":230},[224,1013,347],{"class":238},[224,1015,1016],{"class":226,"line":412},[224,1017,258],{"class":238},[204,1019,1020],{},"However, this will cause compilation error becuase two functions sharing the same signature exist at the\nsame scope. Although they have different return types, it does not change the function signature as long as\nthe parameters stay the same.",[822,1022,1023,1026],{},[204,1024,1025],{},"The parameters only make the signiture different only when:",[263,1027,1028,1031],{},[266,1029,1030],{},"changes in type.",[266,1032,1033],{},"changes in number of parameters.",[629,1035,1037],{"id":1036},"caution","Caution",[213,1039,1041],{"className":215,"code":1040,"language":218,"meta":219,"style":219},"void func(int a, float b){\n  # code ...\n}\n\nvoid func(int x, float y){\n  # code ...\n}\n\nvoid func(float m, int n){\n  # code ...\n}\n",[221,1042,1043,1064,1068,1072,1076,1098,1102,1106,1110,1132,1136],{"__ignoreMap":219},[224,1044,1045,1047,1050,1052,1054,1056,1058,1060,1062],{"class":226,"line":227},[224,1046,431],{"class":335},[224,1048,1049],{"class":234}," func",[224,1051,239],{"class":238},[224,1053,310],{"class":230},[224,1055,320],{"class":230},[224,1057,323],{"class":238},[224,1059,502],{"class":230},[224,1061,328],{"class":230},[224,1063,245],{"class":238},[224,1065,1066],{"class":226,"line":248},[224,1067,252],{"class":251},[224,1069,1070],{"class":226,"line":255},[224,1071,258],{"class":238},[224,1073,1074],{"class":226,"line":354},[224,1075,358],{"emptyLinePlaceholder":357},[224,1077,1078,1080,1082,1084,1086,1089,1091,1093,1096],{"class":226,"line":361},[224,1079,431],{"class":335},[224,1081,1049],{"class":234},[224,1083,239],{"class":238},[224,1085,310],{"class":230},[224,1087,1088],{"class":230}," x",[224,1090,323],{"class":238},[224,1092,502],{"class":230},[224,1094,1095],{"class":230}," y",[224,1097,245],{"class":238},[224,1099,1100],{"class":226,"line":380},[224,1101,252],{"class":251},[224,1103,1104],{"class":226,"line":412},[224,1105,258],{"class":238},[224,1107,1108],{"class":226,"line":422},[224,1109,358],{"emptyLinePlaceholder":357},[224,1111,1112,1114,1116,1118,1120,1123,1125,1127,1130],{"class":226,"line":611},[224,1113,431],{"class":335},[224,1115,1049],{"class":234},[224,1117,239],{"class":238},[224,1119,502],{"class":230},[224,1121,1122],{"class":230}," m",[224,1124,323],{"class":238},[224,1126,310],{"class":230},[224,1128,1129],{"class":230}," n",[224,1131,245],{"class":238},[224,1133,1134],{"class":226,"line":616},[224,1135,252],{"class":251},[224,1137,1138],{"class":226,"line":625},[224,1139,258],{"class":238},[1036,1141,1142,1143,1146],{},"The different identifiers or order of the parameters do not differ the signature. Which means the signatures of the three functions ",[221,1144,1145],{},"func"," above are the same, and this will result in compilation error!",[1148,1149,1150],"style",{},"html pre.shiki code .s8dPH, html code.shiki .s8dPH{--shiki-light:#90A4AE;--shiki-default:#E45649;--shiki-dark:#E06C75}html pre.shiki code .spnjr, html code.shiki .spnjr{--shiki-light:#6182B8;--shiki-default:#4078F2;--shiki-dark:#61AFEF}html pre.shiki code .sM89C, html code.shiki .sM89C{--shiki-light:#90A4AE;--shiki-default:#383A42;--shiki-dark:#ABB2BF}html pre.shiki code .seacL, html code.shiki .seacL{--shiki-light:#90A4AE;--shiki-light-font-style:italic;--shiki-default:#A0A1A7;--shiki-default-font-style:italic;--shiki-dark:#7F848E;--shiki-dark-font-style:italic}html .light .shiki span {color: var(--shiki-light);background: var(--shiki-light-bg);font-style: var(--shiki-light-font-style);font-weight: var(--shiki-light-font-weight);text-decoration: var(--shiki-light-text-decoration);}html.light .shiki span {color: var(--shiki-light);background: var(--shiki-light-bg);font-style: var(--shiki-light-font-style);font-weight: var(--shiki-light-font-weight);text-decoration: var(--shiki-light-text-decoration);}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 .dark .shiki span {color: var(--shiki-dark);background: var(--shiki-dark-bg);font-style: var(--shiki-dark-font-style);font-weight: var(--shiki-dark-font-weight);text-decoration: var(--shiki-dark-text-decoration);}html.dark .shiki span {color: var(--shiki-dark);background: var(--shiki-dark-bg);font-style: var(--shiki-dark-font-style);font-weight: var(--shiki-dark-font-weight);text-decoration: var(--shiki-dark-text-decoration);}html pre.shiki code .sQsOY, html code.shiki .sQsOY{--shiki-light:#39ADB5;--shiki-light-font-style:italic;--shiki-default:#A626A4;--shiki-default-font-style:inherit;--shiki-dark:#C678DD;--shiki-dark-font-style:inherit}html pre.shiki code .sB4Xn, html code.shiki .sB4Xn{--shiki-light:#39ADB5;--shiki-default:#383A42;--shiki-dark:#ABB2BF}html pre.shiki code .sriKn, html code.shiki .sriKn{--shiki-light:#F76D47;--shiki-default:#986801;--shiki-dark:#D19A66}html pre.shiki code .sVH1b, html code.shiki .sVH1b{--shiki-light:#39ADB5;--shiki-default:#50A14F;--shiki-dark:#98C379}html pre.shiki code .spZWa, html code.shiki .spZWa{--shiki-light:#91B859;--shiki-default:#50A14F;--shiki-dark:#98C379}html pre.shiki code .scPpd, html code.shiki .scPpd{--shiki-light:#90A4AE;--shiki-default:#0184BC;--shiki-dark:#56B6C2}",{"title":219,"searchDepth":248,"depth":248,"links":1152},[1153,1154,1158],{"id":210,"depth":248,"text":211},{"id":435,"depth":248,"text":436,"children":1155},[1156],{"id":631,"depth":255,"text":1157},"default keyword",{"id":829,"depth":248,"text":830,"children":1159},[1160],{"id":1036,"depth":255,"text":1037},"Introduction to functions in Cambo.","md",null,{},{"icon":24},{"title":57,"description":1161},"_kMOPIccFfTKAFTv52wGIEY5yTAv6zwXWoMluFn1oME",[1169,1171],{"title":53,"path":54,"stem":55,"description":1170,"icon":24,"children":-1},"Automation is the art of handling repetitive tasks.",{"title":61,"path":62,"stem":63,"description":1172,"icon":24,"children":-1},"Pointer Pointee",1774971227270]