[{"data":1,"prerenderedAt":3030},["ShallowReactive",2],{"navigation_docs":3,"-fundamentals-generics":377,"-fundamentals-generics-surround":3025},[4,39,114,144,184,244,293,362],{"title":5,"icon":6,"path":7,"stem":8,"children":9,"page":6},"Getting Started",false,"\u002Fgetting-started","1.getting-started",[10,15,20,25,30,35],{"title":11,"path":12,"stem":13,"icon":14},"Learning Path","\u002Fgetting-started\u002Flearning-path","1.getting-started\u002F1.learning-path","i-lucide-map",{"title":16,"path":17,"stem":18,"icon":19},"Introduction","\u002Fgetting-started\u002Fintroduction","1.getting-started\u002F2.introduction","i-lucide-house",{"title":21,"path":22,"stem":23,"icon":24},"Installation","\u002Fgetting-started\u002Finstallation","1.getting-started\u002F3.installation","i-lucide-download",{"title":26,"path":27,"stem":28,"icon":29},"Your First Program","\u002Fgetting-started\u002Ffirst-program","1.getting-started\u002F4.first-program","i-lucide-play",{"title":31,"path":32,"stem":33,"icon":34},"Modules and Dependencies","\u002Fgetting-started\u002Fmodules-and-dependencies","1.getting-started\u002F5.modules-and-dependencies","i-lucide-package-open",{"title":36,"path":37,"stem":38,"icon":34},"Advanced Modules","\u002Fgetting-started\u002Fadvanced-modules","1.getting-started\u002F6.advanced-modules",{"title":40,"path":41,"stem":42,"children":43,"page":6},"Fundamentals","\u002Ffundamentals","2.fundamentals",[44,49,54,59,64,69,74,79,84,89,94,99,104,109],{"title":45,"path":46,"stem":47,"icon":48},"Program Structure","\u002Ffundamentals\u002Fprogram-structure","2.fundamentals\u002F1.program-structure","i-lucide-workflow",{"title":50,"path":51,"stem":52,"icon":53},"Structs and Methods","\u002Ffundamentals\u002Fstructs-and-methods","2.fundamentals\u002F10.structs-and-methods","i-lucide-box",{"title":55,"path":56,"stem":57,"icon":58},"Interfaces","\u002Ffundamentals\u002Finterfaces","2.fundamentals\u002F11.interfaces","i-lucide-plug",{"title":60,"path":61,"stem":62,"icon":63},"Error Handling","\u002Ffundamentals\u002Ferrors","2.fundamentals\u002F12.errors","i-lucide-triangle-alert",{"title":65,"path":66,"stem":67,"icon":68},"Defined Types and Type Aliases","\u002Ffundamentals\u002Fdefined-types","2.fundamentals\u002F13.defined-types","i-lucide-tags",{"title":70,"path":71,"stem":72,"icon":73},"Generics","\u002Ffundamentals\u002Fgenerics","2.fundamentals\u002F14.generics","i-lucide-blocks",{"title":75,"path":76,"stem":77,"icon":78},"Project Structure","\u002Ffundamentals\u002Fproject-structure","2.fundamentals\u002F2.project-structure","i-lucide-folder-tree",{"title":80,"path":81,"stem":82,"icon":83},"Project Layout","\u002Ffundamentals\u002Fproject-layout","2.fundamentals\u002F3.project-layout","i-lucide-layout",{"title":85,"path":86,"stem":87,"icon":88},"Variables and Data Types","\u002Ffundamentals\u002Fvariables-and-types","2.fundamentals\u002F4.variables-and-types","i-lucide-variable",{"title":90,"path":91,"stem":92,"icon":93},"Functions","\u002Ffundamentals\u002Ffunctions","2.fundamentals\u002F5.functions","i-lucide-braces",{"title":95,"path":96,"stem":97,"icon":98},"Control Statements","\u002Ffundamentals\u002Fcontrol-statements","2.fundamentals\u002F6.control-statements","i-lucide-git-branch",{"title":100,"path":101,"stem":102,"icon":103},"Pointers","\u002Ffundamentals\u002Fpointers","2.fundamentals\u002F7.pointers","i-lucide-mouse-pointer-2",{"title":105,"path":106,"stem":107,"icon":108},"Arrays and Slices","\u002Ffundamentals\u002Farrays-and-slices","2.fundamentals\u002F8.arrays-and-slices","i-lucide-list",{"title":110,"path":111,"stem":112,"icon":113},"Maps","\u002Ffundamentals\u002Fmaps","2.fundamentals\u002F9.maps","i-lucide-table-properties",{"title":115,"path":116,"stem":117,"children":118,"page":6},"Concurrency","\u002Fconcurrency","3.concurrency",[119,124,129,134,139],{"title":120,"path":121,"stem":122,"icon":123},"Concurrency Model","\u002Fconcurrency\u002Fconcurrency-model","3.concurrency\u002F1.concurrency-model","i-lucide-network",{"title":125,"path":126,"stem":127,"icon":128},"Goroutines","\u002Fconcurrency\u002Fgoroutines","3.concurrency\u002F2.goroutines","i-lucide-git-fork",{"title":130,"path":131,"stem":132,"icon":133},"Channels","\u002Fconcurrency\u002Fchannels","3.concurrency\u002F3.channels","i-lucide-arrow-left-right",{"title":135,"path":136,"stem":137,"icon":138},"Select and Cancellation","\u002Fconcurrency\u002Fselect-and-cancellation","3.concurrency\u002F4.select-and-cancellation","i-lucide-circle-stop",{"title":140,"path":141,"stem":142,"icon":143},"Synchronization","\u002Fconcurrency\u002Fsynchronization","3.concurrency\u002F5.synchronization","i-lucide-lock-keyhole",{"title":145,"path":146,"stem":147,"children":148,"page":6},"Standard Library","\u002Fstandard-library","4.standard-library",[149,154,159,164,169,174,179],{"title":150,"path":151,"stem":152,"icon":153},"Standard Library Overview","\u002Fstandard-library\u002Foverview","4.standard-library\u002F1.overview","i-lucide-library",{"title":155,"path":156,"stem":157,"icon":158},"Text and Formatting","\u002Fstandard-library\u002Ftext-and-formatting","4.standard-library\u002F2.text-and-formatting","i-lucide-text",{"title":160,"path":161,"stem":162,"icon":163},"Files and JSON","\u002Fstandard-library\u002Ffiles-and-json","4.standard-library\u002F3.files-and-json","i-lucide-file-json",{"title":165,"path":166,"stem":167,"icon":168},"HTTP Clients and Servers","\u002Fstandard-library\u002Fhttp","4.standard-library\u002F4.http","i-lucide-server",{"title":170,"path":171,"stem":172,"icon":173},"Testing","\u002Fstandard-library\u002Ftesting","4.standard-library\u002F5.testing","i-lucide-flask-conical",{"title":175,"path":176,"stem":177,"icon":178},"Command-Line Tools and Configuration","\u002Fstandard-library\u002Fcommand-line-and-configuration","4.standard-library\u002F6.command-line-and-configuration","i-lucide-terminal-square",{"title":180,"path":181,"stem":182,"icon":183},"Structured Logging","\u002Fstandard-library\u002Fstructured-logging","4.standard-library\u002F7.structured-logging","i-lucide-scroll-text",{"title":185,"path":186,"stem":187,"children":188,"page":6},"Backend Development","\u002Fbackend-development","5.backend-development",[189,194,199,204,209,214,219,224,229,234,239],{"title":190,"path":191,"stem":192,"icon":193},"Backend Roadmap","\u002Fbackend-development\u002Fbackend-roadmap","5.backend-development\u002F1.backend-roadmap","i-lucide-route",{"title":195,"path":196,"stem":197,"icon":198},"Graceful Shutdown","\u002Fbackend-development\u002Fgraceful-shutdown","5.backend-development\u002F10.graceful-shutdown","i-lucide-power",{"title":200,"path":201,"stem":202,"icon":203},"Production Checklist","\u002Fbackend-development\u002Fproduction-checklist","5.backend-development\u002F11.production-checklist","i-lucide-clipboard-check",{"title":205,"path":206,"stem":207,"icon":208},"HTTP API Design","\u002Fbackend-development\u002Fhttp-api-design","5.backend-development\u002F2.http-api-design","i-lucide-waypoints",{"title":210,"path":211,"stem":212,"icon":213},"Middleware","\u002Fbackend-development\u002Fmiddleware","5.backend-development\u002F3.middleware","i-lucide-layers-3",{"title":215,"path":216,"stem":217,"icon":218},"Validation","\u002Fbackend-development\u002Fvalidation","5.backend-development\u002F4.validation","i-lucide-list-checks",{"title":220,"path":221,"stem":222,"icon":223},"Application Wiring","\u002Fbackend-development\u002Fapplication-wiring","5.backend-development\u002F5.application-wiring","i-lucide-cable",{"title":225,"path":226,"stem":227,"icon":228},"Observability","\u002Fbackend-development\u002Fobservability","5.backend-development\u002F6.observability","i-lucide-activity",{"title":230,"path":231,"stem":232,"icon":233},"Database SQL","\u002Fbackend-development\u002Fdatabase-sql","5.backend-development\u002F7.database-sql","i-lucide-database",{"title":235,"path":236,"stem":237,"icon":238},"Transactions","\u002Fbackend-development\u002Ftransactions","5.backend-development\u002F8.transactions","i-lucide-repeat-2",{"title":240,"path":241,"stem":242,"icon":243},"Authentication and Authorization","\u002Fbackend-development\u002Fauthentication","5.backend-development\u002F9.authentication","i-lucide-shield-check",{"title":245,"path":246,"stem":247,"children":248,"page":6},"Advanced Go","\u002Fadvanced-go","6.advanced-go",[249,254,259,264,269,274,278,283,288],{"title":250,"path":251,"stem":252,"icon":253},"Advanced Go Roadmap","\u002Fadvanced-go\u002Fadvanced-roadmap","6.advanced-go\u002F1.advanced-roadmap","i-lucide-brain-circuit",{"title":255,"path":256,"stem":257,"icon":258},"Reflection","\u002Fadvanced-go\u002Freflection","6.advanced-go\u002F2.reflection","i-lucide-scan-search",{"title":260,"path":261,"stem":262,"icon":263},"Memory and Garbage Collection","\u002Fadvanced-go\u002Fmemory-and-garbage-collection","6.advanced-go\u002F3.memory-and-garbage-collection","i-lucide-memory-stick",{"title":265,"path":266,"stem":267,"icon":268},"Benchmarking and Profiling","\u002Fadvanced-go\u002Fbenchmarking-and-profiling","6.advanced-go\u002F4.benchmarking-and-profiling","i-lucide-gauge",{"title":270,"path":271,"stem":272,"icon":273},"Advanced Testing and Fuzzing","\u002Fadvanced-go\u002Fadvanced-testing-and-fuzzing","6.advanced-go\u002F5.advanced-testing-and-fuzzing","i-lucide-microscope",{"title":275,"path":276,"stem":277,"icon":48},"Advanced Concurrency","\u002Fadvanced-go\u002Fadvanced-concurrency","6.advanced-go\u002F6.advanced-concurrency",{"title":279,"path":280,"stem":281,"icon":282},"Unsafe and C Boundaries","\u002Fadvanced-go\u002Funsafe-and-cgo","6.advanced-go\u002F7.unsafe-and-cgo","i-lucide-radiation",{"title":284,"path":285,"stem":286,"icon":287},"Package and API Design","\u002Fadvanced-go\u002Fpackage-and-api-design","6.advanced-go\u002F8.package-and-api-design","i-lucide-boxes",{"title":289,"path":290,"stem":291,"icon":292},"Distributed Reliability","\u002Fadvanced-go\u002Fdistributed-reliability","6.advanced-go\u002F9.distributed-reliability","i-lucide-cloud-cog",{"title":294,"path":295,"stem":296,"children":297,"page":6},"Projects","\u002Fprojects","7.projects",[298,316,332,347],{"title":299,"path":300,"stem":301,"children":302,"icon":305},"CLI Task Manager","\u002Fprojects\u002Fcli-task-manager","7.projects\u002F1.cli-task-manager\u002Findex",[303,306,311],{"title":304,"path":300,"stem":301,"icon":305},"Project — CLI Task Manager","i-lucide-list-todo",{"title":307,"path":308,"stem":309,"icon":310},"CLI — Domain and Storage","\u002Fprojects\u002Fcli-task-manager\u002Fdomain-and-storage","7.projects\u002F1.cli-task-manager\u002F1.domain-and-storage","i-lucide-save",{"title":312,"path":313,"stem":314,"icon":315},"CLI — Commands and Tests","\u002Fprojects\u002Fcli-task-manager\u002Fcommands-and-tests","7.projects\u002F1.cli-task-manager\u002F2.commands-and-tests","i-lucide-terminal",{"title":317,"path":318,"stem":319,"children":320,"icon":323},"Concurrent URL Checker","\u002Fprojects\u002Fconcurrent-url-checker","7.projects\u002F2.concurrent-url-checker\u002Findex",[321,324,328],{"title":322,"path":318,"stem":319,"icon":323},"Project — Concurrent URL Checker","i-lucide-radar",{"title":325,"path":326,"stem":327,"icon":128},"URL Checker — Worker Pipeline","\u002Fprojects\u002Fconcurrent-url-checker\u002Fworker-pipeline","7.projects\u002F2.concurrent-url-checker\u002F1.worker-pipeline",{"title":329,"path":330,"stem":331,"icon":173},"URL Checker — Cancellation and Tests","\u002Fprojects\u002Fconcurrent-url-checker\u002Fcancellation-and-tests","7.projects\u002F2.concurrent-url-checker\u002F2.cancellation-and-tests",{"title":333,"path":334,"stem":335,"children":336},"File-backed API","\u002Fprojects\u002Ffile-backed-api","7.projects\u002F3.file-backed-api\u002Findex",[337,339,343],{"title":338,"path":334,"stem":335},"File-backed notes API",{"title":340,"path":341,"stem":342},"File store and concurrency","\u002Fprojects\u002Ffile-backed-api\u002Ffile-store-and-concurrency","7.projects\u002F3.file-backed-api\u002F1.file-store-and-concurrency",{"title":344,"path":345,"stem":346},"HTTP layer and tests","\u002Fprojects\u002Ffile-backed-api\u002Fhttp-and-tests","7.projects\u002F3.file-backed-api\u002F2.http-and-tests",{"title":348,"path":349,"stem":350,"children":351},"Production REST API","\u002Fprojects\u002Fproduction-rest-api","7.projects\u002F4.production-rest-api\u002Findex",[352,354,358],{"title":353,"path":349,"stem":350},"Production REST API capstone",{"title":355,"path":356,"stem":357},"Persistence and authentication","\u002Fprojects\u002Fproduction-rest-api\u002Fpersistence-and-auth","7.projects\u002F4.production-rest-api\u002F1.persistence-and-auth",{"title":359,"path":360,"stem":361},"Operations and release","\u002Fprojects\u002Fproduction-rest-api\u002Foperations-and-release","7.projects\u002F4.production-rest-api\u002F2.operations-and-release",{"title":363,"path":364,"stem":365,"children":366,"page":6},"Meta","\u002Fmeta","99.meta",[367,372],{"title":368,"path":369,"stem":370,"icon":371},"About","\u002Fmeta\u002Fabout","99.meta\u002F1.about","i-lucide-info",{"title":373,"path":374,"stem":375,"icon":376},"Acknowledgements","\u002Fmeta\u002Facknowledgements","99.meta\u002F2.acknowledgements","i-lucide-heart-handshake",{"id":378,"title":70,"body":379,"description":3017,"extension":3018,"links":3019,"meta":3020,"navigation":3021,"path":71,"seo":3022,"stem":72,"__hash__":3024},"docs\u002F2.fundamentals\u002F14.generics.md",{"type":380,"value":381,"toc":3001},"minimark",[382,389,394,411,415,418,547,553,557,684,687,762,765,878,890,897,900,956,964,967,1039,1048,1195,1200,1206,1416,1444,1448,1451,1747,1758,1901,1912,1916,1923,2147,2160,2164,2195,2199,2202,2241,2244,2248,2288,2292,2314,2947,2951,2976,2991,2994,2997],[383,384],"learning-lesson-meta",{"description":385,"difficulty":386,"prerequisites":387,"time":388},"Write reusable, type-safe functions and containers with type parameters and constraints.","Intermediate","Functions, Interfaces, Arrays and Slices, Maps, Defined Types and Type Aliases","50 minutes",[390,391,393],"h2",{"id":392},"what-you-will-learn","What you will learn",[395,396,397,398,402,403,406,407,410],"p",{},"Sometimes the logic of a function is identical for every type, and only the type changes. Generics, added in Go 1.18, let you write that logic once. This lesson explains type parameters, how constraints say what a type must be able to do, the meaning of ",[399,400,401],"code",{},"any",", ",[399,404,405],{},"comparable",", and the ",[399,408,409],{},"~"," symbol, how to build a generic type such as a stack, and, just as important, when you should not use generics at all.",[390,412,414],{"id":413},"the-problem","The problem",[395,416,417],{},"Suppose you want to find a value in a slice. Without generics you write one function per type:",[419,420,425],"pre",{"className":421,"code":422,"language":423,"meta":424,"style":424},"language-go shiki shiki-themes solarized-light material-theme one-dark-pro","func IndexString(values []string, target string) int { ... }\nfunc IndexInt(values []int, target int) int { ... }\nfunc IndexFloat(values []float64, target float64) int { ... }\n","go","",[399,426,427,480,513],{"__ignoreMap":424},[428,429,432,436,440,444,448,451,455,458,461,464,467,470,473,477],"span",{"class":430,"line":431},"line",1,[428,433,435],{"class":434},"sEOdo","func",[428,437,439],{"class":438},"sisdC"," IndexString",[428,441,443],{"class":442},"shFME","(",[428,445,447],{"class":446},"syre3","values",[428,449,450],{"class":442}," []",[428,452,454],{"class":453},"sF6sA","string",[428,456,457],{"class":442},",",[428,459,460],{"class":446}," target",[428,462,463],{"class":453}," string",[428,465,466],{"class":442},")",[428,468,469],{"class":453}," int",[428,471,472],{"class":442}," {",[428,474,476],{"class":475},"sN42N"," ...",[428,478,479],{"class":442}," }\n",[428,481,483,485,488,490,492,494,497,499,501,503,505,507,509,511],{"class":430,"line":482},2,[428,484,435],{"class":434},[428,486,487],{"class":438}," IndexInt",[428,489,443],{"class":442},[428,491,447],{"class":446},[428,493,450],{"class":442},[428,495,496],{"class":453},"int",[428,498,457],{"class":442},[428,500,460],{"class":446},[428,502,469],{"class":453},[428,504,466],{"class":442},[428,506,469],{"class":453},[428,508,472],{"class":442},[428,510,476],{"class":475},[428,512,479],{"class":442},[428,514,516,518,521,523,525,527,530,532,534,537,539,541,543,545],{"class":430,"line":515},3,[428,517,435],{"class":434},[428,519,520],{"class":438}," IndexFloat",[428,522,443],{"class":442},[428,524,447],{"class":446},[428,526,450],{"class":442},[428,528,529],{"class":453},"float64",[428,531,457],{"class":442},[428,533,460],{"class":446},[428,535,536],{"class":453}," float64",[428,538,466],{"class":442},[428,540,469],{"class":453},[428,542,472],{"class":442},[428,544,476],{"class":475},[428,546,479],{"class":442},[395,548,549,550,552],{},"The bodies are identical. Before generics, the options were copying code, or accepting ",[399,551,401],{}," and losing type safety. A type parameter solves it properly.",[390,554,556],{"id":555},"a-generic-function","A generic function",[419,558,560],{"className":421,"code":559,"language":423,"meta":424,"style":424},"func Index[T comparable](values []T, target T) int {\n    for i, v := range values {\n        if v == target {\n            return i\n        }\n    }\n    return -1\n}\n",[399,561,562,602,629,644,653,659,665,678],{"__ignoreMap":424},[428,563,564,566,569,572,575,579,582,584,586,588,590,592,595,597,599],{"class":430,"line":431},[428,565,435],{"class":434},[428,567,568],{"class":438}," Index",[428,570,571],{"class":442},"[",[428,573,574],{"class":446},"T",[428,576,578],{"class":577},"snwKR"," comparable",[428,580,581],{"class":442},"](",[428,583,447],{"class":446},[428,585,450],{"class":442},[428,587,574],{"class":577},[428,589,457],{"class":442},[428,591,460],{"class":446},[428,593,594],{"class":577}," T",[428,596,466],{"class":442},[428,598,469],{"class":453},[428,600,601],{"class":442}," {\n",[428,603,604,608,612,614,617,621,624,627],{"class":430,"line":482},[428,605,607],{"class":606},"s7Bcg","    for",[428,609,611],{"class":610},"s45-6"," i",[428,613,457],{"class":442},[428,615,616],{"class":610}," v",[428,618,620],{"class":619},"su2KV"," :=",[428,622,623],{"class":606}," range",[428,625,626],{"class":610}," values",[428,628,601],{"class":442},[428,630,631,634,636,640,642],{"class":430,"line":515},[428,632,633],{"class":606},"        if",[428,635,616],{"class":610},[428,637,639],{"class":638},"sRBoR"," ==",[428,641,460],{"class":610},[428,643,601],{"class":442},[428,645,647,650],{"class":430,"line":646},4,[428,648,649],{"class":606},"            return",[428,651,652],{"class":610}," i\n",[428,654,656],{"class":430,"line":655},5,[428,657,658],{"class":442},"        }\n",[428,660,662],{"class":430,"line":661},6,[428,663,664],{"class":442},"    }\n",[428,666,668,671,674],{"class":430,"line":667},7,[428,669,670],{"class":606},"    return",[428,672,673],{"class":434}," -",[428,675,677],{"class":676},"sAJzr","1\n",[428,679,681],{"class":430,"line":680},8,[428,682,683],{"class":442},"}\n",[395,685,686],{},"Read the signature in pieces:",[688,689,690,703],"table",{},[691,692,693],"thead",{},[694,695,696,700],"tr",{},[697,698,699],"th",{},"Part",[697,701,702],{},"Meaning",[704,705,706,727,739,751],"tbody",{},[694,707,708,714],{},[709,710,711],"td",{},[399,712,713],{},"[T comparable]",[709,715,716,717,721,722,724,725],{},"Declares a ",[718,719,720],"strong",{},"type parameter"," ",[399,723,574],{},", and says it must satisfy the constraint ",[399,726,405],{},[694,728,729,734],{},[709,730,731],{},[399,732,733],{},"values []T",[709,735,736,737],{},"A slice whose elements all have type ",[399,738,574],{},[694,740,741,746],{},[709,742,743],{},[399,744,745],{},"target T",[709,747,748,749],{},"A value of that same type ",[399,750,574],{},[694,752,753,757],{},[709,754,755],{},[399,756,496],{},[709,758,759,760],{},"The result is an ordinary ",[399,761,496],{},[395,763,764],{},"Use it with any suitable type:",[419,766,768],{"className":421,"code":767,"language":423,"meta":424,"style":424},"fmt.Println(Index([]string{\"go\", \"rust\", \"zig\"}, \"rust\")) \u002F\u002F 1\nfmt.Println(Index([]int{10, 20, 30}, 20))                 \u002F\u002F 1\n",[399,769,770,838],{"__ignoreMap":424},[428,771,772,775,778,781,783,786,789,791,794,798,801,803,805,808,811,813,815,817,820,822,825,827,829,831,834],{"class":430,"line":431},[428,773,774],{"class":610},"fmt",[428,776,777],{"class":442},".",[428,779,780],{"class":438},"Println",[428,782,443],{"class":442},[428,784,785],{"class":438},"Index",[428,787,788],{"class":442},"([]",[428,790,454],{"class":453},[428,792,793],{"class":442},"{",[428,795,797],{"class":796},"sED5a","\"",[428,799,423],{"class":800},"sVazx",[428,802,797],{"class":796},[428,804,457],{"class":442},[428,806,807],{"class":796}," \"",[428,809,810],{"class":800},"rust",[428,812,797],{"class":796},[428,814,457],{"class":442},[428,816,807],{"class":796},[428,818,819],{"class":800},"zig",[428,821,797],{"class":796},[428,823,824],{"class":442},"},",[428,826,807],{"class":796},[428,828,810],{"class":800},[428,830,797],{"class":796},[428,832,833],{"class":442},"))",[428,835,837],{"class":836},"sJsHy"," \u002F\u002F 1\n",[428,839,840,842,844,846,848,850,852,854,856,859,861,864,866,869,871,873,875],{"class":430,"line":482},[428,841,774],{"class":610},[428,843,777],{"class":442},[428,845,780],{"class":438},[428,847,443],{"class":442},[428,849,785],{"class":438},[428,851,788],{"class":442},[428,853,496],{"class":453},[428,855,793],{"class":442},[428,857,858],{"class":676},"10",[428,860,457],{"class":442},[428,862,863],{"class":676}," 20",[428,865,457],{"class":442},[428,867,868],{"class":676}," 30",[428,870,824],{"class":442},[428,872,863],{"class":676},[428,874,833],{"class":442},[428,876,877],{"class":836},"                 \u002F\u002F 1\n",[395,879,880,881,721,884,886,887,777],{},"You do not have to write the type. Go ",[718,882,883],{},"infers",[399,885,574],{}," from the arguments. If you want to be explicit, you can: ",[399,888,889],{},"Index[string](names, \"go\")",[390,891,893,894,896],{"id":892},"constraints-what-t-must-be-able-to-do","Constraints: what ",[399,895,574],{}," must be able to do",[395,898,899],{},"Inside a generic function, the compiler knows only what the constraint promises. If you try to use an operation the constraint does not allow, it refuses:",[419,901,903],{"className":421,"code":902,"language":423,"meta":424,"style":424},"func Add[T any](a, b T) T {\n    return a + b \u002F\u002F compile error\n}\n",[399,904,905,937,952],{"__ignoreMap":424},[428,906,907,909,912,914,916,919,921,924,926,929,931,933,935],{"class":430,"line":431},[428,908,435],{"class":434},[428,910,911],{"class":438}," Add",[428,913,571],{"class":442},[428,915,574],{"class":446},[428,917,918],{"class":577}," any",[428,920,581],{"class":442},[428,922,923],{"class":446},"a",[428,925,457],{"class":442},[428,927,928],{"class":446}," b",[428,930,594],{"class":577},[428,932,466],{"class":442},[428,934,594],{"class":577},[428,936,601],{"class":442},[428,938,939,941,944,947,949],{"class":430,"line":482},[428,940,670],{"class":606},[428,942,943],{"class":610}," a",[428,945,946],{"class":434}," +",[428,948,928],{"class":610},[428,950,951],{"class":836}," \u002F\u002F compile error\n",[428,953,954],{"class":430,"line":515},[428,955,683],{"class":442},[419,957,962],{"className":958,"code":960,"language":961,"meta":424},[959],"language-text","invalid operation: operator + not defined on a (variable of type T constrained by any)\n","text",[399,963,960],{"__ignoreMap":424},[395,965,966],{},"A constraint is an interface that lists the permitted types or required methods. The most common ones:",[688,968,969,982],{},[691,970,971],{},[694,972,973,976,979],{},[697,974,975],{},"Constraint",[697,977,978],{},"Allows",[697,980,981],{},"Gives you",[704,983,984,996,1015],{},[694,985,986,990,993],{},[709,987,988],{},[399,989,401],{},[709,991,992],{},"Every type",[709,994,995],{},"Only assignment and passing around",[694,997,998,1002,1012],{},[709,999,1000],{},[399,1001,405],{},[709,1003,1004,1005,1008,1009],{},"Types that support ",[399,1006,1007],{},"=="," and ",[399,1010,1011],{},"!=",[709,1013,1014],{},"Equality comparisons, and use as map keys",[694,1016,1017,1022,1025],{},[709,1018,1019],{},[399,1020,1021],{},"cmp.Ordered",[709,1023,1024],{},"Numbers and strings",[709,1026,1027,402,1030,402,1033,402,1036],{},[399,1028,1029],{},"\u003C",[399,1031,1032],{},"\u003C=",[399,1034,1035],{},">",[399,1037,1038],{},">=",[395,1040,1041,1043,1044,1047],{},[399,1042,1021],{}," lives in the standard library package ",[399,1045,1046],{},"cmp",":",[419,1049,1051],{"className":421,"code":1050,"language":423,"meta":424,"style":424},"func Max[T cmp.Ordered](a, b T) T {\n    if a > b {\n        return a\n    }\n    return b\n}\n\nfmt.Println(Max(3, 7))         \u002F\u002F 7\nfmt.Println(Max(\"apple\", \"pear\")) \u002F\u002F pear\n",[399,1052,1053,1088,1102,1110,1114,1121,1125,1131,1159],{"__ignoreMap":424},[428,1054,1055,1057,1060,1062,1064,1067,1069,1072,1074,1076,1078,1080,1082,1084,1086],{"class":430,"line":431},[428,1056,435],{"class":434},[428,1058,1059],{"class":438}," Max",[428,1061,571],{"class":442},[428,1063,574],{"class":446},[428,1065,1066],{"class":577}," cmp",[428,1068,777],{"class":442},[428,1070,1071],{"class":577},"Ordered",[428,1073,581],{"class":442},[428,1075,923],{"class":446},[428,1077,457],{"class":442},[428,1079,928],{"class":446},[428,1081,594],{"class":577},[428,1083,466],{"class":442},[428,1085,594],{"class":577},[428,1087,601],{"class":442},[428,1089,1090,1093,1095,1098,1100],{"class":430,"line":482},[428,1091,1092],{"class":606},"    if",[428,1094,943],{"class":610},[428,1096,1097],{"class":638}," >",[428,1099,928],{"class":610},[428,1101,601],{"class":442},[428,1103,1104,1107],{"class":430,"line":515},[428,1105,1106],{"class":606},"        return",[428,1108,1109],{"class":610}," a\n",[428,1111,1112],{"class":430,"line":646},[428,1113,664],{"class":442},[428,1115,1116,1118],{"class":430,"line":655},[428,1117,670],{"class":606},[428,1119,1120],{"class":610}," b\n",[428,1122,1123],{"class":430,"line":661},[428,1124,683],{"class":442},[428,1126,1127],{"class":430,"line":667},[428,1128,1130],{"emptyLinePlaceholder":1129},true,"\n",[428,1132,1133,1135,1137,1139,1141,1144,1146,1149,1151,1154,1156],{"class":430,"line":680},[428,1134,774],{"class":610},[428,1136,777],{"class":442},[428,1138,780],{"class":438},[428,1140,443],{"class":442},[428,1142,1143],{"class":438},"Max",[428,1145,443],{"class":442},[428,1147,1148],{"class":676},"3",[428,1150,457],{"class":442},[428,1152,1153],{"class":676}," 7",[428,1155,833],{"class":442},[428,1157,1158],{"class":836},"         \u002F\u002F 7\n",[428,1160,1162,1164,1166,1168,1170,1172,1174,1176,1179,1181,1183,1185,1188,1190,1192],{"class":430,"line":1161},9,[428,1163,774],{"class":610},[428,1165,777],{"class":442},[428,1167,780],{"class":438},[428,1169,443],{"class":442},[428,1171,1143],{"class":438},[428,1173,443],{"class":442},[428,1175,797],{"class":796},[428,1177,1178],{"class":800},"apple",[428,1180,797],{"class":796},[428,1182,457],{"class":442},[428,1184,807],{"class":796},[428,1186,1187],{"class":800},"pear",[428,1189,797],{"class":796},[428,1191,833],{"class":442},[428,1193,1194],{"class":836}," \u002F\u002F pear\n",[1196,1197,1199],"h3",{"id":1198},"writing-your-own-constraint","Writing your own constraint",[395,1201,1202,1203,1047],{},"A constraint can list the exact types it accepts, joined by ",[399,1204,1205],{},"|",[419,1207,1209],{"className":421,"code":1208,"language":423,"meta":424,"style":424},"type Number interface {\n    ~int | ~int64 | ~float64\n}\n\nfunc Sum[T Number](values []T) T {\n    var total T\n    for _, v := range values {\n        total += v\n    }\n    return total\n}\n\nfmt.Println(Sum([]int{1, 2, 3}))        \u002F\u002F 6\nfmt.Println(Sum([]float64{1.5, 2.5}))   \u002F\u002F 4\n",[399,1210,1211,1224,1247,1251,1255,1282,1293,1312,1323,1327,1335,1340,1345,1384],{"__ignoreMap":424},[428,1212,1213,1216,1219,1222],{"class":430,"line":431},[428,1214,1215],{"class":434},"type",[428,1217,1218],{"class":577}," Number",[428,1220,1221],{"class":434}," interface",[428,1223,601],{"class":442},[428,1225,1226,1229,1231,1234,1237,1240,1242,1244],{"class":430,"line":482},[428,1227,1228],{"class":638},"    ~",[428,1230,496],{"class":453},[428,1232,1233],{"class":638}," |",[428,1235,1236],{"class":638}," ~",[428,1238,1239],{"class":453},"int64",[428,1241,1233],{"class":638},[428,1243,1236],{"class":638},[428,1245,1246],{"class":453},"float64\n",[428,1248,1249],{"class":430,"line":515},[428,1250,683],{"class":442},[428,1252,1253],{"class":430,"line":646},[428,1254,1130],{"emptyLinePlaceholder":1129},[428,1256,1257,1259,1262,1264,1266,1268,1270,1272,1274,1276,1278,1280],{"class":430,"line":655},[428,1258,435],{"class":434},[428,1260,1261],{"class":438}," Sum",[428,1263,571],{"class":442},[428,1265,574],{"class":446},[428,1267,1218],{"class":577},[428,1269,581],{"class":442},[428,1271,447],{"class":446},[428,1273,450],{"class":442},[428,1275,574],{"class":577},[428,1277,466],{"class":442},[428,1279,594],{"class":577},[428,1281,601],{"class":442},[428,1283,1284,1287,1290],{"class":430,"line":661},[428,1285,1286],{"class":434},"    var",[428,1288,1289],{"class":610}," total",[428,1291,1292],{"class":577}," T\n",[428,1294,1295,1297,1300,1302,1304,1306,1308,1310],{"class":430,"line":667},[428,1296,607],{"class":606},[428,1298,1299],{"class":610}," _",[428,1301,457],{"class":442},[428,1303,616],{"class":610},[428,1305,620],{"class":619},[428,1307,623],{"class":606},[428,1309,626],{"class":610},[428,1311,601],{"class":442},[428,1313,1314,1317,1320],{"class":430,"line":680},[428,1315,1316],{"class":610},"        total",[428,1318,1319],{"class":619}," +=",[428,1321,1322],{"class":610}," v\n",[428,1324,1325],{"class":430,"line":1161},[428,1326,664],{"class":442},[428,1328,1330,1332],{"class":430,"line":1329},10,[428,1331,670],{"class":606},[428,1333,1334],{"class":610}," total\n",[428,1336,1338],{"class":430,"line":1337},11,[428,1339,683],{"class":442},[428,1341,1343],{"class":430,"line":1342},12,[428,1344,1130],{"emptyLinePlaceholder":1129},[428,1346,1348,1350,1352,1354,1356,1359,1361,1363,1365,1368,1370,1373,1375,1378,1381],{"class":430,"line":1347},13,[428,1349,774],{"class":610},[428,1351,777],{"class":442},[428,1353,780],{"class":438},[428,1355,443],{"class":442},[428,1357,1358],{"class":438},"Sum",[428,1360,788],{"class":442},[428,1362,496],{"class":453},[428,1364,793],{"class":442},[428,1366,1367],{"class":676},"1",[428,1369,457],{"class":442},[428,1371,1372],{"class":676}," 2",[428,1374,457],{"class":442},[428,1376,1377],{"class":676}," 3",[428,1379,1380],{"class":442},"}))",[428,1382,1383],{"class":836},"        \u002F\u002F 6\n",[428,1385,1387,1389,1391,1393,1395,1397,1399,1401,1403,1406,1408,1411,1413],{"class":430,"line":1386},14,[428,1388,774],{"class":610},[428,1390,777],{"class":442},[428,1392,780],{"class":438},[428,1394,443],{"class":442},[428,1396,1358],{"class":438},[428,1398,788],{"class":442},[428,1400,529],{"class":453},[428,1402,793],{"class":442},[428,1404,1405],{"class":676},"1.5",[428,1407,457],{"class":442},[428,1409,1410],{"class":676}," 2.5",[428,1412,1380],{"class":442},[428,1414,1415],{"class":836},"   \u002F\u002F 4\n",[395,1417,1418,1419,1421,1422,1425,1426,1429,1430,1433,1434,1436,1437,1440,1441,1443],{},"The ",[399,1420,409],{}," means \"this type, or any defined type whose underlying type is this one\". Without it, ",[399,1423,1424],{},"Number"," would reject ",[399,1427,1428],{},"type Score int",", because ",[399,1431,1432],{},"Score"," is a different type from ",[399,1435,496],{},". With ",[399,1438,1439],{},"~int",", a slice of ",[399,1442,1432],{}," values works too.",[390,1445,1447],{"id":1446},"generic-types","Generic types",[395,1449,1450],{},"Types can have type parameters as well. A stack is the classic example:",[419,1452,1454],{"className":421,"code":1453,"language":423,"meta":424,"style":424},"type Stack[T any] struct {\n    items []T\n}\n\nfunc (s *Stack[T]) Push(value T) {\n    s.items = append(s.items, value)\n}\n\nfunc (s *Stack[T]) Pop() (T, bool) {\n    var zero T\n    if len(s.items) == 0 {\n        return zero, false\n    }\n    last := len(s.items) - 1\n    value := s.items[last]\n    s.items = s.items[:last]\n    return value, true\n}\n",[399,1455,1456,1477,1487,1491,1495,1532,1565,1569,1573,1610,1619,1643,1655,1659,1683,1706,1730,1742],{"__ignoreMap":424},[428,1457,1458,1460,1463,1465,1467,1469,1472,1475],{"class":430,"line":431},[428,1459,1215],{"class":434},[428,1461,1462],{"class":577}," Stack",[428,1464,571],{"class":442},[428,1466,574],{"class":446},[428,1468,918],{"class":577},[428,1470,1471],{"class":442},"]",[428,1473,1474],{"class":434}," struct",[428,1476,601],{"class":442},[428,1478,1479,1482,1484],{"class":430,"line":482},[428,1480,1481],{"class":610},"    items",[428,1483,450],{"class":442},[428,1485,1486],{"class":577},"T\n",[428,1488,1489],{"class":430,"line":515},[428,1490,683],{"class":442},[428,1492,1493],{"class":430,"line":646},[428,1494,1130],{"emptyLinePlaceholder":1129},[428,1496,1497,1499,1502,1505,1508,1511,1513,1515,1518,1521,1523,1526,1528,1530],{"class":430,"line":655},[428,1498,435],{"class":434},[428,1500,1501],{"class":442}," (",[428,1503,1504],{"class":446},"s ",[428,1506,1507],{"class":434},"*",[428,1509,1510],{"class":577},"Stack",[428,1512,571],{"class":442},[428,1514,574],{"class":577},[428,1516,1517],{"class":442},"])",[428,1519,1520],{"class":438}," Push",[428,1522,443],{"class":442},[428,1524,1525],{"class":446},"value",[428,1527,594],{"class":577},[428,1529,466],{"class":442},[428,1531,601],{"class":442},[428,1533,1534,1537,1539,1542,1545,1548,1550,1553,1555,1557,1559,1562],{"class":430,"line":661},[428,1535,1536],{"class":610},"    s",[428,1538,777],{"class":442},[428,1540,1541],{"class":610},"items",[428,1543,1544],{"class":619}," =",[428,1546,1547],{"class":438}," append",[428,1549,443],{"class":442},[428,1551,1552],{"class":610},"s",[428,1554,777],{"class":442},[428,1556,1541],{"class":610},[428,1558,457],{"class":442},[428,1560,1561],{"class":610}," value",[428,1563,1564],{"class":442},")\n",[428,1566,1567],{"class":430,"line":667},[428,1568,683],{"class":442},[428,1570,1571],{"class":430,"line":680},[428,1572,1130],{"emptyLinePlaceholder":1129},[428,1574,1575,1577,1579,1581,1583,1585,1587,1589,1591,1594,1597,1599,1601,1603,1606,1608],{"class":430,"line":1161},[428,1576,435],{"class":434},[428,1578,1501],{"class":442},[428,1580,1504],{"class":446},[428,1582,1507],{"class":434},[428,1584,1510],{"class":577},[428,1586,571],{"class":442},[428,1588,574],{"class":577},[428,1590,1517],{"class":442},[428,1592,1593],{"class":438}," Pop",[428,1595,1596],{"class":442},"()",[428,1598,1501],{"class":442},[428,1600,574],{"class":577},[428,1602,457],{"class":442},[428,1604,1605],{"class":453}," bool",[428,1607,466],{"class":442},[428,1609,601],{"class":442},[428,1611,1612,1614,1617],{"class":430,"line":1329},[428,1613,1286],{"class":434},[428,1615,1616],{"class":610}," zero",[428,1618,1292],{"class":577},[428,1620,1621,1623,1626,1628,1630,1632,1634,1636,1638,1641],{"class":430,"line":1337},[428,1622,1092],{"class":606},[428,1624,1625],{"class":438}," len",[428,1627,443],{"class":442},[428,1629,1552],{"class":610},[428,1631,777],{"class":442},[428,1633,1541],{"class":610},[428,1635,466],{"class":442},[428,1637,639],{"class":638},[428,1639,1640],{"class":676}," 0",[428,1642,601],{"class":442},[428,1644,1645,1647,1649,1651],{"class":430,"line":1342},[428,1646,1106],{"class":606},[428,1648,1616],{"class":610},[428,1650,457],{"class":442},[428,1652,1654],{"class":1653},"sqQ1y"," false\n",[428,1656,1657],{"class":430,"line":1347},[428,1658,664],{"class":442},[428,1660,1661,1664,1666,1668,1670,1672,1674,1676,1678,1680],{"class":430,"line":1386},[428,1662,1663],{"class":610},"    last",[428,1665,620],{"class":619},[428,1667,1625],{"class":438},[428,1669,443],{"class":442},[428,1671,1552],{"class":610},[428,1673,777],{"class":442},[428,1675,1541],{"class":610},[428,1677,466],{"class":442},[428,1679,673],{"class":434},[428,1681,1682],{"class":676}," 1\n",[428,1684,1686,1689,1691,1694,1696,1698,1700,1703],{"class":430,"line":1685},15,[428,1687,1688],{"class":610},"    value",[428,1690,620],{"class":619},[428,1692,1693],{"class":610}," s",[428,1695,777],{"class":442},[428,1697,1541],{"class":610},[428,1699,571],{"class":442},[428,1701,1702],{"class":610},"last",[428,1704,1705],{"class":442},"]\n",[428,1707,1709,1711,1713,1715,1717,1719,1721,1723,1726,1728],{"class":430,"line":1708},16,[428,1710,1536],{"class":610},[428,1712,777],{"class":442},[428,1714,1541],{"class":610},[428,1716,1544],{"class":619},[428,1718,1693],{"class":610},[428,1720,777],{"class":442},[428,1722,1541],{"class":610},[428,1724,1725],{"class":442},"[:",[428,1727,1702],{"class":610},[428,1729,1705],{"class":442},[428,1731,1733,1735,1737,1739],{"class":430,"line":1732},17,[428,1734,670],{"class":606},[428,1736,1561],{"class":610},[428,1738,457],{"class":442},[428,1740,1741],{"class":1653}," true\n",[428,1743,1745],{"class":430,"line":1744},18,[428,1746,683],{"class":442},[395,1748,1749,1750,1753,1754,1757],{},"Methods repeat the type parameter in the receiver, ",[399,1751,1752],{},"*Stack[T]",". Notice ",[399,1755,1756],{},"var zero T",", the standard way to produce \"the zero value of whatever T is\" when you have nothing to return. You choose the concrete type when you create a value:",[419,1759,1761],{"className":421,"code":1760,"language":423,"meta":424,"style":424},"var names Stack[string]\nnames.Push(\"Ada\")\nnames.Push(\"Grace\")\n\ntop, ok := names.Pop()\nfmt.Println(top, ok) \u002F\u002F Grace true\n\nvar numbers Stack[int]\nnumbers.Push(42)\n",[399,1762,1763,1779,1800,1819,1823,1845,1866,1870,1885],{"__ignoreMap":424},[428,1764,1765,1768,1771,1773,1775,1777],{"class":430,"line":431},[428,1766,1767],{"class":434},"var",[428,1769,1770],{"class":610}," names",[428,1772,1462],{"class":577},[428,1774,571],{"class":442},[428,1776,454],{"class":453},[428,1778,1705],{"class":442},[428,1780,1781,1784,1786,1789,1791,1793,1796,1798],{"class":430,"line":482},[428,1782,1783],{"class":610},"names",[428,1785,777],{"class":442},[428,1787,1788],{"class":438},"Push",[428,1790,443],{"class":442},[428,1792,797],{"class":796},[428,1794,1795],{"class":800},"Ada",[428,1797,797],{"class":796},[428,1799,1564],{"class":442},[428,1801,1802,1804,1806,1808,1810,1812,1815,1817],{"class":430,"line":515},[428,1803,1783],{"class":610},[428,1805,777],{"class":442},[428,1807,1788],{"class":438},[428,1809,443],{"class":442},[428,1811,797],{"class":796},[428,1813,1814],{"class":800},"Grace",[428,1816,797],{"class":796},[428,1818,1564],{"class":442},[428,1820,1821],{"class":430,"line":646},[428,1822,1130],{"emptyLinePlaceholder":1129},[428,1824,1825,1828,1830,1833,1835,1837,1839,1842],{"class":430,"line":655},[428,1826,1827],{"class":610},"top",[428,1829,457],{"class":442},[428,1831,1832],{"class":610}," ok",[428,1834,620],{"class":619},[428,1836,1770],{"class":610},[428,1838,777],{"class":442},[428,1840,1841],{"class":438},"Pop",[428,1843,1844],{"class":442},"()\n",[428,1846,1847,1849,1851,1853,1855,1857,1859,1861,1863],{"class":430,"line":661},[428,1848,774],{"class":610},[428,1850,777],{"class":442},[428,1852,780],{"class":438},[428,1854,443],{"class":442},[428,1856,1827],{"class":610},[428,1858,457],{"class":442},[428,1860,1832],{"class":610},[428,1862,466],{"class":442},[428,1864,1865],{"class":836}," \u002F\u002F Grace true\n",[428,1867,1868],{"class":430,"line":667},[428,1869,1130],{"emptyLinePlaceholder":1129},[428,1871,1872,1874,1877,1879,1881,1883],{"class":430,"line":680},[428,1873,1767],{"class":434},[428,1875,1876],{"class":610}," numbers",[428,1878,1462],{"class":577},[428,1880,571],{"class":442},[428,1882,496],{"class":453},[428,1884,1705],{"class":442},[428,1886,1887,1890,1892,1894,1896,1899],{"class":430,"line":1161},[428,1888,1889],{"class":610},"numbers",[428,1891,777],{"class":442},[428,1893,1788],{"class":438},[428,1895,443],{"class":442},[428,1897,1898],{"class":676},"42",[428,1900,1564],{"class":442},[395,1902,1903,1904,1907,1908,1911],{},"A ",[399,1905,1906],{},"Stack[string]"," and a ",[399,1909,1910],{},"Stack[int]"," are separate types, and the compiler guarantees you never put a number in the string stack.",[390,1913,1915],{"id":1914},"more-than-one-type-parameter","More than one type parameter",[395,1917,1918,1919,1922],{},"Separate them with commas. A ",[399,1920,1921],{},"Map"," function that transforms a slice from one type to another needs two:",[419,1924,1926],{"className":421,"code":1925,"language":423,"meta":424,"style":424},"func Map[T, U any](values []T, convert func(T) U) []U {\n    result := make([]U, 0, len(values))\n    for _, v := range values {\n        result = append(result, convert(v))\n    }\n    return result\n}\n\nlengths := Map([]string{\"go\", \"gopher\"}, func(s string) int { return len(s) })\nfmt.Println(lengths) \u002F\u002F [2 6]\n",[399,1927,1928,1979,2008,2026,2051,2055,2062,2066,2070,2130],{"__ignoreMap":424},[428,1929,1930,1932,1935,1937,1939,1941,1944,1946,1948,1950,1952,1954,1956,1959,1962,1964,1966,1968,1970,1972,1974,1977],{"class":430,"line":431},[428,1931,435],{"class":434},[428,1933,1934],{"class":438}," Map",[428,1936,571],{"class":442},[428,1938,574],{"class":446},[428,1940,457],{"class":442},[428,1942,1943],{"class":446}," U",[428,1945,918],{"class":577},[428,1947,581],{"class":442},[428,1949,447],{"class":446},[428,1951,450],{"class":442},[428,1953,574],{"class":577},[428,1955,457],{"class":442},[428,1957,1958],{"class":446}," convert",[428,1960,1961],{"class":434}," func",[428,1963,443],{"class":442},[428,1965,574],{"class":577},[428,1967,466],{"class":442},[428,1969,1943],{"class":577},[428,1971,466],{"class":442},[428,1973,450],{"class":442},[428,1975,1976],{"class":577},"U",[428,1978,601],{"class":442},[428,1980,1981,1984,1986,1989,1991,1993,1995,1997,1999,2001,2003,2005],{"class":430,"line":482},[428,1982,1983],{"class":610},"    result",[428,1985,620],{"class":619},[428,1987,1988],{"class":438}," make",[428,1990,788],{"class":442},[428,1992,1976],{"class":577},[428,1994,457],{"class":442},[428,1996,1640],{"class":676},[428,1998,457],{"class":442},[428,2000,1625],{"class":438},[428,2002,443],{"class":442},[428,2004,447],{"class":610},[428,2006,2007],{"class":442},"))\n",[428,2009,2010,2012,2014,2016,2018,2020,2022,2024],{"class":430,"line":515},[428,2011,607],{"class":606},[428,2013,1299],{"class":610},[428,2015,457],{"class":442},[428,2017,616],{"class":610},[428,2019,620],{"class":619},[428,2021,623],{"class":606},[428,2023,626],{"class":610},[428,2025,601],{"class":442},[428,2027,2028,2031,2033,2035,2037,2040,2042,2044,2046,2049],{"class":430,"line":646},[428,2029,2030],{"class":610},"        result",[428,2032,1544],{"class":619},[428,2034,1547],{"class":438},[428,2036,443],{"class":442},[428,2038,2039],{"class":610},"result",[428,2041,457],{"class":442},[428,2043,1958],{"class":438},[428,2045,443],{"class":442},[428,2047,2048],{"class":610},"v",[428,2050,2007],{"class":442},[428,2052,2053],{"class":430,"line":655},[428,2054,664],{"class":442},[428,2056,2057,2059],{"class":430,"line":661},[428,2058,670],{"class":606},[428,2060,2061],{"class":610}," result\n",[428,2063,2064],{"class":430,"line":667},[428,2065,683],{"class":442},[428,2067,2068],{"class":430,"line":680},[428,2069,1130],{"emptyLinePlaceholder":1129},[428,2071,2072,2075,2077,2079,2081,2083,2085,2087,2089,2091,2093,2095,2098,2100,2102,2104,2106,2108,2110,2112,2114,2116,2119,2121,2123,2125,2127],{"class":430,"line":1161},[428,2073,2074],{"class":610},"lengths",[428,2076,620],{"class":619},[428,2078,1934],{"class":438},[428,2080,788],{"class":442},[428,2082,454],{"class":453},[428,2084,793],{"class":442},[428,2086,797],{"class":796},[428,2088,423],{"class":800},[428,2090,797],{"class":796},[428,2092,457],{"class":442},[428,2094,807],{"class":796},[428,2096,2097],{"class":800},"gopher",[428,2099,797],{"class":796},[428,2101,824],{"class":442},[428,2103,1961],{"class":434},[428,2105,443],{"class":442},[428,2107,1552],{"class":446},[428,2109,463],{"class":453},[428,2111,466],{"class":442},[428,2113,469],{"class":453},[428,2115,472],{"class":442},[428,2117,2118],{"class":606}," return",[428,2120,1625],{"class":438},[428,2122,443],{"class":442},[428,2124,1552],{"class":610},[428,2126,466],{"class":442},[428,2128,2129],{"class":442}," })\n",[428,2131,2132,2134,2136,2138,2140,2142,2144],{"class":430,"line":1329},[428,2133,774],{"class":610},[428,2135,777],{"class":442},[428,2137,780],{"class":438},[428,2139,443],{"class":442},[428,2141,2074],{"class":610},[428,2143,466],{"class":442},[428,2145,2146],{"class":836}," \u002F\u002F [2 6]\n",[395,2148,2149,2150,2152,2153,1008,2155,2152,2157,2159],{},"Go infers ",[399,2151,574],{}," as ",[399,2154,454],{},[399,2156,1976],{},[399,2158,496],{}," from the arguments.",[390,2161,2163],{"id":2162},"use-the-standard-library-first","Use the standard library first",[395,2165,2166,2167,2170,2171,402,2174,402,2177,2180,2181,2184,2185,2170,2188,1008,2191,2194],{},"Many common generic helpers already exist in the standard library, so check there before writing your own. The ",[399,2168,2169],{},"slices"," package has ",[399,2172,2173],{},"slices.Index",[399,2175,2176],{},"slices.Contains",[399,2178,2179],{},"slices.Sort",", and ",[399,2182,2183],{},"slices.Max",". The ",[399,2186,2187],{},"maps",[399,2189,2190],{},"maps.Keys",[399,2192,2193],{},"maps.Clone",". These are well tested and familiar to other Go programmers.",[390,2196,2198],{"id":2197},"generics-or-interfaces","Generics or interfaces?",[395,2200,2201],{},"Both let one piece of code handle several types, but they suit different situations:",[2203,2204,2205,2220,2235],"ul",{},[2206,2207,2208,2211,2212,402,2214,2216,2217,777],"li",{},[718,2209,2210],{},"Use generics"," when the same algorithm works on many types and you want the result to keep its concrete type, as with ",[399,2213,785],{},[399,2215,1921],{},", or a ",[399,2218,2219],{},"Stack[T]",[2206,2221,2222,2225,2226,2230,2231,2234],{},[718,2223,2224],{},"Use an interface"," when the code needs different ",[2227,2228,2229],"em",{},"behaviour"," from different types at run time, such as calling ",[399,2232,2233],{},"Area()"," on a mix of shapes.",[2206,2236,2237,2240],{},[718,2238,2239],{},"Use an ordinary function"," when only one concrete type is involved. Do not add a type parameter just because you can.",[395,2242,2243],{},"A rule of thumb from the Go team: write concrete code first, and reach for generics when you notice yourself writing the same function a second or third time with a different type.",[390,2245,2247],{"id":2246},"common-mistakes","Common mistakes",[2203,2249,2250,2259,2265,2276,2282],{},[2206,2251,2252,2258],{},[718,2253,2254,2255,2257],{},"Using ",[399,2256,401],{}," and then type-switching inside."," An interface or two separate functions is usually clearer.",[2206,2260,2261,2264],{},[718,2262,2263],{},"Making constraints broader than needed."," Allow only the types the algorithm truly supports.",[2206,2266,2267,2272,2273,2275],{},[718,2268,2269,2270],{},"Forgetting ",[399,2271,409],{}," and wondering why a defined type like ",[399,2274,1432],{}," is rejected.",[2206,2277,2278,2281],{},[718,2279,2280],{},"Expecting methods to have their own type parameters."," A method can only use the type parameters declared on its receiver type.",[2206,2283,2284,2287],{},[718,2285,2286],{},"Hiding a three-line loop behind a complicated generic helper."," A little repetition is often cheaper than an abstraction nobody can read.",[390,2289,2291],{"id":2290},"practice","Practice",[395,2293,2294,2295,2297,2298,2300,2301,2303,2304,2306,2307,2309,2310,2313],{},"Write a generic ",[399,2296,1921],{}," function that takes a slice of ",[399,2299,574],{}," and a conversion function from ",[399,2302,574],{}," to ",[399,2305,1976],{},", and returns a slice of ",[399,2308,1976],{},". Use it to convert a slice of integers into a slice of strings. Then write a generic ",[399,2311,2312],{},"Filter"," function that keeps only the elements for which a test function returns true.",[2315,2316,2317],"accordion",{},[2318,2319,2322,2918],"accordion-item",{"icon":2320,"label":2321},"i-lucide-lightbulb","Show solution",[419,2323,2325],{"className":421,"code":2324,"language":423,"meta":424,"style":424},"package main\n\nimport (\n    \"fmt\"\n    \"strconv\"\n)\n\nfunc Map[T, U any](values []T, convert func(T) U) []U {\n    result := make([]U, 0, len(values))\n    for _, v := range values {\n        result = append(result, convert(v))\n    }\n    return result\n}\n\nfunc Filter[T any](values []T, keep func(T) bool) []T {\n    result := make([]T, 0, len(values))\n    for _, v := range values {\n        if keep(v) {\n            result = append(result, v)\n        }\n    }\n    return result\n}\n\nfunc main() {\n    numbers := []int{10, 15, 20, 25}\n\n    texts := Map(numbers, strconv.Itoa)\n    fmt.Println(texts) \u002F\u002F [10 15 20 25]\n\n    big := Filter(numbers, func(n int) bool { return n >= 20 })\n    fmt.Println(big) \u002F\u002F [20 25]\n\n    words := Filter([]string{\"go\", \"rust\", \"c\"}, func(s string) bool { return len(s) > 1 })\n    fmt.Println(words) \u002F\u002F [go rust]\n}\n",[399,2326,2327,2335,2339,2347,2358,2367,2371,2375,2421,2447,2465,2487,2491,2497,2501,2505,2549,2575,2593,2608,2628,2633,2638,2645,2650,2655,2667,2699,2704,2730,2750,2755,2798,2817,2822,2894,2913],{"__ignoreMap":424},[428,2328,2329,2332],{"class":430,"line":431},[428,2330,2331],{"class":434},"package",[428,2333,2334],{"class":577}," main\n",[428,2336,2337],{"class":430,"line":482},[428,2338,1130],{"emptyLinePlaceholder":1129},[428,2340,2341,2344],{"class":430,"line":515},[428,2342,2343],{"class":606},"import",[428,2345,2346],{"class":442}," (\n",[428,2348,2349,2352,2355],{"class":430,"line":646},[428,2350,2351],{"class":796},"    \"",[428,2353,774],{"class":2354},"sdLNw",[428,2356,2357],{"class":796},"\"\n",[428,2359,2360,2362,2365],{"class":430,"line":655},[428,2361,2351],{"class":796},[428,2363,2364],{"class":2354},"strconv",[428,2366,2357],{"class":796},[428,2368,2369],{"class":430,"line":661},[428,2370,1564],{"class":442},[428,2372,2373],{"class":430,"line":667},[428,2374,1130],{"emptyLinePlaceholder":1129},[428,2376,2377,2379,2381,2383,2385,2387,2389,2391,2393,2395,2397,2399,2401,2403,2405,2407,2409,2411,2413,2415,2417,2419],{"class":430,"line":680},[428,2378,435],{"class":434},[428,2380,1934],{"class":438},[428,2382,571],{"class":442},[428,2384,574],{"class":446},[428,2386,457],{"class":442},[428,2388,1943],{"class":446},[428,2390,918],{"class":577},[428,2392,581],{"class":442},[428,2394,447],{"class":446},[428,2396,450],{"class":442},[428,2398,574],{"class":577},[428,2400,457],{"class":442},[428,2402,1958],{"class":446},[428,2404,1961],{"class":434},[428,2406,443],{"class":442},[428,2408,574],{"class":577},[428,2410,466],{"class":442},[428,2412,1943],{"class":577},[428,2414,466],{"class":442},[428,2416,450],{"class":442},[428,2418,1976],{"class":577},[428,2420,601],{"class":442},[428,2422,2423,2425,2427,2429,2431,2433,2435,2437,2439,2441,2443,2445],{"class":430,"line":1161},[428,2424,1983],{"class":610},[428,2426,620],{"class":619},[428,2428,1988],{"class":438},[428,2430,788],{"class":442},[428,2432,1976],{"class":577},[428,2434,457],{"class":442},[428,2436,1640],{"class":676},[428,2438,457],{"class":442},[428,2440,1625],{"class":438},[428,2442,443],{"class":442},[428,2444,447],{"class":610},[428,2446,2007],{"class":442},[428,2448,2449,2451,2453,2455,2457,2459,2461,2463],{"class":430,"line":1329},[428,2450,607],{"class":606},[428,2452,1299],{"class":610},[428,2454,457],{"class":442},[428,2456,616],{"class":610},[428,2458,620],{"class":619},[428,2460,623],{"class":606},[428,2462,626],{"class":610},[428,2464,601],{"class":442},[428,2466,2467,2469,2471,2473,2475,2477,2479,2481,2483,2485],{"class":430,"line":1337},[428,2468,2030],{"class":610},[428,2470,1544],{"class":619},[428,2472,1547],{"class":438},[428,2474,443],{"class":442},[428,2476,2039],{"class":610},[428,2478,457],{"class":442},[428,2480,1958],{"class":438},[428,2482,443],{"class":442},[428,2484,2048],{"class":610},[428,2486,2007],{"class":442},[428,2488,2489],{"class":430,"line":1342},[428,2490,664],{"class":442},[428,2492,2493,2495],{"class":430,"line":1347},[428,2494,670],{"class":606},[428,2496,2061],{"class":610},[428,2498,2499],{"class":430,"line":1386},[428,2500,683],{"class":442},[428,2502,2503],{"class":430,"line":1685},[428,2504,1130],{"emptyLinePlaceholder":1129},[428,2506,2507,2509,2512,2514,2516,2518,2520,2522,2524,2526,2528,2531,2533,2535,2537,2539,2541,2543,2545,2547],{"class":430,"line":1708},[428,2508,435],{"class":434},[428,2510,2511],{"class":438}," Filter",[428,2513,571],{"class":442},[428,2515,574],{"class":446},[428,2517,918],{"class":577},[428,2519,581],{"class":442},[428,2521,447],{"class":446},[428,2523,450],{"class":442},[428,2525,574],{"class":577},[428,2527,457],{"class":442},[428,2529,2530],{"class":446}," keep",[428,2532,1961],{"class":434},[428,2534,443],{"class":442},[428,2536,574],{"class":577},[428,2538,466],{"class":442},[428,2540,1605],{"class":453},[428,2542,466],{"class":442},[428,2544,450],{"class":442},[428,2546,574],{"class":577},[428,2548,601],{"class":442},[428,2550,2551,2553,2555,2557,2559,2561,2563,2565,2567,2569,2571,2573],{"class":430,"line":1732},[428,2552,1983],{"class":610},[428,2554,620],{"class":619},[428,2556,1988],{"class":438},[428,2558,788],{"class":442},[428,2560,574],{"class":577},[428,2562,457],{"class":442},[428,2564,1640],{"class":676},[428,2566,457],{"class":442},[428,2568,1625],{"class":438},[428,2570,443],{"class":442},[428,2572,447],{"class":610},[428,2574,2007],{"class":442},[428,2576,2577,2579,2581,2583,2585,2587,2589,2591],{"class":430,"line":1744},[428,2578,607],{"class":606},[428,2580,1299],{"class":610},[428,2582,457],{"class":442},[428,2584,616],{"class":610},[428,2586,620],{"class":619},[428,2588,623],{"class":606},[428,2590,626],{"class":610},[428,2592,601],{"class":442},[428,2594,2596,2598,2600,2602,2604,2606],{"class":430,"line":2595},19,[428,2597,633],{"class":606},[428,2599,2530],{"class":438},[428,2601,443],{"class":442},[428,2603,2048],{"class":610},[428,2605,466],{"class":442},[428,2607,601],{"class":442},[428,2609,2611,2614,2616,2618,2620,2622,2624,2626],{"class":430,"line":2610},20,[428,2612,2613],{"class":610},"            result",[428,2615,1544],{"class":619},[428,2617,1547],{"class":438},[428,2619,443],{"class":442},[428,2621,2039],{"class":610},[428,2623,457],{"class":442},[428,2625,616],{"class":610},[428,2627,1564],{"class":442},[428,2629,2631],{"class":430,"line":2630},21,[428,2632,658],{"class":442},[428,2634,2636],{"class":430,"line":2635},22,[428,2637,664],{"class":442},[428,2639,2641,2643],{"class":430,"line":2640},23,[428,2642,670],{"class":606},[428,2644,2061],{"class":610},[428,2646,2648],{"class":430,"line":2647},24,[428,2649,683],{"class":442},[428,2651,2653],{"class":430,"line":2652},25,[428,2654,1130],{"emptyLinePlaceholder":1129},[428,2656,2658,2660,2663,2665],{"class":430,"line":2657},26,[428,2659,435],{"class":434},[428,2661,2662],{"class":438}," main",[428,2664,1596],{"class":442},[428,2666,601],{"class":442},[428,2668,2670,2673,2675,2677,2679,2681,2683,2685,2688,2690,2692,2694,2697],{"class":430,"line":2669},27,[428,2671,2672],{"class":610},"    numbers",[428,2674,620],{"class":619},[428,2676,450],{"class":442},[428,2678,496],{"class":453},[428,2680,793],{"class":442},[428,2682,858],{"class":676},[428,2684,457],{"class":442},[428,2686,2687],{"class":676}," 15",[428,2689,457],{"class":442},[428,2691,863],{"class":676},[428,2693,457],{"class":442},[428,2695,2696],{"class":676}," 25",[428,2698,683],{"class":442},[428,2700,2702],{"class":430,"line":2701},28,[428,2703,1130],{"emptyLinePlaceholder":1129},[428,2705,2707,2710,2712,2714,2716,2718,2720,2723,2725,2728],{"class":430,"line":2706},29,[428,2708,2709],{"class":610},"    texts",[428,2711,620],{"class":619},[428,2713,1934],{"class":438},[428,2715,443],{"class":442},[428,2717,1889],{"class":610},[428,2719,457],{"class":442},[428,2721,2722],{"class":610}," strconv",[428,2724,777],{"class":442},[428,2726,2727],{"class":610},"Itoa",[428,2729,1564],{"class":442},[428,2731,2733,2736,2738,2740,2742,2745,2747],{"class":430,"line":2732},30,[428,2734,2735],{"class":610},"    fmt",[428,2737,777],{"class":442},[428,2739,780],{"class":438},[428,2741,443],{"class":442},[428,2743,2744],{"class":610},"texts",[428,2746,466],{"class":442},[428,2748,2749],{"class":836}," \u002F\u002F [10 15 20 25]\n",[428,2751,2753],{"class":430,"line":2752},31,[428,2754,1130],{"emptyLinePlaceholder":1129},[428,2756,2758,2761,2763,2765,2767,2769,2771,2773,2775,2778,2780,2782,2784,2786,2788,2791,2794,2796],{"class":430,"line":2757},32,[428,2759,2760],{"class":610},"    big",[428,2762,620],{"class":619},[428,2764,2511],{"class":438},[428,2766,443],{"class":442},[428,2768,1889],{"class":610},[428,2770,457],{"class":442},[428,2772,1961],{"class":434},[428,2774,443],{"class":442},[428,2776,2777],{"class":446},"n",[428,2779,469],{"class":453},[428,2781,466],{"class":442},[428,2783,1605],{"class":453},[428,2785,472],{"class":442},[428,2787,2118],{"class":606},[428,2789,2790],{"class":610}," n",[428,2792,2793],{"class":638}," >=",[428,2795,863],{"class":676},[428,2797,2129],{"class":442},[428,2799,2801,2803,2805,2807,2809,2812,2814],{"class":430,"line":2800},33,[428,2802,2735],{"class":610},[428,2804,777],{"class":442},[428,2806,780],{"class":438},[428,2808,443],{"class":442},[428,2810,2811],{"class":610},"big",[428,2813,466],{"class":442},[428,2815,2816],{"class":836}," \u002F\u002F [20 25]\n",[428,2818,2820],{"class":430,"line":2819},34,[428,2821,1130],{"emptyLinePlaceholder":1129},[428,2823,2825,2828,2830,2832,2834,2836,2838,2840,2842,2844,2846,2848,2850,2852,2854,2856,2859,2861,2863,2865,2867,2869,2871,2873,2875,2877,2879,2881,2883,2885,2887,2889,2892],{"class":430,"line":2824},35,[428,2826,2827],{"class":610},"    words",[428,2829,620],{"class":619},[428,2831,2511],{"class":438},[428,2833,788],{"class":442},[428,2835,454],{"class":453},[428,2837,793],{"class":442},[428,2839,797],{"class":796},[428,2841,423],{"class":800},[428,2843,797],{"class":796},[428,2845,457],{"class":442},[428,2847,807],{"class":796},[428,2849,810],{"class":800},[428,2851,797],{"class":796},[428,2853,457],{"class":442},[428,2855,807],{"class":796},[428,2857,2858],{"class":800},"c",[428,2860,797],{"class":796},[428,2862,824],{"class":442},[428,2864,1961],{"class":434},[428,2866,443],{"class":442},[428,2868,1552],{"class":446},[428,2870,463],{"class":453},[428,2872,466],{"class":442},[428,2874,1605],{"class":453},[428,2876,472],{"class":442},[428,2878,2118],{"class":606},[428,2880,1625],{"class":438},[428,2882,443],{"class":442},[428,2884,1552],{"class":610},[428,2886,466],{"class":442},[428,2888,1097],{"class":638},[428,2890,2891],{"class":676}," 1",[428,2893,2129],{"class":442},[428,2895,2897,2899,2901,2903,2905,2908,2910],{"class":430,"line":2896},36,[428,2898,2735],{"class":610},[428,2900,777],{"class":442},[428,2902,780],{"class":438},[428,2904,443],{"class":442},[428,2906,2907],{"class":610},"words",[428,2909,466],{"class":442},[428,2911,2912],{"class":836}," \u002F\u002F [go rust]\n",[428,2914,2916],{"class":430,"line":2915},37,[428,2917,683],{"class":442},[395,2919,2920,2922,2923,2152,2925,1008,2927,2152,2929,2931,2932,2935,2936,2938,2939,2942,2943,2946],{},[399,2921,1921],{}," has two type parameters, because its input and output element types can differ. Go infers ",[399,2924,574],{},[399,2926,496],{},[399,2928,1976],{},[399,2930,454],{}," from ",[399,2933,2934],{},"strconv.Itoa",". ",[399,2937,2312],{}," has one, because its output has the same element type as its input. Both functions are reused with different types without any copying. Each result slice is created with ",[399,2940,2941],{},"make"," and a starting capacity, so ",[399,2944,2945],{},"append"," does not have to reallocate as it grows.",[390,2948,2950],{"id":2949},"summary","Summary",[395,2952,2953,2954,2956,2957,2959,2960,2180,2962,2964,2965,2967,2968,2970,2971,1008,2973,2975],{},"A type parameter, written in square brackets, lets one function or type work with many types while the compiler still checks each use. A constraint states what operations the type must support: ",[399,2955,401],{}," allows everything but offers nothing, ",[399,2958,405],{}," gives ",[399,2961,1007],{},[399,2963,1021],{}," gives ordering. The ",[399,2966,409],{}," in a constraint also accepts defined types built on the named type. Go infers type arguments from your call, generic types like ",[399,2969,2219],{}," are instantiated with a concrete type, and the standard ",[399,2972,2169],{},[399,2974,2187],{}," packages already cover many everyday cases. Reach for generics when the same algorithm repeats across types, and prefer interfaces or plain functions when they say it more clearly.",[395,2977,2978,2979,2985,2986,777],{},"Official reference: ",[923,2980,2984],{"href":2981,"rel":2982},"https:\u002F\u002Fgo.dev\u002Fblog\u002Fintro-generics",[2983],"nofollow","An introduction to generics"," and the ",[923,2987,2990],{"href":2988,"rel":2989},"https:\u002F\u002Fgo.dev\u002Fref\u002Fspec#Type_parameter_declarations",[2983],"Type parameters section of the specification",[2992,2993],"learning-lesson-complete",{},[2995,2996],"learning-lesson-navigation",{"next":121,"nextTitle":120,"previous":66,"previousTitle":65},[2998,2999,3000],"style",{},"html pre.shiki code .sEOdo, html code.shiki .sEOdo{--shiki-light:#859900;--shiki-default:#89DDFF;--shiki-dark:#C678DD}html pre.shiki code .sisdC, html code.shiki .sisdC{--shiki-light:#268BD2;--shiki-default:#82AAFF;--shiki-dark:#61AFEF}html pre.shiki code .shFME, html code.shiki .shFME{--shiki-light:#657B83;--shiki-default:#89DDFF;--shiki-dark:#ABB2BF}html pre.shiki code .syre3, html code.shiki .syre3{--shiki-light:#657B83;--shiki-light-font-style:inherit;--shiki-default:#EEFFFF;--shiki-default-font-style:italic;--shiki-dark:#E06C75;--shiki-dark-font-style:italic}html pre.shiki code .sF6sA, html code.shiki .sF6sA{--shiki-light:#586E75;--shiki-light-font-weight:bold;--shiki-default:#C792EA;--shiki-default-font-weight:inherit;--shiki-dark:#C678DD;--shiki-dark-font-weight:inherit}html pre.shiki code .sN42N, html code.shiki .sN42N{--shiki-light:#859900;--shiki-default:#89DDFF;--shiki-dark:#ABB2BF}html .light .shiki span {color: var(--shiki-light);background: var(--shiki-light-bg);font-style: var(--shiki-light-font-style);font-weight: var(--shiki-light-font-weight);text-decoration: var(--shiki-light-text-decoration);}html.light .shiki span {color: var(--shiki-light);background: var(--shiki-light-bg);font-style: var(--shiki-light-font-style);font-weight: var(--shiki-light-font-weight);text-decoration: var(--shiki-light-text-decoration);}html .default .shiki span {color: var(--shiki-default);background: var(--shiki-default-bg);font-style: var(--shiki-default-font-style);font-weight: var(--shiki-default-font-weight);text-decoration: var(--shiki-default-text-decoration);}html .shiki span {color: var(--shiki-default);background: var(--shiki-default-bg);font-style: var(--shiki-default-font-style);font-weight: var(--shiki-default-font-weight);text-decoration: var(--shiki-default-text-decoration);}html .dark .shiki span {color: var(--shiki-dark);background: var(--shiki-dark-bg);font-style: var(--shiki-dark-font-style);font-weight: var(--shiki-dark-font-weight);text-decoration: var(--shiki-dark-text-decoration);}html.dark .shiki span {color: var(--shiki-dark);background: var(--shiki-dark-bg);font-style: var(--shiki-dark-font-style);font-weight: var(--shiki-dark-font-weight);text-decoration: var(--shiki-dark-text-decoration);}html pre.shiki code .snwKR, html code.shiki .snwKR{--shiki-light:#CB4B16;--shiki-default:#FFCB6B;--shiki-dark:#E5C07B}html pre.shiki code .s7Bcg, html code.shiki .s7Bcg{--shiki-light:#859900;--shiki-light-font-style:inherit;--shiki-default:#89DDFF;--shiki-default-font-style:italic;--shiki-dark:#C678DD;--shiki-dark-font-style:inherit}html pre.shiki code .s45-6, html code.shiki .s45-6{--shiki-light:#268BD2;--shiki-default:#EEFFFF;--shiki-dark:#E06C75}html pre.shiki code .su2KV, html code.shiki .su2KV{--shiki-light:#859900;--shiki-default:#89DDFF;--shiki-dark:#E5C07B}html pre.shiki code .sRBoR, html code.shiki .sRBoR{--shiki-light:#859900;--shiki-default:#89DDFF;--shiki-dark:#56B6C2}html pre.shiki code .sAJzr, html code.shiki .sAJzr{--shiki-light:#D33682;--shiki-default:#F78C6C;--shiki-dark:#D19A66}html pre.shiki code .sED5a, html code.shiki .sED5a{--shiki-light:#2AA198;--shiki-default:#89DDFF;--shiki-dark:#98C379}html pre.shiki code .sVazx, html code.shiki .sVazx{--shiki-light:#2AA198;--shiki-default:#C3E88D;--shiki-dark:#98C379}html pre.shiki code .sJsHy, html code.shiki .sJsHy{--shiki-light:#93A1A1;--shiki-light-font-style:italic;--shiki-default:#546E7A;--shiki-default-font-style:italic;--shiki-dark:#7F848E;--shiki-dark-font-style:italic}html pre.shiki code .sqQ1y, html code.shiki .sqQ1y{--shiki-light:#B58900;--shiki-default:#FF9CAC;--shiki-dark:#D19A66}html pre.shiki code .sdLNw, html code.shiki .sdLNw{--shiki-light:#2AA198;--shiki-default:#FFCB6B;--shiki-dark:#98C379}",{"title":424,"searchDepth":482,"depth":482,"links":3002},[3003,3004,3005,3006,3010,3011,3012,3013,3014,3015,3016],{"id":392,"depth":482,"text":393},{"id":413,"depth":482,"text":414},{"id":555,"depth":482,"text":556},{"id":892,"depth":482,"text":3007,"children":3008},"Constraints: what T must be able to do",[3009],{"id":1198,"depth":515,"text":1199},{"id":1446,"depth":482,"text":1447},{"id":1914,"depth":482,"text":1915},{"id":2162,"depth":482,"text":2163},{"id":2197,"depth":482,"text":2198},{"id":2246,"depth":482,"text":2247},{"id":2290,"depth":482,"text":2291},{"id":2949,"depth":482,"text":2950},"Write one function or data structure that works across many types, using type parameters and constraints.","md",null,{},{"icon":73},{"description":3023,"title":70},"Learn Go generics including type parameters, constraints, any, comparable, cmp.Ordered, the tilde operator, type inference, generic types, and when not to use generics.","1n89XVtfgoFNIJqEmUEj5tO8ANUuGvb9H4INi2lhx10",[3026,3028],{"title":65,"path":66,"stem":67,"description":3027,"icon":68,"children":-1},"Give values domain meaning with defined types, build enum-like constants with iota, and learn how an alias differs.",{"title":75,"path":76,"stem":77,"description":3029,"icon":78,"children":-1},"Learn how modules, packages, and files relate, and how Go commands decide what to build.",1794118097869]