[{"data":1,"prerenderedAt":3829},["ShallowReactive",2],{"page-\u002Fgo\u002F05-functions":3},{"id":4,"title":5,"body":6,"description":3822,"extension":3823,"meta":3824,"navigation":99,"path":3825,"seo":3826,"stem":3827,"__hash__":3828},"content\u002Fgo\u002F05-functions.md","05 — Functions",{"type":7,"value":8,"toc":3802},"minimark",[9,13,18,355,360,752,756,1317,1321,1733,1737,2103,2110,2640,2646,2962,2968,3039,3043,3326,3330,3431,3435,3587,3591,3663,3770,3774,3798],[10,11,5],"h1",{"id":12},"_05-functions",[14,15,17],"h2",{"id":16},"declaration-forms-and-return-patterns","Declaration Forms and Return Patterns",[19,20,22],"code-wrapper",{"language":21},"go",[23,24,28],"pre",{"className":25,"code":26,"language":21,"meta":27,"style":27},"language-go shiki shiki-themes github-light github-dark","\u002F\u002F ┌─────────────────────────────────────────────────────────────────────┐\n\u002F\u002F │ Form                    │ Use Case                                 │\n\u002F\u002F │ ─────────────────────── │ ──────────────────────────────────────── │\n\u002F\u002F │ func f(a, b int) int    │ simple function                          │\n\u002F\u002F │ func f(a, b int)(int,error) │ Go's (value, error) convention       │\n\u002F\u002F │ func f()(q, r int)      │ named returns (defer modification)       │\n\u002F\u002F │ func f(a int, opts ...Opt) T │ variadic (builder\u002Foptions pattern) │\n\u002F\u002F │ func f() func() int     │ returning a closure (stateful function) │\n\u002F\u002F │ var f func(int)int = ... │ function as a value                     │\n\u002F\u002F └─────────────────────────────────────────────────────────────────────┘\n\n\u002F\u002F Multiple returns — Go's primary error-handling mechanism:\nfunc fetchUser(id int64) (*User, error) {\n    if id \u003C= 0 {\n        return nil, fmt.Errorf(\"fetchUser: invalid id %d\", id)\n    }\n    return &User{ID: id}, nil\n}\n\n\u002F\u002F Named returns — pre-declared, zero-initialized, can be modified by defer:\nfunc divide(a, b int) (result int, err error) {\n    if b == 0 {\n        err = errors.New(\"divide by zero\")\n        return  \u002F\u002F naked return — returns (result=0, err=error)\n    }\n    result = a \u002F b\n    return  \u002F\u002F returns (result=quotient, err=nil)\n}\n","",[29,30,31,40,46,52,58,64,70,76,82,88,94,101,107,147,166,196,202,219,225,230,236,274,289,312,320,325,342,350],"code",{"__ignoreMap":27},[32,33,36],"span",{"class":34,"line":35},"line",1,[32,37,39],{"class":38},"sdCPZ","\u002F\u002F ┌─────────────────────────────────────────────────────────────────────┐\n",[32,41,43],{"class":34,"line":42},2,[32,44,45],{"class":38},"\u002F\u002F │ Form                    │ Use Case                                 │\n",[32,47,49],{"class":34,"line":48},3,[32,50,51],{"class":38},"\u002F\u002F │ ─────────────────────── │ ──────────────────────────────────────── │\n",[32,53,55],{"class":34,"line":54},4,[32,56,57],{"class":38},"\u002F\u002F │ func f(a, b int) int    │ simple function                          │\n",[32,59,61],{"class":34,"line":60},5,[32,62,63],{"class":38},"\u002F\u002F │ func f(a, b int)(int,error) │ Go's (value, error) convention       │\n",[32,65,67],{"class":34,"line":66},6,[32,68,69],{"class":38},"\u002F\u002F │ func f()(q, r int)      │ named returns (defer modification)       │\n",[32,71,73],{"class":34,"line":72},7,[32,74,75],{"class":38},"\u002F\u002F │ func f(a int, opts ...Opt) T │ variadic (builder\u002Foptions pattern) │\n",[32,77,79],{"class":34,"line":78},8,[32,80,81],{"class":38},"\u002F\u002F │ func f() func() int     │ returning a closure (stateful function) │\n",[32,83,85],{"class":34,"line":84},9,[32,86,87],{"class":38},"\u002F\u002F │ var f func(int)int = ... │ function as a value                     │\n",[32,89,91],{"class":34,"line":90},10,[32,92,93],{"class":38},"\u002F\u002F └─────────────────────────────────────────────────────────────────────┘\n",[32,95,97],{"class":34,"line":96},11,[32,98,100],{"emptyLinePlaceholder":99},true,"\n",[32,102,104],{"class":34,"line":103},12,[32,105,106],{"class":38},"\u002F\u002F Multiple returns — Go's primary error-handling mechanism:\n",[32,108,110,114,118,122,126,129,132,135,138,141,144],{"class":34,"line":109},13,[32,111,113],{"class":112},"svdQ7","func",[32,115,117],{"class":116},"sIsaT"," fetchUser",[32,119,121],{"class":120},"ssxIu","(",[32,123,125],{"class":124},"sCrzJ","id",[32,127,128],{"class":112}," int64",[32,130,131],{"class":120},") (",[32,133,134],{"class":112},"*",[32,136,137],{"class":116},"User",[32,139,140],{"class":120},", ",[32,142,143],{"class":112},"error",[32,145,146],{"class":120},") {\n",[32,148,150,153,156,159,163],{"class":34,"line":149},14,[32,151,152],{"class":112},"    if",[32,154,155],{"class":120}," id ",[32,157,158],{"class":112},"\u003C=",[32,160,162],{"class":161},"snvgF"," 0",[32,164,165],{"class":120}," {\n",[32,167,169,172,175,178,181,183,187,190,193],{"class":34,"line":168},15,[32,170,171],{"class":112},"        return",[32,173,174],{"class":161}," nil",[32,176,177],{"class":120},", fmt.",[32,179,180],{"class":116},"Errorf",[32,182,121],{"class":120},[32,184,186],{"class":185},"sJ6F3","\"fetchUser: invalid id ",[32,188,189],{"class":161},"%d",[32,191,192],{"class":185},"\"",[32,194,195],{"class":120},", id)\n",[32,197,199],{"class":34,"line":198},16,[32,200,201],{"class":120},"    }\n",[32,203,205,208,211,213,216],{"class":34,"line":204},17,[32,206,207],{"class":112},"    return",[32,209,210],{"class":112}," &",[32,212,137],{"class":116},[32,214,215],{"class":120},"{ID: id}, ",[32,217,218],{"class":161},"nil\n",[32,220,222],{"class":34,"line":221},18,[32,223,224],{"class":120},"}\n",[32,226,228],{"class":34,"line":227},19,[32,229,100],{"emptyLinePlaceholder":99},[32,231,233],{"class":34,"line":232},20,[32,234,235],{"class":38},"\u002F\u002F Named returns — pre-declared, zero-initialized, can be modified by defer:\n",[32,237,239,241,244,246,249,251,254,257,259,262,264,266,269,272],{"class":34,"line":238},21,[32,240,113],{"class":112},[32,242,243],{"class":116}," divide",[32,245,121],{"class":120},[32,247,248],{"class":124},"a",[32,250,140],{"class":120},[32,252,253],{"class":124},"b",[32,255,256],{"class":112}," int",[32,258,131],{"class":120},[32,260,261],{"class":124},"result",[32,263,256],{"class":112},[32,265,140],{"class":120},[32,267,268],{"class":124},"err",[32,270,271],{"class":112}," error",[32,273,146],{"class":120},[32,275,277,279,282,285,287],{"class":34,"line":276},22,[32,278,152],{"class":112},[32,280,281],{"class":120}," b ",[32,283,284],{"class":112},"==",[32,286,162],{"class":161},[32,288,165],{"class":120},[32,290,292,295,298,301,304,306,309],{"class":34,"line":291},23,[32,293,294],{"class":120},"        err ",[32,296,297],{"class":112},"=",[32,299,300],{"class":120}," errors.",[32,302,303],{"class":116},"New",[32,305,121],{"class":120},[32,307,308],{"class":185},"\"divide by zero\"",[32,310,311],{"class":120},")\n",[32,313,315,317],{"class":34,"line":314},24,[32,316,171],{"class":112},[32,318,319],{"class":38},"  \u002F\u002F naked return — returns (result=0, err=error)\n",[32,321,323],{"class":34,"line":322},25,[32,324,201],{"class":120},[32,326,328,331,333,336,339],{"class":34,"line":327},26,[32,329,330],{"class":120},"    result ",[32,332,297],{"class":112},[32,334,335],{"class":120}," a ",[32,337,338],{"class":112},"\u002F",[32,340,341],{"class":120}," b\n",[32,343,345,347],{"class":34,"line":344},27,[32,346,207],{"class":112},[32,348,349],{"class":38},"  \u002F\u002F returns (result=quotient, err=nil)\n",[32,351,353],{"class":34,"line":352},28,[32,354,224],{"class":120},[356,357,359],"h3",{"id":358},"named-returns-the-real-use-case","Named returns — the real use case",[19,361,362],{"language":21},[23,363,365],{"className":25,"code":364,"language":21,"meta":27,"style":27},"\u002F\u002F ❌ ANTI-PATTERN: naked returns in long functions (unreadable)\nfunc process(data []byte) (result []byte, err error) {\n    \u002F\u002F ... 50 lines of code ...\n    result = transform(data)\n    \u002F\u002F ... 30 more lines ...\n    return  \u002F\u002F ← what does this return? reader must scan entire function\n}\n\n\u002F\u002F ✅ CORRECT: named returns for defer-based error decoration and timing:\nfunc timedOperation(ctx context.Context) (result int, err error) {\n    start := time.Now()\n    defer func() {\n        \u002F\u002F Log the duration and decorate the error on the way out:\n        elapsed := time.Since(start)\n        if err != nil {\n            err = fmt.Errorf(\"timedOperation (took %v): %w\", elapsed, err)\n        }\n        log.Printf(\"timedOperation took %v\", elapsed)\n    }()\n\n    \u002F\u002F ... actual work ...\n    result = 42\n    return result, nil\n}\n\n\u002F\u002F ✅ Panic recovery via deferred named return:\nfunc safeExec(fn func() error) (err error) {\n    defer func() {\n        if r := recover(); r != nil {\n            err = fmt.Errorf(\"recovered from panic: %v\", r)\n        }\n    }()\n    return fn()\n}\n",[29,366,367,372,406,411,423,428,435,439,443,448,483,500,511,516,531,546,577,582,602,607,611,616,625,634,638,642,647,674,682,704,727,732,737,747],{"__ignoreMap":27},[32,368,369],{"class":34,"line":35},[32,370,371],{"class":38},"\u002F\u002F ❌ ANTI-PATTERN: naked returns in long functions (unreadable)\n",[32,373,374,376,379,381,384,387,390,392,394,396,398,400,402,404],{"class":34,"line":42},[32,375,113],{"class":112},[32,377,378],{"class":116}," process",[32,380,121],{"class":120},[32,382,383],{"class":124},"data",[32,385,386],{"class":120}," []",[32,388,389],{"class":112},"byte",[32,391,131],{"class":120},[32,393,261],{"class":124},[32,395,386],{"class":120},[32,397,389],{"class":112},[32,399,140],{"class":120},[32,401,268],{"class":124},[32,403,271],{"class":112},[32,405,146],{"class":120},[32,407,408],{"class":34,"line":48},[32,409,410],{"class":38},"    \u002F\u002F ... 50 lines of code ...\n",[32,412,413,415,417,420],{"class":34,"line":54},[32,414,330],{"class":120},[32,416,297],{"class":112},[32,418,419],{"class":116}," transform",[32,421,422],{"class":120},"(data)\n",[32,424,425],{"class":34,"line":60},[32,426,427],{"class":38},"    \u002F\u002F ... 30 more lines ...\n",[32,429,430,432],{"class":34,"line":66},[32,431,207],{"class":112},[32,433,434],{"class":38},"  \u002F\u002F ← what does this return? reader must scan entire function\n",[32,436,437],{"class":34,"line":72},[32,438,224],{"class":120},[32,440,441],{"class":34,"line":78},[32,442,100],{"emptyLinePlaceholder":99},[32,444,445],{"class":34,"line":84},[32,446,447],{"class":38},"\u002F\u002F ✅ CORRECT: named returns for defer-based error decoration and timing:\n",[32,449,450,452,455,457,460,463,466,469,471,473,475,477,479,481],{"class":34,"line":90},[32,451,113],{"class":112},[32,453,454],{"class":116}," timedOperation",[32,456,121],{"class":120},[32,458,459],{"class":124},"ctx",[32,461,462],{"class":116}," context",[32,464,465],{"class":120},".",[32,467,468],{"class":116},"Context",[32,470,131],{"class":120},[32,472,261],{"class":124},[32,474,256],{"class":112},[32,476,140],{"class":120},[32,478,268],{"class":124},[32,480,271],{"class":112},[32,482,146],{"class":120},[32,484,485,488,491,494,497],{"class":34,"line":96},[32,486,487],{"class":120},"    start ",[32,489,490],{"class":112},":=",[32,492,493],{"class":120}," time.",[32,495,496],{"class":116},"Now",[32,498,499],{"class":120},"()\n",[32,501,502,505,508],{"class":34,"line":103},[32,503,504],{"class":112},"    defer",[32,506,507],{"class":112}," func",[32,509,510],{"class":120},"() {\n",[32,512,513],{"class":34,"line":109},[32,514,515],{"class":38},"        \u002F\u002F Log the duration and decorate the error on the way out:\n",[32,517,518,521,523,525,528],{"class":34,"line":149},[32,519,520],{"class":120},"        elapsed ",[32,522,490],{"class":112},[32,524,493],{"class":120},[32,526,527],{"class":116},"Since",[32,529,530],{"class":120},"(start)\n",[32,532,533,536,539,542,544],{"class":34,"line":168},[32,534,535],{"class":112},"        if",[32,537,538],{"class":120}," err ",[32,540,541],{"class":112},"!=",[32,543,174],{"class":161},[32,545,165],{"class":120},[32,547,548,551,553,556,558,560,563,566,569,572,574],{"class":34,"line":198},[32,549,550],{"class":120},"            err ",[32,552,297],{"class":112},[32,554,555],{"class":120}," fmt.",[32,557,180],{"class":116},[32,559,121],{"class":120},[32,561,562],{"class":185},"\"timedOperation (took ",[32,564,565],{"class":161},"%v",[32,567,568],{"class":185},"): ",[32,570,571],{"class":161},"%w",[32,573,192],{"class":185},[32,575,576],{"class":120},", elapsed, err)\n",[32,578,579],{"class":34,"line":204},[32,580,581],{"class":120},"        }\n",[32,583,584,587,590,592,595,597,599],{"class":34,"line":221},[32,585,586],{"class":120},"        log.",[32,588,589],{"class":116},"Printf",[32,591,121],{"class":120},[32,593,594],{"class":185},"\"timedOperation took ",[32,596,565],{"class":161},[32,598,192],{"class":185},[32,600,601],{"class":120},", elapsed)\n",[32,603,604],{"class":34,"line":227},[32,605,606],{"class":120},"    }()\n",[32,608,609],{"class":34,"line":232},[32,610,100],{"emptyLinePlaceholder":99},[32,612,613],{"class":34,"line":238},[32,614,615],{"class":38},"    \u002F\u002F ... actual work ...\n",[32,617,618,620,622],{"class":34,"line":276},[32,619,330],{"class":120},[32,621,297],{"class":112},[32,623,624],{"class":161}," 42\n",[32,626,627,629,632],{"class":34,"line":291},[32,628,207],{"class":112},[32,630,631],{"class":120}," result, ",[32,633,218],{"class":161},[32,635,636],{"class":34,"line":314},[32,637,224],{"class":120},[32,639,640],{"class":34,"line":322},[32,641,100],{"emptyLinePlaceholder":99},[32,643,644],{"class":34,"line":327},[32,645,646],{"class":38},"\u002F\u002F ✅ Panic recovery via deferred named return:\n",[32,648,649,651,654,656,659,661,664,666,668,670,672],{"class":34,"line":344},[32,650,113],{"class":112},[32,652,653],{"class":116}," safeExec",[32,655,121],{"class":120},[32,657,658],{"class":124},"fn",[32,660,507],{"class":112},[32,662,663],{"class":120},"() ",[32,665,143],{"class":112},[32,667,131],{"class":120},[32,669,268],{"class":124},[32,671,271],{"class":112},[32,673,146],{"class":120},[32,675,676,678,680],{"class":34,"line":352},[32,677,504],{"class":112},[32,679,507],{"class":112},[32,681,510],{"class":120},[32,683,685,687,690,692,695,698,700,702],{"class":34,"line":684},29,[32,686,535],{"class":112},[32,688,689],{"class":120}," r ",[32,691,490],{"class":112},[32,693,694],{"class":116}," recover",[32,696,697],{"class":120},"(); r ",[32,699,541],{"class":112},[32,701,174],{"class":161},[32,703,165],{"class":120},[32,705,707,709,711,713,715,717,720,722,724],{"class":34,"line":706},30,[32,708,550],{"class":120},[32,710,297],{"class":112},[32,712,555],{"class":120},[32,714,180],{"class":116},[32,716,121],{"class":120},[32,718,719],{"class":185},"\"recovered from panic: ",[32,721,565],{"class":161},[32,723,192],{"class":185},[32,725,726],{"class":120},", r)\n",[32,728,730],{"class":34,"line":729},31,[32,731,581],{"class":120},[32,733,735],{"class":34,"line":734},32,[32,736,606],{"class":120},[32,738,740,742,745],{"class":34,"line":739},33,[32,741,207],{"class":112},[32,743,744],{"class":116}," fn",[32,746,499],{"class":120},[32,748,750],{"class":34,"line":749},34,[32,751,224],{"class":120},[14,753,755],{"id":754},"variadic-functions-the-options-pattern","Variadic Functions — The Options Pattern",[19,757,758],{"language":21},[23,759,761],{"className":25,"code":760,"language":21,"meta":27,"style":27},"\u002F\u002F Variadic: `...T` becomes a `[]T` inside the function. Must be last param.\n\nfunc sum(nums ...int) int {\n    total := 0\n    for _, n := range nums {\n        total += n\n    }\n    return total\n}\n\u002F\u002F sum(1, 2, 3) → 6\n\u002F\u002F nums := []int{1, 2, 3}; sum(nums...) → 6  (spread a slice)\n\n\u002F\u002F ─── Production pattern: functional options ───\ntype Server struct {\n    addr    string\n    port    int\n    tls     bool\n    timeout time.Duration\n}\n\ntype Option func(*Server)  \u002F\u002F function type that mutates the server config\n\nfunc WithPort(p int) Option {\n    return func(s *Server) { s.port = p }\n}\nfunc WithTLS(cfg *tls.Config) Option {\n    return func(s *Server) { s.tls = true }\n}\nfunc WithTimeout(d time.Duration) Option {\n    return func(s *Server) { s.timeout = d }\n}\n\nfunc NewServer(addr string, opts ...Option) *Server {\n    s := &Server{\n        addr:    addr,\n        port:    8080,           \u002F\u002F sensible default\n        timeout: 30 * time.Second,\n    }\n    for _, opt := range opts {\n        opt(s)  \u002F\u002F apply each option\n    }\n    return s\n}\n\n\u002F\u002F Usage — readable, extensible, zero config structs:\nsrv := NewServer(\":8080\",\n    WithPort(9090),\n    WithTimeout(10*time.Second),\n    WithTLS(tlsConfig),\n)\n",[29,762,763,768,772,795,805,821,832,836,843,847,852,857,861,866,879,887,895,903,916,920,924,946,950,971,995,999,1027,1052,1056,1082,1104,1108,1112,1145,1159,1165,1180,1194,1199,1214,1226,1231,1239,1244,1249,1255,1273,1287,1303,1312],{"__ignoreMap":27},[32,764,765],{"class":34,"line":35},[32,766,767],{"class":38},"\u002F\u002F Variadic: `...T` becomes a `[]T` inside the function. Must be last param.\n",[32,769,770],{"class":34,"line":42},[32,771,100],{"emptyLinePlaceholder":99},[32,773,774,776,779,781,784,787,790,793],{"class":34,"line":48},[32,775,113],{"class":112},[32,777,778],{"class":116}," sum",[32,780,121],{"class":120},[32,782,783],{"class":124},"nums",[32,785,786],{"class":112}," ...int",[32,788,789],{"class":120},") ",[32,791,792],{"class":112},"int",[32,794,165],{"class":120},[32,796,797,800,802],{"class":34,"line":54},[32,798,799],{"class":120},"    total ",[32,801,490],{"class":112},[32,803,804],{"class":161}," 0\n",[32,806,807,810,813,815,818],{"class":34,"line":60},[32,808,809],{"class":112},"    for",[32,811,812],{"class":120}," _, n ",[32,814,490],{"class":112},[32,816,817],{"class":112}," range",[32,819,820],{"class":120}," nums {\n",[32,822,823,826,829],{"class":34,"line":66},[32,824,825],{"class":120},"        total ",[32,827,828],{"class":112},"+=",[32,830,831],{"class":120}," n\n",[32,833,834],{"class":34,"line":72},[32,835,201],{"class":120},[32,837,838,840],{"class":34,"line":78},[32,839,207],{"class":112},[32,841,842],{"class":120}," total\n",[32,844,845],{"class":34,"line":84},[32,846,224],{"class":120},[32,848,849],{"class":34,"line":90},[32,850,851],{"class":38},"\u002F\u002F sum(1, 2, 3) → 6\n",[32,853,854],{"class":34,"line":96},[32,855,856],{"class":38},"\u002F\u002F nums := []int{1, 2, 3}; sum(nums...) → 6  (spread a slice)\n",[32,858,859],{"class":34,"line":103},[32,860,100],{"emptyLinePlaceholder":99},[32,862,863],{"class":34,"line":109},[32,864,865],{"class":38},"\u002F\u002F ─── Production pattern: functional options ───\n",[32,867,868,871,874,877],{"class":34,"line":149},[32,869,870],{"class":112},"type",[32,872,873],{"class":116}," Server",[32,875,876],{"class":112}," struct",[32,878,165],{"class":120},[32,880,881,884],{"class":34,"line":168},[32,882,883],{"class":120},"    addr    ",[32,885,886],{"class":112},"string\n",[32,888,889,892],{"class":34,"line":198},[32,890,891],{"class":120},"    port    ",[32,893,894],{"class":112},"int\n",[32,896,897,900],{"class":34,"line":204},[32,898,899],{"class":120},"    tls     ",[32,901,902],{"class":112},"bool\n",[32,904,905,908,911,913],{"class":34,"line":221},[32,906,907],{"class":120},"    timeout ",[32,909,910],{"class":116},"time",[32,912,465],{"class":120},[32,914,915],{"class":116},"Duration\n",[32,917,918],{"class":34,"line":227},[32,919,224],{"class":120},[32,921,922],{"class":34,"line":232},[32,923,100],{"emptyLinePlaceholder":99},[32,925,926,928,931,933,935,937,940,943],{"class":34,"line":238},[32,927,870],{"class":112},[32,929,930],{"class":116}," Option",[32,932,507],{"class":112},[32,934,121],{"class":120},[32,936,134],{"class":112},[32,938,939],{"class":116},"Server",[32,941,942],{"class":120},")  ",[32,944,945],{"class":38},"\u002F\u002F function type that mutates the server config\n",[32,947,948],{"class":34,"line":276},[32,949,100],{"emptyLinePlaceholder":99},[32,951,952,954,957,959,962,964,966,969],{"class":34,"line":291},[32,953,113],{"class":112},[32,955,956],{"class":116}," WithPort",[32,958,121],{"class":120},[32,960,961],{"class":124},"p",[32,963,256],{"class":112},[32,965,789],{"class":120},[32,967,968],{"class":116},"Option",[32,970,165],{"class":120},[32,972,973,975,977,979,982,985,987,990,992],{"class":34,"line":314},[32,974,207],{"class":112},[32,976,507],{"class":112},[32,978,121],{"class":120},[32,980,981],{"class":124},"s",[32,983,984],{"class":112}," *",[32,986,939],{"class":116},[32,988,989],{"class":120},") { s.port ",[32,991,297],{"class":112},[32,993,994],{"class":120}," p }\n",[32,996,997],{"class":34,"line":322},[32,998,224],{"class":120},[32,1000,1001,1003,1006,1008,1011,1013,1016,1018,1021,1023,1025],{"class":34,"line":327},[32,1002,113],{"class":112},[32,1004,1005],{"class":116}," WithTLS",[32,1007,121],{"class":120},[32,1009,1010],{"class":124},"cfg",[32,1012,984],{"class":112},[32,1014,1015],{"class":116},"tls",[32,1017,465],{"class":120},[32,1019,1020],{"class":116},"Config",[32,1022,789],{"class":120},[32,1024,968],{"class":116},[32,1026,165],{"class":120},[32,1028,1029,1031,1033,1035,1037,1039,1041,1044,1046,1049],{"class":34,"line":344},[32,1030,207],{"class":112},[32,1032,507],{"class":112},[32,1034,121],{"class":120},[32,1036,981],{"class":124},[32,1038,984],{"class":112},[32,1040,939],{"class":116},[32,1042,1043],{"class":120},") { s.tls ",[32,1045,297],{"class":112},[32,1047,1048],{"class":161}," true",[32,1050,1051],{"class":120}," }\n",[32,1053,1054],{"class":34,"line":352},[32,1055,224],{"class":120},[32,1057,1058,1060,1063,1065,1068,1071,1073,1076,1078,1080],{"class":34,"line":684},[32,1059,113],{"class":112},[32,1061,1062],{"class":116}," WithTimeout",[32,1064,121],{"class":120},[32,1066,1067],{"class":124},"d",[32,1069,1070],{"class":116}," time",[32,1072,465],{"class":120},[32,1074,1075],{"class":116},"Duration",[32,1077,789],{"class":120},[32,1079,968],{"class":116},[32,1081,165],{"class":120},[32,1083,1084,1086,1088,1090,1092,1094,1096,1099,1101],{"class":34,"line":706},[32,1085,207],{"class":112},[32,1087,507],{"class":112},[32,1089,121],{"class":120},[32,1091,981],{"class":124},[32,1093,984],{"class":112},[32,1095,939],{"class":116},[32,1097,1098],{"class":120},") { s.timeout ",[32,1100,297],{"class":112},[32,1102,1103],{"class":120}," d }\n",[32,1105,1106],{"class":34,"line":729},[32,1107,224],{"class":120},[32,1109,1110],{"class":34,"line":734},[32,1111,100],{"emptyLinePlaceholder":99},[32,1113,1114,1116,1119,1121,1124,1127,1129,1132,1135,1137,1139,1141,1143],{"class":34,"line":739},[32,1115,113],{"class":112},[32,1117,1118],{"class":116}," NewServer",[32,1120,121],{"class":120},[32,1122,1123],{"class":124},"addr",[32,1125,1126],{"class":112}," string",[32,1128,140],{"class":120},[32,1130,1131],{"class":124},"opts",[32,1133,1134],{"class":112}," ...",[32,1136,968],{"class":116},[32,1138,789],{"class":120},[32,1140,134],{"class":112},[32,1142,939],{"class":116},[32,1144,165],{"class":120},[32,1146,1147,1150,1152,1154,1156],{"class":34,"line":749},[32,1148,1149],{"class":120},"    s ",[32,1151,490],{"class":112},[32,1153,210],{"class":112},[32,1155,939],{"class":116},[32,1157,1158],{"class":120},"{\n",[32,1160,1162],{"class":34,"line":1161},35,[32,1163,1164],{"class":120},"        addr:    addr,\n",[32,1166,1168,1171,1174,1177],{"class":34,"line":1167},36,[32,1169,1170],{"class":120},"        port:    ",[32,1172,1173],{"class":161},"8080",[32,1175,1176],{"class":120},",           ",[32,1178,1179],{"class":38},"\u002F\u002F sensible default\n",[32,1181,1183,1186,1189,1191],{"class":34,"line":1182},37,[32,1184,1185],{"class":120},"        timeout: ",[32,1187,1188],{"class":161},"30",[32,1190,984],{"class":112},[32,1192,1193],{"class":120}," time.Second,\n",[32,1195,1197],{"class":34,"line":1196},38,[32,1198,201],{"class":120},[32,1200,1202,1204,1207,1209,1211],{"class":34,"line":1201},39,[32,1203,809],{"class":112},[32,1205,1206],{"class":120}," _, opt ",[32,1208,490],{"class":112},[32,1210,817],{"class":112},[32,1212,1213],{"class":120}," opts {\n",[32,1215,1217,1220,1223],{"class":34,"line":1216},40,[32,1218,1219],{"class":116},"        opt",[32,1221,1222],{"class":120},"(s)  ",[32,1224,1225],{"class":38},"\u002F\u002F apply each option\n",[32,1227,1229],{"class":34,"line":1228},41,[32,1230,201],{"class":120},[32,1232,1234,1236],{"class":34,"line":1233},42,[32,1235,207],{"class":112},[32,1237,1238],{"class":120}," s\n",[32,1240,1242],{"class":34,"line":1241},43,[32,1243,224],{"class":120},[32,1245,1247],{"class":34,"line":1246},44,[32,1248,100],{"emptyLinePlaceholder":99},[32,1250,1252],{"class":34,"line":1251},45,[32,1253,1254],{"class":38},"\u002F\u002F Usage — readable, extensible, zero config structs:\n",[32,1256,1258,1261,1263,1265,1267,1270],{"class":34,"line":1257},46,[32,1259,1260],{"class":120},"srv ",[32,1262,490],{"class":112},[32,1264,1118],{"class":116},[32,1266,121],{"class":120},[32,1268,1269],{"class":185},"\":8080\"",[32,1271,1272],{"class":120},",\n",[32,1274,1276,1279,1281,1284],{"class":34,"line":1275},47,[32,1277,1278],{"class":116},"    WithPort",[32,1280,121],{"class":120},[32,1282,1283],{"class":161},"9090",[32,1285,1286],{"class":120},"),\n",[32,1288,1290,1293,1295,1298,1300],{"class":34,"line":1289},48,[32,1291,1292],{"class":116},"    WithTimeout",[32,1294,121],{"class":120},[32,1296,1297],{"class":161},"10",[32,1299,134],{"class":112},[32,1301,1302],{"class":120},"time.Second),\n",[32,1304,1306,1309],{"class":34,"line":1305},49,[32,1307,1308],{"class":116},"    WithTLS",[32,1310,1311],{"class":120},"(tlsConfig),\n",[32,1313,1315],{"class":34,"line":1314},50,[32,1316,311],{"class":120},[14,1318,1320],{"id":1319},"closures-capture-semantics","Closures — Capture Semantics",[19,1322,1323],{"language":21},[23,1324,1326],{"className":25,"code":1325,"language":21,"meta":27,"style":27},"\u002F\u002F Closures capture variables BY REFERENCE (not by value).\n\u002F\u002F The captured variable outlives the function that declared it —\n\u002F\u002F it's moved to the heap (escape analysis detects this).\n\nfunc counter() func() int {\n    n := 0                    \u002F\u002F captured by the closure below\n    return func() int {\n        n++                  \u002F\u002F modifies the SAME n across calls\n        return n\n    }\n}\n\u002F\u002F c := counter(); c() → 1; c() → 2; c() → 3\n\u002F\u002F Each call to counter() creates a NEW n (independent counters).\n\n\u002F\u002F ─── Generator pattern ───\nfunc fibonacci() func() int {\n    a, b := 0, 1\n    return func() int {\n        a, b = b, a+b\n        return a\n    }\n}\n\u002F\u002F f := fibonacci(); f() → 1; f() → 1; f() → 2; f() → 3; f() → 5\n\n\u002F\u002F ─── The loop variable capture trap (pre-Go 1.22) ───\nfunc captureTrap() {\n    var fns []func()\n    for i := 0; i \u003C 3; i++ {\n        fns = append(fns, func() { fmt.Println(i) })  \u002F\u002F captures i by reference\n    }\n    for _, f := range fns {\n        f()\n    }\n    \u002F\u002F Go 1.21: 3 3 3  (all see the final i=3 — single variable reused)\n    \u002F\u002F Go 1.22+: 0 1 2 (each iteration has its own i — spec change)\n}\n\n\u002F\u002F ✅ Pre-1.22 fix (still safe on 1.22+):\nfunc captureFixed() {\n    var fns []func()\n    for i := 0; i \u003C 3; i++ {\n        i := i  \u002F\u002F shadow — creates a new i per iteration\n        fns = append(fns, func() { fmt.Println(i) })\n    }\n    \u002F\u002F 0 1 2 on all versions\n}\n",[29,1327,1328,1333,1338,1343,1347,1364,1376,1388,1399,1405,1409,1413,1418,1423,1427,1432,1449,1463,1475,1491,1498,1502,1506,1511,1515,1520,1529,1541,1568,1595,1599,1613,1620,1624,1629,1634,1638,1642,1647,1656,1666,1688,1701,1720,1724,1729],{"__ignoreMap":27},[32,1329,1330],{"class":34,"line":35},[32,1331,1332],{"class":38},"\u002F\u002F Closures capture variables BY REFERENCE (not by value).\n",[32,1334,1335],{"class":34,"line":42},[32,1336,1337],{"class":38},"\u002F\u002F The captured variable outlives the function that declared it —\n",[32,1339,1340],{"class":34,"line":48},[32,1341,1342],{"class":38},"\u002F\u002F it's moved to the heap (escape analysis detects this).\n",[32,1344,1345],{"class":34,"line":54},[32,1346,100],{"emptyLinePlaceholder":99},[32,1348,1349,1351,1354,1356,1358,1360,1362],{"class":34,"line":60},[32,1350,113],{"class":112},[32,1352,1353],{"class":116}," counter",[32,1355,663],{"class":120},[32,1357,113],{"class":112},[32,1359,663],{"class":120},[32,1361,792],{"class":112},[32,1363,165],{"class":120},[32,1365,1366,1369,1371,1373],{"class":34,"line":66},[32,1367,1368],{"class":120},"    n ",[32,1370,490],{"class":112},[32,1372,162],{"class":161},[32,1374,1375],{"class":38},"                    \u002F\u002F captured by the closure below\n",[32,1377,1378,1380,1382,1384,1386],{"class":34,"line":72},[32,1379,207],{"class":112},[32,1381,507],{"class":112},[32,1383,663],{"class":120},[32,1385,792],{"class":112},[32,1387,165],{"class":120},[32,1389,1390,1393,1396],{"class":34,"line":78},[32,1391,1392],{"class":120},"        n",[32,1394,1395],{"class":112},"++",[32,1397,1398],{"class":38},"                  \u002F\u002F modifies the SAME n across calls\n",[32,1400,1401,1403],{"class":34,"line":84},[32,1402,171],{"class":112},[32,1404,831],{"class":120},[32,1406,1407],{"class":34,"line":90},[32,1408,201],{"class":120},[32,1410,1411],{"class":34,"line":96},[32,1412,224],{"class":120},[32,1414,1415],{"class":34,"line":103},[32,1416,1417],{"class":38},"\u002F\u002F c := counter(); c() → 1; c() → 2; c() → 3\n",[32,1419,1420],{"class":34,"line":109},[32,1421,1422],{"class":38},"\u002F\u002F Each call to counter() creates a NEW n (independent counters).\n",[32,1424,1425],{"class":34,"line":149},[32,1426,100],{"emptyLinePlaceholder":99},[32,1428,1429],{"class":34,"line":168},[32,1430,1431],{"class":38},"\u002F\u002F ─── Generator pattern ───\n",[32,1433,1434,1436,1439,1441,1443,1445,1447],{"class":34,"line":198},[32,1435,113],{"class":112},[32,1437,1438],{"class":116}," fibonacci",[32,1440,663],{"class":120},[32,1442,113],{"class":112},[32,1444,663],{"class":120},[32,1446,792],{"class":112},[32,1448,165],{"class":120},[32,1450,1451,1454,1456,1458,1460],{"class":34,"line":204},[32,1452,1453],{"class":120},"    a, b ",[32,1455,490],{"class":112},[32,1457,162],{"class":161},[32,1459,140],{"class":120},[32,1461,1462],{"class":161},"1\n",[32,1464,1465,1467,1469,1471,1473],{"class":34,"line":221},[32,1466,207],{"class":112},[32,1468,507],{"class":112},[32,1470,663],{"class":120},[32,1472,792],{"class":112},[32,1474,165],{"class":120},[32,1476,1477,1480,1482,1485,1488],{"class":34,"line":227},[32,1478,1479],{"class":120},"        a, b ",[32,1481,297],{"class":112},[32,1483,1484],{"class":120}," b, a",[32,1486,1487],{"class":112},"+",[32,1489,1490],{"class":120},"b\n",[32,1492,1493,1495],{"class":34,"line":232},[32,1494,171],{"class":112},[32,1496,1497],{"class":120}," a\n",[32,1499,1500],{"class":34,"line":238},[32,1501,201],{"class":120},[32,1503,1504],{"class":34,"line":276},[32,1505,224],{"class":120},[32,1507,1508],{"class":34,"line":291},[32,1509,1510],{"class":38},"\u002F\u002F f := fibonacci(); f() → 1; f() → 1; f() → 2; f() → 3; f() → 5\n",[32,1512,1513],{"class":34,"line":314},[32,1514,100],{"emptyLinePlaceholder":99},[32,1516,1517],{"class":34,"line":322},[32,1518,1519],{"class":38},"\u002F\u002F ─── The loop variable capture trap (pre-Go 1.22) ───\n",[32,1521,1522,1524,1527],{"class":34,"line":327},[32,1523,113],{"class":112},[32,1525,1526],{"class":116}," captureTrap",[32,1528,510],{"class":120},[32,1530,1531,1534,1537,1539],{"class":34,"line":344},[32,1532,1533],{"class":112},"    var",[32,1535,1536],{"class":120}," fns []",[32,1538,113],{"class":112},[32,1540,499],{"class":120},[32,1542,1543,1545,1548,1550,1552,1555,1558,1561,1564,1566],{"class":34,"line":352},[32,1544,809],{"class":112},[32,1546,1547],{"class":120}," i ",[32,1549,490],{"class":112},[32,1551,162],{"class":161},[32,1553,1554],{"class":120},"; i ",[32,1556,1557],{"class":112},"\u003C",[32,1559,1560],{"class":161}," 3",[32,1562,1563],{"class":120},"; i",[32,1565,1395],{"class":112},[32,1567,165],{"class":120},[32,1569,1570,1573,1575,1578,1581,1583,1586,1589,1592],{"class":34,"line":684},[32,1571,1572],{"class":120},"        fns ",[32,1574,297],{"class":112},[32,1576,1577],{"class":116}," append",[32,1579,1580],{"class":120},"(fns, ",[32,1582,113],{"class":112},[32,1584,1585],{"class":120},"() { fmt.",[32,1587,1588],{"class":116},"Println",[32,1590,1591],{"class":120},"(i) })  ",[32,1593,1594],{"class":38},"\u002F\u002F captures i by reference\n",[32,1596,1597],{"class":34,"line":706},[32,1598,201],{"class":120},[32,1600,1601,1603,1606,1608,1610],{"class":34,"line":729},[32,1602,809],{"class":112},[32,1604,1605],{"class":120}," _, f ",[32,1607,490],{"class":112},[32,1609,817],{"class":112},[32,1611,1612],{"class":120}," fns {\n",[32,1614,1615,1618],{"class":34,"line":734},[32,1616,1617],{"class":116},"        f",[32,1619,499],{"class":120},[32,1621,1622],{"class":34,"line":739},[32,1623,201],{"class":120},[32,1625,1626],{"class":34,"line":749},[32,1627,1628],{"class":38},"    \u002F\u002F Go 1.21: 3 3 3  (all see the final i=3 — single variable reused)\n",[32,1630,1631],{"class":34,"line":1161},[32,1632,1633],{"class":38},"    \u002F\u002F Go 1.22+: 0 1 2 (each iteration has its own i — spec change)\n",[32,1635,1636],{"class":34,"line":1167},[32,1637,224],{"class":120},[32,1639,1640],{"class":34,"line":1182},[32,1641,100],{"emptyLinePlaceholder":99},[32,1643,1644],{"class":34,"line":1196},[32,1645,1646],{"class":38},"\u002F\u002F ✅ Pre-1.22 fix (still safe on 1.22+):\n",[32,1648,1649,1651,1654],{"class":34,"line":1201},[32,1650,113],{"class":112},[32,1652,1653],{"class":116}," captureFixed",[32,1655,510],{"class":120},[32,1657,1658,1660,1662,1664],{"class":34,"line":1216},[32,1659,1533],{"class":112},[32,1661,1536],{"class":120},[32,1663,113],{"class":112},[32,1665,499],{"class":120},[32,1667,1668,1670,1672,1674,1676,1678,1680,1682,1684,1686],{"class":34,"line":1228},[32,1669,809],{"class":112},[32,1671,1547],{"class":120},[32,1673,490],{"class":112},[32,1675,162],{"class":161},[32,1677,1554],{"class":120},[32,1679,1557],{"class":112},[32,1681,1560],{"class":161},[32,1683,1563],{"class":120},[32,1685,1395],{"class":112},[32,1687,165],{"class":120},[32,1689,1690,1693,1695,1698],{"class":34,"line":1233},[32,1691,1692],{"class":120},"        i ",[32,1694,490],{"class":112},[32,1696,1697],{"class":120}," i  ",[32,1699,1700],{"class":38},"\u002F\u002F shadow — creates a new i per iteration\n",[32,1702,1703,1705,1707,1709,1711,1713,1715,1717],{"class":34,"line":1241},[32,1704,1572],{"class":120},[32,1706,297],{"class":112},[32,1708,1577],{"class":116},[32,1710,1580],{"class":120},[32,1712,113],{"class":112},[32,1714,1585],{"class":120},[32,1716,1588],{"class":116},[32,1718,1719],{"class":120},"(i) })\n",[32,1721,1722],{"class":34,"line":1246},[32,1723,201],{"class":120},[32,1725,1726],{"class":34,"line":1251},[32,1727,1728],{"class":38},"    \u002F\u002F 0 1 2 on all versions\n",[32,1730,1731],{"class":34,"line":1257},[32,1732,224],{"class":120},[14,1734,1736],{"id":1735},"functions-as-values-and-types","Functions as Values and Types",[19,1738,1739],{"language":21},[23,1740,1742],{"className":25,"code":1741,"language":21,"meta":27,"style":27},"\u002F\u002F Function types are first-class — assignable, passable, returnable.\n\u002F\u002F A function type is spelled: func(paramTypes) returnTypes\n\ntype Mapper[T, U any] func(T) U  \u002F\u002F generic function type (Go 1.18+)\n\n\u002F\u002F Higher-order: function that takes a function:\nfunc mapSlice[T, U any](items []T, fn Mapper[T, U]) []U {\n    result := make([]U, len(items))\n    for i, item := range items {\n        result[i] = fn(item)\n    }\n    return result\n}\n\n\u002F\u002F Usage:\ndoubled := mapSlice([]int{1, 2, 3}, func(x int) int { return x * 2 })\n\u002F\u002F [2 4 6]\n\n\u002F\u002F Function type as a field — strategy pattern:\ntype Processor struct {\n    transform func([]byte) []byte  \u002F\u002F injected strategy\n}\nfunc (p *Processor) Process(data []byte) []byte {\n    return p.transform(data)\n}\n\n\u002F\u002F ⚠️ Function types are distinct — no implicit conversion:\n\u002F\u002F   func(int) int ≠ func(int64) int (different parameter types)\n\u002F\u002F   func() ≠ func() error (different return types)\n",[29,1743,1744,1749,1754,1758,1795,1799,1804,1852,1874,1888,1900,1904,1911,1915,1919,1924,1986,1991,1995,2000,2011,2030,2034,2068,2080,2084,2088,2093,2098],{"__ignoreMap":27},[32,1745,1746],{"class":34,"line":35},[32,1747,1748],{"class":38},"\u002F\u002F Function types are first-class — assignable, passable, returnable.\n",[32,1750,1751],{"class":34,"line":42},[32,1752,1753],{"class":38},"\u002F\u002F A function type is spelled: func(paramTypes) returnTypes\n",[32,1755,1756],{"class":34,"line":48},[32,1757,100],{"emptyLinePlaceholder":99},[32,1759,1760,1762,1765,1768,1771,1773,1776,1779,1782,1784,1786,1788,1790,1792],{"class":34,"line":54},[32,1761,870],{"class":112},[32,1763,1764],{"class":116}," Mapper",[32,1766,1767],{"class":120},"[",[32,1769,1770],{"class":124},"T",[32,1772,140],{"class":120},[32,1774,1775],{"class":124},"U",[32,1777,1778],{"class":116}," any",[32,1780,1781],{"class":120},"] ",[32,1783,113],{"class":112},[32,1785,121],{"class":120},[32,1787,1770],{"class":116},[32,1789,789],{"class":120},[32,1791,1775],{"class":116},[32,1793,1794],{"class":38},"  \u002F\u002F generic function type (Go 1.18+)\n",[32,1796,1797],{"class":34,"line":60},[32,1798,100],{"emptyLinePlaceholder":99},[32,1800,1801],{"class":34,"line":66},[32,1802,1803],{"class":38},"\u002F\u002F Higher-order: function that takes a function:\n",[32,1805,1806,1808,1811,1813,1815,1817,1819,1821,1824,1827,1829,1831,1833,1835,1837,1839,1841,1843,1845,1848,1850],{"class":34,"line":72},[32,1807,113],{"class":112},[32,1809,1810],{"class":116}," mapSlice",[32,1812,1767],{"class":120},[32,1814,1770],{"class":124},[32,1816,140],{"class":120},[32,1818,1775],{"class":124},[32,1820,1778],{"class":116},[32,1822,1823],{"class":120},"](",[32,1825,1826],{"class":124},"items",[32,1828,386],{"class":120},[32,1830,1770],{"class":116},[32,1832,140],{"class":120},[32,1834,658],{"class":124},[32,1836,1764],{"class":116},[32,1838,1767],{"class":120},[32,1840,1770],{"class":116},[32,1842,140],{"class":120},[32,1844,1775],{"class":116},[32,1846,1847],{"class":120},"]) []",[32,1849,1775],{"class":116},[32,1851,165],{"class":120},[32,1853,1854,1856,1858,1861,1864,1866,1868,1871],{"class":34,"line":78},[32,1855,330],{"class":120},[32,1857,490],{"class":112},[32,1859,1860],{"class":116}," make",[32,1862,1863],{"class":120},"([]",[32,1865,1775],{"class":116},[32,1867,140],{"class":120},[32,1869,1870],{"class":116},"len",[32,1872,1873],{"class":120},"(items))\n",[32,1875,1876,1878,1881,1883,1885],{"class":34,"line":84},[32,1877,809],{"class":112},[32,1879,1880],{"class":120}," i, item ",[32,1882,490],{"class":112},[32,1884,817],{"class":112},[32,1886,1887],{"class":120}," items {\n",[32,1889,1890,1893,1895,1897],{"class":34,"line":90},[32,1891,1892],{"class":120},"        result[i] ",[32,1894,297],{"class":112},[32,1896,744],{"class":116},[32,1898,1899],{"class":120},"(item)\n",[32,1901,1902],{"class":34,"line":96},[32,1903,201],{"class":120},[32,1905,1906,1908],{"class":34,"line":103},[32,1907,207],{"class":112},[32,1909,1910],{"class":120}," result\n",[32,1912,1913],{"class":34,"line":109},[32,1914,224],{"class":120},[32,1916,1917],{"class":34,"line":149},[32,1918,100],{"emptyLinePlaceholder":99},[32,1920,1921],{"class":34,"line":168},[32,1922,1923],{"class":38},"\u002F\u002F Usage:\n",[32,1925,1926,1929,1931,1933,1935,1937,1940,1943,1945,1948,1950,1953,1956,1958,1960,1963,1965,1967,1969,1972,1975,1978,1980,1983],{"class":34,"line":198},[32,1927,1928],{"class":120},"doubled ",[32,1930,490],{"class":112},[32,1932,1810],{"class":116},[32,1934,1863],{"class":120},[32,1936,792],{"class":112},[32,1938,1939],{"class":120},"{",[32,1941,1942],{"class":161},"1",[32,1944,140],{"class":120},[32,1946,1947],{"class":161},"2",[32,1949,140],{"class":120},[32,1951,1952],{"class":161},"3",[32,1954,1955],{"class":120},"}, ",[32,1957,113],{"class":112},[32,1959,121],{"class":120},[32,1961,1962],{"class":124},"x",[32,1964,256],{"class":112},[32,1966,789],{"class":120},[32,1968,792],{"class":112},[32,1970,1971],{"class":120}," { ",[32,1973,1974],{"class":112},"return",[32,1976,1977],{"class":120}," x ",[32,1979,134],{"class":112},[32,1981,1982],{"class":161}," 2",[32,1984,1985],{"class":120}," })\n",[32,1987,1988],{"class":34,"line":204},[32,1989,1990],{"class":38},"\u002F\u002F [2 4 6]\n",[32,1992,1993],{"class":34,"line":221},[32,1994,100],{"emptyLinePlaceholder":99},[32,1996,1997],{"class":34,"line":227},[32,1998,1999],{"class":38},"\u002F\u002F Function type as a field — strategy pattern:\n",[32,2001,2002,2004,2007,2009],{"class":34,"line":232},[32,2003,870],{"class":112},[32,2005,2006],{"class":116}," Processor",[32,2008,876],{"class":112},[32,2010,165],{"class":120},[32,2012,2013,2016,2018,2020,2022,2025,2027],{"class":34,"line":238},[32,2014,2015],{"class":120},"    transform ",[32,2017,113],{"class":112},[32,2019,1863],{"class":120},[32,2021,389],{"class":112},[32,2023,2024],{"class":120},") []",[32,2026,389],{"class":112},[32,2028,2029],{"class":38},"  \u002F\u002F injected strategy\n",[32,2031,2032],{"class":34,"line":276},[32,2033,224],{"class":120},[32,2035,2036,2038,2041,2044,2046,2049,2051,2054,2056,2058,2060,2062,2064,2066],{"class":34,"line":291},[32,2037,113],{"class":112},[32,2039,2040],{"class":120}," (",[32,2042,2043],{"class":124},"p ",[32,2045,134],{"class":112},[32,2047,2048],{"class":116},"Processor",[32,2050,789],{"class":120},[32,2052,2053],{"class":116},"Process",[32,2055,121],{"class":120},[32,2057,383],{"class":124},[32,2059,386],{"class":120},[32,2061,389],{"class":112},[32,2063,2024],{"class":120},[32,2065,389],{"class":112},[32,2067,165],{"class":120},[32,2069,2070,2072,2075,2078],{"class":34,"line":314},[32,2071,207],{"class":112},[32,2073,2074],{"class":120}," p.",[32,2076,2077],{"class":116},"transform",[32,2079,422],{"class":120},[32,2081,2082],{"class":34,"line":322},[32,2083,224],{"class":120},[32,2085,2086],{"class":34,"line":327},[32,2087,100],{"emptyLinePlaceholder":99},[32,2089,2090],{"class":34,"line":344},[32,2091,2092],{"class":38},"\u002F\u002F ⚠️ Function types are distinct — no implicit conversion:\n",[32,2094,2095],{"class":34,"line":352},[32,2096,2097],{"class":38},"\u002F\u002F   func(int) int ≠ func(int64) int (different parameter types)\n",[32,2099,2100],{"class":34,"line":684},[32,2101,2102],{"class":38},"\u002F\u002F   func() ≠ func() error (different return types)\n",[14,2104,2106,2109],{"id":2105},"defer-the-execution-model",[29,2107,2108],{},"defer"," — The Execution Model",[19,2111,2112],{"language":21},[23,2113,2115],{"className":25,"code":2114,"language":21,"meta":27,"style":27},"\u002F\u002F defer schedules a function call to run when the enclosing function returns.\n\u002F\u002F Key properties:\n\u002F\u002F   1. LIFO order (last deferred runs first)\n\u002F\u002F   2. Arguments evaluated IMMEDIATELY (at defer time, not run time)\n\u002F\u002F   3. Runs on panic (before the program crashes) — but NOT on os.Exit\n\u002F\u002F   4. Has a small overhead (~35ns per defer pre-1.14, ~1ns open-coded 1.14+)\n\nfunc deferOrder() {\n    \u002F\u002F LIFO unwind:\n    defer fmt.Println(\"1\")  \u002F\u002F runs 4th (last)\n    defer fmt.Println(\"2\")  \u002F\u002F runs 3rd\n    defer fmt.Println(\"3\")  \u002F\u002F runs 2nd\n    fmt.Println(\"4\")        \u002F\u002F runs 1st (immediate)\n    \u002F\u002F Output: 4, 3, 2, 1\n}\n\n\u002F\u002F ─── Argument evaluation timing ───\nfunc deferArgEval() {\n    i := 1\n    defer fmt.Println(i)  \u002F\u002F prints 1 — i evaluated NOW (at defer time)\n    i = 2\n    defer func() { fmt.Println(i) }()  \u002F\u002F prints 2 — i evaluated at RUN time\n    \u002F\u002F Output: 2, 1  (LIFO: the closure runs first, then the println(i))\n}\n\n\u002F\u002F ─── Resource cleanup (the primary use) ───\nfunc readFile(path string) ([]byte, error) {\n    f, err := os.Open(path)\n    if err != nil {\n        return nil, err\n    }\n    defer f.Close()  \u002F\u002F guaranteed to run on return, early return, OR panic\n    \u002F\u002F This is why defer exists — you can't forget to close.\n    data, err := io.ReadAll(f)\n    if err != nil {\n        return nil, err  \u002F\u002F f.Close() runs here\n    }\n    return data, nil  \u002F\u002F f.Close() runs here\n}\n\n\u002F\u002F ─── defer in reverse order (nested resources) ───\nfunc nestedResources() error {\n    db, _ := sql.Open(\"postgres\", dsn)\n    defer db.Close()  \u002F\u002F runs LAST (opened first, closed last)\n\n    conn, _ := db.Conn(context.Background())\n    defer conn.Close()  \u002F\u002F runs FIRST (opened last, closed first)\n\n    rows, _ := conn.QueryContext(context.Background(), \"SELECT 1\")\n    defer rows.Close()  \u002F\u002F runs before conn.Close\n\n    \u002F\u002F LIFO ensures rows → conn → db (inner to outer)\n    return nil\n}\n",[29,2116,2117,2122,2127,2132,2137,2142,2147,2151,2160,2165,2183,2201,2219,2237,2242,2246,2250,2255,2264,2274,2288,2297,2313,2318,2322,2326,2331,2356,2372,2384,2393,2397,2413,2418,2434,2446,2458,2462,2475,2479,2483,2488,2501,2521,2535,2539,2560,2574,2578,2602,2616,2621,2627,2635],{"__ignoreMap":27},[32,2118,2119],{"class":34,"line":35},[32,2120,2121],{"class":38},"\u002F\u002F defer schedules a function call to run when the enclosing function returns.\n",[32,2123,2124],{"class":34,"line":42},[32,2125,2126],{"class":38},"\u002F\u002F Key properties:\n",[32,2128,2129],{"class":34,"line":48},[32,2130,2131],{"class":38},"\u002F\u002F   1. LIFO order (last deferred runs first)\n",[32,2133,2134],{"class":34,"line":54},[32,2135,2136],{"class":38},"\u002F\u002F   2. Arguments evaluated IMMEDIATELY (at defer time, not run time)\n",[32,2138,2139],{"class":34,"line":60},[32,2140,2141],{"class":38},"\u002F\u002F   3. Runs on panic (before the program crashes) — but NOT on os.Exit\n",[32,2143,2144],{"class":34,"line":66},[32,2145,2146],{"class":38},"\u002F\u002F   4. Has a small overhead (~35ns per defer pre-1.14, ~1ns open-coded 1.14+)\n",[32,2148,2149],{"class":34,"line":72},[32,2150,100],{"emptyLinePlaceholder":99},[32,2152,2153,2155,2158],{"class":34,"line":78},[32,2154,113],{"class":112},[32,2156,2157],{"class":116}," deferOrder",[32,2159,510],{"class":120},[32,2161,2162],{"class":34,"line":84},[32,2163,2164],{"class":38},"    \u002F\u002F LIFO unwind:\n",[32,2166,2167,2169,2171,2173,2175,2178,2180],{"class":34,"line":90},[32,2168,504],{"class":112},[32,2170,555],{"class":120},[32,2172,1588],{"class":116},[32,2174,121],{"class":120},[32,2176,2177],{"class":185},"\"1\"",[32,2179,942],{"class":120},[32,2181,2182],{"class":38},"\u002F\u002F runs 4th (last)\n",[32,2184,2185,2187,2189,2191,2193,2196,2198],{"class":34,"line":96},[32,2186,504],{"class":112},[32,2188,555],{"class":120},[32,2190,1588],{"class":116},[32,2192,121],{"class":120},[32,2194,2195],{"class":185},"\"2\"",[32,2197,942],{"class":120},[32,2199,2200],{"class":38},"\u002F\u002F runs 3rd\n",[32,2202,2203,2205,2207,2209,2211,2214,2216],{"class":34,"line":103},[32,2204,504],{"class":112},[32,2206,555],{"class":120},[32,2208,1588],{"class":116},[32,2210,121],{"class":120},[32,2212,2213],{"class":185},"\"3\"",[32,2215,942],{"class":120},[32,2217,2218],{"class":38},"\u002F\u002F runs 2nd\n",[32,2220,2221,2224,2226,2228,2231,2234],{"class":34,"line":109},[32,2222,2223],{"class":120},"    fmt.",[32,2225,1588],{"class":116},[32,2227,121],{"class":120},[32,2229,2230],{"class":185},"\"4\"",[32,2232,2233],{"class":120},")        ",[32,2235,2236],{"class":38},"\u002F\u002F runs 1st (immediate)\n",[32,2238,2239],{"class":34,"line":149},[32,2240,2241],{"class":38},"    \u002F\u002F Output: 4, 3, 2, 1\n",[32,2243,2244],{"class":34,"line":168},[32,2245,224],{"class":120},[32,2247,2248],{"class":34,"line":198},[32,2249,100],{"emptyLinePlaceholder":99},[32,2251,2252],{"class":34,"line":204},[32,2253,2254],{"class":38},"\u002F\u002F ─── Argument evaluation timing ───\n",[32,2256,2257,2259,2262],{"class":34,"line":221},[32,2258,113],{"class":112},[32,2260,2261],{"class":116}," deferArgEval",[32,2263,510],{"class":120},[32,2265,2266,2269,2271],{"class":34,"line":227},[32,2267,2268],{"class":120},"    i ",[32,2270,490],{"class":112},[32,2272,2273],{"class":161}," 1\n",[32,2275,2276,2278,2280,2282,2285],{"class":34,"line":232},[32,2277,504],{"class":112},[32,2279,555],{"class":120},[32,2281,1588],{"class":116},[32,2283,2284],{"class":120},"(i)  ",[32,2286,2287],{"class":38},"\u002F\u002F prints 1 — i evaluated NOW (at defer time)\n",[32,2289,2290,2292,2294],{"class":34,"line":238},[32,2291,2268],{"class":120},[32,2293,297],{"class":112},[32,2295,2296],{"class":161}," 2\n",[32,2298,2299,2301,2303,2305,2307,2310],{"class":34,"line":276},[32,2300,504],{"class":112},[32,2302,507],{"class":112},[32,2304,1585],{"class":120},[32,2306,1588],{"class":116},[32,2308,2309],{"class":120},"(i) }()  ",[32,2311,2312],{"class":38},"\u002F\u002F prints 2 — i evaluated at RUN time\n",[32,2314,2315],{"class":34,"line":291},[32,2316,2317],{"class":38},"    \u002F\u002F Output: 2, 1  (LIFO: the closure runs first, then the println(i))\n",[32,2319,2320],{"class":34,"line":314},[32,2321,224],{"class":120},[32,2323,2324],{"class":34,"line":322},[32,2325,100],{"emptyLinePlaceholder":99},[32,2327,2328],{"class":34,"line":327},[32,2329,2330],{"class":38},"\u002F\u002F ─── Resource cleanup (the primary use) ───\n",[32,2332,2333,2335,2338,2340,2343,2345,2348,2350,2352,2354],{"class":34,"line":344},[32,2334,113],{"class":112},[32,2336,2337],{"class":116}," readFile",[32,2339,121],{"class":120},[32,2341,2342],{"class":124},"path",[32,2344,1126],{"class":112},[32,2346,2347],{"class":120},") ([]",[32,2349,389],{"class":112},[32,2351,140],{"class":120},[32,2353,143],{"class":112},[32,2355,146],{"class":120},[32,2357,2358,2361,2363,2366,2369],{"class":34,"line":352},[32,2359,2360],{"class":120},"    f, err ",[32,2362,490],{"class":112},[32,2364,2365],{"class":120}," os.",[32,2367,2368],{"class":116},"Open",[32,2370,2371],{"class":120},"(path)\n",[32,2373,2374,2376,2378,2380,2382],{"class":34,"line":684},[32,2375,152],{"class":112},[32,2377,538],{"class":120},[32,2379,541],{"class":112},[32,2381,174],{"class":161},[32,2383,165],{"class":120},[32,2385,2386,2388,2390],{"class":34,"line":706},[32,2387,171],{"class":112},[32,2389,174],{"class":161},[32,2391,2392],{"class":120},", err\n",[32,2394,2395],{"class":34,"line":729},[32,2396,201],{"class":120},[32,2398,2399,2401,2404,2407,2410],{"class":34,"line":734},[32,2400,504],{"class":112},[32,2402,2403],{"class":120}," f.",[32,2405,2406],{"class":116},"Close",[32,2408,2409],{"class":120},"()  ",[32,2411,2412],{"class":38},"\u002F\u002F guaranteed to run on return, early return, OR panic\n",[32,2414,2415],{"class":34,"line":739},[32,2416,2417],{"class":38},"    \u002F\u002F This is why defer exists — you can't forget to close.\n",[32,2419,2420,2423,2425,2428,2431],{"class":34,"line":749},[32,2421,2422],{"class":120},"    data, err ",[32,2424,490],{"class":112},[32,2426,2427],{"class":120}," io.",[32,2429,2430],{"class":116},"ReadAll",[32,2432,2433],{"class":120},"(f)\n",[32,2435,2436,2438,2440,2442,2444],{"class":34,"line":1161},[32,2437,152],{"class":112},[32,2439,538],{"class":120},[32,2441,541],{"class":112},[32,2443,174],{"class":161},[32,2445,165],{"class":120},[32,2447,2448,2450,2452,2455],{"class":34,"line":1167},[32,2449,171],{"class":112},[32,2451,174],{"class":161},[32,2453,2454],{"class":120},", err  ",[32,2456,2457],{"class":38},"\u002F\u002F f.Close() runs here\n",[32,2459,2460],{"class":34,"line":1182},[32,2461,201],{"class":120},[32,2463,2464,2466,2469,2472],{"class":34,"line":1196},[32,2465,207],{"class":112},[32,2467,2468],{"class":120}," data, ",[32,2470,2471],{"class":161},"nil",[32,2473,2474],{"class":38},"  \u002F\u002F f.Close() runs here\n",[32,2476,2477],{"class":34,"line":1201},[32,2478,224],{"class":120},[32,2480,2481],{"class":34,"line":1216},[32,2482,100],{"emptyLinePlaceholder":99},[32,2484,2485],{"class":34,"line":1228},[32,2486,2487],{"class":38},"\u002F\u002F ─── defer in reverse order (nested resources) ───\n",[32,2489,2490,2492,2495,2497,2499],{"class":34,"line":1233},[32,2491,113],{"class":112},[32,2493,2494],{"class":116}," nestedResources",[32,2496,663],{"class":120},[32,2498,143],{"class":112},[32,2500,165],{"class":120},[32,2502,2503,2506,2508,2511,2513,2515,2518],{"class":34,"line":1241},[32,2504,2505],{"class":120},"    db, _ ",[32,2507,490],{"class":112},[32,2509,2510],{"class":120}," sql.",[32,2512,2368],{"class":116},[32,2514,121],{"class":120},[32,2516,2517],{"class":185},"\"postgres\"",[32,2519,2520],{"class":120},", dsn)\n",[32,2522,2523,2525,2528,2530,2532],{"class":34,"line":1246},[32,2524,504],{"class":112},[32,2526,2527],{"class":120}," db.",[32,2529,2406],{"class":116},[32,2531,2409],{"class":120},[32,2533,2534],{"class":38},"\u002F\u002F runs LAST (opened first, closed last)\n",[32,2536,2537],{"class":34,"line":1251},[32,2538,100],{"emptyLinePlaceholder":99},[32,2540,2541,2544,2546,2548,2551,2554,2557],{"class":34,"line":1257},[32,2542,2543],{"class":120},"    conn, _ ",[32,2545,490],{"class":112},[32,2547,2527],{"class":120},[32,2549,2550],{"class":116},"Conn",[32,2552,2553],{"class":120},"(context.",[32,2555,2556],{"class":116},"Background",[32,2558,2559],{"class":120},"())\n",[32,2561,2562,2564,2567,2569,2571],{"class":34,"line":1275},[32,2563,504],{"class":112},[32,2565,2566],{"class":120}," conn.",[32,2568,2406],{"class":116},[32,2570,2409],{"class":120},[32,2572,2573],{"class":38},"\u002F\u002F runs FIRST (opened last, closed first)\n",[32,2575,2576],{"class":34,"line":1289},[32,2577,100],{"emptyLinePlaceholder":99},[32,2579,2580,2583,2585,2587,2590,2592,2594,2597,2600],{"class":34,"line":1305},[32,2581,2582],{"class":120},"    rows, _ ",[32,2584,490],{"class":112},[32,2586,2566],{"class":120},[32,2588,2589],{"class":116},"QueryContext",[32,2591,2553],{"class":120},[32,2593,2556],{"class":116},[32,2595,2596],{"class":120},"(), ",[32,2598,2599],{"class":185},"\"SELECT 1\"",[32,2601,311],{"class":120},[32,2603,2604,2606,2609,2611,2613],{"class":34,"line":1314},[32,2605,504],{"class":112},[32,2607,2608],{"class":120}," rows.",[32,2610,2406],{"class":116},[32,2612,2409],{"class":120},[32,2614,2615],{"class":38},"\u002F\u002F runs before conn.Close\n",[32,2617,2619],{"class":34,"line":2618},51,[32,2620,100],{"emptyLinePlaceholder":99},[32,2622,2624],{"class":34,"line":2623},52,[32,2625,2626],{"class":38},"    \u002F\u002F LIFO ensures rows → conn → db (inner to outer)\n",[32,2628,2630,2632],{"class":34,"line":2629},53,[32,2631,207],{"class":112},[32,2633,2634],{"class":161}," nil\n",[32,2636,2638],{"class":34,"line":2637},54,[32,2639,224],{"class":120},[356,2641,2643,2645],{"id":2642},"defer-in-loops-the-resource-leak",[29,2644,2108],{}," in loops — the resource leak",[19,2647,2648],{"language":21},[23,2649,2651],{"className":25,"code":2650,"language":21,"meta":27,"style":27},"\u002F\u002F ❌ ANTI-PATTERN: defer in a loop — resources accumulate until function returns\nfunc processFilesBad(paths []string) error {\n    for _, p := range paths {\n        f, err := os.Open(p)\n        if err != nil {\n            return err\n        }\n        defer f.Close()  \u002F\u002F ALL files stay open until processFilesBad returns!\n        \u002F\u002F With 10000 files → \"too many open files\" (EMFILE)\n        if err := process(f); err != nil {\n            return err\n        }\n    }\n    return nil\n}\n\n\u002F\u002F ✅ CORRECT: extract loop body into a function — defer runs per iteration\nfunc processFilesGood(paths []string) error {\n    for _, p := range paths {\n        if err := processOneFile(p); err != nil {\n            return err\n        }\n    }\n    return nil\n}\n\nfunc processOneFile(path string) error {\n    f, err := os.Open(path)\n    if err != nil {\n        return err\n    }\n    defer f.Close()  \u002F\u002F runs when processOneFile returns — file closed per iteration\n    return process(f)\n}\n",[29,2652,2653,2658,2681,2695,2709,2721,2729,2733,2747,2752,2771,2777,2781,2785,2791,2795,2799,2804,2825,2837,2857,2863,2867,2871,2877,2881,2885,2903,2915,2927,2933,2937,2950,2958],{"__ignoreMap":27},[32,2654,2655],{"class":34,"line":35},[32,2656,2657],{"class":38},"\u002F\u002F ❌ ANTI-PATTERN: defer in a loop — resources accumulate until function returns\n",[32,2659,2660,2662,2665,2667,2670,2672,2675,2677,2679],{"class":34,"line":42},[32,2661,113],{"class":112},[32,2663,2664],{"class":116}," processFilesBad",[32,2666,121],{"class":120},[32,2668,2669],{"class":124},"paths",[32,2671,386],{"class":120},[32,2673,2674],{"class":112},"string",[32,2676,789],{"class":120},[32,2678,143],{"class":112},[32,2680,165],{"class":120},[32,2682,2683,2685,2688,2690,2692],{"class":34,"line":48},[32,2684,809],{"class":112},[32,2686,2687],{"class":120}," _, p ",[32,2689,490],{"class":112},[32,2691,817],{"class":112},[32,2693,2694],{"class":120}," paths {\n",[32,2696,2697,2700,2702,2704,2706],{"class":34,"line":54},[32,2698,2699],{"class":120},"        f, err ",[32,2701,490],{"class":112},[32,2703,2365],{"class":120},[32,2705,2368],{"class":116},[32,2707,2708],{"class":120},"(p)\n",[32,2710,2711,2713,2715,2717,2719],{"class":34,"line":60},[32,2712,535],{"class":112},[32,2714,538],{"class":120},[32,2716,541],{"class":112},[32,2718,174],{"class":161},[32,2720,165],{"class":120},[32,2722,2723,2726],{"class":34,"line":66},[32,2724,2725],{"class":112},"            return",[32,2727,2728],{"class":120}," err\n",[32,2730,2731],{"class":34,"line":72},[32,2732,581],{"class":120},[32,2734,2735,2738,2740,2742,2744],{"class":34,"line":78},[32,2736,2737],{"class":112},"        defer",[32,2739,2403],{"class":120},[32,2741,2406],{"class":116},[32,2743,2409],{"class":120},[32,2745,2746],{"class":38},"\u002F\u002F ALL files stay open until processFilesBad returns!\n",[32,2748,2749],{"class":34,"line":84},[32,2750,2751],{"class":38},"        \u002F\u002F With 10000 files → \"too many open files\" (EMFILE)\n",[32,2753,2754,2756,2758,2760,2762,2765,2767,2769],{"class":34,"line":90},[32,2755,535],{"class":112},[32,2757,538],{"class":120},[32,2759,490],{"class":112},[32,2761,378],{"class":116},[32,2763,2764],{"class":120},"(f); err ",[32,2766,541],{"class":112},[32,2768,174],{"class":161},[32,2770,165],{"class":120},[32,2772,2773,2775],{"class":34,"line":96},[32,2774,2725],{"class":112},[32,2776,2728],{"class":120},[32,2778,2779],{"class":34,"line":103},[32,2780,581],{"class":120},[32,2782,2783],{"class":34,"line":109},[32,2784,201],{"class":120},[32,2786,2787,2789],{"class":34,"line":149},[32,2788,207],{"class":112},[32,2790,2634],{"class":161},[32,2792,2793],{"class":34,"line":168},[32,2794,224],{"class":120},[32,2796,2797],{"class":34,"line":198},[32,2798,100],{"emptyLinePlaceholder":99},[32,2800,2801],{"class":34,"line":204},[32,2802,2803],{"class":38},"\u002F\u002F ✅ CORRECT: extract loop body into a function — defer runs per iteration\n",[32,2805,2806,2808,2811,2813,2815,2817,2819,2821,2823],{"class":34,"line":221},[32,2807,113],{"class":112},[32,2809,2810],{"class":116}," processFilesGood",[32,2812,121],{"class":120},[32,2814,2669],{"class":124},[32,2816,386],{"class":120},[32,2818,2674],{"class":112},[32,2820,789],{"class":120},[32,2822,143],{"class":112},[32,2824,165],{"class":120},[32,2826,2827,2829,2831,2833,2835],{"class":34,"line":227},[32,2828,809],{"class":112},[32,2830,2687],{"class":120},[32,2832,490],{"class":112},[32,2834,817],{"class":112},[32,2836,2694],{"class":120},[32,2838,2839,2841,2843,2845,2848,2851,2853,2855],{"class":34,"line":232},[32,2840,535],{"class":112},[32,2842,538],{"class":120},[32,2844,490],{"class":112},[32,2846,2847],{"class":116}," processOneFile",[32,2849,2850],{"class":120},"(p); err ",[32,2852,541],{"class":112},[32,2854,174],{"class":161},[32,2856,165],{"class":120},[32,2858,2859,2861],{"class":34,"line":238},[32,2860,2725],{"class":112},[32,2862,2728],{"class":120},[32,2864,2865],{"class":34,"line":276},[32,2866,581],{"class":120},[32,2868,2869],{"class":34,"line":291},[32,2870,201],{"class":120},[32,2872,2873,2875],{"class":34,"line":314},[32,2874,207],{"class":112},[32,2876,2634],{"class":161},[32,2878,2879],{"class":34,"line":322},[32,2880,224],{"class":120},[32,2882,2883],{"class":34,"line":327},[32,2884,100],{"emptyLinePlaceholder":99},[32,2886,2887,2889,2891,2893,2895,2897,2899,2901],{"class":34,"line":344},[32,2888,113],{"class":112},[32,2890,2847],{"class":116},[32,2892,121],{"class":120},[32,2894,2342],{"class":124},[32,2896,1126],{"class":112},[32,2898,789],{"class":120},[32,2900,143],{"class":112},[32,2902,165],{"class":120},[32,2904,2905,2907,2909,2911,2913],{"class":34,"line":352},[32,2906,2360],{"class":120},[32,2908,490],{"class":112},[32,2910,2365],{"class":120},[32,2912,2368],{"class":116},[32,2914,2371],{"class":120},[32,2916,2917,2919,2921,2923,2925],{"class":34,"line":684},[32,2918,152],{"class":112},[32,2920,538],{"class":120},[32,2922,541],{"class":112},[32,2924,174],{"class":161},[32,2926,165],{"class":120},[32,2928,2929,2931],{"class":34,"line":706},[32,2930,171],{"class":112},[32,2932,2728],{"class":120},[32,2934,2935],{"class":34,"line":729},[32,2936,201],{"class":120},[32,2938,2939,2941,2943,2945,2947],{"class":34,"line":734},[32,2940,504],{"class":112},[32,2942,2403],{"class":120},[32,2944,2406],{"class":116},[32,2946,2409],{"class":120},[32,2948,2949],{"class":38},"\u002F\u002F runs when processOneFile returns — file closed per iteration\n",[32,2951,2952,2954,2956],{"class":34,"line":739},[32,2953,207],{"class":112},[32,2955,378],{"class":116},[32,2957,2433],{"class":120},[32,2959,2960],{"class":34,"line":749},[32,2961,224],{"class":120},[356,2963,2965,2967],{"id":2964},"defer-performance-open-coded-defer",[29,2966,2108],{}," performance — open-coded defer",[19,2969,2970],{"language":21},[23,2971,2973],{"className":25,"code":2972,"language":21,"meta":27,"style":27},"\u002F\u002F Go 1.14+ \"open-coded defer\" optimization:\n\u002F\u002F   - If a function has ≤8 defers AND none are in loops\n\u002F\u002F   - The compiler inlines the defer logic (no runtime deferproc call)\n\u002F\u002F   - Cost drops from ~35ns to ~1-2ns per defer\n\u002F\u002F\n\u002F\u002F This means defer is now effectively free for the common case (a few\n\u002F\u002F resource cleanups in a normal function). Don't avoid defer for perf\n\u002F\u002F unless profiling shows it's a bottleneck (extremely rare).\n\u002F\u002F\n\u002F\u002F defer is still expensive when:\n\u002F\u002F   - In a loop (accumulates, not open-coded)\n\u002F\u002F   - In a function with >8 defers\n\u002F\u002F   - The deferred function is dynamic (defer f where f is a variable)\n",[29,2974,2975,2980,2985,2990,2995,3000,3005,3010,3015,3019,3024,3029,3034],{"__ignoreMap":27},[32,2976,2977],{"class":34,"line":35},[32,2978,2979],{"class":38},"\u002F\u002F Go 1.14+ \"open-coded defer\" optimization:\n",[32,2981,2982],{"class":34,"line":42},[32,2983,2984],{"class":38},"\u002F\u002F   - If a function has ≤8 defers AND none are in loops\n",[32,2986,2987],{"class":34,"line":48},[32,2988,2989],{"class":38},"\u002F\u002F   - The compiler inlines the defer logic (no runtime deferproc call)\n",[32,2991,2992],{"class":34,"line":54},[32,2993,2994],{"class":38},"\u002F\u002F   - Cost drops from ~35ns to ~1-2ns per defer\n",[32,2996,2997],{"class":34,"line":60},[32,2998,2999],{"class":38},"\u002F\u002F\n",[32,3001,3002],{"class":34,"line":66},[32,3003,3004],{"class":38},"\u002F\u002F This means defer is now effectively free for the common case (a few\n",[32,3006,3007],{"class":34,"line":72},[32,3008,3009],{"class":38},"\u002F\u002F resource cleanups in a normal function). Don't avoid defer for perf\n",[32,3011,3012],{"class":34,"line":78},[32,3013,3014],{"class":38},"\u002F\u002F unless profiling shows it's a bottleneck (extremely rare).\n",[32,3016,3017],{"class":34,"line":84},[32,3018,2999],{"class":38},[32,3020,3021],{"class":34,"line":90},[32,3022,3023],{"class":38},"\u002F\u002F defer is still expensive when:\n",[32,3025,3026],{"class":34,"line":96},[32,3027,3028],{"class":38},"\u002F\u002F   - In a loop (accumulates, not open-coded)\n",[32,3030,3031],{"class":34,"line":103},[32,3032,3033],{"class":38},"\u002F\u002F   - In a function with >8 defers\n",[32,3035,3036],{"class":34,"line":109},[32,3037,3038],{"class":38},"\u002F\u002F   - The deferred function is dynamic (defer f where f is a variable)\n",[14,3040,3042],{"id":3041},"anonymous-functions-and-iifes","Anonymous Functions and IIFEs",[19,3044,3045],{"language":21},[23,3046,3048],{"className":25,"code":3047,"language":21,"meta":27,"style":27},"\u002F\u002F Immediately-invoked function expression (IIFE):\nresult := func(x int) int {\n    return x * 2\n}(5)  \u002F\u002F 10\n\n\u002F\u002F Use case: scoped computation without polluting the outer scope:\nfunc handler(w http.ResponseWriter, r *http.Request) {\n    \u002F\u002F Parse and validate in an IIFE — keeps temp vars local:\n    input, err := func() (string, error) {\n        body, err := io.ReadAll(r.Body)\n        if err != nil {\n            return \"\", err\n        }\n        return strings.TrimSpace(string(body)), nil\n    }()\n    if err != nil {\n        http.Error(w, err.Error(), 400)\n        return\n    }\n    _ = input\n}\n\n\u002F\u002F Goroutine launch — the most common IIFE:\ngo func() {\n    defer wg.Done()\n    \u002F\u002F concurrent work\n}()\n",[29,3049,3050,3055,3076,3086,3099,3103,3108,3145,3150,3170,3184,3196,3205,3209,3228,3232,3244,3264,3269,3273,3283,3287,3291,3296,3304,3316,3321],{"__ignoreMap":27},[32,3051,3052],{"class":34,"line":35},[32,3053,3054],{"class":38},"\u002F\u002F Immediately-invoked function expression (IIFE):\n",[32,3056,3057,3060,3062,3064,3066,3068,3070,3072,3074],{"class":34,"line":42},[32,3058,3059],{"class":120},"result ",[32,3061,490],{"class":112},[32,3063,507],{"class":112},[32,3065,121],{"class":120},[32,3067,1962],{"class":124},[32,3069,256],{"class":112},[32,3071,789],{"class":120},[32,3073,792],{"class":112},[32,3075,165],{"class":120},[32,3077,3078,3080,3082,3084],{"class":34,"line":48},[32,3079,207],{"class":112},[32,3081,1977],{"class":120},[32,3083,134],{"class":112},[32,3085,2296],{"class":161},[32,3087,3088,3091,3094,3096],{"class":34,"line":54},[32,3089,3090],{"class":120},"}(",[32,3092,3093],{"class":161},"5",[32,3095,942],{"class":120},[32,3097,3098],{"class":38},"\u002F\u002F 10\n",[32,3100,3101],{"class":34,"line":60},[32,3102,100],{"emptyLinePlaceholder":99},[32,3104,3105],{"class":34,"line":66},[32,3106,3107],{"class":38},"\u002F\u002F Use case: scoped computation without polluting the outer scope:\n",[32,3109,3110,3112,3115,3117,3120,3123,3125,3128,3130,3133,3135,3138,3140,3143],{"class":34,"line":72},[32,3111,113],{"class":112},[32,3113,3114],{"class":116}," handler",[32,3116,121],{"class":120},[32,3118,3119],{"class":124},"w",[32,3121,3122],{"class":116}," http",[32,3124,465],{"class":120},[32,3126,3127],{"class":116},"ResponseWriter",[32,3129,140],{"class":120},[32,3131,3132],{"class":124},"r",[32,3134,984],{"class":112},[32,3136,3137],{"class":116},"http",[32,3139,465],{"class":120},[32,3141,3142],{"class":116},"Request",[32,3144,146],{"class":120},[32,3146,3147],{"class":34,"line":78},[32,3148,3149],{"class":38},"    \u002F\u002F Parse and validate in an IIFE — keeps temp vars local:\n",[32,3151,3152,3155,3157,3159,3162,3164,3166,3168],{"class":34,"line":84},[32,3153,3154],{"class":120},"    input, err ",[32,3156,490],{"class":112},[32,3158,507],{"class":112},[32,3160,3161],{"class":120},"() (",[32,3163,2674],{"class":112},[32,3165,140],{"class":120},[32,3167,143],{"class":112},[32,3169,146],{"class":120},[32,3171,3172,3175,3177,3179,3181],{"class":34,"line":90},[32,3173,3174],{"class":120},"        body, err ",[32,3176,490],{"class":112},[32,3178,2427],{"class":120},[32,3180,2430],{"class":116},[32,3182,3183],{"class":120},"(r.Body)\n",[32,3185,3186,3188,3190,3192,3194],{"class":34,"line":96},[32,3187,535],{"class":112},[32,3189,538],{"class":120},[32,3191,541],{"class":112},[32,3193,174],{"class":161},[32,3195,165],{"class":120},[32,3197,3198,3200,3203],{"class":34,"line":103},[32,3199,2725],{"class":112},[32,3201,3202],{"class":185}," \"\"",[32,3204,2392],{"class":120},[32,3206,3207],{"class":34,"line":109},[32,3208,581],{"class":120},[32,3210,3211,3213,3216,3219,3221,3223,3226],{"class":34,"line":149},[32,3212,171],{"class":112},[32,3214,3215],{"class":120}," strings.",[32,3217,3218],{"class":116},"TrimSpace",[32,3220,121],{"class":120},[32,3222,2674],{"class":112},[32,3224,3225],{"class":120},"(body)), ",[32,3227,218],{"class":161},[32,3229,3230],{"class":34,"line":168},[32,3231,606],{"class":120},[32,3233,3234,3236,3238,3240,3242],{"class":34,"line":198},[32,3235,152],{"class":112},[32,3237,538],{"class":120},[32,3239,541],{"class":112},[32,3241,174],{"class":161},[32,3243,165],{"class":120},[32,3245,3246,3249,3252,3255,3257,3259,3262],{"class":34,"line":204},[32,3247,3248],{"class":120},"        http.",[32,3250,3251],{"class":116},"Error",[32,3253,3254],{"class":120},"(w, err.",[32,3256,3251],{"class":116},[32,3258,2596],{"class":120},[32,3260,3261],{"class":161},"400",[32,3263,311],{"class":120},[32,3265,3266],{"class":34,"line":221},[32,3267,3268],{"class":112},"        return\n",[32,3270,3271],{"class":34,"line":227},[32,3272,201],{"class":120},[32,3274,3275,3278,3280],{"class":34,"line":232},[32,3276,3277],{"class":120},"    _ ",[32,3279,297],{"class":112},[32,3281,3282],{"class":120}," input\n",[32,3284,3285],{"class":34,"line":238},[32,3286,224],{"class":120},[32,3288,3289],{"class":34,"line":276},[32,3290,100],{"emptyLinePlaceholder":99},[32,3292,3293],{"class":34,"line":291},[32,3294,3295],{"class":38},"\u002F\u002F Goroutine launch — the most common IIFE:\n",[32,3297,3298,3300,3302],{"class":34,"line":314},[32,3299,21],{"class":112},[32,3301,507],{"class":112},[32,3303,510],{"class":120},[32,3305,3306,3308,3311,3314],{"class":34,"line":322},[32,3307,504],{"class":112},[32,3309,3310],{"class":120}," wg.",[32,3312,3313],{"class":116},"Done",[32,3315,499],{"class":120},[32,3317,3318],{"class":34,"line":327},[32,3319,3320],{"class":38},"    \u002F\u002F concurrent work\n",[32,3322,3323],{"class":34,"line":344},[32,3324,3325],{"class":120},"}()\n",[14,3327,3329],{"id":3328},"tips-tricks","💡 Tips & Tricks",[3331,3332,3333,3348,3356,3369,3390,3412],"ul",{},[3334,3335,3336,3340,3341,140,3344,3347],"li",{},[3337,3338,3339],"strong",{},"Idiom",": use the functional options pattern (",[29,3342,3343],{},"WithPort(8080)",[29,3345,3346],{},"WithTimeout(...)",") for constructors with many optional parameters — it's more readable than a config struct with many nilable fields, and it's extensible (new options don't break existing callers).",[3334,3349,3350,3352,3353,3355],{},[3337,3351,3339],{},": use named returns + ",[29,3354,2108],{}," for error decoration, timing, and panic recovery — this is the legitimate use of named returns. Don't use naked returns in long functions for readability.",[3334,3357,3358,3361,3362,3364,3365,3368],{},[3337,3359,3360],{},"Performance",": ",[29,3363,2108],{}," is nearly free in Go 1.14+ for the open-coded case (≤8 defers, no loops). Don't avoid ",[29,3366,3367],{},"defer f.Close()"," for performance reasons — the safety is worth the ~1ns.",[3334,3370,3371,3373,3374,140,3377,140,3380,140,3383,3386,3387,3389],{},[3337,3372,3339],{},": pair every resource acquisition (",[29,3375,3376],{},"os.Open",[29,3378,3379],{},"sql.Open",[29,3381,3382],{},"os.Create",[29,3384,3385],{},"lock.Lock",") with a ",[29,3388,2108],{}," of the corresponding release — this is the #1 defer use case. Defers run in LIFO order, matching nested resource lifetimes.",[3334,3391,3392,3361,3395,3397,3398,3401,3402,3404,3405,3408,3409,3411],{},[3337,3393,3394],{},"Safety",[29,3396,2108],{}," runs on panic but NOT on ",[29,3399,3400],{},"os.Exit"," — never call ",[29,3403,3400],{}," inside a function with cleanup defers. Return an error to ",[29,3406,3407],{},"main"," and call ",[29,3410,3400],{}," there.",[3334,3413,3414,3361,3417,3419,3420,3423,3424,3427,3428,465],{},[3337,3415,3416],{},"Debug",[29,3418,2108],{}," arguments are evaluated at defer time — ",[29,3421,3422],{},"defer fmt.Println(i)"," captures ",[29,3425,3426],{},"i","'s current value. To capture the value at return time, use a closure: ",[29,3429,3430],{},"defer func() { fmt.Println(i) }()",[14,3432,3434],{"id":3433},"️-edge-cases-gotchas","⚠️ Edge Cases & Gotchas",[3331,3436,3437,3445,3461,3480,3488,3498,3521,3534,3551,3571],{},[3334,3438,3439,3444],{},[3337,3440,3441,3443],{},[29,3442,2108],{}," in a loop accumulates",": deferred calls don't run until the function returns — all resources stay open. Extract the loop body into a function.",[3334,3446,3447,3361,3454,3457,3458,3460],{},[3337,3448,3449,3451,3452],{},[29,3450,2108],{}," doesn't run on ",[29,3453,3400],{},[29,3455,3456],{},"os.Exit(n)"," terminates immediately, skipping all defers. Return errors to ",[29,3459,3407],{}," and exit there.",[3334,3462,3463,3361,3468,3423,3471,3473,3474,3423,3477,3479],{},[3337,3464,3465,3467],{},[29,3466,2108],{}," argument evaluation timing",[29,3469,3470],{},"defer f(i)",[29,3472,3426],{}," at defer time; ",[29,3475,3476],{},"defer func() { f(i) }()",[29,3478,3426],{}," at run time. The difference matters when the variable changes between defer and return.",[3334,3481,3482,3361,3485,3487],{},[3337,3483,3484],{},"Naked returns in long functions",[29,3486,1974],{}," with no values + named returns is opaque in 50+ line functions. Use explicit returns for readability.",[3334,3489,3490,3493,3494,3497],{},[3337,3491,3492],{},"Closure capture by reference",": closures capture variables by reference, not by value. A loop variable captured by a closure sees the final value (pre-1.22). Pass as argument or shadow (",[29,3495,3496],{},"i := i",").",[3334,3499,3500,3361,3506,3509,3510,3512,3513,3516,3517,3520],{},[3337,3501,3502,3505],{},[29,3503,3504],{},"..."," spread requires a slice",[29,3507,3508],{},"sum(nums...)"," works with ",[29,3511,783],{}," = ",[29,3514,3515],{},"[]int","; ",[29,3518,3519],{},"sum(5...)"," is a compile error. The spread is for variadic calls only.",[3334,3522,3523,3361,3526,3529,3530,3533],{},[3337,3524,3525],{},"Function types are distinct",[29,3527,3528],{},"func(int) int"," and ",[29,3531,3532],{},"func(int64) int"," are different types — no implicit conversion. This matches Go's no-implicit-conversion rule.",[3334,3535,3536,3361,3539,3542,3543,3546,3547,3550],{},[3337,3537,3538],{},"Multiple returns must be fully received",[29,3540,3541],{},"f, err := os.Open(...)"," — both values must be used or explicitly discarded (",[29,3544,3545],{},"_","). ",[29,3548,3549],{},"f := os.Open(...)"," is a compile error.",[3334,3552,3553,3361,3559,3562,3563,3566,3567,3570],{},[3337,3554,3555,3556,3558],{},"Variadic ",[29,3557,2471],{}," spread",[29,3560,3561],{},"sum(nil...)"," where the slice is ",[29,3564,3565],{},"[]int(nil)"," — works (zero iterations). But ",[29,3568,3569],{},"var s []int; sum(s...)"," with a nil slice also works (range over nil slice = zero iterations).",[3334,3572,3573,3361,3580,3583,3584,3586],{},[3337,3574,3575,3529,3577],{},[29,3576,2108],{},[29,3578,3579],{},"recover",[29,3581,3582],{},"recover()"," only works inside a deferred function. Calling ",[29,3585,3582],{}," outside defer returns nil even during a panic. This is the only way to catch a panic.",[14,3588,3590],{"id":3589},"quick-quiz","🧠 Quick Quiz",[19,3592,3593,3656],{"language":21},[23,3594,3596],{"className":25,"code":3595,"language":21,"meta":27,"style":27},"func f() (result int) {\n    defer func() { result *= 2 }()\n    defer func() { result += 10 }()\n    return 5\n}\n",[29,3597,3598,3613,3630,3645,3652],{"__ignoreMap":27},[32,3599,3600,3602,3605,3607,3609,3611],{"class":34,"line":35},[32,3601,113],{"class":112},[32,3603,3604],{"class":116}," f",[32,3606,3161],{"class":120},[32,3608,261],{"class":124},[32,3610,256],{"class":112},[32,3612,146],{"class":120},[32,3614,3615,3617,3619,3622,3625,3627],{"class":34,"line":42},[32,3616,504],{"class":112},[32,3618,507],{"class":112},[32,3620,3621],{"class":120},"() { result ",[32,3623,3624],{"class":112},"*=",[32,3626,1982],{"class":161},[32,3628,3629],{"class":120}," }()\n",[32,3631,3632,3634,3636,3638,3640,3643],{"class":34,"line":48},[32,3633,504],{"class":112},[32,3635,507],{"class":112},[32,3637,3621],{"class":120},[32,3639,828],{"class":112},[32,3641,3642],{"class":161}," 10",[32,3644,3629],{"class":120},[32,3646,3647,3649],{"class":34,"line":54},[32,3648,207],{"class":112},[32,3650,3651],{"class":161}," 5\n",[32,3653,3654],{"class":34,"line":60},[32,3655,224],{"class":120},[961,3657,3658,3659,3662],{},"What does ",[29,3660,3661],{},"f()"," return?",[3664,3665,3666,3670,3678,3681,3717,3720,3723,3753,3759],"details",{},[3667,3668,3669],"summary",{},"Answer",[961,3671,3672,3674,3675,465],{},[29,3673,3661],{}," returns ",[3337,3676,3677],{},"20",[961,3679,3680],{},"Execution order:",[3682,3683,3684,3693],"ol",{},[3334,3685,3686,3689,3690],{},[29,3687,3688],{},"return 5"," sets ",[29,3691,3692],{},"result = 5",[3334,3694,3695,3696],{},"Defers run in LIFO order:\n",[3331,3697,3698,3708],{},[3334,3699,3700,3701,3704,3705],{},"First defer (registered second): ",[29,3702,3703],{},"result += 10"," → ",[29,3706,3707],{},"result = 15",[3334,3709,3710,3711,3704,3714],{},"Second defer (registered first): ",[29,3712,3713],{},"result *= 2",[29,3715,3716],{},"result = 30",[961,3718,3719],{},"Wait — that gives 30. Let me re-check.",[961,3721,3722],{},"Actually:",[3682,3724,3725,3732],{},[3334,3726,3727,3704,3729,3731],{},[29,3728,3688],{},[29,3730,3692],{},", then defers run:",[3334,3733,3734,3735],{},"LIFO: the LAST registered defer runs first:\n",[3331,3736,3737,3745],{},[3334,3738,3739,3742,3743],{},[29,3740,3741],{},"defer func() { result += 10 }()"," was registered second, runs first → ",[29,3744,3707],{},[3334,3746,3747,3750,3751],{},[29,3748,3749],{},"defer func() { result *= 2 }()"," was registered first, runs second → ",[29,3752,3716],{},[961,3754,3755,3674,3757,465],{},[29,3756,3661],{},[3337,3758,1188],{},[961,3760,3761,3762,3764,3765,3767,3768,465],{},"The key insight: ",[29,3763,3688],{}," doesn't immediately return — it assigns 5 to the named return ",[29,3766,261],{},", then deferred functions run (in LIFO order), and THEN the function returns with the modified ",[29,3769,261],{},[14,3771,3773],{"id":3772},"whats-next","📚 What's Next",[961,3775,3776,3777,3781,3782,338,3785,338,3788,338,3791,3794,3795,465],{},"→ ",[248,3778,3780],{"href":3779},"\u002Fgo\u002F06-control-flow","06 — Control Flow"," — ",[29,3783,3784],{},"if",[29,3786,3787],{},"for",[29,3789,3790],{},"switch",[29,3792,3793],{},"select",", Go 1.22 loop scoping, labeled breaks, and the absence of ",[29,3796,3797],{},"while",[3799,3800,3801],"style",{},"html pre.shiki code .sdCPZ, html code.shiki .sdCPZ{--shiki-default:#6A737D;--shiki-github-dark:#6A737D}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 .sCrzJ, html code.shiki .sCrzJ{--shiki-default:#E36209;--shiki-github-dark:#FFAB70}html pre.shiki code .snvgF, html code.shiki .snvgF{--shiki-default:#005CC5;--shiki-github-dark:#79B8FF}html pre.shiki code .sJ6F3, html code.shiki .sJ6F3{--shiki-default:#032F62;--shiki-github-dark:#9ECBFF}html .default .shiki span {color: var(--shiki-default);background: var(--shiki-default-bg);font-style: var(--shiki-default-font-style);font-weight: var(--shiki-default-font-weight);text-decoration: var(--shiki-default-text-decoration);}html .shiki span {color: var(--shiki-default);background: var(--shiki-default-bg);font-style: var(--shiki-default-font-style);font-weight: var(--shiki-default-font-weight);text-decoration: var(--shiki-default-text-decoration);}html .github-dark .shiki span {color: var(--shiki-github-dark);background: var(--shiki-github-dark-bg);font-style: var(--shiki-github-dark-font-style);font-weight: var(--shiki-github-dark-font-weight);text-decoration: var(--shiki-github-dark-text-decoration);}html.github-dark .shiki span {color: var(--shiki-github-dark);background: var(--shiki-github-dark-bg);font-style: var(--shiki-github-dark-font-style);font-weight: var(--shiki-github-dark-font-weight);text-decoration: var(--shiki-github-dark-text-decoration);}",{"title":27,"searchDepth":42,"depth":42,"links":3803},[3804,3807,3808,3809,3810,3817,3818,3819,3820,3821],{"id":16,"depth":42,"text":17,"children":3805},[3806],{"id":358,"depth":48,"text":359},{"id":754,"depth":42,"text":755},{"id":1319,"depth":42,"text":1320},{"id":1735,"depth":42,"text":1736},{"id":2105,"depth":42,"text":3811,"children":3812},"defer — The Execution Model",[3813,3815],{"id":2642,"depth":48,"text":3814},"defer in loops — the resource leak",{"id":2964,"depth":48,"text":3816},"defer performance — open-coded defer",{"id":3041,"depth":42,"text":3042},{"id":3328,"depth":42,"text":3329},{"id":3433,"depth":42,"text":3434},{"id":3589,"depth":42,"text":3590},{"id":3772,"depth":42,"text":3773},"Multiple returns, closure capture semantics, defer execution model, variadic mechanics, and function-type patterns for production Go.","md",{},"\u002Fgo\u002F05-functions",{"title":5,"description":3822},"go\u002F05-functions","h1JWTTM7bk-TvsXqTEvo5JowZBPiwKcPjyEuOUojRZc",1789924648306]