[{"data":1,"prerenderedAt":3256},["ShallowReactive",2],{"page-\u002Fgo\u002F11-methods-and-receivers":3},{"id":4,"title":5,"body":6,"description":3249,"extension":3250,"meta":3251,"navigation":75,"path":3252,"seo":3253,"stem":3254,"__hash__":3255},"content\u002Fgo\u002F11-methods-and-receivers.md","11 — Methods & Receivers",{"type":7,"value":8,"toc":3244},"minimark",[9,13,17,22,3153,3227,3231,3240],[10,11,5],"h1",{"id":12},"_11-methods-receivers",[14,15,16],"p",{},"Methods are functions with a receiver bound to a type. Go has no classes — methods on named types provide the closest analog.",[18,19,21],"h2",{"id":20},"value-vs-pointer-receivers-the-core-distinction","Value vs Pointer Receivers — The Core Distinction",[23,24,26,316,320],"code-wrapper",{"language":25},"go",[27,28,32],"pre",{"className":29,"code":30,"language":25,"meta":31,"style":31},"language-go shiki shiki-themes github-light github-dark","type Counter struct {\n    count int\n}\n\n\u002F\u002F VALUE receiver — operates on a COPY; mutations don't persist:\nfunc (c Counter) IncBad() {\n    c.count++  \u002F\u002F modifies the copy — caller's counter unchanged\n}\n\n\u002F\u002F POINTER receiver — operates on the original; mutations persist:\nfunc (c *Counter) Inc() {\n    c.count++  \u002F\u002F modifies the original — caller sees the change\n}\n\nfunc demo() {\n    var c Counter\n    c.IncBad()\n    fmt.Println(c.count)  \u002F\u002F 0 — IncBad got a copy\n\n    c.Inc()\n    fmt.Println(c.count)  \u002F\u002F 1 — Inc modified the original via pointer\n}\n\n\u002F\u002F ┌──────────────────────────────────────────────────────────────────────┐\n\u002F\u002F │ Value receiver                     │ Pointer receiver               │\n\u002F\u002F │ ───────────────────────────────────│ ────────────────────────────── │\n\u002F\u002F │ Copy of receiver (immutability)    │ Original (can mutate)          │\n\u002F\u002F │ Safe for concurrency (no shared    │ Must synchronize if shared    │\n\u002F\u002F │   mutation)                        │                                │\n\u002F\u002F │ Small structs only (copy cost)    │ Large structs (avoid copy)     │\n\u002F\u002F │ Method set: T                      │ Method set: T and *T (all)     │\n\u002F\u002F └──────────────────────────────────────────────────────────────────────┘\n","",[33,34,35,55,64,70,77,84,109,121,126,131,137,158,168,173,178,188,200,211,226,231,240,252,257,262,268,274,280,286,292,298,304,310],"code",{"__ignoreMap":31},[36,37,40,44,48,51],"span",{"class":38,"line":39},"line",1,[36,41,43],{"class":42},"svdQ7","type",[36,45,47],{"class":46},"sIsaT"," Counter",[36,49,50],{"class":42}," struct",[36,52,54],{"class":53},"ssxIu"," {\n",[36,56,58,61],{"class":38,"line":57},2,[36,59,60],{"class":53},"    count ",[36,62,63],{"class":42},"int\n",[36,65,67],{"class":38,"line":66},3,[36,68,69],{"class":53},"}\n",[36,71,73],{"class":38,"line":72},4,[36,74,76],{"emptyLinePlaceholder":75},true,"\n",[36,78,80],{"class":38,"line":79},5,[36,81,83],{"class":82},"sdCPZ","\u002F\u002F VALUE receiver — operates on a COPY; mutations don't persist:\n",[36,85,87,90,93,97,100,103,106],{"class":38,"line":86},6,[36,88,89],{"class":42},"func",[36,91,92],{"class":53}," (",[36,94,96],{"class":95},"sCrzJ","c ",[36,98,99],{"class":46},"Counter",[36,101,102],{"class":53},") ",[36,104,105],{"class":46},"IncBad",[36,107,108],{"class":53},"() {\n",[36,110,112,115,118],{"class":38,"line":111},7,[36,113,114],{"class":53},"    c.count",[36,116,117],{"class":42},"++",[36,119,120],{"class":82},"  \u002F\u002F modifies the copy — caller's counter unchanged\n",[36,122,124],{"class":38,"line":123},8,[36,125,69],{"class":53},[36,127,129],{"class":38,"line":128},9,[36,130,76],{"emptyLinePlaceholder":75},[36,132,134],{"class":38,"line":133},10,[36,135,136],{"class":82},"\u002F\u002F POINTER receiver — operates on the original; mutations persist:\n",[36,138,140,142,144,146,149,151,153,156],{"class":38,"line":139},11,[36,141,89],{"class":42},[36,143,92],{"class":53},[36,145,96],{"class":95},[36,147,148],{"class":42},"*",[36,150,99],{"class":46},[36,152,102],{"class":53},[36,154,155],{"class":46},"Inc",[36,157,108],{"class":53},[36,159,161,163,165],{"class":38,"line":160},12,[36,162,114],{"class":53},[36,164,117],{"class":42},[36,166,167],{"class":82},"  \u002F\u002F modifies the original — caller sees the change\n",[36,169,171],{"class":38,"line":170},13,[36,172,69],{"class":53},[36,174,176],{"class":38,"line":175},14,[36,177,76],{"emptyLinePlaceholder":75},[36,179,181,183,186],{"class":38,"line":180},15,[36,182,89],{"class":42},[36,184,185],{"class":46}," demo",[36,187,108],{"class":53},[36,189,191,194,197],{"class":38,"line":190},16,[36,192,193],{"class":42},"    var",[36,195,196],{"class":53}," c ",[36,198,199],{"class":46},"Counter\n",[36,201,203,206,208],{"class":38,"line":202},17,[36,204,205],{"class":53},"    c.",[36,207,105],{"class":46},[36,209,210],{"class":53},"()\n",[36,212,214,217,220,223],{"class":38,"line":213},18,[36,215,216],{"class":53},"    fmt.",[36,218,219],{"class":46},"Println",[36,221,222],{"class":53},"(c.count)  ",[36,224,225],{"class":82},"\u002F\u002F 0 — IncBad got a copy\n",[36,227,229],{"class":38,"line":228},19,[36,230,76],{"emptyLinePlaceholder":75},[36,232,234,236,238],{"class":38,"line":233},20,[36,235,205],{"class":53},[36,237,155],{"class":46},[36,239,210],{"class":53},[36,241,243,245,247,249],{"class":38,"line":242},21,[36,244,216],{"class":53},[36,246,219],{"class":46},[36,248,222],{"class":53},[36,250,251],{"class":82},"\u002F\u002F 1 — Inc modified the original via pointer\n",[36,253,255],{"class":38,"line":254},22,[36,256,69],{"class":53},[36,258,260],{"class":38,"line":259},23,[36,261,76],{"emptyLinePlaceholder":75},[36,263,265],{"class":38,"line":264},24,[36,266,267],{"class":82},"\u002F\u002F ┌──────────────────────────────────────────────────────────────────────┐\n",[36,269,271],{"class":38,"line":270},25,[36,272,273],{"class":82},"\u002F\u002F │ Value receiver                     │ Pointer receiver               │\n",[36,275,277],{"class":38,"line":276},26,[36,278,279],{"class":82},"\u002F\u002F │ ───────────────────────────────────│ ────────────────────────────── │\n",[36,281,283],{"class":38,"line":282},27,[36,284,285],{"class":82},"\u002F\u002F │ Copy of receiver (immutability)    │ Original (can mutate)          │\n",[36,287,289],{"class":38,"line":288},28,[36,290,291],{"class":82},"\u002F\u002F │ Safe for concurrency (no shared    │ Must synchronize if shared    │\n",[36,293,295],{"class":38,"line":294},29,[36,296,297],{"class":82},"\u002F\u002F │   mutation)                        │                                │\n",[36,299,301],{"class":38,"line":300},30,[36,302,303],{"class":82},"\u002F\u002F │ Small structs only (copy cost)    │ Large structs (avoid copy)     │\n",[36,305,307],{"class":38,"line":306},31,[36,308,309],{"class":82},"\u002F\u002F │ Method set: T                      │ Method set: T and *T (all)     │\n",[36,311,313],{"class":38,"line":312},32,[36,314,315],{"class":82},"\u002F\u002F └──────────────────────────────────────────────────────────────────────┘\n",[18,317,319],{"id":318},"the-consistency-rule","The Consistency Rule",[23,321,322,664,668],{"language":25},[27,323,325],{"className":29,"code":324,"language":25,"meta":31,"style":31},"\u002F\u002F RULE: if ANY method has a pointer receiver, make ALL methods pointer receivers.\n\u002F\u002F Mixing causes method-set asymmetry and interface satisfaction bugs.\n\n\u002F\u002F ❌ ANTI-PATTERN: mixed receivers\ntype BadAccount struct {\n    balance float64\n}\nfunc (a BadAccount) Balance() float64 { return a.balance }       \u002F\u002F value receiver\nfunc (a *BadAccount) Deposit(amt float64) { a.balance += amt }  \u002F\u002F pointer receiver\n\n\u002F\u002F BadAccount{} satisfies nothing with pointer-receiver methods.\n\u002F\u002F &BadAccount{} satisfies both, but the asymmetry is a bug magnet.\n\u002F\u002F go vet \u002F golangci-lint warn: \"receiver name inconsistent\"\n\n\u002F\u002F ✅ CORRECT: consistent pointer receivers (because Deposit mutates):\ntype Account struct {\n    balance float64\n}\nfunc (a *Account) Balance() float64 { return a.balance }        \u002F\u002F pointer\nfunc (a *Account) Deposit(amt float64) { a.balance += amt }     \u002F\u002F pointer\nfunc (a *Account) Withdraw(amt float64) error {                  \u002F\u002F pointer\n    if amt > a.balance {\n        return errors.New(\"insufficient funds\")\n    }\n    a.balance -= amt\n    return nil\n}\n\u002F\u002F *Account satisfies any interface using these methods.\n\u002F\u002F Account{} satisfies only value-receiver methods (none here) —\n\u002F\u002F users must use &Account{} or a constructor.\n",[33,326,327,332,337,341,346,357,365,369,404,442,446,451,456,461,465,470,481,487,491,522,553,586,600,620,625,636,645,649,654,659],{"__ignoreMap":31},[36,328,329],{"class":38,"line":39},[36,330,331],{"class":82},"\u002F\u002F RULE: if ANY method has a pointer receiver, make ALL methods pointer receivers.\n",[36,333,334],{"class":38,"line":57},[36,335,336],{"class":82},"\u002F\u002F Mixing causes method-set asymmetry and interface satisfaction bugs.\n",[36,338,339],{"class":38,"line":66},[36,340,76],{"emptyLinePlaceholder":75},[36,342,343],{"class":38,"line":72},[36,344,345],{"class":82},"\u002F\u002F ❌ ANTI-PATTERN: mixed receivers\n",[36,347,348,350,353,355],{"class":38,"line":79},[36,349,43],{"class":42},[36,351,352],{"class":46}," BadAccount",[36,354,50],{"class":42},[36,356,54],{"class":53},[36,358,359,362],{"class":38,"line":86},[36,360,361],{"class":53},"    balance ",[36,363,364],{"class":42},"float64\n",[36,366,367],{"class":38,"line":111},[36,368,69],{"class":53},[36,370,371,373,375,378,381,383,386,389,392,395,398,401],{"class":38,"line":123},[36,372,89],{"class":42},[36,374,92],{"class":53},[36,376,377],{"class":95},"a ",[36,379,380],{"class":46},"BadAccount",[36,382,102],{"class":53},[36,384,385],{"class":46},"Balance",[36,387,388],{"class":53},"() ",[36,390,391],{"class":42},"float64",[36,393,394],{"class":53}," { ",[36,396,397],{"class":42},"return",[36,399,400],{"class":53}," a.balance }       ",[36,402,403],{"class":82},"\u002F\u002F value receiver\n",[36,405,406,408,410,412,414,416,418,421,424,427,430,433,436,439],{"class":38,"line":128},[36,407,89],{"class":42},[36,409,92],{"class":53},[36,411,377],{"class":95},[36,413,148],{"class":42},[36,415,380],{"class":46},[36,417,102],{"class":53},[36,419,420],{"class":46},"Deposit",[36,422,423],{"class":53},"(",[36,425,426],{"class":95},"amt",[36,428,429],{"class":42}," float64",[36,431,432],{"class":53},") { a.balance ",[36,434,435],{"class":42},"+=",[36,437,438],{"class":53}," amt }  ",[36,440,441],{"class":82},"\u002F\u002F pointer receiver\n",[36,443,444],{"class":38,"line":133},[36,445,76],{"emptyLinePlaceholder":75},[36,447,448],{"class":38,"line":139},[36,449,450],{"class":82},"\u002F\u002F BadAccount{} satisfies nothing with pointer-receiver methods.\n",[36,452,453],{"class":38,"line":160},[36,454,455],{"class":82},"\u002F\u002F &BadAccount{} satisfies both, but the asymmetry is a bug magnet.\n",[36,457,458],{"class":38,"line":170},[36,459,460],{"class":82},"\u002F\u002F go vet \u002F golangci-lint warn: \"receiver name inconsistent\"\n",[36,462,463],{"class":38,"line":175},[36,464,76],{"emptyLinePlaceholder":75},[36,466,467],{"class":38,"line":180},[36,468,469],{"class":82},"\u002F\u002F ✅ CORRECT: consistent pointer receivers (because Deposit mutates):\n",[36,471,472,474,477,479],{"class":38,"line":190},[36,473,43],{"class":42},[36,475,476],{"class":46}," Account",[36,478,50],{"class":42},[36,480,54],{"class":53},[36,482,483,485],{"class":38,"line":202},[36,484,361],{"class":53},[36,486,364],{"class":42},[36,488,489],{"class":38,"line":213},[36,490,69],{"class":53},[36,492,493,495,497,499,501,504,506,508,510,512,514,516,519],{"class":38,"line":228},[36,494,89],{"class":42},[36,496,92],{"class":53},[36,498,377],{"class":95},[36,500,148],{"class":42},[36,502,503],{"class":46},"Account",[36,505,102],{"class":53},[36,507,385],{"class":46},[36,509,388],{"class":53},[36,511,391],{"class":42},[36,513,394],{"class":53},[36,515,397],{"class":42},[36,517,518],{"class":53}," a.balance }        ",[36,520,521],{"class":82},"\u002F\u002F pointer\n",[36,523,524,526,528,530,532,534,536,538,540,542,544,546,548,551],{"class":38,"line":233},[36,525,89],{"class":42},[36,527,92],{"class":53},[36,529,377],{"class":95},[36,531,148],{"class":42},[36,533,503],{"class":46},[36,535,102],{"class":53},[36,537,420],{"class":46},[36,539,423],{"class":53},[36,541,426],{"class":95},[36,543,429],{"class":42},[36,545,432],{"class":53},[36,547,435],{"class":42},[36,549,550],{"class":53}," amt }     ",[36,552,521],{"class":82},[36,554,555,557,559,561,563,565,567,570,572,574,576,578,581,584],{"class":38,"line":242},[36,556,89],{"class":42},[36,558,92],{"class":53},[36,560,377],{"class":95},[36,562,148],{"class":42},[36,564,503],{"class":46},[36,566,102],{"class":53},[36,568,569],{"class":46},"Withdraw",[36,571,423],{"class":53},[36,573,426],{"class":95},[36,575,429],{"class":42},[36,577,102],{"class":53},[36,579,580],{"class":42},"error",[36,582,583],{"class":53}," {                  ",[36,585,521],{"class":82},[36,587,588,591,594,597],{"class":38,"line":254},[36,589,590],{"class":42},"    if",[36,592,593],{"class":53}," amt ",[36,595,596],{"class":42},">",[36,598,599],{"class":53}," a.balance {\n",[36,601,602,605,608,611,613,617],{"class":38,"line":259},[36,603,604],{"class":42},"        return",[36,606,607],{"class":53}," errors.",[36,609,610],{"class":46},"New",[36,612,423],{"class":53},[36,614,616],{"class":615},"sJ6F3","\"insufficient funds\"",[36,618,619],{"class":53},")\n",[36,621,622],{"class":38,"line":264},[36,623,624],{"class":53},"    }\n",[36,626,627,630,633],{"class":38,"line":270},[36,628,629],{"class":53},"    a.balance ",[36,631,632],{"class":42},"-=",[36,634,635],{"class":53}," amt\n",[36,637,638,641],{"class":38,"line":276},[36,639,640],{"class":42},"    return",[36,642,644],{"class":643},"snvgF"," nil\n",[36,646,647],{"class":38,"line":282},[36,648,69],{"class":53},[36,650,651],{"class":38,"line":288},[36,652,653],{"class":82},"\u002F\u002F *Account satisfies any interface using these methods.\n",[36,655,656],{"class":38,"line":294},[36,657,658],{"class":82},"\u002F\u002F Account{} satisfies only value-receiver methods (none here) —\n",[36,660,661],{"class":38,"line":300},[36,662,663],{"class":82},"\u002F\u002F users must use &Account{} or a constructor.\n",[18,665,667],{"id":666},"method-sets-and-interface-satisfaction","Method Sets and Interface Satisfaction",[23,669,670,1021,1025],{"language":25},[27,671,673],{"className":29,"code":672,"language":25,"meta":31,"style":31},"\u002F\u002F ┌──────────────────────────────────────────────────────────────────────┐\n\u002F\u002F │ Method set of T (value type):  value-receiver methods only          │\n\u002F\u002F │ Method set of *T (pointer type): ALL methods (value + pointer)      │\n\u002F\u002F │                                                                      │\n\u002F\u002F │ Interface satisfaction requires the type's method set to include    │\n\u002F\u002F │ ALL the interface's methods.                                         │\n\u002F\u002F │                                                                      │\n\u002F\u002F │ Consequence: if an interface requires a pointer-receiver method,     │\n\u002F\u002F │   you MUST use *T (not T) to satisfy it.                             │\n\u002F\u002F └──────────────────────────────────────────────────────────────────────┘\n\ntype Saver interface{ Save() error }\ntype Loader interface{ Load() error }\n\ntype Doc struct{ ID int64 }\nfunc (d Doc) Load() error { return nil }     \u002F\u002F value receiver\nfunc (d *Doc) Save() error { return nil }    \u002F\u002F pointer receiver\n\nfunc methodSetExample() {\n    var l Loader\n    l = Doc{}    \u002F\u002F ✅ Doc has Load (value receiver)\n    l = &Doc{}   \u002F\u002F ✅ *Doc has Load (promoted)\n\n    var s Saver\n    \u002F\u002F s = Doc{}   \u002F\u002F ❌ compile error: Doc's method set lacks Save (pointer receiver)\n    s = &Doc{}   \u002F\u002F ✅ *Doc has Save\n\n    \u002F\u002F This is the #1 interface gotcha: using a value where a pointer is needed.\n}\n\n\u002F\u002F ─── The compile-time check idiom ───\nvar _ Saver = (*Doc)(nil)  \u002F\u002F compile error if *Doc doesn't satisfy Saver\nvar _ Loader = Doc{}       \u002F\u002F compile error if Doc doesn't satisfy Loader\n",[33,674,675,679,684,689,694,699,704,708,713,718,722,726,749,769,773,790,822,853,857,866,876,892,909,913,923,931,947,951,956,960,964,969,1001],{"__ignoreMap":31},[36,676,677],{"class":38,"line":39},[36,678,267],{"class":82},[36,680,681],{"class":38,"line":57},[36,682,683],{"class":82},"\u002F\u002F │ Method set of T (value type):  value-receiver methods only          │\n",[36,685,686],{"class":38,"line":66},[36,687,688],{"class":82},"\u002F\u002F │ Method set of *T (pointer type): ALL methods (value + pointer)      │\n",[36,690,691],{"class":38,"line":72},[36,692,693],{"class":82},"\u002F\u002F │                                                                      │\n",[36,695,696],{"class":38,"line":79},[36,697,698],{"class":82},"\u002F\u002F │ Interface satisfaction requires the type's method set to include    │\n",[36,700,701],{"class":38,"line":86},[36,702,703],{"class":82},"\u002F\u002F │ ALL the interface's methods.                                         │\n",[36,705,706],{"class":38,"line":111},[36,707,693],{"class":82},[36,709,710],{"class":38,"line":123},[36,711,712],{"class":82},"\u002F\u002F │ Consequence: if an interface requires a pointer-receiver method,     │\n",[36,714,715],{"class":38,"line":128},[36,716,717],{"class":82},"\u002F\u002F │   you MUST use *T (not T) to satisfy it.                             │\n",[36,719,720],{"class":38,"line":133},[36,721,315],{"class":82},[36,723,724],{"class":38,"line":139},[36,725,76],{"emptyLinePlaceholder":75},[36,727,728,730,733,736,739,742,744,746],{"class":38,"line":160},[36,729,43],{"class":42},[36,731,732],{"class":46}," Saver",[36,734,735],{"class":42}," interface",[36,737,738],{"class":53},"{ ",[36,740,741],{"class":46},"Save",[36,743,388],{"class":53},[36,745,580],{"class":42},[36,747,748],{"class":53}," }\n",[36,750,751,753,756,758,760,763,765,767],{"class":38,"line":170},[36,752,43],{"class":42},[36,754,755],{"class":46}," Loader",[36,757,735],{"class":42},[36,759,738],{"class":53},[36,761,762],{"class":46},"Load",[36,764,388],{"class":53},[36,766,580],{"class":42},[36,768,748],{"class":53},[36,770,771],{"class":38,"line":175},[36,772,76],{"emptyLinePlaceholder":75},[36,774,775,777,780,782,785,788],{"class":38,"line":180},[36,776,43],{"class":42},[36,778,779],{"class":46}," Doc",[36,781,50],{"class":42},[36,783,784],{"class":53},"{ ID ",[36,786,787],{"class":42},"int64",[36,789,748],{"class":53},[36,791,792,794,796,799,802,804,806,808,810,812,814,817,820],{"class":38,"line":190},[36,793,89],{"class":42},[36,795,92],{"class":53},[36,797,798],{"class":95},"d ",[36,800,801],{"class":46},"Doc",[36,803,102],{"class":53},[36,805,762],{"class":46},[36,807,388],{"class":53},[36,809,580],{"class":42},[36,811,394],{"class":53},[36,813,397],{"class":42},[36,815,816],{"class":643}," nil",[36,818,819],{"class":53}," }     ",[36,821,403],{"class":82},[36,823,824,826,828,830,832,834,836,838,840,842,844,846,848,851],{"class":38,"line":202},[36,825,89],{"class":42},[36,827,92],{"class":53},[36,829,798],{"class":95},[36,831,148],{"class":42},[36,833,801],{"class":46},[36,835,102],{"class":53},[36,837,741],{"class":46},[36,839,388],{"class":53},[36,841,580],{"class":42},[36,843,394],{"class":53},[36,845,397],{"class":42},[36,847,816],{"class":643},[36,849,850],{"class":53}," }    ",[36,852,441],{"class":82},[36,854,855],{"class":38,"line":213},[36,856,76],{"emptyLinePlaceholder":75},[36,858,859,861,864],{"class":38,"line":228},[36,860,89],{"class":42},[36,862,863],{"class":46}," methodSetExample",[36,865,108],{"class":53},[36,867,868,870,873],{"class":38,"line":233},[36,869,193],{"class":42},[36,871,872],{"class":53}," l ",[36,874,875],{"class":46},"Loader\n",[36,877,878,881,884,886,889],{"class":38,"line":242},[36,879,880],{"class":53},"    l ",[36,882,883],{"class":42},"=",[36,885,779],{"class":46},[36,887,888],{"class":53},"{}    ",[36,890,891],{"class":82},"\u002F\u002F ✅ Doc has Load (value receiver)\n",[36,893,894,896,898,901,903,906],{"class":38,"line":254},[36,895,880],{"class":53},[36,897,883],{"class":42},[36,899,900],{"class":42}," &",[36,902,801],{"class":46},[36,904,905],{"class":53},"{}   ",[36,907,908],{"class":82},"\u002F\u002F ✅ *Doc has Load (promoted)\n",[36,910,911],{"class":38,"line":259},[36,912,76],{"emptyLinePlaceholder":75},[36,914,915,917,920],{"class":38,"line":264},[36,916,193],{"class":42},[36,918,919],{"class":53}," s ",[36,921,922],{"class":46},"Saver\n",[36,924,925,928],{"class":38,"line":270},[36,926,927],{"class":82},"    \u002F\u002F s = Doc{}",[36,929,930],{"class":82},"   \u002F\u002F ❌ compile error: Doc's method set lacks Save (pointer receiver)\n",[36,932,933,936,938,940,942,944],{"class":38,"line":276},[36,934,935],{"class":53},"    s ",[36,937,883],{"class":42},[36,939,900],{"class":42},[36,941,801],{"class":46},[36,943,905],{"class":53},[36,945,946],{"class":82},"\u002F\u002F ✅ *Doc has Save\n",[36,948,949],{"class":38,"line":282},[36,950,76],{"emptyLinePlaceholder":75},[36,952,953],{"class":38,"line":288},[36,954,955],{"class":82},"    \u002F\u002F This is the #1 interface gotcha: using a value where a pointer is needed.\n",[36,957,958],{"class":38,"line":294},[36,959,69],{"class":53},[36,961,962],{"class":38,"line":300},[36,963,76],{"emptyLinePlaceholder":75},[36,965,966],{"class":38,"line":306},[36,967,968],{"class":82},"\u002F\u002F ─── The compile-time check idiom ───\n",[36,970,971,974,977,980,983,985,987,989,992,995,998],{"class":38,"line":312},[36,972,973],{"class":42},"var",[36,975,976],{"class":53}," _ ",[36,978,979],{"class":46},"Saver",[36,981,982],{"class":42}," =",[36,984,92],{"class":53},[36,986,148],{"class":42},[36,988,801],{"class":46},[36,990,991],{"class":53},")(",[36,993,994],{"class":643},"nil",[36,996,997],{"class":53},")  ",[36,999,1000],{"class":82},"\u002F\u002F compile error if *Doc doesn't satisfy Saver\n",[36,1002,1004,1006,1008,1011,1013,1015,1018],{"class":38,"line":1003},33,[36,1005,973],{"class":42},[36,1007,976],{"class":53},[36,1009,1010],{"class":46},"Loader",[36,1012,982],{"class":42},[36,1014,779],{"class":46},[36,1016,1017],{"class":53},"{}       ",[36,1019,1020],{"class":82},"\u002F\u002F compile error if Doc doesn't satisfy Loader\n",[18,1022,1024],{"id":1023},"nil-receiver-methods-safe-patterns","Nil Receiver Methods — Safe Patterns",[23,1026,1027,1343,1347],{"language":25},[27,1028,1030],{"className":29,"code":1029,"language":25,"meta":31,"style":31},"\u002F\u002F Pointer receivers CAN be nil. A method can handle a nil receiver\n\u002F\u002F gracefully — this enables the \"null object\" pattern.\n\ntype Tree struct {\n    value       int\n    left, right *Tree\n}\n\n\u002F\u002F Find works on a nil receiver — returns false, no panic:\nfunc (t *Tree) Find(target int) bool {\n    if t == nil {  \u002F\u002F ✅ nil check — safe to call on a nil *Tree\n        return false\n    }\n    if target == t.value {\n        return true\n    }\n    if target \u003C t.value {\n        return t.left.Find(target)   \u002F\u002F t.left may be nil — handled by the check\n    }\n    return t.right.Find(target)\n}\n\n\u002F\u002F This lets you traverse a tree without nil-checking at every node:\n\u002F\u002F   tree.Find(42)  — works even if tree is nil (returns false)\n\n\u002F\u002F ─── Value receivers PANIC on nil ───\ntype BadTree struct{ value int }\nfunc (t BadTree) Value() int { return t.value }  \u002F\u002F value receiver\n\nfunc nilValuePanic() {\n    var t *BadTree  \u002F\u002F nil\n    \u002F\u002F t.Value()  \u002F\u002F panic: nil pointer dereference\n    \u002F\u002F Go tries to copy *t (nil) → dereference → panic\n    _ = t\n}\n",[33,1031,1032,1037,1042,1046,1057,1064,1074,1078,1082,1087,1121,1139,1146,1150,1162,1169,1173,1184,1199,1203,1215,1219,1223,1228,1233,1237,1242,1259,1288,1292,1301,1314,1322,1327,1338],{"__ignoreMap":31},[36,1033,1034],{"class":38,"line":39},[36,1035,1036],{"class":82},"\u002F\u002F Pointer receivers CAN be nil. A method can handle a nil receiver\n",[36,1038,1039],{"class":38,"line":57},[36,1040,1041],{"class":82},"\u002F\u002F gracefully — this enables the \"null object\" pattern.\n",[36,1043,1044],{"class":38,"line":66},[36,1045,76],{"emptyLinePlaceholder":75},[36,1047,1048,1050,1053,1055],{"class":38,"line":72},[36,1049,43],{"class":42},[36,1051,1052],{"class":46}," Tree",[36,1054,50],{"class":42},[36,1056,54],{"class":53},[36,1058,1059,1062],{"class":38,"line":79},[36,1060,1061],{"class":53},"    value       ",[36,1063,63],{"class":42},[36,1065,1066,1069,1071],{"class":38,"line":86},[36,1067,1068],{"class":53},"    left, right ",[36,1070,148],{"class":42},[36,1072,1073],{"class":46},"Tree\n",[36,1075,1076],{"class":38,"line":111},[36,1077,69],{"class":53},[36,1079,1080],{"class":38,"line":123},[36,1081,76],{"emptyLinePlaceholder":75},[36,1083,1084],{"class":38,"line":128},[36,1085,1086],{"class":82},"\u002F\u002F Find works on a nil receiver — returns false, no panic:\n",[36,1088,1089,1091,1093,1096,1098,1101,1103,1106,1108,1111,1114,1116,1119],{"class":38,"line":133},[36,1090,89],{"class":42},[36,1092,92],{"class":53},[36,1094,1095],{"class":95},"t ",[36,1097,148],{"class":42},[36,1099,1100],{"class":46},"Tree",[36,1102,102],{"class":53},[36,1104,1105],{"class":46},"Find",[36,1107,423],{"class":53},[36,1109,1110],{"class":95},"target",[36,1112,1113],{"class":42}," int",[36,1115,102],{"class":53},[36,1117,1118],{"class":42},"bool",[36,1120,54],{"class":53},[36,1122,1123,1125,1128,1131,1133,1136],{"class":38,"line":139},[36,1124,590],{"class":42},[36,1126,1127],{"class":53}," t ",[36,1129,1130],{"class":42},"==",[36,1132,816],{"class":643},[36,1134,1135],{"class":53}," {  ",[36,1137,1138],{"class":82},"\u002F\u002F ✅ nil check — safe to call on a nil *Tree\n",[36,1140,1141,1143],{"class":38,"line":160},[36,1142,604],{"class":42},[36,1144,1145],{"class":643}," false\n",[36,1147,1148],{"class":38,"line":170},[36,1149,624],{"class":53},[36,1151,1152,1154,1157,1159],{"class":38,"line":175},[36,1153,590],{"class":42},[36,1155,1156],{"class":53}," target ",[36,1158,1130],{"class":42},[36,1160,1161],{"class":53}," t.value {\n",[36,1163,1164,1166],{"class":38,"line":180},[36,1165,604],{"class":42},[36,1167,1168],{"class":643}," true\n",[36,1170,1171],{"class":38,"line":190},[36,1172,624],{"class":53},[36,1174,1175,1177,1179,1182],{"class":38,"line":202},[36,1176,590],{"class":42},[36,1178,1156],{"class":53},[36,1180,1181],{"class":42},"\u003C",[36,1183,1161],{"class":53},[36,1185,1186,1188,1191,1193,1196],{"class":38,"line":213},[36,1187,604],{"class":42},[36,1189,1190],{"class":53}," t.left.",[36,1192,1105],{"class":46},[36,1194,1195],{"class":53},"(target)   ",[36,1197,1198],{"class":82},"\u002F\u002F t.left may be nil — handled by the check\n",[36,1200,1201],{"class":38,"line":228},[36,1202,624],{"class":53},[36,1204,1205,1207,1210,1212],{"class":38,"line":233},[36,1206,640],{"class":42},[36,1208,1209],{"class":53}," t.right.",[36,1211,1105],{"class":46},[36,1213,1214],{"class":53},"(target)\n",[36,1216,1217],{"class":38,"line":242},[36,1218,69],{"class":53},[36,1220,1221],{"class":38,"line":254},[36,1222,76],{"emptyLinePlaceholder":75},[36,1224,1225],{"class":38,"line":259},[36,1226,1227],{"class":82},"\u002F\u002F This lets you traverse a tree without nil-checking at every node:\n",[36,1229,1230],{"class":38,"line":264},[36,1231,1232],{"class":82},"\u002F\u002F   tree.Find(42)  — works even if tree is nil (returns false)\n",[36,1234,1235],{"class":38,"line":270},[36,1236,76],{"emptyLinePlaceholder":75},[36,1238,1239],{"class":38,"line":276},[36,1240,1241],{"class":82},"\u002F\u002F ─── Value receivers PANIC on nil ───\n",[36,1243,1244,1246,1249,1251,1254,1257],{"class":38,"line":282},[36,1245,43],{"class":42},[36,1247,1248],{"class":46}," BadTree",[36,1250,50],{"class":42},[36,1252,1253],{"class":53},"{ value ",[36,1255,1256],{"class":42},"int",[36,1258,748],{"class":53},[36,1260,1261,1263,1265,1267,1270,1272,1275,1277,1279,1281,1283,1286],{"class":38,"line":288},[36,1262,89],{"class":42},[36,1264,92],{"class":53},[36,1266,1095],{"class":95},[36,1268,1269],{"class":46},"BadTree",[36,1271,102],{"class":53},[36,1273,1274],{"class":46},"Value",[36,1276,388],{"class":53},[36,1278,1256],{"class":42},[36,1280,394],{"class":53},[36,1282,397],{"class":42},[36,1284,1285],{"class":53}," t.value }  ",[36,1287,403],{"class":82},[36,1289,1290],{"class":38,"line":294},[36,1291,76],{"emptyLinePlaceholder":75},[36,1293,1294,1296,1299],{"class":38,"line":300},[36,1295,89],{"class":42},[36,1297,1298],{"class":46}," nilValuePanic",[36,1300,108],{"class":53},[36,1302,1303,1305,1307,1309,1311],{"class":38,"line":306},[36,1304,193],{"class":42},[36,1306,1127],{"class":53},[36,1308,148],{"class":42},[36,1310,1269],{"class":46},[36,1312,1313],{"class":82},"  \u002F\u002F nil\n",[36,1315,1316,1319],{"class":38,"line":312},[36,1317,1318],{"class":82},"    \u002F\u002F t.Value()",[36,1320,1321],{"class":82},"  \u002F\u002F panic: nil pointer dereference\n",[36,1323,1324],{"class":38,"line":1003},[36,1325,1326],{"class":82},"    \u002F\u002F Go tries to copy *t (nil) → dereference → panic\n",[36,1328,1330,1333,1335],{"class":38,"line":1329},34,[36,1331,1332],{"class":53},"    _ ",[36,1334,883],{"class":42},[36,1336,1337],{"class":53}," t\n",[36,1339,1341],{"class":38,"line":1340},35,[36,1342,69],{"class":53},[18,1344,1346],{"id":1345},"method-promotion-via-embedding","Method Promotion via Embedding",[23,1348,1349,1772,1776],{"language":25},[27,1350,1352],{"className":29,"code":1351,"language":25,"meta":31,"style":31},"\u002F\u002F Embedded type's methods are PROMOTED to the outer type.\n\u002F\u002F The outer type can SHADOW (not override — no virtual dispatch).\n\ntype Base struct{}\nfunc (b Base) Hello() string  { return \"hello from Base\" }\nfunc (b *Base) Goodbye() string { return \"bye from Base\" }\n\ntype Derived struct {\n    Base  \u002F\u002F embedded — Hello and Goodbye are promoted\n}\n\nfunc (d Derived) Hello() string { return \"hello from Derived\" }  \u002F\u002F shadows Base.Hello\n\nfunc embeddingDemo() {\n    d := Derived{}\n    fmt.Println(d.Hello())      \u002F\u002F \"hello from Derived\" (shadowed)\n    fmt.Println(d.Base.Hello())  \u002F\u002F \"hello from Base\" (explicit access)\n    fmt.Println(d.Goodbye())     \u002F\u002F \"bye from Base\" (promoted, not shadowed)\n\n    \u002F\u002F ⚠️ No virtual dispatch — the method called is determined at\n    \u002F\u002F COMPILE TIME by the static type, not the runtime type.\n    \u002F\u002F This differs from Java\u002FC++ virtual methods.\n}\n\n\u002F\u002F ─── Method promotion and pointer receivers ───\ntype Service struct{ name string }\nfunc (s *Service) Name() string { return s.name }\n\ntype APIService struct {\n    *Service  \u002F\u002F embedded pointer — must be initialized\n}\n\nfunc ptrEmbeddingDemo() {\n    \u002F\u002F ❌ APIService{} leaves *Service as nil → Name() panics\n    \u002F\u002F a := APIService{}; a.Name()  \u002F\u002F panic: nil pointer dereference\n\n    \u002F\u002F ✅ Initialize the embedded pointer:\n    a := APIService{Service: &Service{name: \"api\"}}\n    fmt.Println(a.Name())  \u002F\u002F \"api\" (promoted from *Service)\n}\n",[33,1353,1354,1359,1364,1368,1380,1412,1442,1446,1457,1465,1469,1473,1505,1509,1518,1530,1547,1564,1580,1584,1589,1594,1599,1603,1607,1612,1628,1658,1662,1673,1683,1687,1691,1700,1705,1712,1717,1723,1750,1767],{"__ignoreMap":31},[36,1355,1356],{"class":38,"line":39},[36,1357,1358],{"class":82},"\u002F\u002F Embedded type's methods are PROMOTED to the outer type.\n",[36,1360,1361],{"class":38,"line":57},[36,1362,1363],{"class":82},"\u002F\u002F The outer type can SHADOW (not override — no virtual dispatch).\n",[36,1365,1366],{"class":38,"line":66},[36,1367,76],{"emptyLinePlaceholder":75},[36,1369,1370,1372,1375,1377],{"class":38,"line":72},[36,1371,43],{"class":42},[36,1373,1374],{"class":46}," Base",[36,1376,50],{"class":42},[36,1378,1379],{"class":53},"{}\n",[36,1381,1382,1384,1386,1389,1392,1394,1397,1399,1402,1405,1407,1410],{"class":38,"line":79},[36,1383,89],{"class":42},[36,1385,92],{"class":53},[36,1387,1388],{"class":95},"b ",[36,1390,1391],{"class":46},"Base",[36,1393,102],{"class":53},[36,1395,1396],{"class":46},"Hello",[36,1398,388],{"class":53},[36,1400,1401],{"class":42},"string",[36,1403,1404],{"class":53},"  { ",[36,1406,397],{"class":42},[36,1408,1409],{"class":615}," \"hello from Base\"",[36,1411,748],{"class":53},[36,1413,1414,1416,1418,1420,1422,1424,1426,1429,1431,1433,1435,1437,1440],{"class":38,"line":86},[36,1415,89],{"class":42},[36,1417,92],{"class":53},[36,1419,1388],{"class":95},[36,1421,148],{"class":42},[36,1423,1391],{"class":46},[36,1425,102],{"class":53},[36,1427,1428],{"class":46},"Goodbye",[36,1430,388],{"class":53},[36,1432,1401],{"class":42},[36,1434,394],{"class":53},[36,1436,397],{"class":42},[36,1438,1439],{"class":615}," \"bye from Base\"",[36,1441,748],{"class":53},[36,1443,1444],{"class":38,"line":111},[36,1445,76],{"emptyLinePlaceholder":75},[36,1447,1448,1450,1453,1455],{"class":38,"line":123},[36,1449,43],{"class":42},[36,1451,1452],{"class":46}," Derived",[36,1454,50],{"class":42},[36,1456,54],{"class":53},[36,1458,1459,1462],{"class":38,"line":128},[36,1460,1461],{"class":46},"    Base",[36,1463,1464],{"class":82},"  \u002F\u002F embedded — Hello and Goodbye are promoted\n",[36,1466,1467],{"class":38,"line":133},[36,1468,69],{"class":53},[36,1470,1471],{"class":38,"line":139},[36,1472,76],{"emptyLinePlaceholder":75},[36,1474,1475,1477,1479,1481,1484,1486,1488,1490,1492,1494,1496,1499,1502],{"class":38,"line":160},[36,1476,89],{"class":42},[36,1478,92],{"class":53},[36,1480,798],{"class":95},[36,1482,1483],{"class":46},"Derived",[36,1485,102],{"class":53},[36,1487,1396],{"class":46},[36,1489,388],{"class":53},[36,1491,1401],{"class":42},[36,1493,394],{"class":53},[36,1495,397],{"class":42},[36,1497,1498],{"class":615}," \"hello from Derived\"",[36,1500,1501],{"class":53}," }  ",[36,1503,1504],{"class":82},"\u002F\u002F shadows Base.Hello\n",[36,1506,1507],{"class":38,"line":170},[36,1508,76],{"emptyLinePlaceholder":75},[36,1510,1511,1513,1516],{"class":38,"line":175},[36,1512,89],{"class":42},[36,1514,1515],{"class":46}," embeddingDemo",[36,1517,108],{"class":53},[36,1519,1520,1523,1526,1528],{"class":38,"line":180},[36,1521,1522],{"class":53},"    d ",[36,1524,1525],{"class":42},":=",[36,1527,1452],{"class":46},[36,1529,1379],{"class":53},[36,1531,1532,1534,1536,1539,1541,1544],{"class":38,"line":190},[36,1533,216],{"class":53},[36,1535,219],{"class":46},[36,1537,1538],{"class":53},"(d.",[36,1540,1396],{"class":46},[36,1542,1543],{"class":53},"())      ",[36,1545,1546],{"class":82},"\u002F\u002F \"hello from Derived\" (shadowed)\n",[36,1548,1549,1551,1553,1556,1558,1561],{"class":38,"line":202},[36,1550,216],{"class":53},[36,1552,219],{"class":46},[36,1554,1555],{"class":53},"(d.Base.",[36,1557,1396],{"class":46},[36,1559,1560],{"class":53},"())  ",[36,1562,1563],{"class":82},"\u002F\u002F \"hello from Base\" (explicit access)\n",[36,1565,1566,1568,1570,1572,1574,1577],{"class":38,"line":213},[36,1567,216],{"class":53},[36,1569,219],{"class":46},[36,1571,1538],{"class":53},[36,1573,1428],{"class":46},[36,1575,1576],{"class":53},"())     ",[36,1578,1579],{"class":82},"\u002F\u002F \"bye from Base\" (promoted, not shadowed)\n",[36,1581,1582],{"class":38,"line":228},[36,1583,76],{"emptyLinePlaceholder":75},[36,1585,1586],{"class":38,"line":233},[36,1587,1588],{"class":82},"    \u002F\u002F ⚠️ No virtual dispatch — the method called is determined at\n",[36,1590,1591],{"class":38,"line":242},[36,1592,1593],{"class":82},"    \u002F\u002F COMPILE TIME by the static type, not the runtime type.\n",[36,1595,1596],{"class":38,"line":254},[36,1597,1598],{"class":82},"    \u002F\u002F This differs from Java\u002FC++ virtual methods.\n",[36,1600,1601],{"class":38,"line":259},[36,1602,69],{"class":53},[36,1604,1605],{"class":38,"line":264},[36,1606,76],{"emptyLinePlaceholder":75},[36,1608,1609],{"class":38,"line":270},[36,1610,1611],{"class":82},"\u002F\u002F ─── Method promotion and pointer receivers ───\n",[36,1613,1614,1616,1619,1621,1624,1626],{"class":38,"line":276},[36,1615,43],{"class":42},[36,1617,1618],{"class":46}," Service",[36,1620,50],{"class":42},[36,1622,1623],{"class":53},"{ name ",[36,1625,1401],{"class":42},[36,1627,748],{"class":53},[36,1629,1630,1632,1634,1637,1639,1642,1644,1647,1649,1651,1653,1655],{"class":38,"line":282},[36,1631,89],{"class":42},[36,1633,92],{"class":53},[36,1635,1636],{"class":95},"s ",[36,1638,148],{"class":42},[36,1640,1641],{"class":46},"Service",[36,1643,102],{"class":53},[36,1645,1646],{"class":46},"Name",[36,1648,388],{"class":53},[36,1650,1401],{"class":42},[36,1652,394],{"class":53},[36,1654,397],{"class":42},[36,1656,1657],{"class":53}," s.name }\n",[36,1659,1660],{"class":38,"line":288},[36,1661,76],{"emptyLinePlaceholder":75},[36,1663,1664,1666,1669,1671],{"class":38,"line":294},[36,1665,43],{"class":42},[36,1667,1668],{"class":46}," APIService",[36,1670,50],{"class":42},[36,1672,54],{"class":53},[36,1674,1675,1678,1680],{"class":38,"line":300},[36,1676,1677],{"class":42},"    *",[36,1679,1641],{"class":46},[36,1681,1682],{"class":82},"  \u002F\u002F embedded pointer — must be initialized\n",[36,1684,1685],{"class":38,"line":306},[36,1686,69],{"class":53},[36,1688,1689],{"class":38,"line":312},[36,1690,76],{"emptyLinePlaceholder":75},[36,1692,1693,1695,1698],{"class":38,"line":1003},[36,1694,89],{"class":42},[36,1696,1697],{"class":46}," ptrEmbeddingDemo",[36,1699,108],{"class":53},[36,1701,1702],{"class":38,"line":1329},[36,1703,1704],{"class":82},"    \u002F\u002F ❌ APIService{} leaves *Service as nil → Name() panics\n",[36,1706,1707,1710],{"class":38,"line":1340},[36,1708,1709],{"class":82},"    \u002F\u002F a := APIService{}; a.Name()",[36,1711,1321],{"class":82},[36,1713,1715],{"class":38,"line":1714},36,[36,1716,76],{"emptyLinePlaceholder":75},[36,1718,1720],{"class":38,"line":1719},37,[36,1721,1722],{"class":82},"    \u002F\u002F ✅ Initialize the embedded pointer:\n",[36,1724,1726,1729,1731,1733,1736,1739,1741,1744,1747],{"class":38,"line":1725},38,[36,1727,1728],{"class":53},"    a ",[36,1730,1525],{"class":42},[36,1732,1668],{"class":46},[36,1734,1735],{"class":53},"{Service: ",[36,1737,1738],{"class":42},"&",[36,1740,1641],{"class":46},[36,1742,1743],{"class":53},"{name: ",[36,1745,1746],{"class":615},"\"api\"",[36,1748,1749],{"class":53},"}}\n",[36,1751,1753,1755,1757,1760,1762,1764],{"class":38,"line":1752},39,[36,1754,216],{"class":53},[36,1756,219],{"class":46},[36,1758,1759],{"class":53},"(a.",[36,1761,1646],{"class":46},[36,1763,1560],{"class":53},[36,1765,1766],{"class":82},"\u002F\u002F \"api\" (promoted from *Service)\n",[36,1768,1770],{"class":38,"line":1769},40,[36,1771,69],{"class":53},[18,1773,1775],{"id":1774},"pointer-receiver-methods-on-unaddressable-values","Pointer-Receiver Methods on Unaddressable Values",[23,1777,1778,2047,2051],{"language":25},[27,1779,1781],{"className":29,"code":1780,"language":25,"meta":31,"style":31},"\u002F\u002F Go auto-takes the address of ADDRESSABLE values when calling pointer methods:\nfunc autoAddr() {\n    c := Counter{}   \u002F\u002F addressable (a variable)\n    c.Inc()          \u002F\u002F ✅ Go auto-takes &c → (&c).Inc()\n    (&c).Inc()       \u002F\u002F explicit, equivalent\n}\n\n\u002F\u002F ❌ Unaddressable values — can't auto-take address:\nfunc unaddressable() {\n    \u002F\u002F Counter{}.Inc()  \u002F\u002F ❌ compile error: cannot take address of literal\n    \u002F\u002F (literals are temporaries — not addressable)\n\n    c := Counter{}\n    c.Inc()  \u002F\u002F ✅ c is a variable (addressable)\n\n    \u002F\u002F Map values are NOT addressable (entries can move during rehashing):\n    m := map[string]Counter{\"a\": {}}\n    \u002F\u002F m[\"a\"].Inc()  \u002F\u002F ❌ compile error: cannot call pointer method on m[\"a\"]\n    \u002F\u002F Fix: copy out, modify, assign back, or store *Counter:\n    v := m[\"a\"]\n    v.Inc()\n    m[\"a\"] = v\n\n    \u002F\u002F Or use map[string]*Counter:\n    m2 := map[string]*Counter{\"a\": {}}\n    m2[\"a\"].Inc()  \u002F\u002F ✅ *Counter is addressable (the pointer, not the map entry)\n}\n",[33,1782,1783,1788,1797,1811,1823,1841,1845,1849,1854,1863,1871,1876,1880,1890,1902,1906,1911,1940,1948,1953,1968,1977,1992,1996,2001,2026,2043],{"__ignoreMap":31},[36,1784,1785],{"class":38,"line":39},[36,1786,1787],{"class":82},"\u002F\u002F Go auto-takes the address of ADDRESSABLE values when calling pointer methods:\n",[36,1789,1790,1792,1795],{"class":38,"line":57},[36,1791,89],{"class":42},[36,1793,1794],{"class":46}," autoAddr",[36,1796,108],{"class":53},[36,1798,1799,1802,1804,1806,1808],{"class":38,"line":66},[36,1800,1801],{"class":53},"    c ",[36,1803,1525],{"class":42},[36,1805,47],{"class":46},[36,1807,905],{"class":53},[36,1809,1810],{"class":82},"\u002F\u002F addressable (a variable)\n",[36,1812,1813,1815,1817,1820],{"class":38,"line":72},[36,1814,205],{"class":53},[36,1816,155],{"class":46},[36,1818,1819],{"class":53},"()          ",[36,1821,1822],{"class":82},"\u002F\u002F ✅ Go auto-takes &c → (&c).Inc()\n",[36,1824,1825,1828,1830,1833,1835,1838],{"class":38,"line":79},[36,1826,1827],{"class":53},"    (",[36,1829,1738],{"class":42},[36,1831,1832],{"class":53},"c).",[36,1834,155],{"class":46},[36,1836,1837],{"class":53},"()       ",[36,1839,1840],{"class":82},"\u002F\u002F explicit, equivalent\n",[36,1842,1843],{"class":38,"line":86},[36,1844,69],{"class":53},[36,1846,1847],{"class":38,"line":111},[36,1848,76],{"emptyLinePlaceholder":75},[36,1850,1851],{"class":38,"line":123},[36,1852,1853],{"class":82},"\u002F\u002F ❌ Unaddressable values — can't auto-take address:\n",[36,1855,1856,1858,1861],{"class":38,"line":128},[36,1857,89],{"class":42},[36,1859,1860],{"class":46}," unaddressable",[36,1862,108],{"class":53},[36,1864,1865,1868],{"class":38,"line":133},[36,1866,1867],{"class":82},"    \u002F\u002F Counter{}.Inc()",[36,1869,1870],{"class":82},"  \u002F\u002F ❌ compile error: cannot take address of literal\n",[36,1872,1873],{"class":38,"line":139},[36,1874,1875],{"class":82},"    \u002F\u002F (literals are temporaries — not addressable)\n",[36,1877,1878],{"class":38,"line":160},[36,1879,76],{"emptyLinePlaceholder":75},[36,1881,1882,1884,1886,1888],{"class":38,"line":170},[36,1883,1801],{"class":53},[36,1885,1525],{"class":42},[36,1887,47],{"class":46},[36,1889,1379],{"class":53},[36,1891,1892,1894,1896,1899],{"class":38,"line":175},[36,1893,205],{"class":53},[36,1895,155],{"class":46},[36,1897,1898],{"class":53},"()  ",[36,1900,1901],{"class":82},"\u002F\u002F ✅ c is a variable (addressable)\n",[36,1903,1904],{"class":38,"line":180},[36,1905,76],{"emptyLinePlaceholder":75},[36,1907,1908],{"class":38,"line":190},[36,1909,1910],{"class":82},"    \u002F\u002F Map values are NOT addressable (entries can move during rehashing):\n",[36,1912,1913,1916,1918,1921,1924,1926,1929,1931,1934,1937],{"class":38,"line":202},[36,1914,1915],{"class":53},"    m ",[36,1917,1525],{"class":42},[36,1919,1920],{"class":42}," map",[36,1922,1923],{"class":53},"[",[36,1925,1401],{"class":42},[36,1927,1928],{"class":53},"]",[36,1930,99],{"class":46},[36,1932,1933],{"class":53},"{",[36,1935,1936],{"class":615},"\"a\"",[36,1938,1939],{"class":53},": {}}\n",[36,1941,1942,1945],{"class":38,"line":213},[36,1943,1944],{"class":82},"    \u002F\u002F m[\"a\"].Inc()",[36,1946,1947],{"class":82},"  \u002F\u002F ❌ compile error: cannot call pointer method on m[\"a\"]\n",[36,1949,1950],{"class":38,"line":228},[36,1951,1952],{"class":82},"    \u002F\u002F Fix: copy out, modify, assign back, or store *Counter:\n",[36,1954,1955,1958,1960,1963,1965],{"class":38,"line":233},[36,1956,1957],{"class":53},"    v ",[36,1959,1525],{"class":42},[36,1961,1962],{"class":53}," m[",[36,1964,1936],{"class":615},[36,1966,1967],{"class":53},"]\n",[36,1969,1970,1973,1975],{"class":38,"line":242},[36,1971,1972],{"class":53},"    v.",[36,1974,155],{"class":46},[36,1976,210],{"class":53},[36,1978,1979,1982,1984,1987,1989],{"class":38,"line":254},[36,1980,1981],{"class":53},"    m[",[36,1983,1936],{"class":615},[36,1985,1986],{"class":53},"] ",[36,1988,883],{"class":42},[36,1990,1991],{"class":53}," v\n",[36,1993,1994],{"class":38,"line":259},[36,1995,76],{"emptyLinePlaceholder":75},[36,1997,1998],{"class":38,"line":264},[36,1999,2000],{"class":82},"    \u002F\u002F Or use map[string]*Counter:\n",[36,2002,2003,2006,2008,2010,2012,2014,2016,2018,2020,2022,2024],{"class":38,"line":270},[36,2004,2005],{"class":53},"    m2 ",[36,2007,1525],{"class":42},[36,2009,1920],{"class":42},[36,2011,1923],{"class":53},[36,2013,1401],{"class":42},[36,2015,1928],{"class":53},[36,2017,148],{"class":42},[36,2019,99],{"class":46},[36,2021,1933],{"class":53},[36,2023,1936],{"class":615},[36,2025,1939],{"class":53},[36,2027,2028,2031,2033,2036,2038,2040],{"class":38,"line":276},[36,2029,2030],{"class":53},"    m2[",[36,2032,1936],{"class":615},[36,2034,2035],{"class":53},"].",[36,2037,155],{"class":46},[36,2039,1898],{"class":53},[36,2041,2042],{"class":82},"\u002F\u002F ✅ *Counter is addressable (the pointer, not the map entry)\n",[36,2044,2045],{"class":38,"line":282},[36,2046,69],{"class":53},[18,2048,2050],{"id":2049},"methods-on-non-struct-types","Methods on Non-Struct Types",[23,2052,2053,2274,2278],{"language":25},[27,2054,2056],{"className":29,"code":2055,"language":25,"meta":31,"style":31},"\u002F\u002F Methods can be on any NAMED type (not on imported types or unnamed types).\n\ntype Celsius float64\n\nfunc (c Celsius) String() string { return fmt.Sprintf(\"%.1f°C\", c) }\nfunc (c Celsius) ToF() Fahrenheit { return Fahrenheit(c*9\u002F5 + 32) }\n\n\u002F\u002F ✅ Named type — methods allowed:\ntype MyInt int\nfunc (m MyInt) IsEven() bool { return m%2 == 0 }\n\n\u002F\u002F ❌ Can't add methods to int (not your type — it's a predeclared type):\n\u002F\u002F func (n int) IsEven() bool { ... }  \u002F\u002F compile error\n\n\u002F\u002F ❌ Can't add methods to []int (unnamed type):\n\u002F\u002F func (s []int) Sum() int { ... }  \u002F\u002F compile error\n\u002F\u002F Fix: name the type first: type IntSlice []int; func (s IntSlice) Sum() int\n",[33,2057,2058,2063,2067,2077,2081,2125,2175,2179,2184,2194,2236,2240,2245,2253,2257,2262,2269],{"__ignoreMap":31},[36,2059,2060],{"class":38,"line":39},[36,2061,2062],{"class":82},"\u002F\u002F Methods can be on any NAMED type (not on imported types or unnamed types).\n",[36,2064,2065],{"class":38,"line":57},[36,2066,76],{"emptyLinePlaceholder":75},[36,2068,2069,2071,2074],{"class":38,"line":66},[36,2070,43],{"class":42},[36,2072,2073],{"class":46}," Celsius",[36,2075,2076],{"class":42}," float64\n",[36,2078,2079],{"class":38,"line":72},[36,2080,76],{"emptyLinePlaceholder":75},[36,2082,2083,2085,2087,2089,2092,2094,2097,2099,2101,2103,2105,2108,2111,2113,2116,2119,2122],{"class":38,"line":79},[36,2084,89],{"class":42},[36,2086,92],{"class":53},[36,2088,96],{"class":95},[36,2090,2091],{"class":46},"Celsius",[36,2093,102],{"class":53},[36,2095,2096],{"class":46},"String",[36,2098,388],{"class":53},[36,2100,1401],{"class":42},[36,2102,394],{"class":53},[36,2104,397],{"class":42},[36,2106,2107],{"class":53}," fmt.",[36,2109,2110],{"class":46},"Sprintf",[36,2112,423],{"class":53},[36,2114,2115],{"class":615},"\"",[36,2117,2118],{"class":643},"%.1f",[36,2120,2121],{"class":615},"°C\"",[36,2123,2124],{"class":53},", c) }\n",[36,2126,2127,2129,2131,2133,2135,2137,2140,2142,2145,2147,2149,2152,2155,2157,2160,2163,2166,2169,2172],{"class":38,"line":86},[36,2128,89],{"class":42},[36,2130,92],{"class":53},[36,2132,96],{"class":95},[36,2134,2091],{"class":46},[36,2136,102],{"class":53},[36,2138,2139],{"class":46},"ToF",[36,2141,388],{"class":53},[36,2143,2144],{"class":46},"Fahrenheit",[36,2146,394],{"class":53},[36,2148,397],{"class":42},[36,2150,2151],{"class":46}," Fahrenheit",[36,2153,2154],{"class":53},"(c",[36,2156,148],{"class":42},[36,2158,2159],{"class":643},"9",[36,2161,2162],{"class":42},"\u002F",[36,2164,2165],{"class":643},"5",[36,2167,2168],{"class":42}," +",[36,2170,2171],{"class":643}," 32",[36,2173,2174],{"class":53},") }\n",[36,2176,2177],{"class":38,"line":111},[36,2178,76],{"emptyLinePlaceholder":75},[36,2180,2181],{"class":38,"line":123},[36,2182,2183],{"class":82},"\u002F\u002F ✅ Named type — methods allowed:\n",[36,2185,2186,2188,2191],{"class":38,"line":128},[36,2187,43],{"class":42},[36,2189,2190],{"class":46}," MyInt",[36,2192,2193],{"class":42}," int\n",[36,2195,2196,2198,2200,2203,2206,2208,2211,2213,2215,2217,2219,2222,2225,2228,2231,2234],{"class":38,"line":133},[36,2197,89],{"class":42},[36,2199,92],{"class":53},[36,2201,2202],{"class":95},"m ",[36,2204,2205],{"class":46},"MyInt",[36,2207,102],{"class":53},[36,2209,2210],{"class":46},"IsEven",[36,2212,388],{"class":53},[36,2214,1118],{"class":42},[36,2216,394],{"class":53},[36,2218,397],{"class":42},[36,2220,2221],{"class":53}," m",[36,2223,2224],{"class":42},"%",[36,2226,2227],{"class":643},"2",[36,2229,2230],{"class":42}," ==",[36,2232,2233],{"class":643}," 0",[36,2235,748],{"class":53},[36,2237,2238],{"class":38,"line":139},[36,2239,76],{"emptyLinePlaceholder":75},[36,2241,2242],{"class":38,"line":160},[36,2243,2244],{"class":82},"\u002F\u002F ❌ Can't add methods to int (not your type — it's a predeclared type):\n",[36,2246,2247,2250],{"class":38,"line":170},[36,2248,2249],{"class":82},"\u002F\u002F func (n int) IsEven() bool { ... }",[36,2251,2252],{"class":82},"  \u002F\u002F compile error\n",[36,2254,2255],{"class":38,"line":175},[36,2256,76],{"emptyLinePlaceholder":75},[36,2258,2259],{"class":38,"line":180},[36,2260,2261],{"class":82},"\u002F\u002F ❌ Can't add methods to []int (unnamed type):\n",[36,2263,2264,2267],{"class":38,"line":190},[36,2265,2266],{"class":82},"\u002F\u002F func (s []int) Sum() int { ... }",[36,2268,2252],{"class":82},[36,2270,2271],{"class":38,"line":202},[36,2272,2273],{"class":82},"\u002F\u002F Fix: name the type first: type IntSlice []int; func (s IntSlice) Sum() int\n",[18,2275,2277],{"id":2276},"production-pattern-builder-with-fluent-api","Production Pattern — Builder with Fluent API",[23,2279,2280,2825,2829,2903,2907,3019,3023],{"language":25},[27,2281,2283],{"className":29,"code":2282,"language":25,"meta":31,"style":31},"type Request struct {\n    method  string\n    url     string\n    headers map[string]string\n    body    []byte\n    timeout time.Duration\n}\n\ntype RequestBuilder struct {\n    req Request\n}\n\n\u002F\u002F Pointer receiver — mutates the builder, returns the builder for chaining:\nfunc (b *RequestBuilder) Method(m string) *RequestBuilder {\n    b.req.method = m\n    return b  \u002F\u002F return the builder for fluent chaining\n}\n\nfunc (b *RequestBuilder) URL(u string) *RequestBuilder {\n    b.req.url = u\n    return b\n}\n\nfunc (b *RequestBuilder) Header(k, v string) *RequestBuilder {\n    if b.req.headers == nil {\n        b.req.headers = make(map[string]string)\n    }\n    b.req.headers[k] = v\n    return b\n}\n\nfunc (b *RequestBuilder) Timeout(d time.Duration) *RequestBuilder {\n    b.req.timeout = d\n    return b\n}\n\nfunc (b *RequestBuilder) Build() Request {\n    return b.req\n}\n\n\u002F\u002F Usage — fluent, readable, type-safe:\nreq := (&RequestBuilder{}).\n    Method(\"POST\").\n    URL(\"https:\u002F\u002Fapi.example.com\u002Fusers\").\n    Header(\"Content-Type\", \"application\u002Fjson\").\n    Header(\"Authorization\", \"Bearer \"+token).\n    Timeout(30 * time.Second).\n    Build()\n",[33,2284,2285,2296,2304,2311,2327,2335,2349,2353,2357,2368,2376,2380,2384,2389,2423,2433,2443,2447,2451,2483,2493,2500,2504,2508,2546,2559,2583,2587,2596,2602,2606,2610,2648,2658,2664,2668,2672,2696,2703,2707,2711,2717,2734,2748,2761,2779,2800,2817],{"__ignoreMap":31},[36,2286,2287,2289,2292,2294],{"class":38,"line":39},[36,2288,43],{"class":42},[36,2290,2291],{"class":46}," Request",[36,2293,50],{"class":42},[36,2295,54],{"class":53},[36,2297,2298,2301],{"class":38,"line":57},[36,2299,2300],{"class":53},"    method  ",[36,2302,2303],{"class":42},"string\n",[36,2305,2306,2309],{"class":38,"line":66},[36,2307,2308],{"class":53},"    url     ",[36,2310,2303],{"class":42},[36,2312,2313,2316,2319,2321,2323,2325],{"class":38,"line":72},[36,2314,2315],{"class":53},"    headers ",[36,2317,2318],{"class":42},"map",[36,2320,1923],{"class":53},[36,2322,1401],{"class":42},[36,2324,1928],{"class":53},[36,2326,2303],{"class":42},[36,2328,2329,2332],{"class":38,"line":79},[36,2330,2331],{"class":53},"    body    []",[36,2333,2334],{"class":42},"byte\n",[36,2336,2337,2340,2343,2346],{"class":38,"line":86},[36,2338,2339],{"class":53},"    timeout ",[36,2341,2342],{"class":46},"time",[36,2344,2345],{"class":53},".",[36,2347,2348],{"class":46},"Duration\n",[36,2350,2351],{"class":38,"line":111},[36,2352,69],{"class":53},[36,2354,2355],{"class":38,"line":123},[36,2356,76],{"emptyLinePlaceholder":75},[36,2358,2359,2361,2364,2366],{"class":38,"line":128},[36,2360,43],{"class":42},[36,2362,2363],{"class":46}," RequestBuilder",[36,2365,50],{"class":42},[36,2367,54],{"class":53},[36,2369,2370,2373],{"class":38,"line":133},[36,2371,2372],{"class":53},"    req ",[36,2374,2375],{"class":46},"Request\n",[36,2377,2378],{"class":38,"line":139},[36,2379,69],{"class":53},[36,2381,2382],{"class":38,"line":160},[36,2383,76],{"emptyLinePlaceholder":75},[36,2385,2386],{"class":38,"line":170},[36,2387,2388],{"class":82},"\u002F\u002F Pointer receiver — mutates the builder, returns the builder for chaining:\n",[36,2390,2391,2393,2395,2397,2399,2402,2404,2407,2409,2412,2415,2417,2419,2421],{"class":38,"line":175},[36,2392,89],{"class":42},[36,2394,92],{"class":53},[36,2396,1388],{"class":95},[36,2398,148],{"class":42},[36,2400,2401],{"class":46},"RequestBuilder",[36,2403,102],{"class":53},[36,2405,2406],{"class":46},"Method",[36,2408,423],{"class":53},[36,2410,2411],{"class":95},"m",[36,2413,2414],{"class":42}," string",[36,2416,102],{"class":53},[36,2418,148],{"class":42},[36,2420,2401],{"class":46},[36,2422,54],{"class":53},[36,2424,2425,2428,2430],{"class":38,"line":180},[36,2426,2427],{"class":53},"    b.req.method ",[36,2429,883],{"class":42},[36,2431,2432],{"class":53}," m\n",[36,2434,2435,2437,2440],{"class":38,"line":190},[36,2436,640],{"class":42},[36,2438,2439],{"class":53}," b  ",[36,2441,2442],{"class":82},"\u002F\u002F return the builder for fluent chaining\n",[36,2444,2445],{"class":38,"line":202},[36,2446,69],{"class":53},[36,2448,2449],{"class":38,"line":213},[36,2450,76],{"emptyLinePlaceholder":75},[36,2452,2453,2455,2457,2459,2461,2463,2465,2468,2470,2473,2475,2477,2479,2481],{"class":38,"line":228},[36,2454,89],{"class":42},[36,2456,92],{"class":53},[36,2458,1388],{"class":95},[36,2460,148],{"class":42},[36,2462,2401],{"class":46},[36,2464,102],{"class":53},[36,2466,2467],{"class":46},"URL",[36,2469,423],{"class":53},[36,2471,2472],{"class":95},"u",[36,2474,2414],{"class":42},[36,2476,102],{"class":53},[36,2478,148],{"class":42},[36,2480,2401],{"class":46},[36,2482,54],{"class":53},[36,2484,2485,2488,2490],{"class":38,"line":233},[36,2486,2487],{"class":53},"    b.req.url ",[36,2489,883],{"class":42},[36,2491,2492],{"class":53}," u\n",[36,2494,2495,2497],{"class":38,"line":242},[36,2496,640],{"class":42},[36,2498,2499],{"class":53}," b\n",[36,2501,2502],{"class":38,"line":254},[36,2503,69],{"class":53},[36,2505,2506],{"class":38,"line":259},[36,2507,76],{"emptyLinePlaceholder":75},[36,2509,2510,2512,2514,2516,2518,2520,2522,2525,2527,2530,2533,2536,2538,2540,2542,2544],{"class":38,"line":264},[36,2511,89],{"class":42},[36,2513,92],{"class":53},[36,2515,1388],{"class":95},[36,2517,148],{"class":42},[36,2519,2401],{"class":46},[36,2521,102],{"class":53},[36,2523,2524],{"class":46},"Header",[36,2526,423],{"class":53},[36,2528,2529],{"class":95},"k",[36,2531,2532],{"class":53},", ",[36,2534,2535],{"class":95},"v",[36,2537,2414],{"class":42},[36,2539,102],{"class":53},[36,2541,148],{"class":42},[36,2543,2401],{"class":46},[36,2545,54],{"class":53},[36,2547,2548,2550,2553,2555,2557],{"class":38,"line":270},[36,2549,590],{"class":42},[36,2551,2552],{"class":53}," b.req.headers ",[36,2554,1130],{"class":42},[36,2556,816],{"class":643},[36,2558,54],{"class":53},[36,2560,2561,2564,2566,2569,2571,2573,2575,2577,2579,2581],{"class":38,"line":276},[36,2562,2563],{"class":53},"        b.req.headers ",[36,2565,883],{"class":42},[36,2567,2568],{"class":46}," make",[36,2570,423],{"class":53},[36,2572,2318],{"class":42},[36,2574,1923],{"class":53},[36,2576,1401],{"class":42},[36,2578,1928],{"class":53},[36,2580,1401],{"class":42},[36,2582,619],{"class":53},[36,2584,2585],{"class":38,"line":282},[36,2586,624],{"class":53},[36,2588,2589,2592,2594],{"class":38,"line":288},[36,2590,2591],{"class":53},"    b.req.headers[k] ",[36,2593,883],{"class":42},[36,2595,1991],{"class":53},[36,2597,2598,2600],{"class":38,"line":294},[36,2599,640],{"class":42},[36,2601,2499],{"class":53},[36,2603,2604],{"class":38,"line":300},[36,2605,69],{"class":53},[36,2607,2608],{"class":38,"line":306},[36,2609,76],{"emptyLinePlaceholder":75},[36,2611,2612,2614,2616,2618,2620,2622,2624,2627,2629,2632,2635,2637,2640,2642,2644,2646],{"class":38,"line":312},[36,2613,89],{"class":42},[36,2615,92],{"class":53},[36,2617,1388],{"class":95},[36,2619,148],{"class":42},[36,2621,2401],{"class":46},[36,2623,102],{"class":53},[36,2625,2626],{"class":46},"Timeout",[36,2628,423],{"class":53},[36,2630,2631],{"class":95},"d",[36,2633,2634],{"class":46}," time",[36,2636,2345],{"class":53},[36,2638,2639],{"class":46},"Duration",[36,2641,102],{"class":53},[36,2643,148],{"class":42},[36,2645,2401],{"class":46},[36,2647,54],{"class":53},[36,2649,2650,2653,2655],{"class":38,"line":1003},[36,2651,2652],{"class":53},"    b.req.timeout ",[36,2654,883],{"class":42},[36,2656,2657],{"class":53}," d\n",[36,2659,2660,2662],{"class":38,"line":1329},[36,2661,640],{"class":42},[36,2663,2499],{"class":53},[36,2665,2666],{"class":38,"line":1340},[36,2667,69],{"class":53},[36,2669,2670],{"class":38,"line":1714},[36,2671,76],{"emptyLinePlaceholder":75},[36,2673,2674,2676,2678,2680,2682,2684,2686,2689,2691,2694],{"class":38,"line":1719},[36,2675,89],{"class":42},[36,2677,92],{"class":53},[36,2679,1388],{"class":95},[36,2681,148],{"class":42},[36,2683,2401],{"class":46},[36,2685,102],{"class":53},[36,2687,2688],{"class":46},"Build",[36,2690,388],{"class":53},[36,2692,2693],{"class":46},"Request",[36,2695,54],{"class":53},[36,2697,2698,2700],{"class":38,"line":1725},[36,2699,640],{"class":42},[36,2701,2702],{"class":53}," b.req\n",[36,2704,2705],{"class":38,"line":1752},[36,2706,69],{"class":53},[36,2708,2709],{"class":38,"line":1769},[36,2710,76],{"emptyLinePlaceholder":75},[36,2712,2714],{"class":38,"line":2713},41,[36,2715,2716],{"class":82},"\u002F\u002F Usage — fluent, readable, type-safe:\n",[36,2718,2720,2723,2725,2727,2729,2731],{"class":38,"line":2719},42,[36,2721,2722],{"class":53},"req ",[36,2724,1525],{"class":42},[36,2726,92],{"class":53},[36,2728,1738],{"class":42},[36,2730,2401],{"class":46},[36,2732,2733],{"class":53},"{}).\n",[36,2735,2737,2740,2742,2745],{"class":38,"line":2736},43,[36,2738,2739],{"class":46},"    Method",[36,2741,423],{"class":53},[36,2743,2744],{"class":615},"\"POST\"",[36,2746,2747],{"class":53},").\n",[36,2749,2751,2754,2756,2759],{"class":38,"line":2750},44,[36,2752,2753],{"class":46},"    URL",[36,2755,423],{"class":53},[36,2757,2758],{"class":615},"\"https:\u002F\u002Fapi.example.com\u002Fusers\"",[36,2760,2747],{"class":53},[36,2762,2764,2767,2769,2772,2774,2777],{"class":38,"line":2763},45,[36,2765,2766],{"class":46},"    Header",[36,2768,423],{"class":53},[36,2770,2771],{"class":615},"\"Content-Type\"",[36,2773,2532],{"class":53},[36,2775,2776],{"class":615},"\"application\u002Fjson\"",[36,2778,2747],{"class":53},[36,2780,2782,2784,2786,2789,2791,2794,2797],{"class":38,"line":2781},46,[36,2783,2766],{"class":46},[36,2785,423],{"class":53},[36,2787,2788],{"class":615},"\"Authorization\"",[36,2790,2532],{"class":53},[36,2792,2793],{"class":615},"\"Bearer \"",[36,2795,2796],{"class":42},"+",[36,2798,2799],{"class":53},"token).\n",[36,2801,2803,2806,2808,2811,2814],{"class":38,"line":2802},47,[36,2804,2805],{"class":46},"    Timeout",[36,2807,423],{"class":53},[36,2809,2810],{"class":643},"30",[36,2812,2813],{"class":42}," *",[36,2815,2816],{"class":53}," time.Second).\n",[36,2818,2820,2823],{"class":38,"line":2819},48,[36,2821,2822],{"class":46},"    Build",[36,2824,210],{"class":53},[18,2826,2828],{"id":2827},"tips-tricks","💡 Tips & Tricks",[2830,2831,2832,2840,2854,2863,2879,2897],"ul",{},[2833,2834,2835,2839],"li",{},[2836,2837,2838],"strong",{},"Idiom",": consistent receivers — if ANY method has a pointer receiver, ALL methods should. Mixing causes method-set confusion (a value doesn't satisfy interfaces requiring pointer-receiver methods) and is flagged by linters.",[2833,2841,2842,2844,2845,2532,2848,2532,2851,2853],{},[2836,2843,2838],{},": use value receivers for small, immutable types (",[33,2846,2847],{},"Point",[33,2849,2850],{},"Time",[33,2852,2091],{},") — copies are cheap and immutability is a feature. Use pointer receivers for large structs or when mutation is needed.",[2833,2855,2856,2858,2859,2862],{},[2836,2857,2838],{},": nil receiver methods enable the null-object pattern — ",[33,2860,2861],{},"func (t *Tree) Find(x int) bool { if t == nil { return false }; ... }",". This eliminates nil-checking at every call site, making tree traversal code clean.",[2833,2864,2865,2867,2868,2532,2871,2874,2875,2878],{},[2836,2866,2838],{},": receiver names should be short and consistent — ",[33,2869,2870],{},"func (c Circle) Area()",[33,2872,2873],{},"func (c *Circle) Scale()",". Use the same receiver name across all methods of a type. ",[33,2876,2877],{},"gofmt"," aligns them.",[2833,2880,2881,2884,2885,2888,2889,2892,2893,2896],{},[2836,2882,2883],{},"Debug",": ",[33,2886,2887],{},"var i Interface = T{}"," failing with \"does not implement Interface (method X has pointer receiver)\" means a method is on ",[33,2890,2891],{},"*T"," but you're using a value — use ",[33,2894,2895],{},"&T{}"," or change the receiver to value.",[2833,2898,2899,2902],{},[2836,2900,2901],{},"Performance",": value receivers copy the receiver — for large structs, this is expensive. For small structs (≤ 64 bytes), the copy is cheaper than the pointer indirection (cache locality, no escape).",[18,2904,2906],{"id":2905},"️-edge-cases-gotchas","⚠️ Edge Cases & Gotchas",[2830,2908,2909,2922,2934,2940,2956,2962,2980,2989],{},[2833,2910,2911,2884,2914,2917,2918,2921],{},[2836,2912,2913],{},"Value receiver can't mutate",[33,2915,2916],{},"func (c Circle) Scale()"," modifies a copy — the original is unchanged. Use ",[33,2919,2920],{},"*Circle"," for mutation.",[2833,2923,2924,2884,2927,2930,2931,2345],{},[2836,2925,2926],{},"Pointer receiver on unaddressable value",[33,2928,2929],{},"Counter{}.Inc()"," (pointer receiver) fails — the literal isn't addressable. Use a variable: ",[33,2932,2933],{},"c := Counter{}; c.Inc()",[2833,2935,2936,2939],{},[2836,2937,2938],{},"Method set and interfaces",": a value type doesn't satisfy interfaces requiring pointer-receiver methods. This is the most common \"doesn't implement interface\" confusion.",[2833,2941,2942,2884,2945,2948,2949,2951,2952,2955],{},[2836,2943,2944],{},"Pointer-receiver method on map value",[33,2946,2947],{},"m[key].Method()"," fails if ",[33,2950,2406],{}," is pointer-receiver (map values aren't addressable). Use ",[33,2953,2954],{},"map[K]*V"," or copy-out-modify-assign-back.",[2833,2957,2958,2961],{},[2836,2959,2960],{},"No virtual dispatch",": shadowing a promoted method is resolved at compile time by the static type, not at runtime. This differs from Java\u002FC++ virtual methods.",[2833,2963,2964,2884,2967,2970,2971,2532,2973,2975,2976,2979],{},[2836,2965,2966],{},"Methods on non-struct named types",[33,2968,2969],{},"type MyInt int; func (m MyInt) IsEven() bool"," — works. But not on predeclared types (",[33,2972,1256],{},[33,2974,1401],{},") or unnamed types (",[33,2977,2978],{},"[]int",").",[2833,2981,2982,2985,2986,2988],{},[2836,2983,2984],{},"Nil receiver panic on value receiver",": a value-receiver method called on a nil ",[33,2987,2891],{}," panics (Go tries to dereference nil to copy the value). Only pointer-receiver methods can handle nil.",[2833,2990,2991,2884,3001,3004,3005,3008,3009,3012,3013,3015,3016,3018],{},[2836,2992,2993,2996,2997,3000],{},[33,2994,2995],{},"fmt"," doesn't call ",[33,2998,2999],{},"String()"," on nested values",[33,3002,3003],{},"fmt.Println(map[int]User{})"," prints ",[33,3006,3007],{},"map[1:{Alice}]",", not ",[33,3010,3011],{},"User: Alice"," — ",[33,3014,2995],{}," calls ",[33,3017,2999],{}," on the top-level value, not on elements inside containers.",[18,3020,3022],{"id":3021},"quick-quiz","🧠 Quick Quiz",[23,3024,3025,3150],{"language":25},[27,3026,3028],{"className":29,"code":3027,"language":25,"meta":31,"style":31},"type Counter struct{ n int }\nfunc (c Counter) Value() int { return c.n }\nfunc (c *Counter) Inc() { c.n++ }\n\nfunc main() {\n    c := Counter{}\n    c.Inc()\n    c.Inc()\n    fmt.Println(c.Value())\n}\n",[33,3029,3030,3045,3070,3093,3097,3106,3116,3124,3132,3146],{"__ignoreMap":31},[36,3031,3032,3034,3036,3038,3041,3043],{"class":38,"line":39},[36,3033,43],{"class":42},[36,3035,47],{"class":46},[36,3037,50],{"class":42},[36,3039,3040],{"class":53},"{ n ",[36,3042,1256],{"class":42},[36,3044,748],{"class":53},[36,3046,3047,3049,3051,3053,3055,3057,3059,3061,3063,3065,3067],{"class":38,"line":57},[36,3048,89],{"class":42},[36,3050,92],{"class":53},[36,3052,96],{"class":95},[36,3054,99],{"class":46},[36,3056,102],{"class":53},[36,3058,1274],{"class":46},[36,3060,388],{"class":53},[36,3062,1256],{"class":42},[36,3064,394],{"class":53},[36,3066,397],{"class":42},[36,3068,3069],{"class":53}," c.n }\n",[36,3071,3072,3074,3076,3078,3080,3082,3084,3086,3089,3091],{"class":38,"line":66},[36,3073,89],{"class":42},[36,3075,92],{"class":53},[36,3077,96],{"class":95},[36,3079,148],{"class":42},[36,3081,99],{"class":46},[36,3083,102],{"class":53},[36,3085,155],{"class":46},[36,3087,3088],{"class":53},"() { c.n",[36,3090,117],{"class":42},[36,3092,748],{"class":53},[36,3094,3095],{"class":38,"line":72},[36,3096,76],{"emptyLinePlaceholder":75},[36,3098,3099,3101,3104],{"class":38,"line":79},[36,3100,89],{"class":42},[36,3102,3103],{"class":46}," main",[36,3105,108],{"class":53},[36,3107,3108,3110,3112,3114],{"class":38,"line":86},[36,3109,1801],{"class":53},[36,3111,1525],{"class":42},[36,3113,47],{"class":46},[36,3115,1379],{"class":53},[36,3117,3118,3120,3122],{"class":38,"line":111},[36,3119,205],{"class":53},[36,3121,155],{"class":46},[36,3123,210],{"class":53},[36,3125,3126,3128,3130],{"class":38,"line":123},[36,3127,205],{"class":53},[36,3129,155],{"class":46},[36,3131,210],{"class":53},[36,3133,3134,3136,3138,3141,3143],{"class":38,"line":128},[36,3135,216],{"class":53},[36,3137,219],{"class":46},[36,3139,3140],{"class":53},"(c.",[36,3142,1274],{"class":46},[36,3144,3145],{"class":53},"())\n",[36,3147,3148],{"class":38,"line":133},[36,3149,69],{"class":53},[14,3151,3152],{},"What's printed?",[3154,3155,3156,3160,3168,3197,3210],"details",{},[3157,3158,3159],"summary",{},"Answer",[27,3161,3166],{"className":3162,"code":3164,"language":3165},[3163],"language-text","2\n","text",[33,3167,3164],{"__ignoreMap":31},[14,3169,3170,3171,3174,3175,3178,3179,3182,3183,3186,3187,3190,3191,3193,3194,3196],{},"Even though ",[33,3172,3173],{},"Value()"," has a value receiver and ",[33,3176,3177],{},"Inc()"," has a pointer receiver, ",[33,3180,3181],{},"c.Inc()"," works because ",[33,3184,3185],{},"c"," is an addressable variable — Go auto-takes ",[33,3188,3189],{},"&c"," for the pointer-receiver method call. Both ",[33,3192,3177],{}," calls modify the original ",[33,3195,3185],{}," via the pointer.",[14,3198,3199,3202,3203,3205,3206,3209],{},[33,3200,3201],{},"c.Value()"," copies ",[33,3204,3185],{}," (value receiver) and returns ",[33,3207,3208],{},"c.n"," = 2.",[14,3211,3212,3213,3216,3217,3219,3220,3223,3224,3226],{},"This compiles and works, but ",[2836,3214,3215],{},"mixing receivers is an anti-pattern"," — it causes confusion with interface satisfaction and is flagged by linters. The consistent fix: make ",[33,3218,3173],{}," a pointer receiver too (",[33,3221,3222],{},"func (c *Counter) Value() int","), since ",[33,3225,3177],{}," already requires a pointer receiver.",[18,3228,3230],{"id":3229},"whats-next","📚 What's Next",[14,3232,3233,3234,3239],{},"→ ",[3235,3236,3238],"a",{"href":3237},"\u002Fgo\u002F12-interfaces","12 — Interfaces"," — implicit satisfaction, the nil interface trap, interface internals, and the \"accept interfaces, return structs\" idiom.",[3241,3242,3243],"style",{},"html pre.shiki code .svdQ7, html code.shiki .svdQ7{--shiki-default:#D73A49;--shiki-github-dark:#F97583}html pre.shiki code .sIsaT, html code.shiki .sIsaT{--shiki-default:#6F42C1;--shiki-github-dark:#B392F0}html pre.shiki code .ssxIu, html code.shiki .ssxIu{--shiki-default:#24292E;--shiki-github-dark:#E1E4E8}html pre.shiki code .sdCPZ, html code.shiki .sdCPZ{--shiki-default:#6A737D;--shiki-github-dark:#6A737D}html pre.shiki code .sCrzJ, html code.shiki .sCrzJ{--shiki-default:#E36209;--shiki-github-dark:#FFAB70}html .default .shiki span {color: var(--shiki-default);background: var(--shiki-default-bg);font-style: var(--shiki-default-font-style);font-weight: var(--shiki-default-font-weight);text-decoration: var(--shiki-default-text-decoration);}html .shiki span {color: var(--shiki-default);background: var(--shiki-default-bg);font-style: var(--shiki-default-font-style);font-weight: var(--shiki-default-font-weight);text-decoration: var(--shiki-default-text-decoration);}html .github-dark .shiki span {color: var(--shiki-github-dark);background: var(--shiki-github-dark-bg);font-style: var(--shiki-github-dark-font-style);font-weight: var(--shiki-github-dark-font-weight);text-decoration: var(--shiki-github-dark-text-decoration);}html.github-dark .shiki span {color: var(--shiki-github-dark);background: var(--shiki-github-dark-bg);font-style: var(--shiki-github-dark-font-style);font-weight: var(--shiki-github-dark-font-weight);text-decoration: var(--shiki-github-dark-text-decoration);}html pre.shiki code .sJ6F3, html code.shiki .sJ6F3{--shiki-default:#032F62;--shiki-github-dark:#9ECBFF}html pre.shiki code .snvgF, html code.shiki .snvgF{--shiki-default:#005CC5;--shiki-github-dark:#79B8FF}",{"title":31,"searchDepth":57,"depth":57,"links":3245},[3246,3247,3248],{"id":20,"depth":57,"text":21},{"id":318,"depth":57,"text":319},{"id":3229,"depth":57,"text":3230},"Value vs pointer receiver semantics, method-set rules for interface satisfaction, nil receiver methods, embedding promotion, and the consistency rule.","md",{},"\u002Fgo\u002F11-methods-and-receivers",{"title":5,"description":3249},"go\u002F11-methods-and-receivers","VAH2qCnW1Gdyjp0IgVQzDrWCq_4uiRm1FFeP4PY3P0M",1789924648475]